Clean commit for Hugging Face Spaces without binary files

.github/CODE_OF_CONDUCT.md

@@ -0,0 +1,128 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, religion, or sexual identity
+and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the
+  overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+xjasonlyu@gmail.com.
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series
+of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or
+permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior,  harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within
+the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.0, available at
+https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct
+enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at
+https://www.contributor-covenant.org/translations.

.github/CONTRIBUTING.md

@@ -0,0 +1,11 @@
+## Contributing
+
+- With issues:
+    - Use the search tool before opening a new issue.
+    - Please provide source code and commit sha if you found a bug.
+    - Review existing issues and provide feedback or react to them.
+
+- With pull requests:
+    - Open your pull request against `main`
+    - It should pass all tests in the available continuous integration systems such as GitHub Actions.
+    - You should add/modify tests to cover your proposed code changes.

.github/FUNDING.yml

@@ -0,0 +1,13 @@
+# These are supported funding model platforms
+
+github: [xjasonlyu]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
+custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,25 @@
+name: Feature request
+description: Suggest an idea or improvement
+title: "[Feature] "
+body:
+  - type: textarea
+    id: description
+    attributes:
+      label: Description
+      placeholder: A clear description of the feature or enhancement.
+    validations:
+      required: true
+
+  - type: textarea
+    id: related
+    attributes:
+      label: Is this feature related to a specific bug?
+      description: Please include a bug references if yes.
+
+  - type: textarea
+    id: solution
+    attributes:
+      label: Do you have a specific solution in mind?
+      description: >
+        Please include any details about a solution that you have in mind,
+        including any alternatives considered.

.github/SECURITY.md

@@ -0,0 +1,29 @@
+# Security Policy
+
+## Supported Versions
+
+| Version | Supported          |
+| :-----: | :----------------: |
+|   1.2.x   | :white_check_mark: |
+|   1.1.x   | :x: |
+|   1.0.x   | :x: |
+
+## Reporting a Vulnerability
+
+If you believe you have found a security vulnerability in this repository, please report it to me through coordinated disclosure.
+
+**Please do not report security vulnerabilities through public GitHub issues, discussions, or pull requests.**
+
+Instead, please send an email to xjasonlyu[@]gmail.com.
+
+Please include as much of the information listed below as you can to help me better understand and resolve the issue:
+
+  * The type of issue (e.g., buffer overflow, payload attack)
+  * Full paths of source file(s) related to the manifestation of the issue
+  * The location of the affected source code (tag/branch/commit or direct URL)
+  * Any special configuration required to reproduce the issue
+  * Step-by-step instructions to reproduce the issue
+  * Proof-of-concept or exploit code (if possible)
+  * Impact of the issue, including how an attacker might exploit the issue
+
+This information will help me triage your report more quickly.

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,41 @@
+name: "CodeQL"
+
+concurrency:
+  group: codeql-${{ github.event_name }}-${{ github.ref }}
+  cancel-in-progress: true
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'go' ]
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v5
+
+      - name: Setup Go
+        uses: actions/setup-go@v6
+        with:
+          check-latest: true
+          go-version-file: 'go.mod'
+
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@v4
+        with:
+          languages: ${{ matrix.language }}
+
+      - name: Autobuild
+        uses: github/codeql-action/autobuild@v4
+
+      - name: Perform CodeQL Analysis
+        uses: github/codeql-action/analyze@v4

.github/workflows/docker.yml

@@ -0,0 +1,73 @@
+name: Publish Docker Image
+
+concurrency:
+  group: docker-${{ github.event_name }}-${{ github.ref }}
+  cancel-in-progress: true
+
+on:
+  push:
+    branches:
+      - 'main'
+    tags:
+      - '*'
+
+jobs:
+
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    steps:
+
+      - name: Check out code into the Go module directory
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+        with:
+          platforms: all
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+        with:
+          version: latest
+
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Get Version
+        id: shell
+        run: |
+          echo "version=$(git describe --abbrev=0 --tags HEAD | cut -d'v' -f 2)" >> $GITHUB_OUTPUT
+
+      - name: Build and Push (dev)
+        if: github.ref == 'refs/heads/main'
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: Dockerfile
+          push: true
+          platforms: linux/amd64,linux/arm64
+          tags: |
+            ghcr.io/metatube-community/metatube-server:dev
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+
+      - name: Build and Push (latest)
+        if: startsWith(github.ref, 'refs/tags/')
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: Dockerfile
+          push: true
+          platforms: linux/amd64,linux/arm64
+          tags: |
+            ghcr.io/metatube-community/metatube-server:latest
+            ghcr.io/metatube-community/metatube-server:${{ steps.shell.outputs.version }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max

.github/workflows/linter.yml

@@ -0,0 +1,28 @@
+name: Linter
+
+concurrency:
+  group: linter-${{ github.event_name }}-${{ github.ref }}
+  cancel-in-progress: true
+
+on:
+  push:
+    branches:
+      - 'main'
+  pull_request:
+
+jobs:
+  golangci-lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Setup Go
+        uses: actions/setup-go@v6
+        with:
+          check-latest: true
+          go-version-file: 'go.mod'
+
+      - name: golangci-lint
+        uses: golangci/golangci-lint-action@v8
+        with:
+          version: latest

.github/workflows/release.yml

@@ -0,0 +1,49 @@
+name: Publish Go Releases
+
+concurrency:
+  group: release-${{ github.event_name }}-${{ github.ref }}
+  cancel-in-progress: true
+
+on:
+  push:
+    tags:
+      - '*'
+
+jobs:
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out code into the Go module directory
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+
+      - name: Setup Go
+        uses: actions/setup-go@v6
+        with:
+          check-latest: true
+          go-version-file: 'go.mod'
+
+      - name: Cache go module
+        uses: actions/cache@v4
+        with:
+          path: ~/go/pkg/mod
+          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
+          restore-keys: |
+            ${{ runner.os }}-go-
+
+      - name: Build
+        if: startsWith(github.ref, 'refs/tags/')
+        run: make releases
+
+      - name: Upload Releases
+        uses: softprops/action-gh-release@v2
+        if: startsWith(github.ref, 'refs/tags/')
+        with:
+          body: _Auto Released by Actions_
+          files: build/*
+          draft: false
+          prerelease: false
+          repository: metatube-community/metatube-server-releases
+          token: ${{ secrets.ORG_PAT }}

.github/workflows/stale.yml

@@ -0,0 +1,16 @@
+name: Mark stale issues and pull requests
+
+on:
+  schedule:
+    - cron: "0 10 * * *"
+
+jobs:
+  stale:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/stale@v10
+        with:
+          stale-issue-message: 'This issue is stale because it has been open 60 days with no activity. Remove stale label or comment or this will be closed in 7 days'
+          exempt-issue-labels: 'question,bug,enhancement'
+          days-before-stale: 60
+          days-before-close: 7

.github/workflows/test.yml

@@ -0,0 +1,36 @@
+name: Test
+
+concurrency:
+  group: test-${{ github.event_name }}-${{ github.ref }}
+  cancel-in-progress: true
+
+on:
+  push:
+    branches:
+      - 'main'
+  pull_request:
+
+jobs:
+  go-test:
+    name: Go Test
+    runs-on: ubuntu-latest
+    services:
+      dind:
+        image: docker:dind-rootless
+        ports:
+          - 2375:2375
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v5
+
+      - name: Setup Go
+        uses: actions/setup-go@v6
+        with:
+          check-latest: true
+          go-version-file: 'go.mod'
+
+      - name: Run test
+        run: |
+          go version
+          go test $(go list ./... | grep -Ev "github.com/metatube-community/metatube-sdk-go/translate")

.gitignore

@@ -0,0 +1,28 @@
+# If you prefer the allow list template instead of the deny list, see community template:
+# https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore
+#
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, built with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+# Dependency directories (remove the comment below to include it)
+# vendor/
+
+# Go workspace file
+go.work
+go.work.sum
+
+# env file
+.env
+
+# Build files
+build/

.golangci.yaml

@@ -0,0 +1,33 @@
+version: "2"
+linters:
+  default: none
+  enable:
+    - govet
+    - ineffassign
+    - misspell
+    - staticcheck
+    - unconvert
+    - unused
+    - usestdlibvars
+  exclusions:
+    generated: lax
+    presets:
+      - comments
+      - common-false-positives
+      - legacy
+      - std-error-handling
+    paths: [ ]
+formatters:
+  enable:
+    - gci
+    - gofumpt
+  settings:
+    gci:
+      sections:
+        - standard
+        - default
+        - prefix(github.com/metatube-community/metatube-sdk-go)
+      custom-order: true
+  exclusions:
+    generated: lax
+    paths: [ ]

Dockerfile

@@ -0,0 +1,32 @@
+FROM --platform=$BUILDPLATFORM golang:alpine AS builder
+
+ARG TARGETOS
+ARG TARGETARCH
+
+WORKDIR /src
+COPY . /src
+
+RUN apk add --update --no-cache --no-progress make git \
+    && GOOS=$TARGETOS GOARCH=$TARGETARCH make server BUILD_COMMIT=unknown BUILD_VERSION=unknown
+
+FROM alpine:latest
+LABEL org.opencontainers.image.licenses=Apache-2.0
+LABEL org.opencontainers.image.source="https://github.com/metatube-community/metatube-sdk-go"
+
+COPY --from=builder /src/build/metatube-server .
+
+RUN apk add --update --no-cache --no-progress ca-certificates tzdata
+
+ENV GIN_MODE=release
+ENV PORT=7860
+ENV TOKEN=""
+ENV DSN=""
+ENV REQUEST_TIMEOUT=""
+ENV DB_MAX_IDLE_CONNS=0
+ENV DB_MAX_OPEN_CONNS=0
+ENV DB_PREPARED_STMT=0
+ENV DB_AUTO_MIGRATE=0
+
+EXPOSE 7860
+
+ENTRYPOINT ["/metatube-server"]

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

Makefile

@@ -0,0 +1,132 @@
+MODULE := github.com/metatube-community/metatube-sdk-go
+
+SERVER_NAME := metatube-server
+SERVER_CODE := cmd/server/main.go
+
+BUILD_DIR     := build
+BUILD_TAGS    :=
+BUILD_FLAGS   := -v
+BUILD_COMMIT  := $(shell git rev-parse --short HEAD)
+BUILD_VERSION := $(shell git describe --abbrev=0 --tags HEAD | cut -d'v' -f 2)
+
+CGO_ENABLED := 0
+GO111MODULE := on
+
+LDFLAGS += -w -s -buildid=
+LDFLAGS += -X "$(MODULE)/internal/version.Version=$(BUILD_VERSION)"
+LDFLAGS += -X "$(MODULE)/internal/version.GitCommit=$(BUILD_COMMIT)"
+
+GO_BUILD = GO111MODULE=$(GO111MODULE) CGO_ENABLED=$(CGO_ENABLED) \
+	go build $(BUILD_FLAGS) -ldflags '$(LDFLAGS)' -tags '$(BUILD_TAGS)' -trimpath
+
+UNIX_ARCH_LIST = \
+	darwin-amd64 \
+	darwin-amd64-v3 \
+	darwin-arm64 \
+	freebsd-amd64 \
+	freebsd-amd64-v3 \
+	freebsd-arm64 \
+	linux-386 \
+	linux-amd64 \
+	linux-amd64-v3 \
+	linux-arm64 \
+	linux-armv5 \
+	linux-armv6 \
+	linux-armv7 \
+	linux-ppc64le \
+	linux-s390x \
+	openbsd-amd64 \
+	openbsd-amd64-v3
+
+WINDOWS_ARCH_LIST = \
+	windows-amd64 \
+	windows-amd64-v3 \
+	windows-arm64
+
+all: development
+
+development: BUILD_TAGS += experimental
+development:
+	$(GO_BUILD) -o $(BUILD_DIR)/$(SERVER_NAME) $(SERVER_CODE)
+
+server:
+	$(GO_BUILD) -o $(BUILD_DIR)/$(SERVER_NAME) $(SERVER_CODE)
+
+darwin-amd64:
+	GOARCH=amd64 GOOS=darwin $(GO_BUILD) -o $(BUILD_DIR)/$(SERVER_NAME)-$@ $(SERVER_CODE)
+
+darwin-amd64-v3:
+	GOARCH=amd64 GOOS=darwin GOAMD64=v3 $(GO_BUILD) -o $(BUILD_DIR)/$(SERVER_NAME)-$@ $(SERVER_CODE)
+
+darwin-arm64:
+	GOARCH=arm64 GOOS=darwin $(GO_BUILD) -o $(BUILD_DIR)/$(SERVER_NAME)-$@ $(SERVER_CODE)
+
+freebsd-amd64:
+	GOARCH=amd64 GOOS=freebsd $(GO_BUILD) -o $(BUILD_DIR)/$(SERVER_NAME)-$@ $(SERVER_CODE)
+
+freebsd-amd64-v3:
+	GOARCH=amd64 GOOS=freebsd GOAMD64=v3 $(GO_BUILD) -o $(BUILD_DIR)/$(SERVER_NAME)-$@ $(SERVER_CODE)
+
+freebsd-arm64:
+	GOARCH=arm64 GOOS=freebsd $(GO_BUILD) -o $(BUILD_DIR)/$(SERVER_NAME)-$@ $(SERVER_CODE)
+
+linux-386:
+	GOARCH=386 GOOS=linux $(GO_BUILD) -o $(BUILD_DIR)/$(SERVER_NAME)-$@ $(SERVER_CODE)
+
+linux-amd64:
+	GOARCH=amd64 GOOS=linux $(GO_BUILD) -o $(BUILD_DIR)/$(SERVER_NAME)-$@ $(SERVER_CODE)
+
+linux-amd64-v3:
+	GOARCH=amd64 GOOS=linux GOAMD64=v3 $(GO_BUILD) -o $(BUILD_DIR)/$(SERVER_NAME)-$@ $(SERVER_CODE)
+
+linux-arm64:
+	GOARCH=arm64 GOOS=linux $(GO_BUILD) -o $(BUILD_DIR)/$(SERVER_NAME)-$@ $(SERVER_CODE)
+
+linux-armv5:
+	GOARCH=arm GOARM=5 GOOS=linux $(GO_BUILD) -o $(BUILD_DIR)/$(SERVER_NAME)-$@ $(SERVER_CODE)
+
+linux-armv6:
+	GOARCH=arm GOARM=6 GOOS=linux $(GO_BUILD) -o $(BUILD_DIR)/$(SERVER_NAME)-$@ $(SERVER_CODE)
+
+linux-armv7:
+	GOARCH=arm GOARM=7 GOOS=linux $(GO_BUILD) -o $(BUILD_DIR)/$(SERVER_NAME)-$@ $(SERVER_CODE)
+
+linux-ppc64le:
+	GOARCH=ppc64le GOOS=linux $(GO_BUILD) -o $(BUILD_DIR)/$(SERVER_NAME)-$@ $(SERVER_CODE)
+
+linux-s390x:
+	GOARCH=s390x GOOS=linux $(GO_BUILD) -o $(BUILD_DIR)/$(SERVER_NAME)-$@ $(SERVER_CODE)
+
+openbsd-amd64:
+	GOARCH=amd64 GOOS=openbsd $(GO_BUILD) -o $(BUILD_DIR)/$(SERVER_NAME)-$@ $(SERVER_CODE)
+
+openbsd-amd64-v3:
+	GOARCH=amd64 GOOS=openbsd GOAMD64=v3 $(GO_BUILD) -o $(BUILD_DIR)/$(SERVER_NAME)-$@ $(SERVER_CODE)
+
+windows-amd64:
+	GOARCH=amd64 GOOS=windows $(GO_BUILD) -o $(BUILD_DIR)/$(SERVER_NAME)-$@.exe $(SERVER_CODE)
+
+windows-amd64-v3:
+	GOARCH=amd64 GOOS=windows GOAMD64=v3 $(GO_BUILD) -o $(BUILD_DIR)/$(SERVER_NAME)-$@.exe $(SERVER_CODE)
+
+windows-arm64:
+	GOARCH=arm64 GOOS=windows $(GO_BUILD) -o $(BUILD_DIR)/$(SERVER_NAME)-$@.exe $(SERVER_CODE)
+
+unix_releases := $(addsuffix .zip, $(UNIX_ARCH_LIST))
+windows_releases := $(addsuffix .zip, $(WINDOWS_ARCH_LIST))
+
+$(unix_releases): %.zip: %
+	@zip -qmj $(BUILD_DIR)/$(SERVER_NAME)-$(basename $@).zip $(BUILD_DIR)/$(SERVER_NAME)-$(basename $@)
+
+$(windows_releases): %.zip: %
+	@zip -qmj $(BUILD_DIR)/$(SERVER_NAME)-$(basename $@).zip $(BUILD_DIR)/$(SERVER_NAME)-$(basename $@).exe
+
+all-arch: $(UNIX_ARCH_LIST) $(WINDOWS_ARCH_LIST)
+
+releases: $(unix_releases) $(windows_releases)
+
+lint:
+	golangci-lint run ./...
+
+clean:
+	rm -rf $(BUILD_DIR)

README.md

@@ -0,0 +1,73 @@
+---
+title: MetaTube
+emoji: 📽️
+colorFrom: indigo
+colorTo: blue
+sdk: docker
+pinned: false
+---
+
+# MetaTube SDK Go
+
+[![Build Status](https://img.shields.io/github/actions/workflow/status/metatube-community/metatube-sdk-go/docker.yml?branch=main&style=flat-square&logo=github-actions)](https://github.com/metatube-community/metatube-sdk-go/actions/workflows/release.yml)
+[![Go Report Card](https://goreportcard.com/badge/github.com/metatube-community/metatube-sdk-go?style=flat-square)](https://github.com/metatube-community/metatube-sdk-go)
+[![Require Go Version](https://img.shields.io/badge/go-%3E%3D1.25-30dff3?style=flat-square&logo=go)](https://github.com/metatube-community/metatube-sdk-go/blob/main/go.mod)
+[![GitHub License](https://img.shields.io/github/license/metatube-community/metatube-sdk-go?color=e4682a&logo=apache&style=flat-square)](https://github.com/metatube-community/metatube-sdk-go/blob/main/LICENSE)
+[![Tag](https://img.shields.io/github/v/tag/metatube-community/metatube-sdk-go?color=%23ff8936&logo=fitbit&style=flat-square)](https://github.com/metatube-community/metatube-sdk-go/tags)
+
+Metadata Tube SDK in Golang.
+
+## Contents
+
+- [MetaTube SDK Go](#metatube-sdk-go)
+    - [Contents](#contents)
+    - [Features](#features)
+    - [Installation](#installation)
+    - [Credits](#credits)
+    - [License](#license)
+
+## Features
+
+- Supported platforms
+    - Linux
+    - Darwin
+    - Windows
+    - BSD(s)
+- Supported Databases
+    - [SQLite](https://gitlab.com/cznic/sqlite)
+    - [PostgreSQL](https://github.com/jackc/pgx)
+- Image processing
+    - Auto cropping
+    - Badge support
+    - Face detection
+    - Image hashing
+- RESTful API
+- 20+ providers
+- Text translation
+
+## Installation
+
+To install this package, you first need [Go](https://golang.org/) installed (**go1.25+ is required**), then you can use
+the below Go command to install SDK.
+
+```sh
+go get -u github.com/metatube-community/metatube-sdk-go
+```
+
+## Credits
+
+| Library														                                           | Description																						                                                                    |
+|-----------------------------------------------------------------|------------------------------------------------------------------------------------------------------|
+| [gocolly/colly](https://github.com/gocolly/colly)			            | Elegant Scraper and Crawler Framework for Golang													                                        |
+| [gin-gonic/gin](https://github.com/gin-gonic/gin)			            | Gin is a HTTP web framework written in Go															                                             |
+| [gorm.io/gorm](https://gorm.io/)								                        | The fantastic ORM library for Golang																                                                 |
+| [esimov/pigo](https://github.com/esimov/pigo)				               | Fast face detection, pupil/eyes localization and facial landmark points detection library in pure Go |
+| [robertkrimen/otto](https://github.com/robertkrimen/otto)       | A JavaScript interpreter in Go (golang)                                                              |
+| [modernc.org/sqlite](https://gitlab.com/cznic/sqlite)		         | Package sqlite is a CGo-free port of SQLite/SQLite3												                                      |
+| [corona10/goimagehash](https://github.com/corona10/goimagehash) | Go Perceptual image hashing package																                                                  |
+| [antchfx/xpath](https://github.com/antchfx/xpath)			            | XPath package for Golang, supports HTML, XML, JSON document query									                           |
+| [gen2brain/jpegli](https://github.com/gen2brain/jpegli)         | Go encoder/decoder for JPEG based on jpegli                                                          |
+
+## License
+
+[Apache-2.0 License](https://github.com/metatube-community/metatube-sdk-go/blob/main/LICENSE)

cmd/cmd.go

@@ -0,0 +1,111 @@
+package cmd
+
+import (
+	goflag "flag"
+	"log"
+	"os"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/peterbourgon/ff/v3"
+
+	"github.com/metatube-community/metatube-sdk-go/database"
+	"github.com/metatube-community/metatube-sdk-go/engine"
+	"github.com/metatube-community/metatube-sdk-go/internal/envconfig"
+	"github.com/metatube-community/metatube-sdk-go/route"
+	"github.com/metatube-community/metatube-sdk-go/route/auth"
+)
+
+var Config = &struct {
+	// main config
+	Bind  string
+	Port  string
+	Token string
+	DSN   string
+
+	// engine config
+	RequestTimeout time.Duration
+
+	// database config
+	DBMaxIdleConns int
+	DBMaxOpenConns int
+	DBAutoMigrate  bool
+	DBPreparedStmt bool
+
+	// version flag
+	VersionFlag bool
+}{}
+
+func init() {
+	// gin init
+	gin.DisableConsoleColor()
+
+	// flag init
+	flag := goflag.NewFlagSet("", goflag.ExitOnError)
+
+	// flag parse
+	flag.StringVar(&Config.Bind, "bind", "", "Bind address of server")
+	flag.StringVar(&Config.Port, "port", "8080", "Port number of server")
+	flag.StringVar(&Config.Token, "token", "", "Token to access server")
+	flag.StringVar(&Config.DSN, "dsn", "", "Database Service Name")
+	flag.DurationVar(&Config.RequestTimeout, "request-timeout", engine.DefaultRequestTimeout, "Timeout per request")
+	flag.IntVar(&Config.DBMaxIdleConns, "db-max-idle-conns", 0, "Database max idle connections")
+	flag.IntVar(&Config.DBMaxOpenConns, "db-max-open-conns", 0, "Database max open connections")
+	flag.BoolVar(&Config.DBAutoMigrate, "db-auto-migrate", false, "Database auto migration")
+	flag.BoolVar(&Config.DBPreparedStmt, "db-prepared-stmt", false, "Database prepared statement")
+	flag.BoolVar(&Config.VersionFlag, "version", false, "Show version")
+	ff.Parse(flag, os.Args[1:], ff.WithEnvVars())
+}
+
+func Router(names ...string) *gin.Engine {
+	db, err := database.Open(&database.Config{
+		DSN:                  Config.DSN,
+		PreparedStmt:         Config.DBPreparedStmt,
+		MaxIdleConns:         Config.DBMaxIdleConns,
+		MaxOpenConns:         Config.DBMaxOpenConns,
+		DisableAutomaticPing: true,
+	})
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// engine options
+	var opts []engine.Option
+
+	// timeout must >= 1 second
+	if Config.RequestTimeout >= time.Second {
+		opts = append(opts, engine.WithRequestTimeout(Config.RequestTimeout))
+	}
+
+	// specify engine name
+	for _, name := range names {
+		opts = append(opts, engine.WithEngineName(name))
+	}
+
+	// // set actor provider configs if any
+	for provider, config := range envconfig.ActorProviderConfigs.Iterator() {
+		opts = append(opts, engine.WithActorProviderConfig(provider, config))
+	}
+
+	// set movie provider configs if any
+	for provider, config := range envconfig.MovieProviderConfigs.Iterator() {
+		opts = append(opts, engine.WithMovieProviderConfig(provider, config))
+	}
+
+	app := engine.New(db, opts...)
+
+	// always enable auto migrate for sqlite DB
+	if app.DBDriver() == database.Sqlite {
+		Config.DBAutoMigrate = true
+	}
+	if err = app.DBAutoMigrate(Config.DBAutoMigrate); err != nil {
+		log.Fatal(err)
+	}
+
+	var token auth.Validator
+	if Config.Token != "" {
+		token = auth.Token(Config.Token)
+	}
+
+	return route.New(app, token)
+}

cmd/init.go

@@ -0,0 +1,9 @@
+package cmd
+
+import (
+	"go.uber.org/automaxprocs/maxprocs"
+)
+
+func init() {
+	maxprocs.Set(maxprocs.Logger(func(string, ...any) {}))
+}

cmd/server/main.go

@@ -0,0 +1,35 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"net"
+	"net/http"
+	"os"
+
+	"github.com/metatube-community/metatube-sdk-go/cmd"
+	"github.com/metatube-community/metatube-sdk-go/engine"
+	V "github.com/metatube-community/metatube-sdk-go/internal/version"
+)
+
+func showVersionAndExit() {
+	fmt.Println(V.BuildString())
+	os.Exit(0)
+}
+
+func main() {
+	if _, isSet := os.LookupEnv("VERSION"); cmd.Config.VersionFlag &&
+		!isSet /* NOTE: ignore this flag if ENV contains VERSION variable. */ {
+		showVersionAndExit()
+	}
+
+	var (
+		addr = net.JoinHostPort(
+			cmd.Config.Bind,
+			cmd.Config.Port)
+		router = cmd.Router(engine.DefaultEngineName)
+	)
+	if err := http.ListenAndServe(addr, router); err != nil {
+		log.Fatal(err)
+	}
+}

collection/maps/cimap.go

@@ -0,0 +1,96 @@
+package maps
+
+import (
+	"encoding/json"
+	"iter"
+
+	"github.com/projectbarks/cimap"
+)
+
+var (
+	_ json.Marshaler   = (*CaseInsensitiveMap[any])(nil)
+	_ json.Unmarshaler = (*CaseInsensitiveMap[any])(nil)
+)
+
+type CaseInsensitiveMap[T any] struct {
+	internalMap *cimap.CaseInsensitiveMap[T]
+}
+
+func NewCaseInsensitiveMap[T any]() *CaseInsensitiveMap[T] {
+	return &CaseInsensitiveMap[T]{
+		internalMap: cimap.New[T](),
+	}
+}
+
+func NewCaseInsensitiveMapWithCapacity[T any](capacity int) *CaseInsensitiveMap[T] {
+	return &CaseInsensitiveMap[T]{
+		internalMap: cimap.New[T](capacity),
+	}
+}
+
+func (m *CaseInsensitiveMap[T]) Copy() *CaseInsensitiveMap[T] {
+	m2 := NewCaseInsensitiveMapWithCapacity[T](m.Len())
+	for key, value := range m.Iterator() {
+		m2.Set(key, value)
+	}
+	return m2
+}
+
+func (m *CaseInsensitiveMap[T]) Has(key string) bool {
+	_, exist := m.internalMap.Get(key)
+	return exist
+}
+
+func (m *CaseInsensitiveMap[T]) Get(key string) (T, bool) {
+	return m.internalMap.Get(key)
+}
+
+func (m *CaseInsensitiveMap[T]) GetOrDefault(key string, defaultValues ...T) T {
+	value, exist := m.internalMap.Get(key)
+	if exist {
+		return value
+	}
+	if len(defaultValues) > 0 {
+		return defaultValues[0]
+	}
+	var defaultValue T
+	return defaultValue
+}
+
+func (m *CaseInsensitiveMap[T]) Set(key string, value T) {
+	m.internalMap.Add(key, value)
+}
+
+func (m *CaseInsensitiveMap[T]) Delete(key string) {
+	m.internalMap.Delete(key)
+}
+
+func (m *CaseInsensitiveMap[T]) Len() int {
+	return m.internalMap.Len()
+}
+
+func (m *CaseInsensitiveMap[T]) Keys() iter.Seq[string] {
+	return m.internalMap.Keys()
+}
+
+func (m *CaseInsensitiveMap[T]) Values() iter.Seq[T] {
+	return func(yield func(T) bool) {
+		for _, value := range m.Iterator() {
+			if !yield(value) {
+				return
+			}
+		}
+	}
+}
+
+func (m *CaseInsensitiveMap[T]) Iterator() iter.Seq2[string, T] {
+	return m.internalMap.Iterator()
+}
+
+func (m *CaseInsensitiveMap[T]) MarshalJSON() ([]byte, error) {
+	return m.internalMap.MarshalJSON()
+}
+
+func (m *CaseInsensitiveMap[T]) UnmarshalJSON(data []byte) error {
+	return m.internalMap.UnmarshalJSON(data)
+}

collection/maps/cimap_test.go

@@ -0,0 +1,90 @@
+package maps
+
+import (
+	"encoding/json"
+	"slices"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCaseInsensitiveMap(t *testing.T) {
+	m := NewCaseInsensitiveMap[string]()
+
+	// Set with mixed casing
+	m.Set("FOO", "bar")
+	m.Set("Baz", "qux")
+	assert.Equal(t, 2, m.Len())
+
+	// Should be case-insensitive
+	val, ok := m.Get("foo")
+	assert.True(t, ok)
+	assert.Equal(t, "bar", val)
+
+	val, ok = m.Get("baz")
+	assert.True(t, ok)
+	assert.Equal(t, "qux", val)
+
+	val, ok = m.Get("BAZ")
+	assert.True(t, ok)
+	assert.Equal(t, "qux", val)
+
+	exist := m.Has("foo")
+	assert.True(t, exist)
+
+	exist = m.Has("baz")
+	assert.True(t, exist)
+
+	exist = m.Has("BAZ")
+	assert.True(t, exist)
+
+	val = m.GetOrDefault("foo", "quux")
+	assert.Equal(t, "bar", val)
+
+	val = m.GetOrDefault("baz", "quux")
+	assert.Equal(t, "qux", val)
+
+	val = m.GetOrDefault("bar", "quux")
+	assert.Equal(t, "quux", val)
+
+	val = m.GetOrDefault("bar")
+	assert.Equal(t, "", val)
+
+	keys := slices.Collect(m.Keys())
+	slices.Sort(keys)
+	assert.Equal(t, []string{"Baz", "FOO"}, keys)
+
+	values := slices.Collect(m.Values())
+	slices.Sort(values)
+	assert.Equal(t, []string{"bar", "qux"}, values)
+
+	// Delete should also be case-insensitive
+	m.Delete("FOO")
+	_, ok = m.Get("foo")
+	assert.False(t, ok)
+	assert.Equal(t, 1, m.Len())
+
+	// Test JSON marshal/unmarshal
+	data, err := json.Marshal(m)
+	if assert.NoError(t, err) {
+		assert.JSONEq(t, `{
+			"Baz":"qux"
+		}`, string(data))
+	}
+
+	copied := m.Copy()
+	data2, err := json.Marshal(copied)
+	if assert.NoError(t, err) {
+		assert.JSONEq(t, `{
+			"Baz":"qux"
+		}`, string(data2))
+	}
+
+	m2 := NewCaseInsensitiveMapWithCapacity[string](m.Len())
+	err = json.Unmarshal(data, m2)
+	if assert.NoError(t, err) {
+		val, ok = m2.Get("baz")
+		assert.True(t, ok)
+		assert.Equal(t, "qux", val)
+	}
+}

collection/maps/orderedmap.go

@@ -0,0 +1,79 @@
+package maps
+
+import (
+	"bytes"
+	"encoding/json"
+	"iter"
+
+	"github.com/elliotchance/orderedmap/v3"
+	jsoniter "github.com/json-iterator/go"
+)
+
+var (
+	_ json.Marshaler   = (*OrderedMap[int, any])(nil)
+	_ json.Unmarshaler = (*OrderedMap[int, any])(nil)
+)
+
+type OrderedMap[K comparable, V any] struct {
+	*orderedmap.OrderedMap[K, V]
+	escapeHTML bool
+}
+
+func NewOrderedMap[K comparable, V any]() *OrderedMap[K, V] {
+	return &OrderedMap[K, V]{OrderedMap: orderedmap.NewOrderedMap[K, V]()}
+}
+
+func (m *OrderedMap[K, V]) SetEscapeHTML(on bool) {
+	m.escapeHTML = on
+}
+
+func (m *OrderedMap[K, V]) Copy() *OrderedMap[K, V] {
+	return &OrderedMap[K, V]{
+		OrderedMap: m.OrderedMap.Copy(),
+		escapeHTML: m.escapeHTML,
+	}
+}
+
+func (m *OrderedMap[K, V]) Iterator() iter.Seq2[K, V] {
+	return m.AllFromFront() // For compatibility.
+}
+
+func (m *OrderedMap[K, V]) MarshalJSON() ([]byte, error) {
+	buf := bytes.NewBuffer(nil)
+	buf.WriteByte('{')
+	enc := json.NewEncoder(buf)
+	enc.SetEscapeHTML(m.escapeHTML)
+	for el := m.Front(); el != nil; el = el.Next() {
+		if el != m.Front() {
+			buf.WriteByte(',')
+		}
+		// add key
+		if err := enc.Encode(el.Key); err != nil {
+			return nil, err
+		}
+		buf.WriteByte(':')
+		// add value
+		if err := enc.Encode(el.Value); err != nil {
+			return nil, err
+		}
+	}
+	buf.WriteByte('}')
+	return buf.Bytes(), nil
+}
+
+func (m *OrderedMap[K, V]) UnmarshalJSON(data []byte) error {
+	if m.OrderedMap == nil {
+		m.OrderedMap = orderedmap.NewOrderedMap[K, V]()
+	}
+	temp := make(map[K]V)
+	defer clear(temp) // for gc
+	if err := json.Unmarshal(data, &temp); err != nil {
+		return err
+	}
+	root := jsoniter.Get(data)
+	for _, key := range root.Keys() {
+		k := any(key).(K)
+		m.Set(k, temp[k])
+	}
+	return nil
+}

collection/maps/orderedmap_test.go

@@ -0,0 +1,112 @@
+package maps
+
+import (
+	"encoding/json"
+	"slices"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestOrderedMap(t *testing.T) {
+	t.Run("JSON Marshal", func(t *testing.T) {
+		m := NewOrderedMap[string, any]()
+		b, _ := json.Marshal(m)
+		assert.JSONEq(t, `{}`, string(b))
+
+		m.Set("a", 1)
+		m.Set("c", "2")
+		m.Set("b", 3.0)
+		m.Set("b", 1.5)
+		assert.Equal(t, []any{1, "2", 1.5}, slices.Collect(m.Values()))
+
+		b, _ = json.Marshal(m)
+		assert.JSONEq(t, `{
+			"a":1,
+			"c":"2",
+			"b":1.5
+		}`, string(b))
+	})
+
+	t.Run("fixed type map unmarshal", func(t *testing.T) {
+		jsonData := `{
+			"a":1,
+			"c":2,
+			"b":0
+		}`
+		m := NewOrderedMap[string, int]()
+		err := m.UnmarshalJSON([]byte(jsonData))
+		if assert.NoError(t, err) {
+			b, _ := json.Marshal(m)
+			assert.JSONEq(t, `{"a":1,"c":2,"b":0}`, string(b))
+		}
+	})
+
+	t.Run("any type map unmarshal", func(t *testing.T) {
+		jsonData := `{
+			"a":1,
+			"c":"2",
+			"b":1.5,
+			"?":{"x":"y","j":"k","3":2}
+		}`
+		m := NewOrderedMap[string, any]()
+		err := m.UnmarshalJSON([]byte(jsonData))
+		if assert.NoError(t, err) {
+			b, _ := json.Marshal(m)
+			assert.JSONEq(t, `{
+				"a":1,"c":"2","b":1.5,
+				"?":{"3":2,"j":"k","x":"y"}
+			}`, string(b))
+		}
+	})
+
+	t.Run("Sorted sub map unmarshal", func(t *testing.T) {
+		jsonData := `{
+			"w":{"n":3,"m":5},
+			"b":{"f":1,"j":0}
+		}`
+		m := NewOrderedMap[string, map[string]int]()
+		err := m.UnmarshalJSON([]byte(jsonData))
+		if assert.NoError(t, err) {
+			b, _ := json.Marshal(m)
+			assert.JSONEq(t, `{
+				"w":{"m":5,"n":3},
+				"b":{"f":1,"j":0}
+			}`, string(b))
+		}
+	})
+
+	t.Run("Ordered sub map unmarshal", func(t *testing.T) {
+		jsonData := `{
+			"w":{"n":3,"m":5},
+			"b":{"f":1,"j":0}
+		}`
+		m := NewOrderedMap[string, *OrderedMap[string, int]]()
+		err := m.UnmarshalJSON([]byte(jsonData))
+		if assert.NoError(t, err) {
+			b, _ := json.Marshal(m)
+			assert.JSONEq(t, `{
+				"w":{"n":3,"m":5},
+				"b":{"f":1,"j":0}
+			}`, string(b))
+		}
+	})
+
+	t.Run("A lot of ordered sub maps unmarshal", func(t *testing.T) {
+		jsonData := `{
+			"w":{"n":{"g":3,"5":5},"m":{"v":3,"2":5}},
+			"b":{"f":{"h":3,"3":5},"j":{"x":3,"c":5}}
+		}`
+		m := NewOrderedMap[string, *OrderedMap[string, *OrderedMap[string, any]]]()
+		err := m.UnmarshalJSON([]byte(jsonData))
+		if assert.NoError(t, err) {
+			b, _ := json.Marshal(m)
+			assert.JSONEq(t, `{
+				"w":{"n":{"g":3,"5":5},
+				"m":{"v":3,"2":5}},
+				"b":{"f":{"h":3,"3":5},
+				"j":{"x":3,"c":5}}
+			}`, string(b))
+		}
+	})
+}

collection/sets/orderedset.go

@@ -0,0 +1,76 @@
+package sets
+
+import (
+	"encoding/json"
+	"iter"
+	"slices"
+
+	"github.com/elliotchance/orderedmap/v3"
+)
+
+var (
+	_ json.Marshaler   = (*OrderedSet[int, any])(nil)
+	_ json.Unmarshaler = (*OrderedSet[int, any])(nil)
+)
+
+type OrderedSet[K comparable, V any] struct {
+	h func(V) K
+	m *orderedmap.OrderedMap[K, V]
+}
+
+func NewOrderedSet[T comparable]() *OrderedSet[T, T] {
+	return &OrderedSet[T, T]{
+		h: func(t T) T { return t },
+		m: orderedmap.NewOrderedMap[T, T](),
+	}
+}
+
+func NewOrderedSetWithHash[K comparable, V any](hash func(V) K) *OrderedSet[K, V] {
+	return &OrderedSet[K, V]{
+		h: hash,
+		m: orderedmap.NewOrderedMap[K, V](),
+	}
+}
+
+func (s *OrderedSet[K, V]) Len() int {
+	return s.m.Len()
+}
+
+func (s *OrderedSet[K, V]) Add(items ...V) {
+	for _, result := range items {
+		s.m.Set(s.h(result), result)
+	}
+}
+
+func (s *OrderedSet[K, V]) Del(items ...V) {
+	for _, result := range items {
+		s.m.Delete(s.h(result))
+	}
+}
+
+func (s *OrderedSet[K, V]) Iterator() iter.Seq[V] {
+	return func(yield func(V) bool) {
+		for _, v := range s.m.AllFromFront() {
+			if !yield(v) {
+				return
+			}
+		}
+	}
+}
+
+func (s *OrderedSet[K, V]) AsSlice() []V {
+	return slices.Collect(s.Iterator())
+}
+
+func (s *OrderedSet[K, V]) MarshalJSON() ([]byte, error) {
+	return json.Marshal(s.AsSlice())
+}
+
+func (s *OrderedSet[K, V]) UnmarshalJSON(data []byte) error {
+	vs := make([]V, 0)
+	if err := json.Unmarshal(data, &vs); err != nil {
+		return err
+	}
+	s.Add(vs...)
+	return nil
+}

collection/sets/orderedset_test.go

@@ -0,0 +1,32 @@
+package sets
+
+import (
+	"encoding/json"
+	"strconv"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestOrderedSet(t *testing.T) {
+	set := NewOrderedSet[int]()
+
+	set.Add(1, 4, 6, 8, 9)
+	set.Add(7, 4, 9, 2, 3)
+	assert.Equal(t, 8, set.Len())
+	assert.Equal(t, []int{1, 4, 6, 8, 9, 7, 2, 3}, set.AsSlice())
+
+	set.Del(4, 5, 6, 7)
+	assert.Equal(t, 5, set.Len())
+	assert.Equal(t, []int{1, 8, 9, 2, 3}, set.AsSlice())
+
+	b, _ := json.Marshal(set)
+	assert.JSONEq(t, `[1,8,9,2,3]`, string(b))
+
+	set2 := NewOrderedSetWithHash(func(v int) string {
+		return strconv.Itoa(v)
+	})
+	_ = json.Unmarshal(b, set2)
+	assert.Equal(t, 5, set.Len())
+	assert.Equal(t, []int{1, 8, 9, 2, 3}, set.AsSlice())
+}

collection/slices/flatten.go

@@ -0,0 +1,18 @@
+package slices
+
+import (
+	"slices"
+)
+
+// Flatten flattens a 2D slice into a 1D slice by merging all inner slices.
+func Flatten[E any](s [][]E) []E {
+	return slices.Collect(func(yield func(E) bool) {
+		for _, i := range s {
+			for _, j := range i {
+				if !yield(j) {
+					return
+				}
+			}
+		}
+	})
+}

collection/slices/flatten_test.go

@@ -0,0 +1,16 @@
+package slices
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestFlatten(t *testing.T) {
+	k := [][]int{{1, 2}, {3, 4}}
+	assert.Equal(t, []int{1, 2, 3, 4}, Flatten(k))
+
+	s := [][][]string{{{"a", "b"}, {"c", "d"}}, {{"e", "f"}, {"g", "h"}}}
+	assert.Equal(t, [][]string{{"a", "b"}, {"c", "d"}, {"e", "f"}, {"g", "h"}}, Flatten(s))
+	assert.Equal(t, []string{"a", "b", "c", "d", "e", "f", "g", "h"}, Flatten(Flatten(s)))
+}

collection/slices/wslice.go

@@ -0,0 +1,48 @@
+package slices
+
+import (
+	"cmp"
+	"sort"
+)
+
+var _ sort.Interface = (*WeightedSlice[any, int])(nil)
+
+type WeightedSlice[O any, W cmp.Ordered] struct {
+	objects []O
+	weights []W
+}
+
+func NewWeightedSlice[O any, W cmp.Ordered](objects []O, weights []W) *WeightedSlice[O, W] {
+	if len(objects) != len(weights) {
+		panic("objects and weights must have the same length")
+	}
+	return &WeightedSlice[O, W]{objects, weights}
+}
+
+func (s *WeightedSlice[O, W]) Len() int {
+	return len(s.objects)
+}
+
+func (s *WeightedSlice[O, W]) Less(i int, j int) bool {
+	// higher-weighted item comes first.
+	return s.weights[i] > s.weights[j]
+}
+
+func (s *WeightedSlice[O, W]) Swap(i int, j int) {
+	s.weights[i], s.weights[j] = s.weights[j], s.weights[i]
+	s.objects[i], s.objects[j] = s.objects[j], s.objects[i]
+}
+
+func (s *WeightedSlice[O, W]) Append(object O, weight W) {
+	s.weights = append(s.weights, weight)
+	s.objects = append(s.objects, object)
+}
+
+func (s *WeightedSlice[O, W]) Slice() []O {
+	return s.objects
+}
+
+func (s *WeightedSlice[O, W]) SortFunc(sortFn func(p sort.Interface)) *WeightedSlice[O, W] {
+	sortFn(s)
+	return s
+}

collection/slices/wslice_test.go

@@ -0,0 +1,28 @@
+package slices
+
+import (
+	"sort"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestWeightedSlice(t *testing.T) {
+	s := NewWeightedSlice(
+		// initialized pairs.
+		[]int{9}, []float64{3},
+	)
+	s.Append(5, 2)
+	s.Append(1, 3)
+	s.Append(9, 1)
+	s.Append(-1, 6)
+	s.Append(9, 6)
+	s.Append(8, 6)
+	s.Append(7, 6)
+	s.Append(0, 6)
+	s.Append(12, 0)
+
+	exp := []int{-1, 9, 8, 7, 0, 9, 1, 5, 9, 12}
+	got := s.SortFunc(sort.Stable).Slice()
+	assert.Equal(t, exp, got)
+}

collection/unionfind/README.md

@@ -0,0 +1,3 @@
+# Union-Find
+
+Package copied from: <https://github.com/moorara/algo/blob/main/unionfind/unionfind.go>

collection/unionfind/unionfind.go

@@ -0,0 +1,235 @@
+// Package unionfind implements union-find data structures and algorithms.
+// It supports union and find queries.
+//
+// The union-find (a.k.a. disjoint-sets) data type is collection of n elements.
+// Initially, each element belongs to exactly one set (n sets initially).
+// Each set is represented by one element (canonical element, root, identifier, leader, or set representative).
+// The union operation merges the set containing the element p with the set containing the element q.
+// The find operation returns the canonical element of the set containing the element p.
+//
+// Elements in one set are considered connected to each other.
+// "p is connected to q" is an equivalence relation:
+//
+//	Reflexive: p is connected to p.
+//	Symmetric: If p is connected to q, then q is connected to p.
+//	Transitive: If p is connected to q and q is connected to r, then p is connected to r.
+//
+// An equivalence relation partitions the objects into equivalence classes.
+package unionfind
+
+// UnionFind is the interface a union-find data type.
+type UnionFind interface {
+	Union(int, int)
+	Find(int) (int, bool)
+	IsConnected(int, int) bool
+	Count() int
+}
+
+type quickFind struct {
+	count int   // number of components (equivalence classes)
+	id    []int // determines component IDs (class representatives)
+}
+
+// NewQuickFind creates a new union-find data structure with quick find.
+func NewQuickFind(n int) UnionFind {
+	id := make([]int, n)
+	for i := 0; i < n; i++ {
+		id[i] = i
+	}
+
+	return &quickFind{
+		count: n,
+		id:    id,
+	}
+}
+
+func (u *quickFind) isValid(i int) bool {
+	return 0 <= i && i < len(u.id)
+}
+
+func (u *quickFind) Union(p, q int) {
+	if !u.isValid(p) || !u.isValid(q) {
+		return
+	}
+
+	pid, _ := u.Find(p)
+	qid, _ := u.Find(q)
+
+	if pid == qid {
+		return
+	}
+
+	// Rename p's component to q's id
+	for i := range u.id {
+		if u.id[i] == pid {
+			u.id[i] = qid
+		}
+	}
+
+	u.count--
+}
+
+func (u *quickFind) Find(p int) (int, bool) {
+	if !u.isValid(p) {
+		return -1, false
+	}
+
+	return u.id[p], true
+}
+
+func (u *quickFind) IsConnected(p, q int) bool {
+	if !u.isValid(p) || !u.isValid(q) {
+		return false
+	}
+
+	pid, _ := u.Find(p)
+	qid, _ := u.Find(q)
+
+	return pid == qid
+}
+
+func (u *quickFind) Count() int {
+	return u.count
+}
+
+type quickUnion struct {
+	count int   // number of components (equivalence classes)
+	root  []int // determines component parents (class representatives)
+}
+
+// NewQuickUnion creates a new union-find data structure with quick union.
+func NewQuickUnion(n int) UnionFind {
+	root := make([]int, n)
+	for i := 0; i < n; i++ {
+		root[i] = i
+	}
+
+	return &quickUnion{
+		count: n,
+		root:  root,
+	}
+}
+
+func (u *quickUnion) isValid(i int) bool {
+	return 0 <= i && i < len(u.root)
+}
+
+func (u *quickUnion) Union(p, q int) {
+	if !u.isValid(p) || !u.isValid(q) {
+		return
+	}
+
+	proot, _ := u.Find(p)
+	qroot, _ := u.Find(q)
+
+	if proot == qroot {
+		return
+	}
+
+	u.root[proot] = qroot
+	u.count--
+}
+
+func (u *quickUnion) Find(p int) (int, bool) {
+	if !u.isValid(p) {
+		return -1, false
+	}
+
+	for p != u.root[p] {
+		p = u.root[p]
+	}
+
+	return p, true
+}
+
+func (u *quickUnion) IsConnected(p, q int) bool {
+	if !u.isValid(p) || !u.isValid(q) {
+		return false
+	}
+
+	proot, _ := u.Find(p)
+	qroot, _ := u.Find(q)
+
+	return proot == qroot
+}
+
+func (u *quickUnion) Count() int {
+	return u.count
+}
+
+type weightedQuickUnion struct {
+	count int   // number of components (equivalence classes)
+	root  []int // determines component parents (class representatives)
+	size  []int // number of elements in component (class) rooted at i
+}
+
+// NewWeightedQuickUnion creates a new weighted union-find data structure with quick union.
+func NewWeightedQuickUnion(n int) UnionFind {
+	root := make([]int, n)
+	size := make([]int, n)
+	for i := 0; i < n; i++ {
+		root[i] = i
+		size[i] = 1
+	}
+
+	return &weightedQuickUnion{
+		count: n,
+		root:  root,
+		size:  size,
+	}
+}
+
+func (u *weightedQuickUnion) isValid(i int) bool {
+	return 0 <= i && i < len(u.root)
+}
+
+func (u *weightedQuickUnion) Union(p, q int) {
+	if !u.isValid(p) || !u.isValid(q) {
+		return
+	}
+
+	proot, _ := u.Find(p)
+	qroot, _ := u.Find(q)
+
+	if proot == qroot {
+		return
+	}
+
+	// make smaller root point to larger one
+	if u.size[proot] < u.size[qroot] {
+		u.root[proot] = qroot
+		u.size[qroot] += u.size[proot]
+	} else {
+		u.root[qroot] = proot
+		u.size[proot] += u.size[qroot]
+	}
+
+	u.count--
+}
+
+func (u *weightedQuickUnion) Find(p int) (int, bool) {
+	if !u.isValid(p) {
+		return -1, false
+	}
+
+	for p != u.root[p] {
+		p = u.root[p]
+	}
+
+	return p, true
+}
+
+func (u *weightedQuickUnion) IsConnected(p, q int) bool {
+	if !u.isValid(p) || !u.isValid(q) {
+		return false
+	}
+
+	proot, _ := u.Find(p)
+	qroot, _ := u.Find(q)
+
+	return proot == qroot
+}
+
+func (u *weightedQuickUnion) Count() int {
+	return u.count
+}

collection/unionfind/unionfind_test.go

@@ -0,0 +1,374 @@
+package unionfind
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+type (
+	findTest struct {
+		name       string
+		p          int
+		expectedID int
+		expectedOK bool
+	}
+
+	connectivityTest struct {
+		name                string
+		p, q                int
+		expectedIsConnected bool
+	}
+
+	unionFindTest struct {
+		name              string
+		n                 int
+		unions            [][2]int
+		expectedCount     int
+		findTests         []findTest
+		connectivityTests []connectivityTest
+	}
+)
+
+var runTest = func(t *testing.T, tc unionFindTest, uf UnionFind) {
+	for _, u := range tc.unions {
+		uf.Union(u[0], u[1])
+	}
+
+	t.Run("Count", func(t *testing.T) {
+		assert.Equal(t, tc.expectedCount, uf.Count())
+	})
+
+	t.Run("Find", func(t *testing.T) {
+		for _, tc := range tc.findTests {
+			t.Run(tc.name, func(t *testing.T) {
+				id, ok := uf.Find(tc.p)
+				assert.Equal(t, tc.expectedID, id)
+				assert.Equal(t, tc.expectedOK, ok)
+			})
+		}
+	})
+
+	t.Run("IsConnected", func(t *testing.T) {
+		for _, tc := range tc.connectivityTests {
+			t.Run(tc.name, func(t *testing.T) {
+				assert.Equal(t, tc.expectedIsConnected, uf.IsConnected(tc.p, tc.q))
+			})
+		}
+	})
+}
+
+func TestQuickFind(t *testing.T) {
+	tests := []unionFindTest{
+		{
+			name: "OK",
+			n:    10,
+			unions: [][2]int{
+				{-1, -2}, // invalid
+				{0, 1},
+				{2, 3},
+				{2, 4},
+				{3, 4}, // alredy connected
+				{5, 6},
+				{6, 7},
+				{8, 7},
+				{8, 6},   // alredy connected
+				{11, 12}, // invalid
+			},
+			expectedCount: 4,
+			findTests: []findTest{
+				{
+					name:       "Invalid",
+					p:          -1,
+					expectedID: -1,
+					expectedOK: false,
+				},
+				{
+					name:       "First",
+					p:          1,
+					expectedID: 1,
+					expectedOK: true,
+				},
+				{
+					name:       "Second",
+					p:          4,
+					expectedID: 4,
+					expectedOK: true,
+				},
+				{
+					name:       "Third",
+					p:          8,
+					expectedID: 7,
+					expectedOK: true,
+				},
+				{
+					name:       "Fourth",
+					p:          9,
+					expectedID: 9,
+					expectedOK: true,
+				},
+			},
+			connectivityTests: []connectivityTest{
+				{
+					name:                "Invalid",
+					p:                   -1,
+					q:                   11,
+					expectedIsConnected: false,
+				},
+				{
+					name:                "Connected#1",
+					p:                   0,
+					q:                   1,
+					expectedIsConnected: true,
+				},
+				{
+					name:                "Connected#2",
+					p:                   2,
+					q:                   4,
+					expectedIsConnected: true,
+				},
+				{
+					name:                "Connected#3",
+					p:                   6,
+					q:                   8,
+					expectedIsConnected: true,
+				},
+				{
+					name:                "Disconnected#1",
+					p:                   1,
+					q:                   3,
+					expectedIsConnected: false,
+				},
+				{
+					name:                "Disconnected#2",
+					p:                   3,
+					q:                   5,
+					expectedIsConnected: false,
+				},
+				{
+					name:                "Disconnected#3",
+					p:                   7,
+					q:                   9,
+					expectedIsConnected: false,
+				},
+			},
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			uf := NewQuickFind(tc.n)
+			runTest(t, tc, uf)
+		})
+	}
+}
+
+func TestQuickUnion(t *testing.T) {
+	tests := []unionFindTest{
+		{
+			name: "OK",
+			n:    10,
+			unions: [][2]int{
+				{-1, -2}, // invalid
+				{0, 1},
+				{2, 3},
+				{2, 4},
+				{3, 4}, // alredy connected
+				{5, 6},
+				{6, 7},
+				{8, 7},
+				{8, 6},   // alredy connected
+				{11, 12}, // invalid
+			},
+			expectedCount: 4,
+			findTests: []findTest{
+				{
+					name:       "Invalid",
+					p:          -1,
+					expectedID: -1,
+					expectedOK: false,
+				},
+				{
+					name:       "First",
+					p:          1,
+					expectedID: 1,
+					expectedOK: true,
+				},
+				{
+					name:       "Second",
+					p:          4,
+					expectedID: 4,
+					expectedOK: true,
+				},
+				{
+					name:       "Third",
+					p:          8,
+					expectedID: 7,
+					expectedOK: true,
+				},
+				{
+					name:       "Fourth",
+					p:          9,
+					expectedID: 9,
+					expectedOK: true,
+				},
+			},
+			connectivityTests: []connectivityTest{
+				{
+					name:                "Invalid",
+					p:                   -1,
+					q:                   11,
+					expectedIsConnected: false,
+				},
+				{
+					name:                "Connected#1",
+					p:                   0,
+					q:                   1,
+					expectedIsConnected: true,
+				},
+				{
+					name:                "Connected#2",
+					p:                   2,
+					q:                   4,
+					expectedIsConnected: true,
+				},
+				{
+					name:                "Connected#3",
+					p:                   6,
+					q:                   8,
+					expectedIsConnected: true,
+				},
+				{
+					name:                "Disconnected#1",
+					p:                   1,
+					q:                   3,
+					expectedIsConnected: false,
+				},
+				{
+					name:                "Disconnected#2",
+					p:                   3,
+					q:                   5,
+					expectedIsConnected: false,
+				},
+				{
+					name:                "Disconnected#3",
+					p:                   7,
+					q:                   9,
+					expectedIsConnected: false,
+				},
+			},
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			uf := NewQuickUnion(tc.n)
+			runTest(t, tc, uf)
+		})
+	}
+}
+
+func TestWeightedQuickUnion(t *testing.T) {
+	tests := []unionFindTest{
+		{
+			name: "OK",
+			n:    10,
+			unions: [][2]int{
+				{-1, -2}, // invalid
+				{0, 1},
+				{2, 3},
+				{2, 4},
+				{3, 4}, // alredy connected
+				{5, 6},
+				{6, 7},
+				{8, 7},
+				{8, 6},   // alredy connected
+				{11, 12}, // invalid
+			},
+			expectedCount: 4,
+			findTests: []findTest{
+				{
+					name:       "Invalid",
+					p:          -1,
+					expectedID: -1,
+					expectedOK: false,
+				},
+				{
+					name:       "First",
+					p:          1,
+					expectedID: 0,
+					expectedOK: true,
+				},
+				{
+					name:       "Second",
+					p:          4,
+					expectedID: 2,
+					expectedOK: true,
+				},
+				{
+					name:       "Third",
+					p:          8,
+					expectedID: 5,
+					expectedOK: true,
+				},
+				{
+					name:       "Fourth",
+					p:          9,
+					expectedID: 9,
+					expectedOK: true,
+				},
+			},
+			connectivityTests: []connectivityTest{
+				{
+					name:                "Invalid",
+					p:                   -1,
+					q:                   11,
+					expectedIsConnected: false,
+				},
+				{
+					name:                "Connected#1",
+					p:                   0,
+					q:                   1,
+					expectedIsConnected: true,
+				},
+				{
+					name:                "Connected#2",
+					p:                   2,
+					q:                   4,
+					expectedIsConnected: true,
+				},
+				{
+					name:                "Connected#3",
+					p:                   6,
+					q:                   8,
+					expectedIsConnected: true,
+				},
+				{
+					name:                "Disconnected#1",
+					p:                   1,
+					q:                   3,
+					expectedIsConnected: false,
+				},
+				{
+					name:                "Disconnected#2",
+					p:                   3,
+					q:                   5,
+					expectedIsConnected: false,
+				},
+				{
+					name:                "Disconnected#3",
+					p:                   7,
+					q:                   9,
+					expectedIsConnected: false,
+				},
+			},
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			uf := NewWeightedQuickUnion(tc.n)
+			runTest(t, tc, uf)
+		})
+	}
+}

common/bufferpool/bufferpool.go

@@ -0,0 +1,29 @@
+package bufferpool
+
+import (
+	"bytes"
+
+	"github.com/metatube-community/metatube-sdk-go/common/pool"
+)
+
+type BufferPool struct {
+	pool *pool.Pool[*bytes.Buffer]
+}
+
+func New(size int) *BufferPool {
+	return &BufferPool{
+		pool: pool.New(func() *bytes.Buffer {
+			return bytes.NewBuffer(make([]byte, 0, size))
+		}),
+	}
+}
+
+func (bp *BufferPool) Get() *bytes.Buffer {
+	buf := bp.pool.Get()
+	buf.Reset()
+	return buf
+}
+
+func (bp *BufferPool) Put(b *bytes.Buffer) {
+	bp.pool.Put(b)
+}

common/bufferpool/bufferpool_test.go

@@ -0,0 +1,21 @@
+package bufferpool
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestBufferPool(t *testing.T) {
+	const size = 1024
+	bp := New(size)
+	for i := 0; i < 10; i++ {
+		buf := bp.Get()
+		assert.NotNil(t, buf)
+		assert.Equal(t, buf.Len(), 0)
+		assert.GreaterOrEqual(t, buf.Cap(), size)
+		buf.WriteString(strings.Repeat("\x00", size*2))
+		bp.Put(buf)
+	}
+}

common/cluster/group.go

@@ -0,0 +1,42 @@
+package cluster
+
+import (
+	"cmp"
+
+	"github.com/metatube-community/metatube-sdk-go/collection/unionfind"
+)
+
+type Group[T Locatable[T, R], R cmp.Ordered] struct {
+	Items []T
+}
+
+// GroupByDistance partitions a slice of items into proximity-based groups.
+// Any two items whose DistanceTo value is less than or equal to the given
+// threshold are considered to belong to the same group.
+func GroupByDistance[T Locatable[T, R], R cmp.Ordered](items []T, threshold R) []Group[T, R] {
+	n := len(items)
+	uf := unionfind.NewQuickUnion(n)
+
+	for i := 0; i < n; i++ {
+		for j := i + 1; j < n; j++ {
+			if items[i].DistanceTo(items[j]) <= threshold {
+				uf.Union(i, j)
+			}
+		}
+	}
+
+	groupMap := make(map[int][]T)
+	for i := 0; i < n; i++ {
+		root, _ := uf.Find(i)
+		groupMap[root] = append(groupMap[root], items[i])
+	}
+
+	var groups []Group[T, R]
+	for _, group := range groupMap {
+		groups = append(groups, Group[T, R]{
+			Items: group,
+		})
+	}
+
+	return groups
+}

common/cluster/group_test.go

@@ -0,0 +1,56 @@
+package cluster
+
+import (
+	"math"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+var _ WeightedLocatable[weightedPoint, float64, float64] = (*weightedPoint)(nil)
+
+// weightedPoint is a simple 2D point that implements Locatable[weightedPoint].
+type weightedPoint struct {
+	X, Y, W float64
+}
+
+func (a weightedPoint) DistanceTo(b weightedPoint) float64 {
+	dx := a.X - b.X
+	dy := a.Y - b.Y
+	return math.Hypot(dx, dy)
+}
+
+func (a weightedPoint) Weight() float64 {
+	return a.W
+}
+
+func TestGroupByDistanceAndSort(t *testing.T) {
+	points := []weightedPoint{
+		{0.10, 0.10, 1.0},
+		{0.12, 0.10, 1.0},
+		{0.13, 0.12, 2.0},
+		{0.90, 0.90, 3.0},
+		{0.91, 0.93, 3.0},
+		{0.52, 0.90, 5.0},
+	}
+
+	threshold := 0.05
+
+	// Group points by distance.
+	groups := GroupByDistance[weightedPoint, float64](points, threshold)
+
+	// Assert group count.
+	assert.Len(t, groups, 3)
+
+	// Sort groups by size (descending) and verify.
+	SortGroupsBySize(groups)
+	assert.Len(t, groups[0].Items, 3)
+	assert.Len(t, groups[1].Items, 2)
+	assert.Len(t, groups[2].Items, 1)
+
+	// Sort groups by total weight (descending) and verify.
+	SortGroupsByWeight(groups)
+	assert.Len(t, groups[0].Items, 2)
+	assert.Len(t, groups[1].Items, 1)
+	assert.Len(t, groups[2].Items, 3)
+}

common/cluster/locatable.go

@@ -0,0 +1,22 @@
+package cluster
+
+import (
+	"cmp"
+)
+
+// Locatable is a generic interface for any type that can
+// measure distance to another value of the same type.
+type Locatable[T any, R cmp.Ordered] interface {
+	DistanceTo(T) R
+}
+
+// Weighted represents a value that carries a weight.
+type Weighted[W cmp.Ordered] interface {
+	Weight() W
+}
+
+// WeightedLocatable combines both Locatable and Weighted behaviors.
+type WeightedLocatable[T any, R cmp.Ordered, W cmp.Ordered] interface {
+	Locatable[T, R]
+	Weighted[W]
+}

common/cluster/sort.go

@@ -0,0 +1,44 @@
+package cluster
+
+import (
+	"cmp"
+	"slices"
+	"sort"
+
+	weighted "github.com/metatube-community/metatube-sdk-go/collection/slices"
+)
+
+// SortGroupsBySize sorts the provided groups in-place by descending the number of items.
+func SortGroupsBySize[T Locatable[T, R], R cmp.Ordered](groups []Group[T, R]) {
+	sort.SliceStable(groups, func(i, j int) bool {
+		return len(groups[i].Items) > len(groups[j].Items)
+	})
+}
+
+// SortGroupsByWeight sorts the provided groups in descending order of total weight.
+func SortGroupsByWeight[T WeightedLocatable[T, R, W], R cmp.Ordered, W cmp.Ordered](groups []Group[T, R]) {
+	if len(groups) <= 1 {
+		return
+	}
+
+	// group weight calculator.
+	weight := func(group Group[T, R]) W {
+		var sum W
+		for _, item := range group.Items {
+			sum += item.Weight()
+		}
+		return sum
+	}
+
+	// calculate weights for each group.
+	weights := slices.Collect(func(yield func(W) bool) {
+		for _, group := range groups {
+			if !yield(weight(group)) {
+				return
+			}
+		}
+	})
+
+	// weighted stable sort.
+	weighted.NewWeightedSlice(groups, weights).SortFunc(sort.Stable)
+}

common/comparer/compare.go

@@ -0,0 +1,16 @@
+package comparer
+
+import (
+	"github.com/adrg/strutil/metrics"
+)
+
+// Compare returns the similarity between two strings.
+func Compare(a, b string) float64 {
+	m := &metrics.Levenshtein{
+		CaseSensitive: false,
+		InsertCost:    1,
+		DeleteCost:    1,
+		ReplaceCost:   2,
+	}
+	return m.Compare(a, b)
+}

common/comparer/compare_test.go

@@ -0,0 +1,28 @@
+package comparer
+
+import "testing"
+
+func TestCompare(t *testing.T) {
+	for _, unit := range []struct {
+		a, b string
+	}{
+		{"ABP-030", "ABP-030"},
+		{"abp-030", "ABP-030"},
+		{"ABS-030", "ABP-030"},
+		{"AABP-030", "ABP-030"},
+		{"KABP-030", "ABP-030"},
+		{"ABP-030SP", "ABP-030"},
+		{"松下紗栄子", "松下紗栄"},
+		{"松下紗栄子", "松下栄子"},
+		{"つぼみ", "Bae Bom"},
+		{"松下紗栄子", "つぼみ"},
+		{"つ", "つぼみ"},
+		{"木村夏菜子", "木村夏"},
+		{"木村夏菜子", "夏菜子"},
+		{"葵", "葵千恵"},
+		{"葵", "葵千"},
+		{"葵", "葵つかさ"},
+	} {
+		t.Log(unit.a, unit.b, Compare(unit.a, unit.b))
+	}
+}

common/convertor/convert.go

@@ -0,0 +1,11 @@
+package convertor
+
+import (
+	"math"
+)
+
+// ConvertToCentimeters converts feet and inch to cm.
+func ConvertToCentimeters(feet, inches int) int {
+	cm := math.Round(float64(feet*12+inches) * 2.54)
+	return int(cm)
+}

common/convertor/convert_test.go

@@ -0,0 +1,22 @@
+package convertor
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestConvertToCentimeters(t *testing.T) {
+	for _, unit := range []struct {
+		ft, in, cm int
+	}{
+		{5, 5, 165},
+		{5, 6, 168},
+		{5, 7, 170},
+		{5, 8, 173},
+		{5, 9, 175},
+		{5, 10, 178},
+	} {
+		assert.Equal(t, unit.cm, ConvertToCentimeters(unit.ft, unit.in))
+	}
+}

common/convertor/replace.go

@@ -0,0 +1,18 @@
+package convertor
+
+import (
+	"strings"
+	"unicode"
+)
+
+// ReplaceSpaceAll removes all spaces in string.
+func ReplaceSpaceAll(s string) string {
+	var b strings.Builder
+	b.Grow(len(s))
+	for _, c := range s {
+		if !unicode.IsSpace(c) {
+			b.WriteRune(c)
+		}
+	}
+	return b.String()
+}

common/convertor/replace_test.go

@@ -0,0 +1,19 @@
+package convertor
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestReplaceSpaceAll(t *testing.T) {
+	for _, unit := range []struct {
+		origin, expect string
+	}{
+		{"Hello, world!", "Hello,world!"},
+		{"Hello,\tworld!", "Hello,world!"},
+		{"\t\tHe\tllo, \tworld!  \t", "Hello,world!"},
+	} {
+		assert.Equal(t, unit.expect, ReplaceSpaceAll(unit.origin))
+	}
+}

common/fetch/body.go

@@ -0,0 +1,25 @@
+package fetch
+
+import (
+	"bytes"
+	"encoding/json"
+	"io"
+	"net/url"
+	"strings"
+)
+
+func WithJSONBody(v any) io.Reader {
+	buf := &bytes.Buffer{}
+	if err := json.NewEncoder(buf).Encode(v); err != nil {
+		panic(err)
+	}
+	return buf
+}
+
+func WithURLEncodedBody(query map[string]string) io.Reader {
+	v := &url.Values{}
+	for key, value := range query {
+		v.Set(key, value)
+	}
+	return strings.NewReader(v.Encode())
+}

common/fetch/fetch.go

@@ -0,0 +1,167 @@
+package fetch
+
+import (
+	"crypto/tls"
+	"io"
+	"net/http"
+	"net/http/cookiejar"
+	"time"
+
+	"github.com/hashicorp/go-cleanhttp"
+	"github.com/hashicorp/go-retryablehttp"
+
+	"github.com/metatube-community/metatube-sdk-go/common/random"
+	"github.com/metatube-community/metatube-sdk-go/errors"
+)
+
+var DefaultFetcher = Default(&Config{RandomUserAgent: true})
+
+type Config struct {
+	// Set User-Agent Header.
+	UserAgent string
+
+	// Set Referer Header.
+	Referer string
+
+	// Enable cookies.
+	EnableCookies bool
+
+	// Use random User-Agent.
+	RandomUserAgent bool
+
+	// Return error when status is not OK.
+	RaiseForStatus bool
+
+	// HTTP Request timeout.
+	Timeout time.Duration
+
+	// Custom HTTP Transport.
+	Transport http.RoundTripper
+
+	// Skip TLS verification. Applies only
+	// to *http.Transport based transport.
+	SkipVerify bool
+}
+
+type Fetcher struct {
+	client *http.Client
+	config *Config
+}
+
+func New(c *http.Client, cfg *Config) *Fetcher {
+	if cfg.RandomUserAgent {
+		// assign a random user-agent.
+		cfg.UserAgent = random.UserAgent()
+	}
+	if cfg.EnableCookies {
+		jar, _ := cookiejar.New(nil)
+		c.Jar = jar // assign a cookie jar.
+	}
+	return &Fetcher{
+		client: c,
+		config: cfg,
+	}
+}
+
+func Default(cfg *Config) *Fetcher {
+	if cfg == nil /* init if nil */ {
+		cfg = new(Config)
+	}
+	// Enable status check by default.
+	cfg.RaiseForStatus = true
+	// Enable random UA if not set.
+	if cfg.UserAgent == "" {
+		cfg.RandomUserAgent = true
+	}
+	c := &retryablehttp.Client{
+		HTTPClient:   cleanhttp.DefaultPooledClient(),
+		RetryWaitMin: 1 * time.Second,
+		RetryWaitMax: 3 * time.Second,
+		RetryMax:     3,
+		CheckRetry:   retryablehttp.DefaultRetryPolicy,
+		Backoff:      retryablehttp.DefaultBackoff,
+	}
+	if cfg.Timeout > time.Second {
+		c.HTTPClient.Timeout = cfg.Timeout
+	}
+	if cfg.Transport != nil {
+		c.HTTPClient.Transport = cfg.Transport
+	}
+	if cfg.SkipVerify {
+		if transport, ok := c.HTTPClient.Transport.(*http.Transport); ok {
+			if transport.TLSClientConfig == nil {
+				// init TLS config if is nil.
+				transport.TLSClientConfig = &tls.Config{}
+			}
+			transport.TLSClientConfig.InsecureSkipVerify = true
+		}
+	}
+	return New(c.StandardClient(), cfg)
+}
+
+func (f *Fetcher) Fetch(url string) (resp *http.Response, err error) {
+	return f.Get(url)
+}
+
+func (f *Fetcher) Get(url string, opts ...Option) (resp *http.Response, err error) {
+	return f.Request(http.MethodGet, url, nil, opts...)
+}
+
+func (f *Fetcher) Post(url string, body io.Reader, opts ...Option) (resp *http.Response, err error) {
+	return f.Request(http.MethodPost, url, body, opts...)
+}
+
+func (f *Fetcher) Request(method, url string, body io.Reader, opts ...Option) (resp *http.Response, err error) {
+	var req *http.Request
+	if req, err = http.NewRequest(method, url, body); err != nil {
+		return
+	}
+	c := &Context{
+		req:    req,
+		Config: *f.config, /* clone */
+	}
+	// compose options.
+	var options []Option
+	if c.UserAgent != "" {
+		options = append(options, WithUserAgent(c.UserAgent))
+	}
+	if c.Referer != "" {
+		options = append(options, WithReferer(c.Referer))
+	}
+	// apply options.
+	for _, option := range append(options, opts...) {
+		option.apply(c)
+	}
+	// make HTTP request.
+	if resp, err = f.client.Do(req); err != nil {
+		return
+	}
+	if c.RaiseForStatus && resp.StatusCode != http.StatusOK {
+		defer resp.Body.Close()
+		return nil, errors.FromCode(resp.StatusCode)
+	}
+	return
+}
+
+func Fetch(url string) (*http.Response, error) {
+	return DefaultFetcher.Fetch(url)
+}
+
+func Get(url string, opts ...Option) (*http.Response, error) {
+	return DefaultFetcher.Get(url, opts...)
+}
+
+func Post(url string, body io.Reader, opts ...Option) (*http.Response, error) {
+	return DefaultFetcher.Post(url, body, opts...)
+}
+
+func Request(method, url string, body io.Reader, opts ...Option) (*http.Response, error) {
+	return DefaultFetcher.Request(method, url, body, opts...)
+}
+
+var (
+	_ = Fetch
+	_ = Get
+	_ = Post
+	_ = Request
+)

common/fetch/option.go

@@ -0,0 +1,92 @@
+package fetch
+
+import (
+	"net/http"
+
+	"github.com/metatube-community/metatube-sdk-go/common/random"
+)
+
+// Context is used for each request.
+type Context struct {
+	req *http.Request
+	Config
+}
+
+type Option func(*Context)
+
+func (opt Option) apply(c *Context) { opt(c) }
+
+func WithRaiseForStatus(v bool) Option {
+	return func(c *Context) { c.RaiseForStatus = v }
+}
+
+func WithRequest(fn func(req *http.Request)) Option {
+	return func(c *Context) { fn(c.req) }
+}
+
+func WithHeader(key, value string) Option {
+	return WithRequest(func(req *http.Request) {
+		req.Header.Set(key, value)
+	})
+}
+
+func WithHeaders(headers map[string]string) Option {
+	return WithRequest(func(req *http.Request) {
+		for key, value := range headers {
+			req.Header.Set(key, value)
+		}
+	})
+}
+
+func WithReferer(referer string) Option {
+	return WithHeader("Referer", referer)
+}
+
+func WithUserAgent(ua string) Option {
+	return WithHeader("User-Agent", ua)
+}
+
+func WithRandomUserAgent() Option {
+	return WithUserAgent(random.UserAgent())
+}
+
+func WithAuthorization(token string) Option {
+	return WithHeader("Authorization", "Bearer "+token)
+}
+
+func WithBasicAuth(username, password string) Option {
+	return WithRequest(func(req *http.Request) {
+		req.SetBasicAuth(username, password)
+	})
+}
+
+func WithQuery(key, value string) Option {
+	return WithRequest(func(req *http.Request) {
+		q := req.URL.Query()
+		q.Set(key, value)
+		req.URL.RawQuery = q.Encode()
+	})
+}
+
+func WithQueryMap(query map[string]string) Option {
+	return WithRequest(func(req *http.Request) {
+		q := req.URL.Query()
+		for key, value := range query {
+			q.Set(key, value)
+		}
+		req.URL.RawQuery = q.Encode()
+	})
+}
+
+func WithQueryPairs(kv ...string) Option {
+	return WithRequest(func(req *http.Request) {
+		q := req.URL.Query()
+		if len(kv)%2 != 0 {
+			panic("invalid key-value pairs")
+		}
+		for i := 0; i < len(kv); i += 2 {
+			q.Set(kv[i], kv[i+1])
+		}
+		req.URL.RawQuery = q.Encode()
+	})
+}

common/js/js.go

@@ -0,0 +1,30 @@
+package js
+
+import (
+	"encoding/json"
+	"errors"
+
+	"github.com/robertkrimen/otto"
+)
+
+func UnmarshalObject[T ~string | ~[]byte](jsCode T, objName string, i any) error {
+	if len(jsCode) == 0 {
+		return errors.New("empty JS code snippet")
+	}
+
+	vm := otto.New()
+	v, _ := vm.Run(jsCode)
+
+	var err error
+	if objName != "" {
+		v, err = vm.Get(objName)
+		if err != nil {
+			return err
+		}
+	}
+	b, err := v.MarshalJSON()
+	if err != nil {
+		return err
+	}
+	return json.Unmarshal(b, i)
+}

common/js/js_test.go

@@ -0,0 +1,48 @@
+package js
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestUnmarshalObject(t *testing.T) {
+	{
+		data := struct {
+			MovieSeq     string `json:"movie_seq"`
+			Page         int    `json:"page"`
+			Lang         string `json:"lang"`
+			ProviderName string `json:"provider_name"`
+		}{}
+		jsCode := `var object = {movie_seq: '2969', page: 1, type: 'monthly', provider_name: 'heyzo', lang: 'ja'};
+				reviews_get(object);`
+		objName := "object"
+		err := UnmarshalObject(jsCode, objName, &data)
+		assert.NoError(t, err)
+		assert.Equal(t, "2969", data.MovieSeq)
+		assert.Equal(t, 1, data.Page)
+		assert.Equal(t, "ja", data.Lang)
+	}
+
+	{
+		data := struct {
+			Comments []struct {
+				Username string `json:"user_name"`
+			} `json:"comments"`
+		}{}
+		jsCode := `var reviews = {"comments":[{"star":"\u2605?","user_name":"HEY","date":"2023-02-11 18:38:18","comment":"\u30bf\u30c4\u541b\u3001\u3044\u3064\u3082\u306f\u3082\u3063\u3068\u7a4d\u6975\u7684\u306a\u611f\u3058\u306a\u306e\u306b\u4eca\u56de\u306f\u89aa\u53cb\u306e\u5f7c\u5973\u3068\u7d61\u3080\u3068\u3044\u3046\u5f79\u67c4\u8a2d\u5b9a\u304b\u3089\u306a\u306e\u304b\u7a4d\u6975\u6027\u306b\u6b20\u3051\u307e\u3059\u306d\u3002\u306a\u307f\u3061\u3083\u3093\u306f\u7a4d\u6975\u7684\u306a\u5f79\u306a\u306e\u3067\u3001\u306a\u307f\u3061\u3083\u3093\u306b\u305f\u3059\u3051\u3063\u308c\u3066\u3044\u308b\u90e8\u5206\u304c\u5927\u304d\u3044\u304b\u306a\uff1f\u306a\u307f\u3061\u3083\u3093\u306e\u304a\u304b\u3052\u3067\u6e80\u70b9\u3067\u3059\u203c\u3067\u3082\u9732\u51fa\u597d\u304d\u306a\u3089\u3001\u30bf\u30c4\u541b\u304c\u8208\u596e\u3059\u308b\u3088\u3046\u306b\u3082\u3063\u3068\u30a8\u30c3\u30c1\u306a\u6311\u767a\u3057\u306a\u3044\u3068\u306d\u3002","comment_res":"","point_flag":0,"monthly_point_flag":0,"hash":"f0cbd8148980aed6709e52907a9c8b8b","base64":"8MvYFImArt","id":"53627","eng":"0","score":{"overall":"5","quality":"5","content":"5","actress":"5","play":"5","price":"5"},"vote":{"yes":"0","no":"0"}},{"star":"\u2605?","user_name":"\u98a8\u96f2\u5150","date":"2023-01-05 11:45:15","comment":"\u306a\u3093\u304b\u7537\u512a\u304b\u3089\u306e\u8cac\u3081\u3067\u76db\u308a\u4e0a\u304c\u308a\u306b\u6b20\u3051\u308b\u306e\u304c\u6b98\u5ff5\u3002\u5973\u512a\u3055\u3093\u304c\u305f\u3060\u4e00\u751f\u61f8\u547d\u9811\u5f35\u3063\u3066\u308b\u3063\u3066\u611f\u3058\u3002\u3042\u3068\u3001\u3069\u3053\u304c\u300c\u9732\u51fa\u300d\u3060\u3088\uff57\uff57","comment_res":"","point_flag":0,"monthly_point_flag":0,"hash":"ce115f66a3a91e055804734830ba43c8","base64":"zhFfZqOpHg","id":"53477","eng":"0","score":{"overall":"4","quality":"5","content":"5","actress":"5","play":"5","price":"5"},"vote":{"yes":"0","no":"0"}},{"star":"\u2605?","user_name":"\u4e16\u754c\uff11\u4f4d\u306e\u7537","date":"2023-01-03 09:06:15","comment":"\u3053\u308c\u306f\u6587\u53e5\u306a\u3057\u306e\u826f\u4f5c\u3067\u3059\u306d\u3002\u3053\u3093\u306a\u306b\u30a8\u30ed\u304f\u8feb\u3063\u3066\u304f\u308c\u305f\u3089\u3059\u3050\u6483\u6c88\u3057\u305d\u3046\u3067\u3059\u3002","comment_res":"","point_flag":0,"monthly_point_flag":0,"hash":"385f9d684324bec37663651c02b8010d","base64":"OF+daEMkvs","id":"53463","eng":"0","score":{"overall":"5","quality":"5","content":"5","actress":"5","play":"5","price":"5"},"vote":{"yes":"0","no":"0"}},{"star":"\u2605?","user_name":"\u30aa\u30b8\u30b5\u30f3","date":"2023-01-01 13:07:18","comment":"\u5b89\u5ba4\u306a\u307f\u3061\u3083\u3093\u304b\u308f\u3044\u304f\u3066\u5927\u304d\u3081\u306e\u30aa\u30c3\u30d1\u30a4\u306b\u30d7\u30ea\u30f3\u3068\u3057\u305f\u304a\u5c3b\u306e\u30b9\u30ec\u30f3\u30c0\u30fc\u306a\u8eab\u4f53\u3067\u4e00\u672c\u7b4b\u306e\u7f8e\u30de\u30f3\u304c\u3044\u3044\u3067\u3059\u306d\u3002\u4f8b\u3048\u89aa\u53cb\u306e\u5f7c\u5973\u3067\u3042\u3063\u305f\u3068\u3057\u3066\u3082\u306a\u307f\u3061\u3083\u3093\u306e\u65b9\u304b\u3089\u7a4d\u6975\u7684\u306b\u8feb\u3089\u308c\u305f\u3089\u30bb\u30c3\u30af\u30b9\u3057\u306a\u3044\u8a33\u306b\u306f\u3044\u304d\u307e\u305b\u3093\u306d\u3002\u30bf\u30c4\u304f\u3093\u3068\u306e\u604b\u4eba\u540c\u58eb\u306e\u3088\u3046\u306a\u7d61\u307f\u306e\u30bb\u30c3\u30af\u30b9\u3092\u3057\u3066\u3044\u308b\u306a\u307f\u3061\u3083\u3093\u306f\u7f8e\u30dc\u30c7\u30a3\u3082\u76f8\u307e\u3063\u3066\u3068\u3066\u3082\u30ad\u30ec\u30a4\u3067\u7d20\u6575\u3067\u3057\u305f\u3002\u6587\u53e5\u306a\u3057\u306e\u6e80\u70b9\u3067\u3059\u3002","comment_res":"","point_flag":0,"monthly_point_flag":0,"hash":"91cf09fbcca9303e8a4d34775f830fed","base64":"kc8J+8ypMD","id":"53455","eng":"0","score":{"overall":"5","quality":"5","content":"5","actress":"5","play":"5","price":"5"},"vote":{"yes":"0","no":"0"}},{"star":"\u2605?","user_name":"\u6c41\u5973\u512a\u547d","date":"2023-01-01 12:42:16","comment":"\u9a0e\u4e57\u4f4d\u3067\u306e\u7d20\u6674\u3089\u3057\u3044\u8170\u632f\u308a\u3002\u30bd\u30d5\u30a1\u30fc\u3067\uff13\uff10\u5206\u4f4d\u3001\u80cc\u9762\u9a0e\u4e57\u3057\u3066\u308b\u5f71\u50cf\u304c\u3001\u898b\u305f\u3044\u3067\u3059\u3002","comment_res":"","point_flag":0,"monthly_point_flag":0,"hash":"215632e4acfffdabadfc20bad4823cbc","base64":"IVYy5Kz\/\/a","id":"53454","eng":"0","score":{"overall":"5","quality":"5","content":"5","actress":"5","play":"5","price":"5"},"vote":{"yes":"0","no":"0"}},{"star":"\u2605?","user_name":"tsuruman","date":"2023-01-01 07:52:02","comment":"\u5de6\u80a9\u306e\u30bf\u30c8\u30a5\u306f\u3082\u3046\u5c11\u3057\u4e0a\u624b\u304f\u6d88\u305b\u306a\u3044\u306e\u304b\u3057\u3089\u3002\u3053\u308c\u304c\u76ee\u306b\u3064\u3044\u3066\u3001\u3069\u3046\u3057\u3066\u3082\u5b89\u3063\u307d\u3044\u5973\u306b\u898b\u3048\u3061\u3083\u3046\u3002","comment_res":"","point_flag":0,"monthly_point_flag":0,"hash":"bfe6cd26fc89ffbb479d6b4087dd7a2a","base64":"v+bNJvyJ\/7","id":"53453","eng":"0","score":{"overall":"4","quality":"5","content":"5","actress":"5","play":"5","price":"5"},"vote":{"yes":"0","no":"0"}},{"star":"\u2605?","user_name":"nanchun","date":"2023-01-01 02:17:23","comment":"just amazing","comment_res":"","point_flag":0,"monthly_point_flag":0,"hash":"93157bc26dcea2d1a16f28e7816dc07a","base64":"kxV7wm3Oot","id":"53452","eng":"0","score":{"overall":"5","quality":"5","content":"5","actress":"5","play":"5","price":"5"},"vote":{"yes":"0","no":"0"}}],"pages":{"curr":"1","movie_seq":"2969","showall":0,"prev":0,"next":0,"first":0,"last":0,"lang":"ja","n":[1]},"count_ja":7,"count_en":1};`
+		objName := "reviews"
+		err := UnmarshalObject(jsCode, objName, &data)
+		assert.NoError(t, err)
+		assert.Equal(t, "HEY", data.Comments[0].Username)
+	}
+
+	{
+		data := ""
+		jsCode := []byte(`var abc = 'hello'`)
+		objName := "abc"
+		err := UnmarshalObject(jsCode, objName, &data)
+		assert.NoError(t, err)
+		assert.Equal(t, "hello", data)
+	}
+}