Merge pull request 'Add support for Firefox addon / 提供对 Firefox 拓展的支持' (#5) from THR-hub/web:main into main

Reviewed-on: https://git.unlock-music.dev/um/web/pulls/5

.drone.yml

@@ -0,0 +1,25 @@
+---
+kind: pipeline
+type: docker
+name: default
+
+steps:
+  - name: build
+    image: node:16.18-bullseye
+    commands:
+      - apt-get update
+      - apt-get install -y jq zip
+      - npm ci
+      - npm run test
+      - ./scripts/build-and-package.sh legacy
+      - ./scripts/build-and-package.sh extension
+      - ./scripts/build-and-package.sh modern
+
+  - name: upload artifact
+    image: node:16.18-bullseye
+    environment:
+      DRONE_GITEA_SERVER: https://git.unlock-music.dev
+      GITEA_API_KEY:
+        from_secret: GITEA_API_KEY
+    commands:
+      - ./scripts/upload-packages.sh

.github/ISSUE_TEMPLATE/bug-report.md

@@ -1,39 +0,0 @@
----
-name: Bug报告
-about: 报告Bug以帮助改进程序
-title: ''
-labels: bug
-assignees: ''
-
----
-
-* 请按照此模板填写，否则可能立即被关闭
-
-- [x] 我确认已经搜索过Issue不存并确认相同的Issue
-- [x] 我有证据表明这是程序导致的问题（如不确认，可以在[Discussions](https://github.com/ix64/unlock-music/discussions)内提出）
-
-
-**Bug描述**
-
-简要地复述你遇到的Bug
-
-**复现方法**
-
-描述复现方法，必要时请提供样本文件
-
-**程序截图或者Console报错信息**
-
-如果可以请提供二者之一
-
-
-**环境信息:**
-
- - 操作系统和浏览器：
- - 程序版本：
- - 获取音乐文件所使用的客户端及其版本信息：
-
-
-**附加信息**
-
-其他能够帮助确认问题的信息
-

.github/ISSUE_TEMPLATE/new-feature.md

@@ -1,26 +0,0 @@
----
-name: 新功能
-about: 对于程序新的想法或建议
-title: ''
-labels: enhancement
-assignees: ''
-
----
-
-- 请按照此模板填写，否则可能立即被关闭
-
-**背景和说明**
-
-简要说明产生此想法的背景和此想法的具体内容
-
-
-**实现途径**
-
-- 如果没有设计方案，请简要描述实现思路
-- 如果你没有任何的实现思路，请通过[Discussions](https://github.com/ix64/unlock-music/discussions)或者Telegram进行讨论
-
-
-**附加信息**
-
-更多你想要表达的内容
-

.github/workflows/build.yml

@@ -1,74 +0,0 @@
-name: Test Build
-on:
-  push:
-    paths:
-      - "**/*.js"
-      - "**/*.vue"
-      - "public/**/*"
-      - "package-lock.json"
-      - "package.json"
-  pull_request:
-    branches: [ master ]
-    types: [ opened, synchronize, reopened ]
-    paths:
-      - "**/*.js"
-      - "**/*.vue"
-      - "public/**/*"
-      - "package-lock.json"
-      - "package.json"
-
-
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        build: [ legacy, modern ]
-        include:
-          - build: legacy
-            BUILD_ARGS: ""
-            BUILD_EXTENSION: true
-          - build: modern
-            BUILD_ARGS: "-- --modern"
-            BUILD_EXTENSION: false
-    steps:
-      - uses: actions/checkout@v2
-
-      - name: Use Node.js 14.x
-        uses: actions/setup-node@v2
-        with:
-          node-version: "14"
-
-      - name: Install Dependencies
-        run: |
-          npm ci
-          npm run fix-compatibility
-
-      - name: Build
-        env:
-          GZIP: "--best"
-        run: |
-          npm run build ${{ matrix.BUILD_ARGS }}
-          tar -czvf dist.tar.gz -C ./dist .
-
-      - name: Build Extension
-        if: ${{ matrix.BUILD_EXTENSION }}
-        run: |
-          npm run make-extension
-          cd dist
-          zip -rJ9 ../extension.zip *
-          cd ..
-
-      - name: Publish artifact
-        uses: actions/upload-artifact@v2
-        with:
-          name: unlock-music-${{ matrix.build }}.tar.gz
-          path: ./dist.tar.gz
-
-      - name: Publish artifact - Extension
-        if: ${{ matrix.BUILD_EXTENSION }}
-        uses: actions/upload-artifact@v2
-        with:
-          name: extension.zip
-          path: ./extension.zip

.github/workflows/post-release.yml

@@ -1,65 +0,0 @@
-name: Post Release
-on:
-  release:
-    types: [ published ]
-jobs:
-  release-docker:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-
-      - name: Setup vars
-        id: vars
-        env:
-          RELEASE_REF: ${{ github.ref }}
-        run: echo "::set-output name=tag::${RELEASE_REF#refs/tags/}"
-
-      - name: Download release content
-        run: |
-          echo "https://github.com/${{ github.repository }}/releases/download/${{ steps.vars.outputs.tag }}/modern.tar.gz"
-          wget -O modern.tar.gz "https://github.com/${{ github.repository }}/releases/download/${{ steps.vars.outputs.tag }}/modern.tar.gz"
-          mkdir ./dist
-          tar zxf modern.tar.gz -C ./dist
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v1
-
-      - name: Login to DockerHub
-        uses: docker/login-action@v1
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-
-      - name: Build docker and push (on modern)
-        uses: docker/build-push-action@v2
-        with:
-          context: .
-          file: ./Dockerfile
-          platforms: linux/amd64,linux/arm64,linux/386
-          push: true
-          tags: |
-            ix64/unlock-music:latest
-            ix64/unlock-music:${{ steps.vars.outputs.tag }}
-
-  gh-pages:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Setup vars
-        id: vars
-        env:
-          RELEASE_REF: ${{ github.ref }}
-        run: echo "::set-output name=tag::${RELEASE_REF#refs/tags/}"
-
-      - name: Download release content
-        run: |
-          echo "https://github.com/${{ github.repository }}/releases/download/${{ steps.vars.outputs.tag }}/modern.tar.gz"
-          wget -O modern.tar.gz "https://github.com/${{ github.repository }}/releases/download/${{ steps.vars.outputs.tag }}/modern.tar.gz"
-          mkdir ./dist
-          tar zxf modern.tar.gz -C ./dist
-
-      - name: Deploy
-        uses: peaceiris/actions-gh-pages@v3
-        with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          publish_dir: ./dist
-

.github/workflows/release-build.yml

@@ -1,128 +0,0 @@
-name: Build Release
-
-on:
-  push:
-    tags:
-      - "v*"
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-
-      - name: Use Node.js 14.x
-        uses: actions/setup-node@v2
-        with:
-          node-version: "14"
-
-      - name: Install Dependencies
-        run: |
-          npm ci
-          npm run fix-compatibility
-
-      - name: Build Legacy
-        env:
-          GZIP: "--best"
-        run: |
-          npm run build
-          tar -czf legacy.tar.gz -C ./dist .
-          cd dist
-          zip -rJ9 ../legacy.zip *
-          cd ..
-
-      - name: Build Extension (on legacy)
-        env:
-          GZIP: "--best"
-        run: |
-          npm run make-extension
-          cd dist
-          zip -rJ9 ../extension.zip *
-          cd ..
-
-      - name: Build Modern
-        env:
-          GZIP: "--best"
-        run: |
-          npm run build -- --modern
-          tar -czf modern.tar.gz -C ./dist .
-          cd dist
-          zip -rJ9 ../modern.zip *
-          cd ..
-
-      - name: Checksum
-        run: sha256sum *.tar.gz *.zip > sha256sum.txt
-
-      - name: Get current time
-        id: date
-        run: echo "::set-output name=date::$(date +'%Y/%m/%d')"
-
-      - name: Create a Release
-        id: create_release
-        uses: actions/create-release@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          tag_name: ${{ github.ref }}
-          release_name: "Build ${{ steps.date.outputs.date }}"
-          draft: true
-
-      - name: Upload Release Assets - legacy.tar.gz
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: ./legacy.tar.gz
-          asset_name: legacy.tar.gz
-          asset_content_type: application/gzip
-
-      - name: Upload Release Assets - legacy.zip
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: ./legacy.zip
-          asset_name: legacy.zip
-          asset_content_type: application/zip
-
-      - name: Upload Release Assets - modern.tar.gz
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: ./modern.tar.gz
-          asset_name: modern.tar.gz
-          asset_content_type: application/gzip
-
-      - name: Upload Release Assets - modern.zip
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: ./modern.zip
-          asset_name: modern.zip
-          asset_content_type: application/zip
-
-      - name: Upload Release Assets - extension.zip
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: ./extension.zip
-          asset_name: extension.zip
-          asset_content_type: application/zip
-
-      - name: Upload Release Assets - sha256sum.txt
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: ./sha256sum.txt
-          asset_name: sha256sum.txt
-          asset_content_type: text/plain

.gitignore

@@ -1,6 +1,8 @@
 .DS_Store
 node_modules
 /dist
+/build
+/coverage
 
 # local env files
 .env.local
@@ -19,3 +21,14 @@ yarn-error.log*
 *.njsproj
 *.sln
 *.sw?
+
+/src/KgmWasm/build
+/src/KgmWasm/*.js
+/src/KgmWasm/*.wasm
+/src/QmcWasm/build
+/src/QmcWasm/*.js
+/src/QmcWasm/*.wasm
+
+*.zip
+*.tar.gz
+/sha256sum.txt

.gitlab-ci.yml

@@ -0,0 +1,47 @@
+image: node:16
+cache:
+  paths:
+    - node_modules/
+
+stages:          
+  - build
+
+
+build-job:
+  stage: build
+  script: |
+    sed -i 's/deb.debian.org/mirrors.cloud.tencent.com/g' /etc/apt/sources.list
+    apt-get update
+    apt-get -y install zip
+
+    npm config set registry http://mirrors.cloud.tencent.com/npm/
+    npm ci
+
+    npm run build
+    tar -czf legacy.tar.gz -C ./dist .
+    cd dist
+    zip -rJ9 ../legacy.zip *
+    cd ..
+
+    npm run make-extension
+    cd dist
+    zip -rJ9 ../extension.zip *
+    cd ..
+
+    npm run build -- --modern
+    tar -czf modern.tar.gz -C ./dist .
+    cd dist
+    zip -rJ9 ../modern.zip *
+    cd ..
+
+    sha256sum *.tar.gz *.zip > sha256sum.txt
+
+  artifacts:
+    name: "$CI_JOB_NAME"
+    paths:
+      - legacy.zip
+      - legacy.tar.gz
+      - extension.zip
+      - modern.zip
+      - modern.tar.gz
+      - sha256sum.txt

.gitlab/ISSUE_TEMPLATE/bug-crypto-guided.yaml

@@ -0,0 +1,76 @@
+name: 解码错误报告 (填表)
+about: 遇到文件解码失败的问题请选择该项。
+title: '[Bug/Crypto] '
+labels:
+  - bug
+  - crypto
+body:
+  - type: textarea
+    id: what-happened
+    attributes:
+      label: 错误描述
+      description: 请描述你所遇到的问题，以及你期待的行为。
+      placeholder: ''
+      value: ''
+    validations:
+      required: true
+  - type: dropdown
+    id: version
+    attributes:
+      label: Unlock Music 版本
+      description: |
+        能够重现错误的版本，版本号通常在页面底部。
+        如果不确定，请升级到最新版确认问题是否解决。
+      multiple: true
+      options:
+        - 1.10.5 (仓库最新)
+        - 1.10.3 (官方 DEMO)
+        - 其它（请在错误描述中指定）
+    validations:
+      required: true
+  - type: dropdown
+    id: browsers
+    attributes:
+      label: 产生错误的浏览器
+      multiple: true
+      options:
+        - 火狐 / Firefox
+        - Chrome
+        - Safari
+        - 其它基于 Chromium 的浏览器 (Edge、Brave、Opera 等)
+  - type: dropdown
+    id: music-platform
+    attributes:
+      label: 音乐平台
+      description: |
+        如果需要报告多个平台的问题，请每个平台提交一个新的 Issue。
+        请注意：播放器缓存文件不属于该项目支持的文件类型。
+      multiple: false
+      options:
+        - 其它 (请在错误描述指定)
+        - QQ 音乐
+        - Joox (QQ 音乐海外版)
+        - 虾米音乐
+        - 网易云音乐
+        - 酷我音乐
+        - 酷狗音乐
+        - 喜马拉雅
+        - 咪咕 3D
+    validations:
+      required: true
+  - type: textarea
+    id: logs
+    attributes:
+      label: 日志信息
+      description: 如果有，请提供浏览器开发者控制台（Console）的错误日志：
+      render: text
+  - type: checkboxes
+    id: terms
+    attributes:
+      label: 我已经阅读并确认下述内容
+      description: ''
+      options:
+        - label: 我已经检索过 Issue 列表，并确认这是一个为报告过的问题。
+          required: true
+        - label: 我有证据表明这是程序导致的问题（如不确认，可以通过 Telegram 讨论组 (https://t.me/unlock_music_chat) 进行讨论）
+          required: true

.gitlab/ISSUE_TEMPLATE/bug-report.md

@@ -0,0 +1,40 @@
+---
+
+name: "错误报告"
+about: "报告 Bug 以帮助改进程序，非填表。"
+title: "[BUG] "
+labels:
+
+- bug
+
+---
+
+* 请按照此模板填写，否则可能立即被关闭
+
+- [x] 我确认已经搜索过Issue不存并确认相同的Issue
+- [x] 我有证据表明这是程序导致的问题（如不确认，可以通过 Telegram 讨论组 (https://t.me/unlock_music_chat) 进行讨论）
+
+## Bug描述
+
+简要地复述你遇到的Bug
+
+## 复现方法
+
+描述复现方法，必要时请提供样本文件
+
+## 程序截图或浏览器开发者控制台（Console）的报错信息
+
+如果可以请提供二者之一
+
+## 环境信息
+
+ - 操作系统和浏览器：
+ - 程序版本：
+ - 网页版的地址（如果为非官方部署请注明）：
+
+注意：如果需要会员才能获取该资源，你可能也需要作为附件提交。
+
+## 附加信息
+
+如果有，请提供其他能够帮助确认问题的信息到下方：
+

.gitlab/ISSUE_TEMPLATE/new-feature.md

@@ -0,0 +1,29 @@
+---
+
+name: "新功能"
+about: "对于程序新的想法或建议"
+title: "[新功能] "
+labels:
+
+- enhancement
+
+---
+
+<!-- ⚠ 请按照此模板填写，否则可能立即被关闭 -->
+<!-- 提交前请使用【Preview】预览提交的更改 -->
+
+## 背景和说明
+
+<!-- 简要说明产生此想法的背景和此想法的具体内容 -->
+
+
+## 实现途径
+
+- 如果没有设计方案，请简要描述实现思路
+- 如果你没有任何的实现思路，请通过 Telegram 讨论组 (https://t.me/unlock_music_chat) 进行讨论
+
+
+## 附加信息
+
+<!-- 更多你想要表达的内容 -->
+

.npmrc

@@ -0,0 +1 @@
+@unlock-music:registry=https://git.unlock-music.dev/api/packages/um/npm/

.nvmrc

@@ -0,0 +1 @@
+v16.18.1

.prettierrc.js

@@ -0,0 +1,42 @@
+// .prettierrc.js
+module.exports = {
+  // 一行最多 120 字符
+  printWidth: 120,
+  // 使用 2 个空格缩进
+  tabWidth: 2,
+  // 不使用缩进符，而使用空格
+  useTabs: false,
+  // 行尾需要有分号
+  semi: true,
+  // 使用单引号
+  singleQuote: true,
+  // 对象的 key 仅在必要时用引号
+  quoteProps: 'as-needed',
+  // jsx 不使用单引号，而使用双引号
+  jsxSingleQuote: false,
+  // 末尾需要有逗号
+  trailingComma: 'all',
+  // 大括号内的首尾需要空格
+  bracketSpacing: true,
+  // jsx 标签的反尖括号需要换行
+  bracketSameLine: false,
+  // 箭头函数，只有一个参数的时候，也需要括号
+  arrowParens: 'always',
+  // 每个文件格式化的范围是文件的全部内容
+  rangeStart: 0,
+  rangeEnd: Infinity,
+  // 不需要写文件开头的 @prettier
+  requirePragma: false,
+  // 不需要自动在文件开头插入 @prettier
+  insertPragma: false,
+  // 使用默认的折行标准
+  proseWrap: 'preserve',
+  // 根据显示样式决定 html 要不要折行
+  htmlWhitespaceSensitivity: 'css',
+  // vue 文件中的 script 和 style 内不用缩进
+  vueIndentScriptAndStyle: false,
+  // 换行符使用 lf
+  endOfLine: 'lf',
+  // 格式化嵌入的内容
+  embeddedLanguageFormatting: 'auto',
+};

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2019-2020 MengYX
+Copyright (c) 2019-2023 MengYX
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -18,4 +18,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+SOFTWARE.

README.md

@@ -1,55 +1,80 @@
 # Unlock Music 音乐解锁
 
+[![Build Status](https://ci.unlock-music.dev/api/badges/um/web/status.svg)](https://ci.unlock-music.dev/um/web)
+
 - 在浏览器中解锁加密的音乐文件。 Unlock encrypted music file in the browser.
-- unlock-music项目是以学习和技术研究的初衷创建的，修改、再分发时请遵循[License](https://github.com/ix64/unlock-music/blob/master/LICENSE)
-- Unlock Music的CLI版本正在开发中。
-- 我们新建了Telegram群组，欢迎加入！[https://t.me/unlock_music_chat](https://t.me/unlock_music_chat)
-- [CLI版本 Alpha](https://github.com/unlock-music/cli) 大批量转换建议使用CLI版本
-- [相关的其他项目](https://github.com/ix64/unlock-music/wiki/%E5%92%8CUnlockMusic%E7%9B%B8%E5%85%B3%E7%9A%84%E9%A1%B9%E7%9B%AE)
-- ![Release and GitHub Pages](https://github.com/ix64/unlock-music/workflows/Release%20and%20GitHub%20Pages/badge.svg)
+- Unlock Music 项目是以学习和技术研究的初衷创建的，修改、再分发时请遵循[授权协议]。
+- Unlock Music 的 CLI 版本可以在 [unlock-music/cli] 找到，大批量转换建议使用 CLI 版本。
+- 我们新建了 Telegram 群组 [`@unlock_music_chat`] ，欢迎加入！
+- CI 自动构建已经部署，可以在 [um-packages] 下载
+
+> **WARNING**
+> 在本站 fork 不会起到备份的作用，只会浪费服务器储存空间。如无必要请勿 fork 该仓库。
+
+[授权协议]: https://git.unlock-music.dev/um/web/src/branch/master/LICENSE
+[unlock-music/cli]: https://git.unlock-music.dev/um/cli
+[`@unlock_music_chat`]: https://t.me/unlock_music_chat
+[um-packages]: https://git.unlock-music.dev/um/-/packages/generic/web-build/
 
 ## 特性
 
 ### 支持的格式
 
-- [x] QQ音乐 (.qmc0/.qmc2/.qmc3/.qmcflac/.qmcogg/[.tkm](https://github.com/ix64/unlock-music/issues/9))
-  - [x] 写入封面图片
-- [x] Moo音乐格式 ([.bkcmp3/.bkcflac](https://github.com/ix64/unlock-music/issues/11))
-- [x] QQ音乐Tm格式 (.tm0/.tm2/.tm3/.tm6)
-- [x] QQ音乐新格式 (实验性支持)
-  - [x] .mflac
-  - [x] [.mgg](https://github.com/ix64/unlock-music/issues/3)
+- [x] QQ 音乐 (.qmc0/.qmc2/.qmc3/.qmcflac/.qmcogg/.tkm)
+- [x] Moo 音乐格式 (.bkcmp3/.bkcflac/...)
+- [x] QQ 音乐 Tm 格式 (.tm0/.tm2/.tm3/.tm6)
+- [x] QQ 音乐新格式 (.mflac/.mgg/.mflac0/.mgg1/.mggl)
+- [x] <ruby>QQ 音乐海外版<rt>JOOX Music</rt></ruby> (.ofl_en)
 - [x] 网易云音乐格式 (.ncm)
-  - [x] 补全ncm的ID3/FlacMeta信息
-- [x] 虾米音乐格式 (.xm) (测试阶段)
-- [x] 酷我音乐格式 (.kwm) (测试阶段)
-- [x] 酷狗音乐格式 (
-  .kgm) ([CLI版本](https://github.com/ix64/unlock-music/wiki/%E5%85%B6%E4%BB%96%E9%9F%B3%E4%B9%90%E6%A0%BC%E5%BC%8F%E5%B7%A5%E5%85%B7#%E9%85%B7%E7%8B%97%E9%9F%B3%E4%B9%90-kgmvpr%E8%A7%A3%E9%94%81%E5%B7%A5%E5%85%B7))
+- [x] 虾米音乐格式 (.xm)
+- [x] 酷我音乐格式 (.kwm)
+- [x] 酷狗音乐格式 (.kgm/.vpr)
+- [x] Android 版喜马拉雅文件格式 (.x2m/.x3m)
+- [x] 咪咕音乐格式 (.mg3d)
 
 ### 其他特性
 
 - [x] 在浏览器中解锁
 - [x] 拖放文件
-- [x] 在线播放
 - [x] 批量解锁
-- [x] 渐进式Web应用
+- [x] 渐进式 Web 应用 (PWA)
 - [x] 多线程
+- [x] 写入和编辑元信息与专辑封面
 
 ## 使用方法
 
-### 使用已构建版本
+### 使用预构建版本
 
-- 从[GitHub Release](https://github.com/ix64/unlock-music/releases/latest)下载已构建的版本
-  - 本地使用请下载`legacy版本`（`modern版本`只能通过**http/https协议**访问）
+- 从 [Release] 或 [CI 构建][um-packages] 下载预构建的版本
+  - :warning: 本地使用请下载`legacy版本`（`modern版本`只能通过 **http(s)协议** 访问）
 - 解压缩后即可部署或本地使用（**请勿直接运行源代码**）
 
+[release]: https://git.unlock-music.dev/um/web/releases/latest
+
 ### 自行构建
 
 - 环境要求
-  - nodejs
+  - nodejs (v16.x)
   - npm
 
-1. 获取项目源代码后执行 `npm install` 安装相关依赖
-2. 执行 `npm run build` 即可进行构建，构建输出为 dist 目录
-  - `npm run serve` 可用于开发
-3. 如需构建浏览器扩展，build完成后还需要执行`npm run make-extension`
+1. 获取项目源代码后安装相关依赖：
+
+   ```sh
+   npm install
+   npm ci
+   ```
+
+2. 然后进行构建：
+
+   ```sh
+   npm run build
+   ```
+
+   - 构建后的产物可以在 `dist` 目录找到。
+   - 如果是用于开发，可以执行 `npm run serve`。
+
+3. 如需构建浏览器扩展，构建成功后还需要执行：
+
+   ```sh
+   npm run make-extension
+   ```

babel.config.js

@@ -1,6 +1,7 @@
 module.exports = {
     presets: [
-        '@vue/app'
+        '@vue/app',
+        '@babel/preset-typescript'
     ],
     plugins: [
         ["component", {

extension-manifest.json

@@ -1,16 +1,29 @@
 {
-  "manifest_version": 2,
+  "manifest_version": 3,
+  "content_security_policy": {
+    "extension_pages": "script-src 'self' 'wasm-unsafe-eval'; object-src 'self';"
+  },
   "name": "音乐解锁",
   "short_name": "音乐解锁",
   "icons": {
-    "128": "./img/icons/msapplication-icon-144x144.png"
+    "16": "img/icons/favicon-16x16.png",
+    "32": "img/icons/favicon-32x32.png",
+    "192": "img/icons/android-chrome-192x192.png",
+    "512": "img/icons/android-chrome-512x512.png"
   },
   "description": "在任何设备上解锁已购的加密音乐！",
+  "permissions": ["storage"],
   "offline_enabled": true,
-  "options_page": "./index.html",
-  "homepage_url": "https://github.com/ix64/unlock-music",
-  "browser_action": {
+  "options_page": "index.html",
+  "homepage_url": "https://git.unlock-music.dev/um/web",
+  "action": {
+    "default_icon": "img/icons/favicon-32x32.png",
     "default_popup": "./popup.html"
   },
-  "content_security_policy": "script-src 'self' https://stats.ixarea.com; object-src 'self'"
-}
+  "browser_specific_settings": {
+    "gecko": {
+      "id": "addon@unlock-music.dev",
+      "strict_min_version": "128.0"
+    }
+  }
+}

jest.config.js

@@ -0,0 +1,7 @@
+module.exports = {
+  testPathIgnorePatterns: ['/build/', '/dist/', '/node_modules/'],
+  setupFilesAfterEnv: ['./src/__test__/setup_jest.js'],
+  moduleNameMapper: {
+    '@/(.*)': '<rootDir>/src/$1',
+  },
+};

make-extension.js

@@ -1,20 +1,25 @@
-const fs = require('fs')
-const path = require('path')
-const src = "./src/extension/"
-const dst = "./dist"
-fs.readdirSync(src).forEach(file => {
-    let srcPath = path.join(src, file)
-    let dstPath = path.join(dst, file)
-    fs.copyFileSync(srcPath, dstPath)
-    console.log(`Copy: ${srcPath} => ${dstPath}`)
-})
-
-const manifestRaw = fs.readFileSync("./extension-manifest.json", "utf-8")
-const manifest = JSON.parse(manifestRaw)
-
-const pkgRaw = fs.readFileSync("./package.json", "utf-8")
-const pkg = JSON.parse(pkgRaw)
-
-manifest["version"] = pkg["version"]
-fs.writeFileSync("./dist/manifest.json", JSON.stringify(manifest), "utf-8")
-console.log("Write: manifest.json")
+const fs = require('fs')
+const path = require('path')
+const src = __dirname + "/src/extension/"
+const dst = __dirname + "/dist"
+fs.readdirSync(src).forEach(file => {
+    let srcPath = path.join(src, file)
+    let dstPath = path.join(dst, file)
+    fs.copyFileSync(srcPath, dstPath)
+    console.log(`Copy: ${srcPath} => ${dstPath}`)
+})
+
+const manifestRaw = fs.readFileSync(__dirname + "/extension-manifest.json", "utf-8")
+const manifest = JSON.parse(manifestRaw)
+
+const pkgRaw = fs.readFileSync(__dirname + "/package.json", "utf-8")
+const pkg = JSON.parse(pkgRaw)
+
+verExt = pkg["version"]
+if (verExt.startsWith("v")) verExt = verExt.slice(1)
+if (verExt.includes("-")) verExt = verExt.split("-")[0]
+manifest["version"] = `${verExt}.${pkg["ext_build"]}`
+manifest["version_name"] = pkg["version"]
+
+fs.writeFileSync(__dirname + "/dist/manifest.json", JSON.stringify(manifest), "utf-8")
+console.log("Write: manifest.json")

package.json

@@ -1,42 +1,60 @@
 {
   "name": "unlock-music",
-  "version": "1.8.1",
-  "updateInfo": "添加构建为Docker镜像",
+  "version": "1.10.8",
+  "ext_build": 0,
+  "updateInfo": "修正 joox 在远程获取 API 信息出错时不能正确回退到本地元信息获取的错误。",
   "license": "MIT",
   "description": "Unlock encrypted music file in browser.",
   "repository": {
     "type": "git",
-    "url": "https://github.com/ix64/unlock-music"
+    "url": "https://git.unlock-music.dev/um/web"
   },
   "private": true,
   "scripts": {
+    "postinstall": "patch-package",
     "serve": "vue-cli-service serve",
     "build": "vue-cli-service build",
-    "fix-compatibility": "node ./src/fix-compatibility.js",
+    "test": "jest",
+    "pretty": "prettier --write src/{**/*,*}.{js,ts,jsx,tsx,vue}",
+    "pretty:check": "prettier --check src/{**/*,*}.{js,ts,jsx,tsx,vue}",
     "make-extension": "node ./make-extension.js"
   },
   "dependencies": {
+    "@babel/preset-typescript": "^7.16.5",
+    "@unlock-music/joox-crypto": "^0.0.1",
+    "@xhacker/kgmwasm": "^1.0.0",
+    "@xhacker/qmcwasm": "^1.0.0",
     "base64-js": "^1.5.1",
     "browser-id3-writer": "^4.4.0",
-    "core-js": "^3.8.3",
-    "crypto-js": "^4.0.0",
-    "element-ui": "^2.15.0",
-    "iconv-lite": "^0.6.2",
+    "core-js": "^3.16.0",
+    "crypto-js": "^4.1.1",
+    "element-ui": "^2.15.5",
+    "iconv-lite": "^0.6.3",
     "jimp": "^0.16.1",
     "metaflac-js": "^1.0.5",
-    "music-metadata-browser": "^2.2.4",
+    "music-metadata": "7.9.0",
+    "music-metadata-browser": "2.2.7",
     "register-service-worker": "^1.7.2",
-    "vue": "^2.6.12"
+    "threads": "^1.6.5",
+    "vue": "^2.6.14"
   },
   "devDependencies": {
-    "@vue/cli-plugin-babel": "^4.5.11",
-    "@vue/cli-plugin-pwa": "^4.5.11",
-    "@vue/cli-service": "^4.5.11",
+    "@types/crypto-js": "^4.0.2",
+    "@types/jest": "^27.0.3",
+    "@vue/cli-plugin-babel": "^4.5.13",
+    "@vue/cli-plugin-pwa": "^4.5.13",
+    "@vue/cli-plugin-typescript": "^4.5.13",
+    "@vue/cli-service": "^4.5.13",
     "babel-plugin-component": "^1.1.1",
+    "jest": "^27.4.5",
+    "patch-package": "^6.4.7",
+    "prettier": "2.5.1",
+    "sass": "^1.38.1",
+    "sass-loader": "^10.2.0",
+    "semver": "^7.3.5",
+    "threads-plugin": "^1.4.0",
+    "typescript": "^4.5.4",
     "vue-cli-plugin-element": "^1.0.1",
-    "vue-template-compiler": "^2.6.12",
-    "workerize-loader": "^1.3.0",
-    "sass-loader": "^10.1.1",
-    "node-sass": "^5.0.0"
+    "vue-template-compiler": "^2.6.14"
   }
 }

patches/threads+1.7.0.patch

@@ -0,0 +1,11 @@
+diff --git a/node_modules/threads/worker.mjs b/node_modules/threads/worker.mjs
+index c53ac7d..619007b 100644
+--- a/node_modules/threads/worker.mjs
++++ b/node_modules/threads/worker.mjs
+@@ -1,4 +1,5 @@
+-import WorkerContext from "./dist/worker/index.js"
++// Workaround: use of import seems to break minifier.
++const WorkerContext = require("./dist/worker/index.js")
+ 
+ export const expose = WorkerContext.expose
+ export const registerSerializer = WorkerContext.registerSerializer

public/index.html

@@ -1,43 +1,89 @@
 <!DOCTYPE html>
 <html lang="zh-CN">
-<head>
-    <meta charset="utf-8">
-    <meta content="webkit" name="renderer">
-    <meta content="IE=edge,chrome=1" http-equiv="X-UA-Compatible">
-    <meta content="width=device-width,initial-scale=1.0" name="viewport">
+  <head>
+    <meta charset="utf-8" />
+    <meta content="webkit" name="renderer" />
+    <meta content="IE=edge,chrome=1" http-equiv="X-UA-Compatible" />
+    <meta content="width=device-width,initial-scale=1.0" name="viewport" />
     <title>音乐解锁</title>
-    <meta content="音乐,解锁,ncm,qmc,mgg,mflac,qq音乐,网易云音乐,加密" name="keywords"/>
-    <meta content="音乐解锁 - 在任何设备上解锁已购的加密音乐！" name="description"/>
-    <script src="./ixarea-stats.js"></script>
-    <!--@formatter:off-->
-    <style>#loader{position:absolute;left:50%;top:50%;z-index:1010;margin:-75px 0 0 -75px;border:16px solid #f3f3f3;border-radius:50%;border-top:16px solid #1db1ff;width:120px;height:120px;animation:spin 2s linear infinite}@keyframes spin{0%{transform:rotate(0)}100%{transform:rotate(360deg)}}#loader-mask{text-align:center;position:absolute;width:100%;height:100%;bottom:0;left:0;right:0;top:0;z-index:1009;background-color:rgba(242,246,252,.88)}@media (prefers-color-scheme:dark){#loader-mask{color:#fff;background-color:rgba(0,0,0,.85)}#loader-mask a{color:#ddd}#loader-mask a:hover{color:#1db1ff}}#loader-source{font-size:1.5rem}#loader-tips-timeout{font-size:1.2rem}</style>
-    <!--@formatter:on-->
-</head>
-<body>
+    <meta content="音乐,解锁,ncm,qmc,mgg,mflac,qq音乐,网易云音乐,加密" name="keywords" />
+    <meta content="音乐解锁 - 在任何设备上解锁已购的加密音乐！" name="description" />
+    <style>
+      #loader {
+        position: absolute;
+        left: 50%;
+        top: 50%;
+        z-index: 1010;
+        margin: -75px 0 0 -75px;
+        border: 16px solid #f3f3f3;
+        border-radius: 50%;
+        border-top: 16px solid #1db1ff;
+        width: 120px;
+        height: 120px;
+        animation: spin 2s linear infinite;
+      }
+      @keyframes spin {
+        0% {
+          transform: rotate(0);
+        }
+        100% {
+          transform: rotate(360deg);
+        }
+      }
+      #loader-mask {
+        text-align: center;
+        position: absolute;
+        width: 100%;
+        height: 100%;
+        bottom: 0;
+        left: 0;
+        right: 0;
+        top: 0;
+        z-index: 1009;
+        background-color: rgba(242, 246, 252, 0.88);
+      }
+      @media (prefers-color-scheme: dark) {
+        #loader-mask {
+          color: #fff;
+          background-color: rgba(0, 0, 0, 0.85);
+        }
+        #loader-mask a {
+          color: #ddd;
+        }
+        #loader-mask a:hover {
+          color: #1db1ff;
+        }
+      }
+      #loader-source {
+        font-size: 1.5rem;
+      }
+      #loader-tips-timeout {
+        font-size: 1.2rem;
+      }
+    </style>
+  </head>
 
-<div id="loader-mask">
-    <div id="loader"></div>
-    <noscript>
+  <body>
+    <div id="loader-mask">
+      <div id="loader"></div>
+      <noscript>
         <h3 id="loader-js">请启用JavaScript</h3>
-        <img alt=""
-             src="https://stats.ixarea.com/ixarea-stats/report?rec=1&action_name=音乐解锁-NoJS&idsite=2"
-             style="border:0"/>
-    </noscript>
-    <h3 id="loader-source"> 请勿直接运行源代码！ </h3>
-    <div id="loader-tips-outdated" hidden>
-        <h2>您可能在使用不受支持的<span style="color:#f00;">过时</span>浏览器，这可能导致此应用无法正常工作。</h2>
-        <h3>如果您使用双核浏览器，您可以尝试切换到 <span style="color:#f00;">“极速模式”</span> 解决此问题。</h3>
+      </noscript>
+      <h3 id="loader-source">请勿直接运行源代码！</h3>
+      <div id="loader-tips-outdated" hidden>
+        <h2>您可能在使用不受支持的<span style="color: #f00">过时</span>浏览器，这可能导致此应用无法正常工作。</h2>
+        <h3>如果您使用双核浏览器，您可以尝试切换到 <span style="color: #f00">“极速模式”</span> 解决此问题。</h3>
         <h3>或者，您可以尝试更换下方的几个浏览器之一。</h3>
-    </div>
-    <h3 id="loader-tips-timeout" hidden>
+      </div>
+      <h3 id="loader-tips-timeout" hidden>
         音乐解锁采用了一些新特性！建议使用
         <a href="https://www.microsoft.com/zh-cn/edge" target="_blank">Microsoft Edge Chromium</a>
         <a href="https://www.google.cn/chrome/" target="_blank">Google Chrome</a>
         <a href="https://www.firefox.com.cn/" target="_blank">Mozilla Firefox</a>
-        | <a href="https://github.com/ix64/unlock-music/wiki/使用提示" target="_blank">使用提示</a>
-    </h3>
-</div>
-<div id="app"></div>
-<script src="./loader.js"></script>
-</body>
+        | <a href="https://git.unlock-music.dev/um/web/wiki/使用提示" target="_blank">使用提示</a>
+      </h3>
+    </div>
+    <div id="app"></div>
+    <script src="./loader.js"></script>
+  </body>
 </html>

public/ixarea-stats.js

@@ -1,10 +0,0 @@
-var _paq = window._paq || [];
-_paq.push(["setRequestMethod", "POST"], ["trackPageView"], ["enableLinkTracking"],
-    ["setSiteId", "2"], ["setTrackerUrl", "https://stats.ixarea.com/ixarea-stats/report"]);
-
-var tag = document.createElement('script');
-tag.type = 'text/javascript';
-tag.async = true;
-tag.src = 'https://stats.ixarea.com/ixarea-stats.js';
-var s = document.getElementsByTagName('script')[0];
-s.parentNode.insertBefore(tag, s);

scripts/build-and-package.sh

@@ -0,0 +1,29 @@
+#!/bin/sh
+
+set -ex
+
+cd "$(git rev-parse --show-toplevel)"
+
+VERSION="$(jq -r ".version" <package.json)"
+DIST_NAME="um-web.$1.v${VERSION}"
+
+case "$1" in
+"modern") npm run build -- --modern ;;
+"legacy") npm run build ;;
+"extension") npm run make-extension ;;
+
+*)
+  echo "Unknown command: $1"
+  exit 1
+  ;;
+esac
+
+mv dist "${DIST_NAME}"
+zip -rJ9 "${DIST_NAME}.zip" "${DIST_NAME}"
+
+if [ "$1" = "legacy" ]; then
+  # For upcoming extension build
+  mv "${DIST_NAME}" dist
+else
+  rm -rf "${DIST_NAME}"
+fi

scripts/upload-packages.sh

@@ -0,0 +1,19 @@
+#!/bin/sh
+
+set -ex
+
+cd "$(git rev-parse --show-toplevel)"
+
+if [ -z "$GITEA_API_KEY" ]; then
+  echo "GITEA_API_KEY is empty, skip upload."
+  exit 0
+fi
+
+URL_BASE="$DRONE_GITEA_SERVER/api/packages/${DRONE_REPO_NAMESPACE}/generic/${DRONE_REPO_NAME}-build"
+
+for ZIP_NAME in *.zip; do
+  UPLOAD_URL="${URL_BASE}/${DRONE_BUILD_NUMBER}/${ZIP_NAME}"
+  sha256sum "${ZIP_NAME}"
+  curl -sLifu "um-release-bot:$GITEA_API_KEY" -T "${ZIP_NAME}" "${UPLOAD_URL}"
+  echo "Uploaded to: ${UPLOAD_URL}"
+done

src/App.vue

@@ -1,184 +1,94 @@
 <template>
-
-    <el-container id="app">
-        <el-main>
-            <x-upload v-on:handle_error="showFail" v-on:handle_finish="showSuccess"></x-upload>
-
-            <div id="app-control">
-                <el-row class="mb-3">
-                    <span>歌曲命名格式：</span>
-                    <el-radio label="1" name="format" v-model="download_format">歌手-歌曲名</el-radio>
-                    <el-radio label="2" name="format" v-model="download_format">歌曲名</el-radio>
-                    <el-radio label="3" name="format" v-model="download_format">歌曲名-歌手</el-radio>
-                    <el-radio label="4" name="format" v-model="download_format">同原文件名</el-radio>
-                </el-row>
-                <el-row>
-                    <el-button @click="handleDownloadAll" icon="el-icon-download" plain>下载全部</el-button>
-                    <el-button @click="handleDeleteAll" icon="el-icon-delete" plain type="danger">清除全部</el-button>
-
-                    <el-tooltip class="item" effect="dark" placement="top-start">
-                        <div slot="content">
-                            当您使用此工具进行大量文件解锁的时候，建议开启此选项。<br/>
-                            开启后，解锁结果将不会存留于浏览器中，防止内存不足。
-                        </div>
-                        <el-checkbox border class="ml-2" v-model="instant_download">立即保存</el-checkbox>
-                    </el-tooltip>
-                </el-row>
-            </div>
-
-            <audio :autoplay="playing_auto" :src="playing_url" controls/>
-
-            <x-preview :download_format="download_format" :table-data="tableData"
-                       v-on:music_changed="changePlaying"></x-preview>
-
-        </el-main>
-        <el-footer id="app-footer">
-            <el-row>
-                <a href="https://github.com/ix64/unlock-music" target="_blank">音乐解锁</a>(v<span
-                    v-text="version"></span>)：移除已购音乐的加密保护。
-                <a href="https://github.com/ix64/unlock-music/wiki/使用提示" target="_blank">使用提示</a>
-            </el-row>
-            <el-row>
-                目前支持网易云音乐(ncm), QQ音乐(qmc, mflac, mgg), 酷狗音乐(kgm), 虾米音乐(xm), 酷我音乐(.kwm)
-                <a href="https://github.com/ix64/unlock-music/blob/master/README.md" target="_blank">更多</a>。
-            </el-row>
-            <el-row>
-                <!--如果进行二次开发，此行版权信息不得移除且应明显地标注于页面上-->
-                <span>Copyright &copy; 2019-</span><span v-text="(new Date()).getFullYear()"></span> MengYX
-                音乐解锁使用
-                <a href="https://github.com/ix64/unlock-music/blob/master/LICENSE" target="_blank">MIT许可协议</a>
-                开放源代码
-            </el-row>
-        </el-footer>
-    </el-container>
-
+  <el-container id="app">
+    <el-main>
+      <Home />
+    </el-main>
+    <el-footer id="app-footer">
+      <div>
+        <a href="https://git.unlock-music.dev/um/web" target="_blank">音乐解锁</a>({{ version }})
+        ：移除已购音乐的加密保护。
+        <a href="https://git.unlock-music.dev/um/web/wiki/使用提示" target="_blank">使用提示</a>
+      </div>
+      <div>
+        目前支持 网易云音乐(ncm), QQ音乐(qmc, mflac, mgg), 酷狗音乐(kgm), 虾米音乐(xm), 酷我音乐(.kwm)
+        <a href="https://git.unlock-music.dev/um/web/src/branch/master/README.md" target="_blank">更多</a>。
+      </div>
+      <div>
+        <!--如果进行二次开发，此行版权信息不得移除且应明显地标注于页面上-->
+        <span>Copyright &copy; 2019 - {{ new Date().getFullYear() }} MengYX</span>
+        音乐解锁使用
+        <a href="https://git.unlock-music.dev/um/web/src/branch/master/LICENSE" target="_blank">MIT许可协议</a>
+        开放源代码
+      </div>
+    </el-footer>
+  </el-container>
 </template>
 
 <script>
+import FileSelector from '@/component/FileSelector';
+import PreviewTable from '@/component/PreviewTable';
+import config from '@/../package.json';
+import Home from '@/view/Home';
+import { checkUpdate } from '@/utils/api';
 
-    import upload from "./component/upload"
-    import preview from "./component/preview"
-    import {DownloadBlobMusic, RemoveBlobMusic} from "./component/util"
-    import config from "../package"
-    import {IXAREA_API_ENDPOINT} from "./decrypt/util";
-
-    export default {
-        name: 'app',
-        components: {
-            xUpload: upload,
-            xPreview: preview
-        },
-        data() {
-            return {
-                version: config.version,
-                activeIndex: '1',
-                tableData: [],
-                playing_url: "",
-                playing_auto: false,
-                download_format: '1',
-                instant_download: false,
-            }
-        },
-        created() {
-            this.$nextTick(function () {
-                this.finishLoad();
-            });
-        },
-        methods: {
-            async finishLoad() {
-                const mask = document.getElementById("loader-mask");
-                if (!!mask) mask.remove();
-                let updateInfo;
-                try {
-                    const resp = await fetch(IXAREA_API_ENDPOINT + "/music/app-version", {
-                        method: "POST", headers: {"Content-Type": "application/json"},
-                        body: JSON.stringify({"Version": this.version})
-                    });
-                    updateInfo = await resp.json();
-                } catch (e) {
-                }
-                if ((!!updateInfo && process.env.NODE_ENV === 'production') && (!!updateInfo.HttpsFound ||
-                    (!!updateInfo.Found && window.location.protocol !== "https:"))) {
-                  this.$notify.warning({
-                    title: '发现更新',
-                    message: '发现新版本 v' + updateInfo.Version +
-                        '<br/>更新详情：' + updateInfo.Detail +
-                        '<br/><a target="_blank" href="' + updateInfo.URL + '">获取更新</a>',
-                    dangerouslyUseHTMLString: true,
-                    duration: 15000,
-                    position: 'top-left'
-                  });
-                } else {
-                    this.$notify.info({
-                        title: '离线使用',
-                        message: '我们使用PWA技术，无网络也能使用' +
-                            '<br/>最近更新：' + config.updateInfo +
-                            '<br/><a target="_blank" href="https://github.com/ix64/unlock-music/wiki/使用提示">使用提示</a>',
-                        dangerouslyUseHTMLString: true,
-                        duration: 10000,
-                        position: 'top-left'
-                    });
-                }
-            },
-            showSuccess(data) {
-                if (data.status) {
-                    if (this.instant_download) {
-                        DownloadBlobMusic(data, this.download_format);
-                        RemoveBlobMusic(data);
-                    } else {
-                        this.tableData.push(data);
-                        this.$notify.success({
-                            title: '解锁成功',
-                            message: '成功解锁 ' + data.title,
-                            duration: 3000
-                        });
-                    }
-                    if (process.env.NODE_ENV === 'production') {
-                        let _rp_data = [data.title, data.artist, data.album];
-                        window._paq.push(["trackEvent", "Unlock", data.rawExt + "," + data.mime, JSON.stringify(_rp_data)]);
-                    }
-                } else {
-                    this.showFail(data.message, data.rawFilename + "." + data.rawExt)
-                }
-            },
-            showFail(errInfo, filename) {
-                this.$notify.error({
-                    title: '出现问题',
-                    message: errInfo + "，" + filename +
-                        '，参考<a target="_blank" href="https://github.com/ix64/unlock-music/wiki/使用提示">使用提示</a>',
-                    dangerouslyUseHTMLString: true,
-                    duration: 6000
-                });
-                if (process.env.NODE_ENV === 'production') {
-                    window._paq.push(["trackEvent", "Error", errInfo, filename]);
-                }
-                console.error(errInfo, filename);
-            },
-            changePlaying(url) {
-                this.playing_url = url;
-                this.playing_auto = true;
-            },
-            handleDeleteAll() {
-                this.tableData.forEach(value => {
-                    RemoveBlobMusic(value);
-                });
-                this.tableData = [];
-            },
-            handleDownloadAll() {
-                let index = 0;
-                let c = setInterval(() => {
-                    if (index < this.tableData.length) {
-                        DownloadBlobMusic(this.tableData[index], this.download_format);
-                        index++;
-                    } else {
-                        clearInterval(c);
-                    }
-                }, 300);
-            }
-        },
-    }
+export default {
+  name: 'app',
+  components: {
+    FileSelector,
+    PreviewTable,
+    Home,
+  },
+  data() {
+    return {
+      version: config.version,
+    };
+  },
+  created() {
+    this.$nextTick(() => this.finishLoad());
+  },
+  methods: {
+    async finishLoad() {
+      const mask = document.getElementById('loader-mask');
+      if (!!mask) mask.remove();
+      let updateInfo;
+      try {
+        updateInfo = await checkUpdate(this.version);
+      } catch (e) {
+        console.warn('check version info failed', e);
+      }
+      if (
+        updateInfo &&
+        process.env.NODE_ENV === 'production' &&
+        (updateInfo.HttpsFound || (updateInfo.Found && window.location.protocol !== 'https:'))
+      ) {
+        this.$notify.warning({
+          title: '发现更新',
+          message: `发现新版本 v${updateInfo.Version}<br/>更新详情：${updateInfo.Detail}<br/> <a target="_blank" href="${updateInfo.URL}">获取更新</a>`,
+          dangerouslyUseHTMLString: true,
+          duration: 15000,
+          position: 'top-left',
+        });
+      } else {
+        this.$notify.info({
+          title: '离线使用',
+          message: `<div>
+                        <p>我们使用 PWA 技术，无网络也能使用</p>
+                        <div class="update-info">
+                            <div class="update-title">最近更新</div>
+                            <div class="update-content"> ${config.updateInfo} </div>
+                        </div>
+                        <a target="_blank" href="https://git.unlock-music.dev/um/web/wiki/使用提示">使用提示</a>
+                    </div>`,
+          dangerouslyUseHTMLString: true,
+          duration: 10000,
+          position: 'top-left',
+        });
+      }
+    },
+  },
+};
 </script>
 
 <style lang="scss">
-   @import "scss/unlock-music";
+@import 'scss/unlock-music';
 </style>

src/__test__/setup_jest.js

@@ -0,0 +1,2 @@
+// Polyfill for node.
+global.Blob = global.Blob || require("node:buffer").Blob;

src/component/ConfigDialog.vue

@@ -0,0 +1,105 @@
+<style scoped>
+label {
+  cursor: pointer;
+  line-height: 1.2;
+  display: block;
+}
+
+form >>> input {
+  font-family: 'Courier New', Courier, monospace;
+}
+
+* >>> .um-config-dialog {
+  max-width: 90%;
+  width: 40em;
+}
+</style>
+
+<template>
+  <el-dialog @close="cancel()" title="解密设定" :visible="show" custom-class="um-config-dialog" center>
+    <el-form ref="form" :rules="rules" status-icon :model="form" label-width="0">
+      <section>
+        <label>
+          <span>
+            JOOX Music ·
+            <Ruby caption="Unique Device Identifier">设备唯一识别码</Ruby>
+          </span>
+          <el-form-item prop="jooxUUID">
+            <el-input type="text" v-model="form.jooxUUID" clearable maxlength="32" show-word-limit> </el-input>
+          </el-form-item>
+        </label>
+
+        <p class="tip">
+          下载该加密文件的 JOOX 应用所记录的设备唯一识别码。
+          <br />
+          参见：
+          <a
+            href="https://git.unlock-music.dev/um/joox-crypto/wiki/%E8%8E%B7%E5%8F%96%E8%AE%BE%E5%A4%87-UUID#%E5%89%8D%E8%A8%80"
+          >
+            获取设备 UUID · unlock-music/joox-crypto Wiki</a
+          >。
+        </p>
+      </section>
+    </el-form>
+    <span slot="footer" class="dialog-footer">
+      <el-button type="primary" :loading="saving" @click="emitConfirm()">确 定</el-button>
+    </span>
+  </el-dialog>
+</template>
+
+<script>
+import { storage } from '@/utils/storage';
+import Ruby from './Ruby';
+
+// FIXME: 看起来不会触发这个验证提示？
+function validateJooxUUID(rule, value, callback) {
+  if (!value || !/^[\da-fA-F]{32}$/.test(value)) {
+    callback(new Error('无效的 Joox UUID，请参考 Wiki 获取。'));
+  } else {
+    callback();
+  }
+}
+
+const rules = {
+  jooxUUID: { validator: validateJooxUUID, trigger: 'change' },
+};
+
+export default {
+  components: {
+    Ruby,
+  },
+  props: {
+    show: { type: Boolean, required: true },
+  },
+  data() {
+    return {
+      rules,
+      saving: false,
+      form: {
+        jooxUUID: '',
+      },
+      centerDialogVisible: false,
+    };
+  },
+  async mounted() {
+    await this.resetForm();
+  },
+  methods: {
+    async resetForm() {
+      this.form.jooxUUID = await storage.loadJooxUUID();
+    },
+
+    async cancel() {
+      await this.resetForm();
+      this.$emit('done');
+    },
+
+    async emitConfirm() {
+      this.saving = true;
+      await storage.saveJooxUUID(this.form.jooxUUID);
+      this.saving = false;
+      this.$emit('done');
+    },
+  },
+};
+</script>

src/component/EditDialog.vue

@@ -0,0 +1,163 @@
+<style scoped>
+* >>> .um-edit-dialog {
+  max-width: 90%;
+  width: 30em;
+}
+</style>
+
+<template>
+  <el-dialog @close="cancel()" title="音乐标签编辑" :visible="show" custom-class="um-edit-dialog" center>
+    <el-form ref="form" status-icon :model="form" label-width="0">
+      <section>
+        <div class="music-cover">
+          <el-image v-show="!editPicture" :src="imgFile.url || picture">
+            <div slot="error" class="image-slot el-image__error">暂无封面</div>
+          </el-image>
+          <el-upload v-show="editPicture" :auto-upload="false" :on-change="addFile" :on-remove="rmvFile" :show-file-list="true" :limit="1" list-type="picture" action="" drag>
+            <i class="el-icon-upload" />
+            <div class="el-upload__text">将新图片拖到此处，或<em>点击选择</em><br />以替换自动匹配的图片</div>
+            <div slot="tip" class="el-upload__tip">
+              新拖到此处的图片将覆盖原始图片
+            </div>
+          </el-upload>
+          <i :class="{'el-icon-edit': !editPicture, 'el-icon-check': editPicture}"
+               @click="changeCover"></i>
+        </div>
+
+        <div class="edit-item">
+          <div class="label">标题</div>
+          <div class="value" v-show="!editTitle">{{title}}</div>
+          <el-input class="input" size="small" v-show="editTitle" v-model="title"/>
+          <i :class="{'el-icon-edit': !editTitle, 'el-icon-check': editTitle}"
+             @click="editTitle = !editTitle"/>
+        </div>
+        <div class="edit-item">
+          <div class="label">艺术家</div>
+          <div class="value" v-show="!editArtist">{{artist}}</div>
+          <el-input class="input" size="small" v-show="editArtist" v-model="artist"/>
+          <i :class="{'el-icon-edit': !editArtist, 'el-icon-check': editArtist}"
+             @click="editArtist = !editArtist"
+          />
+        </div>
+        <div class="edit-item">
+          <div class="label">专辑</div>
+          <div class="value" v-show="!editAlbum">{{album}}</div>
+          <el-input class="input" size="small" v-show="editAlbum" v-model="album"/>
+          <i :class="{'el-icon-edit': !editAlbum, 'el-icon-check': editAlbum}"
+             @click="editAlbum = !editAlbum"
+          />
+        </div>
+        <div class="edit-item">
+          <div class="label">专辑艺术家</div>
+          <div class="value" v-show="!editAlbumartist">{{albumartist}}</div>
+          <el-input class="input" size="small" v-show="editAlbumartist" v-model="albumartist"/>
+          <i :class="{'el-icon-edit': !editAlbumartist, 'el-icon-check': editAlbumartist}"
+             @click="editAlbumartist = !editAlbumartist"
+          />
+        </div>
+        <div class="edit-item">
+          <div class="label">风格</div>
+          <div class="value" v-show="!editGenre">{{genre}}</div>
+          <el-input class="input" size="small" v-show="editGenre" v-model="genre"/>
+          <i :class="{'el-icon-edit': !editGenre, 'el-icon-check': editGenre}"
+             @click="editGenre = !editGenre"
+          />
+        </div>
+
+        <p class="tip">
+          为了节省您设备的资源，请在确定前充分检查，避免反复修改。<br />
+          直接关闭此对话框不会保留所作的更改。
+        </p>
+      </section>
+    </el-form>
+    <span slot="footer" class="dialog-footer">
+      <el-button type="primary" @click="emitConfirm()">确 定</el-button>
+    </span>
+  </el-dialog>
+</template>
+
+<script>
+import Ruby from './Ruby';
+
+export default {
+  components: {
+    Ruby,
+  },
+  props: {
+    show: { type: Boolean, required: true },
+    picture: { type: String | undefined, required: true },
+    title: { type: String | undefined, required: true },
+    artist: { type: String | undefined, required: true },
+    album: { type: String | undefined, required: true },
+    albumartist: { type: String | undefined, required: true },
+    genre: { type: String | undefined, required: true },
+  },
+  data() {
+    return {
+      form: {
+      },
+      imgFile: { tmpblob: undefined, blob: undefined, url: undefined },
+      editPicture: false,
+      editTitle: false,
+      editArtist: false,
+      editAlbum: false,
+      editAlbumartist: false,
+      editGenre: false,
+    };
+  },
+  async mounted() {
+    this.refreshForm();
+  },
+  methods: {
+    addFile(file) {
+      this.imgFile.tmpblob = file.raw;
+    },
+    rmvFile() {
+      this.imgFile.tmpblob = undefined;
+    },
+    changeCover() {
+      this.editPicture = !this.editPicture;
+      if (!this.editPicture && this.imgFile.tmpblob) {
+        this.imgFile.blob = this.imgFile.tmpblob;
+        if (this.imgFile.url) {
+          URL.revokeObjectURL(this.imgFile.url);
+        }
+        this.imgFile.url = URL.createObjectURL(this.imgFile.blob);
+      }
+    },
+
+    async refreshForm() {
+      if (this.imgFile.url) {
+        URL.revokeObjectURL(this.imgFile.url);
+      }
+      this.imgFile = { tmpblob: undefined, blob: undefined, url: undefined };
+      this.editPicture = false;
+      this.editTitle = false;
+      this.editArtist = false;
+      this.editAlbum = false;
+      this.editAlbumartist = false;
+      this.editGenre = false;
+    },
+    async cancel() {
+      this.refreshForm();
+      this.$emit('cancel');
+    },
+    async emitConfirm() {
+      if (this.editPicture) {
+        this.changeCover();
+      }
+      if (this.imgFile.url) {
+        URL.revokeObjectURL(this.imgFile.url);
+      }
+      this.$emit('ok', {
+        picture: this.imgFile.blob,
+        title: this.title,
+        artist: this.artist,
+        album: this.album,
+        albumartist: this.albumartist,
+        genre: this.genre,
+      });
+    },
+  },
+};
+</script>

src/component/FileSelector.vue

@@ -0,0 +1,91 @@
+<template>
+  <el-upload :auto-upload="false" :on-change="addFile" :show-file-list="false" action="" drag multiple>
+    <i class="el-icon-upload" />
+    <div class="el-upload__text">将文件拖到此处，或 <em>点击选择</em></div>
+    <div slot="tip" class="el-upload__tip">
+      <div>
+        仅在浏览器内对文件进行解锁，无需消耗流量
+        <el-tooltip effect="dark" placement="top-start">
+          <div slot="content">算法在源代码中已经提供，所有运算都发生在本地</div>
+          <i class="el-icon-info" style="font-size: 12px" />
+        </el-tooltip>
+      </div>
+      <div>
+        工作模式: {{ parallel ? '多线程 Worker' : '单线程 Queue' }}
+        <el-tooltip effect="dark" placement="top-start">
+          <div slot="content">
+            将此工具部署在HTTPS环境下，可以启用Web Worker特性，<br />
+            从而更快的利用并行处理完成解锁
+          </div>
+          <i class="el-icon-info" style="font-size: 12px" />
+        </el-tooltip>
+      </div>
+    </div>
+    <transition name="el-fade-in"
+      ><!--todo: add delay to animation-->
+      <el-progress
+        v-show="progress_show"
+        :format="progress_string"
+        :percentage="progress_value"
+        :stroke-width="16"
+        :text-inside="true"
+        style="margin: 16px 6px 0 6px"
+      ></el-progress>
+    </transition>
+  </el-upload>
+</template>
+
+<script>
+import { spawn, Worker, Pool } from 'threads';
+import { Decrypt } from '@/decrypt';
+import { DecryptQueue } from '@/utils/utils';
+import { storage } from '@/utils/storage';
+
+export default {
+  name: 'FileSelector',
+  data() {
+    return {
+      task_all: 0,
+      task_finished: 0,
+      queue: new DecryptQueue(), // for http or file protocol
+      parallel: false,
+    };
+  },
+  computed: {
+    progress_value() {
+      return this.task_all ? (this.task_finished / this.task_all) * 100 : 0;
+    },
+    progress_show() {
+      return this.task_all !== this.task_finished;
+    },
+  },
+  mounted() {
+    if (window.Worker && window.location.protocol !== 'file:' && process.env.NODE_ENV === 'production') {
+      console.log('Using Worker Pool');
+      this.queue = Pool(() => spawn(new Worker('@/utils/worker.ts')), navigator.hardwareConcurrency || 1);
+      this.parallel = true;
+    } else {
+      console.log('Using Queue in Main Thread');
+    }
+  },
+  methods: {
+    progress_string() {
+      return `${this.task_finished} / ${this.task_all}`;
+    },
+    async addFile(file) {
+      this.task_all++;
+      this.queue.queue(async (dec = Decrypt) => {
+        console.log('start handling', file.name);
+        try {
+          this.$emit('success', await dec(file, await storage.getAll()));
+        } catch (e) {
+          console.error(e);
+          this.$emit('error', e, file.name);
+        } finally {
+          this.task_finished++;
+        }
+      });
+    },
+  },
+};
+</script>

src/component/PreviewTable.vue

@@ -0,0 +1,66 @@
+<template>
+  <el-table :data="tableData" style="width: 100%">
+    <el-table-column label="封面">
+      <template slot-scope="scope">
+        <el-image :src="scope.row.picture" style="width: 100px; height: 100px">
+          <div slot="error" class="image-slot el-image__error">暂无封面</div>
+        </el-image>
+      </template>
+    </el-table-column>
+    <el-table-column label="歌曲">
+      <template #default="scope">
+        <p>{{ scope.row.title }}</p>
+      </template>
+    </el-table-column>
+    <el-table-column label="歌手">
+      <template #default="scope">
+        <p>{{ scope.row.artist }}</p>
+      </template>
+    </el-table-column>
+    <el-table-column label="专辑">
+      <template #default="scope">
+        <p>{{ scope.row.album }}</p>
+      </template>
+    </el-table-column>
+    <el-table-column label="操作">
+      <template #default="scope">
+        <el-button circle icon="el-icon-video-play" type="success" @click="handlePlay(scope.$index, scope.row)">
+        </el-button>
+        <el-button circle icon="el-icon-download" @click="handleDownload(scope.row)"></el-button>
+        <el-button circle icon="el-icon-edit" @click="handleEdit(scope.row)"></el-button>
+        <el-button circle icon="el-icon-delete" type="danger" @click="handleDelete(scope.$index, scope.row)">
+        </el-button>
+      </template>
+    </el-table-column>
+  </el-table>
+</template>
+
+<script>
+import { RemoveBlobMusic } from '@/utils/utils';
+
+export default {
+  name: 'PreviewTable',
+  props: {
+    tableData: { type: Array, required: true },
+    policy: { type: Number, required: true },
+  },
+
+  methods: {
+    handlePlay(index, row) {
+      this.$emit('play', row.file);
+    },
+    handleDelete(index, row) {
+      RemoveBlobMusic(row);
+      this.tableData.splice(index, 1);
+    },
+    handleDownload(row) {
+      this.$emit('download', row);
+    },
+    handleEdit(row) {
+      this.$emit('edit', row);
+    },
+  },
+};
+</script>
+
+<style scoped></style>

src/component/Ruby.vue

@@ -0,0 +1,18 @@
+<template>
+  <ruby :title="caption">
+    <slot></slot>
+
+    <rp>（</rp>
+    <rt v-text="caption"></rt>
+    <rp>）</rp>
+  </ruby>
+</template>
+
+<script>
+export default {
+  name: 'Ruby',
+  props: {
+    caption: { type: String, required: true },
+  },
+};
+</script>

src/component/preview.vue

@@ -1,71 +0,0 @@
-<template>
-    <el-table :data="tableData" style="width: 100%">
-
-        <el-table-column label="封面">
-            <template slot-scope="scope">
-                <el-image :src="scope.row.picture" style="width: 100px; height: 100px">
-                    <div class="image-slot el-image__error" slot="error">
-                        暂无封面
-                    </div>
-                </el-image>
-            </template>
-        </el-table-column>
-        <el-table-column label="歌曲">
-            <template slot-scope="scope">
-                <span>{{ scope.row.title }}</span>
-            </template>
-        </el-table-column>
-        <el-table-column label="歌手">
-            <template slot-scope="scope">
-                <p>{{ scope.row.artist }}</p>
-            </template>
-        </el-table-column>
-        <el-table-column label="专辑">
-            <template slot-scope="scope">
-                <p>{{ scope.row.album }}</p>
-            </template>
-        </el-table-column>
-        <el-table-column label="操作">
-            <template slot-scope="scope">
-                <el-button @click="handlePlay(scope.$index, scope.row)"
-                           circle icon="el-icon-video-play" type="success">
-                </el-button>
-                <el-button @click="handleDownload(scope.row)"
-                           circle icon="el-icon-download">
-                </el-button>
-                <el-button @click="handleDelete(scope.$index, scope.row)"
-                           circle icon="el-icon-delete" type="danger">
-                </el-button>
-            </template>
-        </el-table-column>
-    </el-table>
-</template>
-
-<script>
-    import {DownloadBlobMusic, RemoveBlobMusic} from './util'
-
-    export default {
-        name: "preview",
-        props: {
-            tableData: {type: Array, required: true},
-            download_format: {type: String, required: true}
-        },
-
-        methods: {
-            handlePlay(index, row) {
-                this.$emit("music_changed", row.file);
-            },
-            handleDelete(index, row) {
-                RemoveBlobMusic(row);
-                this.tableData.splice(index, 1);
-            },
-            handleDownload(row) {
-                DownloadBlobMusic(row, this.download_format)
-            },
-        }
-    }
-</script>
-
-<style scoped>
-
-</style>

src/component/upload.vue

@@ -1,120 +0,0 @@
-<template>
-    <el-upload
-            :auto-upload="false"
-            :on-change="handleFile"
-            :show-file-list="false"
-            action=""
-            drag
-            multiple>
-        <i class="el-icon-upload"/>
-        <div class="el-upload__text">将文件拖到此处，或<em>点击选择</em></div>
-        <div class="el-upload__tip" slot="tip">本工具仅在浏览器内对文件进行解锁，无需消耗流量</div>
-        <transition name="el-fade-in">
-            <el-progress
-                    :format="progressFormat" :percentage="progress_percent" :stroke-width="16"
-                    :text-inside="true" style="margin: 16px 6px 0 6px"
-                    v-show="progress_show"
-            ></el-progress>
-        </transition>
-    </el-upload>
-</template>
-
-<script>
-    "use strict";// 严格模式 用于尾调用优化
-
-    export default {
-        name: "upload",
-        data() {
-            return {
-                cacheQueue: [],
-                workers: [],
-                idle_workers: [],
-                thread_num: 1,
-
-                progress_show: false,
-
-                progress_finished: 0,
-                progress_all: 0,
-                progress_percent: 0,
-            }
-        },
-        mounted() {
-            if (document.location.host !== "" && process.env.NODE_ENV === 'production') {
-                this.thread_num = navigator.hardwareConcurrency || 1;
-                const worker = require("workerize-loader!../decrypt/common");
-                // noinspection JSValidateTypes,JSUnresolvedVariable
-                this.workers.push(worker().CommonDecrypt);
-                this.idle_workers.push(0);
-                // delay to optimize for first loading
-                setTimeout(() => {
-                  for (let i = 1; i < this.thread_num; i++) {
-                    // noinspection JSValidateTypes,JSUnresolvedVariable
-                    this.workers.push(worker().CommonDecrypt);
-                    this.idle_workers.push(i);
-                  }
-                }, 5000);
-            } else {
-                const dec = require('../decrypt/common');
-                this.workers.push(dec.CommonDecrypt);
-                this.idle_workers.push(0)
-            }
-        },
-        methods: {
-            progressFormat() {
-                return this.progress_finished + "/" + (this.progress_all)
-            },
-            progressChange(finish, all) {
-                this.progress_all += all;
-                this.progress_finished += finish;
-                this.progress_percent = Math.round(this.progress_finished / this.progress_all * 100);
-                if (this.progress_finished === this.progress_all) {
-                    setTimeout(() => {
-                        this.progress_show = false;
-                        this.progress_finished = 0;
-                        this.progress_all = 0;
-                    }, 3000);
-                } else {
-                    this.progress_show = true;
-                }
-            },
-            handleFile(file) {
-                this.progressChange(0, +1);
-                // 有空闲worker 立刻处理文件
-                if (this.idle_workers.length > 0) {
-                    this.handleDoFile(file, this.idle_workers.shift());
-                }
-                // 无空闲worker 则放入缓存队列
-                else {
-                    this.cacheQueue.push(file);
-                }
-            },
-            handleCacheQueue(worker_id) {
-                // 调用方法消费缓存队列中的数据
-                if (this.cacheQueue.length === 0) {
-                    this.idle_workers.push(worker_id);
-                    return
-                }
-                this.handleDoFile(this.cacheQueue.shift(), worker_id);
-            },
-            handleDoFile(file, worker_id) {
-                this.workers[worker_id](file).then(data => {
-                    this.$emit("handle_finish", data);
-                    // 完成之后 执行新任务 todo: 可能导致call stack过长
-                    this.handleCacheQueue(worker_id);
-                    this.progressChange(+1, 0);
-                }).catch(err => {
-                    this.$emit("handle_error", err, file.name);
-                    this.handleCacheQueue(worker_id);
-                    this.progressChange(+1, 0);
-                })
-            },
-        }
-    }
-</script>
-
-<style scoped>
-    /*noinspection CssUnusedSymbol*/
-    .el-upload-dragger {
-        width: 80vw !important;
-    }
-</style>

src/component/util.js

@@ -1,30 +0,0 @@
-export function DownloadBlobMusic(data, format) {
-    const a = document.createElement('a');
-    a.href = data.file;
-    switch (format) {
-        default:
-        case "1":
-            a.download = data.artist + " - " + data.title + "." + data.ext;
-            break;
-        case "2":
-            a.download = data.title + "." + data.ext;
-            break;
-        case "3":
-            a.download = data.title + " - " + data.artist + "." + data.ext;
-            break;
-        case "4":
-            a.download = data.rawFilename + "." + data.ext;
-            break;
-    }
-    document.body.append(a);
-    a.click();
-    a.remove();
-}
-
-export function RemoveBlobMusic(data) {
-    URL.revokeObjectURL(data.file);
-    if (data.picture.startsWith("blob:")) {
-        URL.revokeObjectURL(data.picture);
-    }
-
-}

src/decrypt/__test__/joox.test.ts

@@ -0,0 +1,52 @@
+import fs from 'fs';
+import { storage } from '@/utils/storage';
+
+import { Decrypt as decryptJoox } from '../joox';
+import { extractQQMusicMeta as extractQQMusicMetaOrig } from '@/utils/qm_meta';
+
+jest.mock('@/utils/storage');
+jest.mock('@/utils/qm_meta');
+
+const loadJooxUUID = storage.loadJooxUUID as jest.MockedFunction<typeof storage.loadJooxUUID>;
+const extractQQMusicMeta = extractQQMusicMetaOrig as jest.MockedFunction<typeof extractQQMusicMetaOrig>;
+
+const TEST_UUID_ZEROS = ''.padStart(32, '0');
+const encryptedFile1 = fs.readFileSync(__dirname + '/fixture/joox_1.bin');
+
+describe('decrypt/joox', () => {
+  it('should be able to decrypt sample file (v4)', async () => {
+    loadJooxUUID.mockResolvedValue(TEST_UUID_ZEROS);
+    extractQQMusicMeta.mockImplementationOnce(async (blob: Blob) => {
+      return {
+        title: 'unused',
+        album: 'unused',
+        blob: blob,
+        artist: 'unused',
+        imgUrl: 'https://example.unlock-music.dev/',
+      };
+    });
+
+    const result = await decryptJoox(new Blob([encryptedFile1]), 'test.bin', 'bin');
+    const resultBuf = await result.blob.arrayBuffer();
+    expect(resultBuf).toEqual(Buffer.from('Hello World', 'utf-8').buffer);
+  });
+
+  it('should reject E!99 files', async () => {
+    loadJooxUUID.mockResolvedValue(TEST_UUID_ZEROS);
+
+    const input = new Blob([Buffer.from('E!99....')]);
+    await expect(decryptJoox(input, 'test.bin', 'bin')).rejects.toThrow('不支持的 joox 加密格式');
+  });
+
+  it('should reject empty uuid', async () => {
+    loadJooxUUID.mockResolvedValue('');
+    const input = new Blob([encryptedFile1]);
+    await expect(decryptJoox(input, 'test.bin', 'bin')).rejects.toThrow('UUID');
+  });
+
+  it('should reject invalid uuid', async () => {
+    loadJooxUUID.mockResolvedValue('hello!');
+    const input = new Blob([encryptedFile1]);
+    await expect(decryptJoox(input, 'test.bin', 'bin')).rejects.toThrow('UUID');
+  });
+});

src/decrypt/common.js

@@ -1,68 +0,0 @@
-const NcmDecrypt = require("./ncm");
-const KwmDecrypt = require("./kwm");
-const XmDecrypt = require("./xm");
-const QmcDecrypt = require("./qmc");
-const RawDecrypt = require("./raw");
-const TmDecrypt = require("./tm");
-const KgmDecrypt = require("./kgm");
-
-export async function CommonDecrypt(file) {
-    let raw_ext = file.name.substring(file.name.lastIndexOf(".") + 1, file.name.length).toLowerCase();
-    let raw_filename = file.name.substring(0, file.name.lastIndexOf("."));
-    let rt_data;
-    switch (raw_ext) {
-        case "ncm":// Netease Mp3/Flac
-            rt_data = await NcmDecrypt.Decrypt(file.raw, raw_filename, raw_ext);
-            break;
-        case "kwm":// Kuwo Mp3/Flac
-            rt_data = await KwmDecrypt.Decrypt(file.raw, raw_filename, raw_ext);
-            break
-        case "xm": // Xiami Wav/M4a/Mp3/Flac
-        case "wav":// Xiami/Raw Wav
-        case "mp3":// Xiami/Raw Mp3
-        case "flac":// Xiami/Raw Flac
-        case "m4a":// Xiami/Raw M4a
-            rt_data = await XmDecrypt.Decrypt(file.raw, raw_filename, raw_ext);
-            break;
-        case "ogg":// Raw Ogg
-            rt_data = await RawDecrypt.Decrypt(file.raw, raw_filename, raw_ext);
-            break;
-        case "tm0":// QQ Music IOS Mp3
-        case "tm3":// QQ Music IOS Mp3
-            rt_data = await RawDecrypt.Decrypt(file.raw, raw_filename, "mp3");
-            break;
-        case "qmc3"://QQ Music Android Mp3
-        case "qmc2"://QQ Music Android Ogg
-        case "qmc0"://QQ Music Android Mp3
-        case "qmcflac"://QQ Music Android Flac
-        case "qmcogg"://QQ Music Android Ogg
-        case "tkm"://QQ Music Accompaniment M4a
-        case "bkcmp3"://Moo Music Mp3
-        case "bkcflac"://Moo Music Flac
-        case "mflac"://QQ Music Desktop Flac
-        case "mgg": //QQ Music Desktop Ogg
-        case "666c6163"://QQ Music Weiyun Flac
-        case "6d7033"://QQ Music Weiyun Mp3
-        case "6f6767"://QQ Music Weiyun Ogg
-        case "6d3461"://QQ Music Weiyun M4a
-        case "776176"://QQ Music Weiyun Wav
-            rt_data = await QmcDecrypt.Decrypt(file.raw, raw_filename, raw_ext);
-            break;
-        case "tm2":// QQ Music IOS M4a
-        case "tm6":// QQ Music IOS M4a
-            rt_data = await TmDecrypt.Decrypt(file.raw, raw_filename);
-            break;
-        case "vpr":
-        case "kgm":
-        case "kgma":
-            rt_data = await KgmDecrypt.Decrypt(file.raw, raw_filename, raw_ext);
-            break
-        default:
-            rt_data = {status: false, message: "不支持此文件格式",}
-    }
-
-    if (!rt_data.rawExt) rt_data.rawExt = raw_ext;
-    if (!rt_data.rawFilename) rt_data.rawFilename = raw_filename;
-    console.log(rt_data);
-    return rt_data;
-}

src/decrypt/entity.ts

@@ -0,0 +1,25 @@
+export interface DecryptResult {
+  title: string;
+  album?: string;
+  artist?: string;
+
+  mime: string;
+  ext: string;
+
+  file: string;
+  blob: Blob;
+  picture?: string;
+
+  message?: string;
+  rawExt?: string;
+  rawFilename?: string;
+}
+
+export interface FileInfo {
+  status: string;
+  name: string;
+  size: number;
+  percentage: number;
+  uid: number;
+  raw: File;
+}

src/decrypt/index.ts

@@ -0,0 +1,115 @@
+import { Decrypt as Mg3dDecrypt } from '@/decrypt/mg3d';
+import { Decrypt as NcmDecrypt } from '@/decrypt/ncm';
+import { Decrypt as NcmCacheDecrypt } from '@/decrypt/ncmcache';
+import { Decrypt as XmDecrypt } from '@/decrypt/xm';
+import { Decrypt as QmcDecrypt } from '@/decrypt/qmc';
+import { Decrypt as QmcCacheDecrypt } from '@/decrypt/qmccache';
+import { Decrypt as KgmDecrypt } from '@/decrypt/kgm';
+import { Decrypt as KwmDecrypt } from '@/decrypt/kwm';
+import { Decrypt as RawDecrypt } from '@/decrypt/raw';
+import { Decrypt as TmDecrypt } from '@/decrypt/tm';
+import { Decrypt as JooxDecrypt } from '@/decrypt/joox';
+import { Decrypt as XimalayaDecrypt } from './ximalaya';
+import { DecryptResult, FileInfo } from '@/decrypt/entity';
+import { SplitFilename } from '@/decrypt/utils';
+import { storage } from '@/utils/storage';
+import InMemoryStorage from '@/utils/storage/InMemoryStorage';
+
+export async function Decrypt(file: FileInfo, config: Record<string, any>): Promise<DecryptResult> {
+  // Worker thread will fallback to in-memory storage.
+  if (storage instanceof InMemoryStorage) {
+    await storage.setAll(config);
+  }
+
+  const raw = SplitFilename(file.name);
+  let rt_data: DecryptResult;
+  switch (raw.ext) {
+    case 'mg3d': // Migu Wav
+      rt_data = await Mg3dDecrypt(file.raw, raw.name);
+      break;
+    case 'ncm': // Netease Mp3/Flac
+      rt_data = await NcmDecrypt(file.raw, raw.name, raw.ext);
+      break;
+    case 'uc': // Netease Cache
+      rt_data = await NcmCacheDecrypt(file.raw, raw.name, raw.ext);
+      break;
+    case 'kwm': // Kuwo Mp3/Flac
+      rt_data = await KwmDecrypt(file.raw, raw.name, raw.ext);
+      break;
+    case 'xm': // Xiami Wav/M4a/Mp3/Flac
+    case 'wav': // Xiami/Raw Wav
+    case 'mp3': // Xiami/Raw Mp3
+    case 'flac': // Xiami/Raw Flac
+    case 'm4a': // Xiami/Raw M4a
+      rt_data = await XmDecrypt(file.raw, raw.name, raw.ext);
+      break;
+    case 'ogg': // Raw Ogg
+      rt_data = await RawDecrypt(file.raw, raw.name, raw.ext);
+      break;
+    case 'tm0': // QQ Music IOS Mp3
+    case 'tm3': // QQ Music IOS Mp3
+      rt_data = await RawDecrypt(file.raw, raw.name, 'mp3');
+      break;
+    case 'qmc0': //QQ Music Android Mp3
+    case 'qmc3': //QQ Music Android Mp3
+    case 'qmc2': //QQ Music Android Ogg
+    case 'qmc4': //QQ Music Android Ogg
+    case 'qmc6': //QQ Music Android Ogg
+    case 'qmc8': //QQ Music Android Ogg
+    case 'qmcflac': //QQ Music Android Flac
+    case 'qmcogg': //QQ Music Android Ogg
+    case 'tkm': //QQ Music Accompaniment M4a
+    // Moo Music
+    case 'bkcmp3':
+    case 'bkcm4a':
+    case 'bkcflac':
+    case 'bkcwav':
+    case 'bkcape':
+    case 'bkcogg':
+    case 'bkcwma':
+    // QQ Music v2
+    case 'mggl': //QQ Music Mac
+    case 'mflac': //QQ Music New Flac
+    case 'mflac0': //QQ Music New Flac
+    case 'mflach': //QQ Music New Flac
+    case 'mgg': //QQ Music New Ogg
+    case 'mgg1': //QQ Music New Ogg
+    case 'mgg0':
+    case 'mmp4': // QMC MP4 Container w/ E-AC-3 JOC
+    case '666c6163': //QQ Music Weiyun Flac
+    case '6d7033': //QQ Music Weiyun Mp3
+    case '6f6767': //QQ Music Weiyun Ogg
+    case '6d3461': //QQ Music Weiyun M4a
+    case '776176': //QQ Music Weiyun Wav
+      rt_data = await QmcDecrypt(file.raw, raw.name, raw.ext);
+      break;
+    case 'tm2': // QQ Music IOS M4a
+    case 'tm6': // QQ Music IOS M4a
+      rt_data = await TmDecrypt(file.raw, raw.name);
+      break;
+    case 'cache': //QQ Music Cache
+      rt_data = await QmcCacheDecrypt(file.raw, raw.name, raw.ext);
+      break;
+    case 'vpr':
+    case 'kgm':
+    case 'kgma':
+      rt_data = await KgmDecrypt(file.raw, raw.name, raw.ext);
+      break;
+    case 'ofl_en':
+      rt_data = await JooxDecrypt(file.raw, raw.name, raw.ext);
+      break;
+    case 'x2m':
+    case 'x3m':
+      rt_data = await XimalayaDecrypt(file.raw, raw.name, raw.ext);
+      break;
+    case 'mflach': //QQ Music New Flac
+      throw '网页版无法解锁，请使用<a target="_blank" href="https://git.unlock-music.dev/um/cli">CLI版本</a>'
+    default:
+      throw '不支持此文件格式';
+  }
+
+  if (!rt_data.rawExt) rt_data.rawExt = raw.ext;
+  if (!rt_data.rawFilename) rt_data.rawFilename = raw.name;
+  console.log(rt_data);
+  return rt_data;
+}

src/decrypt/joox.ts

@@ -0,0 +1,44 @@
+import jooxFactory from '@unlock-music/joox-crypto';
+
+import { DecryptResult } from './entity';
+import { AudioMimeType, GetArrayBuffer, SniffAudioExt } from './utils';
+
+import { MergeUint8Array } from '@/utils/MergeUint8Array';
+import { storage } from '@/utils/storage';
+import { extractQQMusicMeta } from '@/utils/qm_meta';
+
+export async function Decrypt(file: Blob, raw_filename: string, raw_ext: string): Promise<DecryptResult> {
+  const uuid = await storage.loadJooxUUID('');
+  if (!uuid || uuid.length !== 32) {
+    throw new Error('请在“解密设定”填写应用 Joox 应用的 UUID。');
+  }
+
+  const fileBuffer = new Uint8Array(await GetArrayBuffer(file));
+  const decryptor = jooxFactory(fileBuffer, uuid);
+  if (!decryptor) {
+    throw new Error('不支持的 joox 加密格式');
+  }
+
+  const musicDecoded = MergeUint8Array(decryptor.decryptFile(fileBuffer));
+  const ext = SniffAudioExt(musicDecoded);
+  const mime = AudioMimeType[ext];
+
+  const songId = raw_filename.match(/^(\d+)\s\[mqms\d*]$/i)?.[1];
+  const { album, artist, imgUrl, blob, title } = await extractQQMusicMeta(
+    new Blob([musicDecoded], { type: mime }),
+    raw_filename,
+    ext,
+    songId,
+  );
+
+  return {
+    title: title,
+    artist: artist,
+    ext: ext,
+    album: album,
+    picture: imgUrl,
+    file: URL.createObjectURL(blob),
+    blob: blob,
+    mime: mime,
+  };
+}

src/decrypt/kgm.js

@@ -1,120 +0,0 @@
-import {AudioMimeType, DetectAudioExt, GetArrayBuffer, GetFileInfo, GetMetaCoverURL, IsBytesEqual} from "./util";
-
-const musicMetadata = require("music-metadata-browser");
-const VprHeader = [
-    0x05, 0x28, 0xBC, 0x96, 0xE9, 0xE4, 0x5A, 0x43,
-    0x91, 0xAA, 0xBD, 0xD0, 0x7A, 0xF5, 0x36, 0x31]
-const KgmHeader = [
-    0x7C, 0xD5, 0x32, 0xEB, 0x86, 0x02, 0x7F, 0x4B,
-    0xA8, 0xAF, 0xA6, 0x8E, 0x0F, 0xFF, 0x99, 0x14]
-const VprMaskDiff = [0x25, 0xDF, 0xE8, 0xA6, 0x75, 0x1E, 0x75, 0x0E,
-    0x2F, 0x80, 0xF3, 0x2D, 0xB8, 0xB6, 0xE3, 0x11,
-    0x00]
-
-export async function Decrypt(file, raw_filename, raw_ext) {
-    try {
-        if (window.location.protocol === "file:") {
-            return {
-                status: false,
-                message: "请使用<a target='_blank' href='https://github.com/ix64/unlock-music/wiki/其他音乐格式工具'>CLI版本</a>进行解锁"
-            }
-        }
-    } catch {
-    }
-    const oriData = new Uint8Array(await GetArrayBuffer(file));
-    if (raw_ext === "vpr") {
-        if (!IsBytesEqual(VprHeader, oriData.slice(0, 0x10)))
-            return {status: false, message: "Not a valid vpr file!"}
-    } else {
-        if (!IsBytesEqual(KgmHeader, oriData.slice(0, 0x10)))
-            return {status: false, message: "Not a valid kgm/kgma file!"}
-    }
-    let bHeaderLen = new DataView(oriData.slice(0x10, 0x14).buffer)
-    let headerLen = bHeaderLen.getUint32(0, true)
-
-    let audioData = oriData.slice(headerLen)
-    let dataLen = audioData.length
-    if (audioData.byteLength > 1 << 26) {
-        return {
-            status: false,
-            message: "文件过大，请使用<a target='_blank' href='https://github.com/ix64/unlock-music/wiki/其他音乐格式工具'>CLI版本</a>进行解锁"
-        }
-    }
-
-    let key1 = new Uint8Array(17)
-    key1.set(oriData.slice(0x1c, 0x2c), 0)
-    if (MaskV2 == null) {
-        if (!await LoadMaskV2()) {
-            return {status: false, message: "加载Kgm/Vpr Mask数据失败"}
-        }
-    }
-
-    for (let i = 0; i < dataLen; i++) {
-        let med8 = key1[i % 17] ^ audioData[i]
-        med8 ^= (med8 & 0xf) << 4
-
-        let msk8 = GetMask(i)
-        msk8 ^= (msk8 & 0xf) << 4
-        audioData[i] = med8 ^ msk8
-    }
-    if (raw_ext === "vpr") {
-        for (let i = 0; i < dataLen; i++) audioData[i] ^= VprMaskDiff[i % 17]
-    }
-
-    const ext = DetectAudioExt(audioData, "mp3");
-    const mime = AudioMimeType[ext];
-    let musicBlob = new Blob([audioData], {type: mime});
-    const musicMeta = await musicMetadata.parseBlob(musicBlob);
-    const info = GetFileInfo(musicMeta.common.artist, musicMeta.common.title, raw_filename);
-    const imgUrl = GetMetaCoverURL(musicMeta);
-    return {
-        status: true,
-        title: info.title,
-        artist: info.artist,
-        ext: ext,
-        album: musicMeta.common.album,
-        picture: imgUrl,
-        file: URL.createObjectURL(musicBlob),
-        mime: mime
-    }
-}
-
-function GetMask(pos) {
-    return MaskV2PreDef[pos % 272] ^ MaskV2[pos >> 4]
-}
-
-let MaskV2 = null;
-
-async function LoadMaskV2() {
-    try {
-        let resp = await fetch("./static/kgm.mask", {
-            method: "GET"
-        })
-        MaskV2 = new Uint8Array(await resp.arrayBuffer());
-        return true
-    } catch (e) {
-        console.error(e)
-        return false
-    }
-}
-
-const MaskV2PreDef = [
-    0xB8, 0xD5, 0x3D, 0xB2, 0xE9, 0xAF, 0x78, 0x8C, 0x83, 0x33, 0x71, 0x51, 0x76, 0xA0, 0xCD, 0x37,
-    0x2F, 0x3E, 0x35, 0x8D, 0xA9, 0xBE, 0x98, 0xB7, 0xE7, 0x8C, 0x22, 0xCE, 0x5A, 0x61, 0xDF, 0x68,
-    0x69, 0x89, 0xFE, 0xA5, 0xB6, 0xDE, 0xA9, 0x77, 0xFC, 0xC8, 0xBD, 0xBD, 0xE5, 0x6D, 0x3E, 0x5A,
-    0x36, 0xEF, 0x69, 0x4E, 0xBE, 0xE1, 0xE9, 0x66, 0x1C, 0xF3, 0xD9, 0x02, 0xB6, 0xF2, 0x12, 0x9B,
-    0x44, 0xD0, 0x6F, 0xB9, 0x35, 0x89, 0xB6, 0x46, 0x6D, 0x73, 0x82, 0x06, 0x69, 0xC1, 0xED, 0xD7,
-    0x85, 0xC2, 0x30, 0xDF, 0xA2, 0x62, 0xBE, 0x79, 0x2D, 0x62, 0x62, 0x3D, 0x0D, 0x7E, 0xBE, 0x48,
-    0x89, 0x23, 0x02, 0xA0, 0xE4, 0xD5, 0x75, 0x51, 0x32, 0x02, 0x53, 0xFD, 0x16, 0x3A, 0x21, 0x3B,
-    0x16, 0x0F, 0xC3, 0xB2, 0xBB, 0xB3, 0xE2, 0xBA, 0x3A, 0x3D, 0x13, 0xEC, 0xF6, 0x01, 0x45, 0x84,
-    0xA5, 0x70, 0x0F, 0x93, 0x49, 0x0C, 0x64, 0xCD, 0x31, 0xD5, 0xCC, 0x4C, 0x07, 0x01, 0x9E, 0x00,
-    0x1A, 0x23, 0x90, 0xBF, 0x88, 0x1E, 0x3B, 0xAB, 0xA6, 0x3E, 0xC4, 0x73, 0x47, 0x10, 0x7E, 0x3B,
-    0x5E, 0xBC, 0xE3, 0x00, 0x84, 0xFF, 0x09, 0xD4, 0xE0, 0x89, 0x0F, 0x5B, 0x58, 0x70, 0x4F, 0xFB,
-    0x65, 0xD8, 0x5C, 0x53, 0x1B, 0xD3, 0xC8, 0xC6, 0xBF, 0xEF, 0x98, 0xB0, 0x50, 0x4F, 0x0F, 0xEA,
-    0xE5, 0x83, 0x58, 0x8C, 0x28, 0x2C, 0x84, 0x67, 0xCD, 0xD0, 0x9E, 0x47, 0xDB, 0x27, 0x50, 0xCA,
-    0xF4, 0x63, 0x63, 0xE8, 0x97, 0x7F, 0x1B, 0x4B, 0x0C, 0xC2, 0xC1, 0x21, 0x4C, 0xCC, 0x58, 0xF5,
-    0x94, 0x52, 0xA3, 0xF3, 0xD3, 0xE0, 0x68, 0xF4, 0x00, 0x23, 0xF3, 0x5E, 0x0A, 0x7B, 0x93, 0xDD,
-    0xAB, 0x12, 0xB2, 0x13, 0xE8, 0x84, 0xD7, 0xA7, 0x9F, 0x0F, 0x32, 0x4C, 0x55, 0x1D, 0x04, 0x36,
-    0x52, 0xDC, 0x03, 0xF3, 0xF9, 0x4E, 0x42, 0xE9, 0x3D, 0x61, 0xEF, 0x7C, 0xB6, 0xB3, 0x93, 0x50,
-]
-

src/decrypt/kgm.ts

@@ -0,0 +1,57 @@
+import {
+  AudioMimeType,
+  BytesHasPrefix,
+  GetArrayBuffer,
+  GetCoverFromFile,
+  GetMetaFromFile,
+  SniffAudioExt,
+} from '@/decrypt/utils';
+import { parseBlob as metaParseBlob } from 'music-metadata-browser';
+import { DecryptResult } from '@/decrypt/entity';
+import { DecryptKgmWasm } from '@/decrypt/kgm_wasm';
+
+//prettier-ignore
+const VprHeader = [
+  0x05, 0x28, 0xBC, 0x96, 0xE9, 0xE4, 0x5A, 0x43,
+  0x91, 0xAA, 0xBD, 0xD0, 0x7A, 0xF5, 0x36, 0x31
+]
+//prettier-ignore
+const KgmHeader = [
+  0x7C, 0xD5, 0x32, 0xEB, 0x86, 0x02, 0x7F, 0x4B,
+  0xA8, 0xAF, 0xA6, 0x8E, 0x0F, 0xFF, 0x99, 0x14
+]
+
+export async function Decrypt(file: File, raw_filename: string, raw_ext: string): Promise<DecryptResult> {
+  const oriData = await GetArrayBuffer(file);
+  if (raw_ext === 'vpr') {
+    if (!BytesHasPrefix(new Uint8Array(oriData), VprHeader)) throw Error('Not a valid vpr file!');
+  } else {
+    if (!BytesHasPrefix(new Uint8Array(oriData), KgmHeader)) throw Error('Not a valid kgm(a) file!');
+  }
+  let musicDecoded = new Uint8Array();
+  if (globalThis.WebAssembly) {
+    const kgmDecrypted = await DecryptKgmWasm(oriData, raw_ext);
+    if (kgmDecrypted.success) {
+      musicDecoded = kgmDecrypted.data;
+      console.log('kgm wasm decoder suceeded');
+    } else {
+      throw new Error(kgmDecrypted.error || '(unknown error)');
+    }
+  }
+
+  const ext = SniffAudioExt(musicDecoded);
+  const mime = AudioMimeType[ext];
+  let musicBlob = new Blob([musicDecoded], { type: mime });
+  const musicMeta = await metaParseBlob(musicBlob);
+  const { title, artist } = GetMetaFromFile(raw_filename, musicMeta.common.title, String(musicMeta.common.artists || musicMeta.common.artist || ""));
+  return {
+    album: musicMeta.common.album,
+    picture: GetCoverFromFile(musicMeta),
+    file: URL.createObjectURL(musicBlob),
+    blob: musicBlob,
+    ext,
+    mime,
+    title,
+    artist,
+  };
+}

src/decrypt/kgm_wasm.ts

@@ -0,0 +1,68 @@
+import { KgmCrypto } from '@xhacker/kgmwasm/KgmWasmBundle';
+import KgmCryptoModule from '@xhacker/kgmwasm/KgmWasmBundle';
+import { MergeUint8Array } from '@/utils/MergeUint8Array';
+
+// 每次可以处理 2M 的数据
+const DECRYPTION_BUF_SIZE = 2 *1024 * 1024;
+
+export interface KGMDecryptionResult {
+  success: boolean;
+  data: Uint8Array;
+  error: string;
+}
+
+/**
+ * 解密一个 KGM 加密的文件。
+ *
+ * 如果检测并解密成功，返回解密后的 Uint8Array 数据。
+ * @param  {ArrayBuffer} kgmBlob 读入的文件 Blob
+ */
+export async function DecryptKgmWasm(kgmBlob: ArrayBuffer, ext: string): Promise<KGMDecryptionResult> {
+  const result: KGMDecryptionResult = { success: false, data: new Uint8Array(), error: '' };
+
+  // 初始化模组
+  let KgmCryptoObj: KgmCrypto;
+
+  try {
+    KgmCryptoObj = await KgmCryptoModule();
+  } catch (err: any) {
+    result.error = err?.message || 'wasm 加载失败';
+    return result;
+  }
+  if (!KgmCryptoObj) {
+    result.error = 'wasm 加载失败';
+    return result;
+  }
+
+  // 申请内存块，并文件末端数据到 WASM 的内存堆
+  let kgmBuf = new Uint8Array(kgmBlob);
+  const pKgmBuf = KgmCryptoObj._malloc(DECRYPTION_BUF_SIZE);
+  const preDecDataSize = Math.min(DECRYPTION_BUF_SIZE, kgmBlob.byteLength); // 初始化缓冲区大小
+  KgmCryptoObj.writeArrayToMemory(kgmBuf.slice(0, preDecDataSize), pKgmBuf);
+
+  // 进行解密初始化
+  const headerSize = KgmCryptoObj.preDec(pKgmBuf, preDecDataSize, ext);
+  kgmBuf = kgmBuf.slice(headerSize);
+
+  const decryptedParts = [];
+  let offset = 0;
+  let bytesToDecrypt = kgmBuf.length;
+  while (bytesToDecrypt > 0) {
+    const blockSize = Math.min(bytesToDecrypt, DECRYPTION_BUF_SIZE);
+
+    // 解密一些片段
+    const blockData = new Uint8Array(kgmBuf.slice(offset, offset + blockSize));
+    KgmCryptoObj.writeArrayToMemory(blockData, pKgmBuf);
+    KgmCryptoObj.decBlob(pKgmBuf, blockSize, offset);
+    decryptedParts.push(KgmCryptoObj.HEAPU8.slice(pKgmBuf, pKgmBuf + blockSize));
+
+    offset += blockSize;
+    bytesToDecrypt -= blockSize;
+  }
+  KgmCryptoObj._free(pKgmBuf);
+
+  result.data = MergeUint8Array(decryptedParts);
+  result.success = true;
+
+  return result;
+}

src/decrypt/kwm.js

@@ -1,66 +0,0 @@
-import {AudioMimeType, DetectAudioExt, GetArrayBuffer, GetFileInfo, GetMetaCoverURL, IsBytesEqual} from "./util";
-
-const musicMetadata = require("music-metadata-browser");
-const MagicHeader = [
-    0x79, 0x65, 0x65, 0x6C, 0x69, 0x6F, 0x6E, 0x2D,
-    0x6B, 0x75, 0x77, 0x6F, 0x2D, 0x74, 0x6D, 0x65,
-]
-const PreDefinedKey = "MoOtOiTvINGwd2E6n0E1i7L5t2IoOoNk"
-
-export async function Decrypt(file, raw_filename, raw_ext) {
-    const oriData = new Uint8Array(await GetArrayBuffer(file));
-    if (!IsBytesEqual(MagicHeader, oriData.slice(0, 0x10)))
-        return {status: false, message: "Not a valid kwm file!"}
-
-    let fileKey = oriData.slice(0x18, 0x20)
-    let mask = createMaskFromKey(fileKey)
-    let audioData = oriData.slice(0x400);
-    let lenAudioData = audioData.length;
-    for (let cur = 0; cur < lenAudioData; ++cur)
-        audioData[cur] ^= mask[cur % 0x20];
-
-
-    const ext = DetectAudioExt(audioData, "mp3");
-    const mime = AudioMimeType[ext];
-    let musicBlob = new Blob([audioData], {type: mime});
-
-    const musicMeta = await musicMetadata.parseBlob(musicBlob);
-    const info = GetFileInfo(musicMeta.common.artist, musicMeta.common.title, raw_filename);
-
-    const imgUrl = GetMetaCoverURL(musicMeta);
-
-    return {
-        status: true,
-        title: info.title,
-        artist: info.artist,
-        ext: ext,
-        album: musicMeta.common.album,
-        picture: imgUrl,
-        file: URL.createObjectURL(musicBlob),
-        mime: mime
-    }
-}
-
-
-function createMaskFromKey(keyBytes) {
-    let keyView = new DataView(keyBytes.buffer)
-    let keyStr = keyView.getBigUint64(0, true).toString()
-    let keyStrTrim = trimKey(keyStr)
-    let key = new Uint8Array(32)
-    for (let i = 0; i < 32; i++) {
-        key[i] = PreDefinedKey[i].charCodeAt() ^ keyStrTrim[i].charCodeAt()
-    }
-    return key
-}
-
-
-function trimKey(keyRaw) {
-    let lenRaw = keyRaw.length;
-    let out = keyRaw;
-    if (lenRaw > 32) {
-        out = keyRaw.slice(0, 32)
-    } else if (lenRaw < 32) {
-        out = keyRaw.padEnd(32, keyRaw)
-    }
-    return out
-}

src/decrypt/kwm.ts

@@ -0,0 +1,78 @@
+import {
+  AudioMimeType,
+  BytesHasPrefix,
+  GetArrayBuffer,
+  GetCoverFromFile,
+  GetMetaFromFile,
+  SniffAudioExt,
+} from '@/decrypt/utils';
+import { Decrypt as RawDecrypt } from '@/decrypt/raw';
+
+import { parseBlob as metaParseBlob } from 'music-metadata-browser';
+import { DecryptResult } from '@/decrypt/entity';
+
+//prettier-ignore
+const MagicHeader = [
+    0x79, 0x65, 0x65, 0x6C, 0x69, 0x6F, 0x6E, 0x2D,
+    0x6B, 0x75, 0x77, 0x6F, 0x2D, 0x74, 0x6D, 0x65,
+];
+const MagicHeader2 = [
+    0x79, 0x65, 0x65, 0x6C, 0x69, 0x6F, 0x6E, 0x2D,
+    0x6B, 0x75, 0x77, 0x6F, 0x00, 0x00, 0x00, 0x00,
+];
+const PreDefinedKey = 'MoOtOiTvINGwd2E6n0E1i7L5t2IoOoNk';
+
+export async function Decrypt(file: File, raw_filename: string, _: string): Promise<DecryptResult> {
+  const oriData = new Uint8Array(await GetArrayBuffer(file));
+    if (!BytesHasPrefix(oriData, MagicHeader) && !BytesHasPrefix(oriData, MagicHeader2)) {
+    if (SniffAudioExt(oriData) === 'aac') {
+      return await RawDecrypt(file, raw_filename, 'aac', false);
+    }
+    throw Error('not a valid kwm file');
+  }
+
+  let fileKey = oriData.slice(0x18, 0x20);
+  let mask = createMaskFromKey(fileKey);
+  let audioData = oriData.slice(0x400);
+  let lenAudioData = audioData.length;
+  for (let cur = 0; cur < lenAudioData; ++cur) audioData[cur] ^= mask[cur % 0x20];
+
+  const ext = SniffAudioExt(audioData);
+  const mime = AudioMimeType[ext];
+  let musicBlob = new Blob([audioData], { type: mime });
+
+  const musicMeta = await metaParseBlob(musicBlob);
+  const { title, artist } = GetMetaFromFile(raw_filename, musicMeta.common.title, String(musicMeta.common.artists || musicMeta.common.artist || ""));
+  return {
+    album: musicMeta.common.album,
+    picture: GetCoverFromFile(musicMeta),
+    file: URL.createObjectURL(musicBlob),
+    blob: musicBlob,
+    mime,
+    title,
+    artist,
+    ext,
+  };
+}
+
+function createMaskFromKey(keyBytes: Uint8Array): Uint8Array {
+  let keyView = new DataView(keyBytes.buffer);
+  let keyStr = keyView.getBigUint64(0, true).toString();
+  let keyStrTrim = trimKey(keyStr);
+  let key = new Uint8Array(32);
+  for (let i = 0; i < 32; i++) {
+    key[i] = PreDefinedKey.charCodeAt(i) ^ keyStrTrim.charCodeAt(i);
+  }
+  return key;
+}
+
+function trimKey(keyRaw: string): string {
+  let lenRaw = keyRaw.length;
+  let out = keyRaw;
+  if (lenRaw > 32) {
+    out = keyRaw.slice(0, 32);
+  } else if (lenRaw < 32) {
+    out = keyRaw.padEnd(32, keyRaw);
+  }
+  return out;
+}

src/decrypt/mg3d.ts

@@ -0,0 +1,71 @@
+import { Decrypt as RawDecrypt } from './raw';
+import { GetArrayBuffer } from '@/decrypt/utils';
+import { DecryptResult } from '@/decrypt/entity';
+
+const segmentSize = 0x20;
+
+function isPrintableAsciiChar(ch: number) {
+    return ch >= 0x20 && ch <= 0x7E;
+}
+
+function isUpperHexChar(ch: number) {
+    return (ch >= 0x30 && ch <= 0x39) || (ch >= 0x41 && ch <= 0x46);
+}
+
+/**
+ * @param {Buffer} data 
+ * @param {Buffer} key 
+ * @param {boolean} copy 
+ * @returns Buffer
+ */
+function decryptSegment(data: Uint8Array, key: Uint8Array) {
+    for (let i = 0; i < data.byteLength; i++) {
+      data[i] -= key[i % segmentSize];
+    }
+    return Buffer.from(data);
+}
+
+export async function Decrypt(file: File, raw_filename: string): Promise<DecryptResult> {
+  const buf = new Uint8Array(await GetArrayBuffer(file));
+
+  // 咪咕编码的 WAV 文件有很多“空洞”内容，尝试密钥。
+  const header = buf.slice(0, 0x100);
+  const bytesRIFF = Buffer.from('RIFF', 'ascii');
+  const bytesWaveFormat = Buffer.from('WAVEfmt ', 'ascii');
+  const possibleKeys = [];
+  
+  for (let i = segmentSize; i < segmentSize * 20; i += segmentSize) {
+      const possibleKey = buf.slice(i, i + segmentSize);
+      if (!possibleKey.every(isUpperHexChar)) continue;
+  
+      const tempHeader = decryptSegment(header, possibleKey);
+      if (tempHeader.slice(0, 4).compare(bytesRIFF)) continue;
+      if (tempHeader.slice(8, 16).compare(bytesWaveFormat)) continue;
+      
+      // fmt chunk 大小可以是 16 / 18 / 40。
+      const fmtChunkSize = tempHeader.readUInt32LE(0x10);
+      if (![16, 18, 40].includes(fmtChunkSize)) continue;
+  
+      // 下一个 chunk
+      const firstDataChunkOffset = 0x14 + fmtChunkSize;
+      const chunkName = tempHeader.slice(firstDataChunkOffset, firstDataChunkOffset + 4);
+      if (!chunkName.every(isPrintableAsciiChar)) continue;
+  
+      const secondDataChunkOffset = firstDataChunkOffset + 8 + tempHeader.readUInt32LE(firstDataChunkOffset + 4);
+      if (secondDataChunkOffset <= header.byteLength) {
+          const secondChunkName = tempHeader.slice(secondDataChunkOffset, secondDataChunkOffset + 4);
+          if (!secondChunkName.every(isPrintableAsciiChar)) continue;
+      }
+  
+      possibleKeys.push(Buffer.from(possibleKey).toString('ascii'));
+  }
+  
+  if (possibleKeys.length <= 0) {
+    throw new Error(`ERROR: no suitable key discovered`);
+  }
+  
+  const decryptionKey = Buffer.from(possibleKeys[0], 'ascii');
+  decryptSegment(buf, decryptionKey);
+  const musicData = new Blob([buf], { type: 'audio/x-wav' });
+  return await RawDecrypt(musicData, raw_filename, 'wav', false);
+}

src/decrypt/ncm.js

@@ -1,180 +0,0 @@
-const CryptoJS = require("crypto-js");
-const MetaFlac = require('metaflac-js');
-const CORE_KEY = CryptoJS.enc.Hex.parse("687a4852416d736f356b496e62617857");
-const META_KEY = CryptoJS.enc.Hex.parse("2331346C6A6B5F215C5D2630553C2728");
-const MagicHeader = [0x43, 0x54, 0x45, 0x4E, 0x46, 0x44, 0x41, 0x4D];
-const musicMetadata = require("music-metadata-browser");
-import jimp from 'jimp';
-
-import {
-    AudioMimeType,
-    DetectAudioExt,
-    GetArrayBuffer,
-    GetFileInfo,
-    GetWebImage,
-    IsBytesEqual,
-    WriteMp3Meta
-} from "./util"
-
-export async function Decrypt(file, raw_filename, raw_ext) {
-    const fileBuffer = await GetArrayBuffer(file);
-    const dataView = new DataView(fileBuffer);
-
-    if (!IsBytesEqual(MagicHeader, new Uint8Array(fileBuffer, 0, 8)))
-        return {status: false, message: "此ncm文件已损坏"};
-
-    const keyDataObj = getKeyData(dataView, fileBuffer, 10);
-    const keyBox = getKeyBox(keyDataObj.data);
-
-    const musicMetaObj = getMetaData(dataView, fileBuffer, keyDataObj.offset);
-    const musicMeta = musicMetaObj.data;
-    let audioOffset = musicMetaObj.offset + dataView.getUint32(musicMetaObj.offset + 5, true) + 13;
-    let audioData = new Uint8Array(fileBuffer, audioOffset);
-
-    let lenAudioData = audioData.length;
-    for (let cur = 0; cur < lenAudioData; ++cur) audioData[cur] ^= keyBox[cur & 0xff];
-
-    if (musicMeta.album === undefined) musicMeta.album = "";
-
-    const artists = [];
-    if (!!musicMeta.artist) musicMeta.artist.forEach(arr => artists.push(arr[0]));
-    const info = GetFileInfo(artists.join("; "), musicMeta.musicName, raw_filename);
-    if (artists.length === 0) artists.push(info.artist);
-
-    if (musicMeta.format === undefined) musicMeta.format = DetectAudioExt(audioData, "mp3");
-    console.log(musicMeta)
-
-    const imageInfo = await GetWebImage(musicMeta.albumPic);
-    while (!!imageInfo.buffer && imageInfo.buffer.byteLength >= 16 * 1024 * 1024) {
-        let img = await jimp.read(imageInfo.buffer)
-        await img.resize(Math.round(img.getHeight() / 2), jimp.AUTO)
-        imageInfo.buffer = await img.getBufferAsync("image/jpeg")
-    }
-    console.log(imageInfo)
-    const mime = AudioMimeType[musicMeta.format]
-    try {
-        let musicBlob = new Blob([audioData], {type: mime});
-        const originalMeta = await musicMetadata.parseBlob(musicBlob);
-        console.log(originalMeta)
-        let shouldWrite = !originalMeta.common.album && !originalMeta.common.artists && !originalMeta.common.title
-        if (musicMeta.format === "mp3") {
-            audioData = await WriteMp3Meta(
-                audioData, artists, info.title, musicMeta.album, imageInfo.buffer, musicMeta.albumPic, shouldWrite ? null : originalMeta)
-        } else if (musicMeta.format === "flac") {
-            const writer = new MetaFlac(Buffer.from(audioData))
-            if (shouldWrite) {
-                writer.setTag("TITLE=" + info.title)
-                writer.setTag("ALBUM=" + musicMeta.album)
-                writer.removeTag("ARTIST")
-                artists.forEach(artist => writer.setTag("ARTIST=" + artist))
-            }
-            writer.importPictureFromBuffer(Buffer.from(imageInfo.buffer))
-            audioData = writer.save()
-        }
-    } catch (e) {
-        console.warn("Error while appending cover image to file " + e)
-    }
-
-    const musicData = new Blob([audioData], {type: mime})
-
-    return {
-        status: true,
-        title: info.title,
-        artist: info.artist,
-        ext: musicMeta.format,
-        album: musicMeta.album,
-        picture: imageInfo.url,
-        file: URL.createObjectURL(musicData),
-        mime: mime
-    }
-}
-
-
-function getKeyData(dataView, fileBuffer, offset) {
-    const keyLen = dataView.getUint32(offset, true);
-    offset += 4;
-    const cipherText = new Uint8Array(fileBuffer, offset, keyLen).map(
-        uint8 => uint8 ^ 0x64
-    );
-    offset += keyLen;
-
-    const plainText = CryptoJS.AES.decrypt(
-        {ciphertext: CryptoJS.lib.WordArray.create(cipherText)},
-        CORE_KEY,
-        {
-            mode: CryptoJS.mode.ECB,
-            padding: CryptoJS.pad.Pkcs7
-        }
-    );
-
-    const result = new Uint8Array(plainText.sigBytes);
-
-    const words = plainText.words;
-    const sigBytes = plainText.sigBytes;
-    for (let i = 0; i < sigBytes; i++) {
-        result[i] = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
-    }
-
-    return {offset: offset, data: result.slice(17)};
-}
-
-function getKeyBox(keyData) {
-    const box = new Uint8Array(Array(256).keys());
-
-    const keyDataLen = keyData.length;
-
-    let j = 0;
-
-    for (let i = 0; i < 256; i++) {
-        j = (box[i] + j + keyData[i % keyDataLen]) & 0xff;
-        [box[i], box[j]] = [box[j], box[i]];
-    }
-
-    return box.map((_, i, arr) => {
-        i = (i + 1) & 0xff;
-        const si = arr[i];
-        const sj = arr[(i + si) & 0xff];
-        return arr[(si + sj) & 0xff];
-    });
-}
-
-/**
- * @typedef {Object} MusicMetaType
- * @property {Number} musicId
- * @property {String} musicName
- * @property {[[String, Number]]} artist
- * @property {String} album
- * @property {"flac"|"mp3"} format
- * @property {String} albumPic
- */
-
-function getMetaData(dataView, fileBuffer, offset) {
-    const metaDataLen = dataView.getUint32(offset, true);
-    offset += 4;
-    if (metaDataLen === 0) return {data: {}, offset: offset};
-
-    const cipherText = new Uint8Array(fileBuffer, offset, metaDataLen).map(
-        data => data ^ 0x63
-    );
-    offset += metaDataLen;
-
-    const plainText = CryptoJS.AES.decrypt({
-            ciphertext: CryptoJS.enc.Base64.parse(
-                CryptoJS.lib.WordArray.create(cipherText.slice(22)).toString(CryptoJS.enc.Utf8)
-            )
-        },
-        META_KEY,
-        {mode: CryptoJS.mode.ECB, padding: CryptoJS.pad.Pkcs7}
-    ).toString(CryptoJS.enc.Utf8);
-    const labelIndex = plainText.indexOf(":");
-    let result = JSON.parse(plainText.slice(labelIndex + 1));
-    if (plainText.slice(0, labelIndex) === "dj") {
-        result = result.mainMusic;
-    }
-    if (!!result.albumPic && result.albumPic !== "")
-        result.albumPic = result.albumPic.replace("http://", "https://") + "?param=500y500";
-
-    return {data: result, offset: offset};
-}
-
-

src/decrypt/ncm.ts

@@ -0,0 +1,248 @@
+import {
+  AudioMimeType,
+  BytesHasPrefix,
+  GetArrayBuffer,
+  GetImageFromURL,
+  GetMetaFromFile,
+  IMusicMeta,
+  SniffAudioExt,
+  WriteMetaToFlac,
+  WriteMetaToMp3,
+} from '@/decrypt/utils';
+import { parseBlob as metaParseBlob } from 'music-metadata-browser';
+import jimp from 'jimp';
+
+import AES from 'crypto-js/aes';
+import PKCS7 from 'crypto-js/pad-pkcs7';
+import ModeECB from 'crypto-js/mode-ecb';
+import WordArray from 'crypto-js/lib-typedarrays';
+import Base64 from 'crypto-js/enc-base64';
+import EncUTF8 from 'crypto-js/enc-utf8';
+import EncHex from 'crypto-js/enc-hex';
+
+import { DecryptResult } from '@/decrypt/entity';
+
+const CORE_KEY = EncHex.parse('687a4852416d736f356b496e62617857');
+const META_KEY = EncHex.parse('2331346C6A6B5F215C5D2630553C2728');
+const MagicHeader = [0x43, 0x54, 0x45, 0x4e, 0x46, 0x44, 0x41, 0x4d];
+
+export async function Decrypt(file: File, raw_filename: string, _: string): Promise<DecryptResult> {
+  return new NcmDecrypt(await GetArrayBuffer(file), raw_filename).decrypt();
+}
+
+interface NcmMusicMeta {
+  //musicId: number
+  musicName?: string;
+  artist?: Array<string | number>[];
+  format?: string;
+  album?: string;
+  albumPic?: string;
+}
+
+interface NcmDjMeta {
+  mainMusic: NcmMusicMeta;
+}
+
+class NcmDecrypt {
+  raw: ArrayBuffer;
+  view: DataView;
+  offset: number = 0;
+  filename: string;
+  format: string = '';
+  mime: string = '';
+  audio?: Uint8Array;
+  blob?: Blob;
+  oriMeta?: NcmMusicMeta;
+  newMeta?: IMusicMeta;
+  image?: { mime: string; buffer: ArrayBuffer; url: string };
+
+  constructor(buf: ArrayBuffer, filename: string) {
+    const prefix = new Uint8Array(buf, 0, 8);
+    if (!BytesHasPrefix(prefix, MagicHeader)) throw Error('此ncm文件已损坏');
+    this.offset = 10;
+    this.raw = buf;
+    this.view = new DataView(buf);
+    this.filename = filename;
+  }
+
+  _getKeyData(): Uint8Array {
+    const keyLen = this.view.getUint32(this.offset, true);
+    this.offset += 4;
+    const cipherText = new Uint8Array(this.raw, this.offset, keyLen).map((uint8) => uint8 ^ 0x64);
+    this.offset += keyLen;
+
+    const plainText = AES.decrypt(
+      // @ts-ignore
+      { ciphertext: WordArray.create(cipherText) },
+      CORE_KEY,
+      { mode: ModeECB, padding: PKCS7 },
+    );
+
+    const result = new Uint8Array(plainText.sigBytes);
+
+    const words = plainText.words;
+    const sigBytes = plainText.sigBytes;
+    for (let i = 0; i < sigBytes; i++) {
+      result[i] = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
+    }
+
+    return result.slice(17);
+  }
+
+  _getKeyBox(): Uint8Array {
+    const keyData = this._getKeyData();
+    const box = new Uint8Array(Array(256).keys());
+
+    const keyDataLen = keyData.length;
+
+    let j = 0;
+
+    for (let i = 0; i < 256; i++) {
+      j = (box[i] + j + keyData[i % keyDataLen]) & 0xff;
+      [box[i], box[j]] = [box[j], box[i]];
+    }
+
+    return box.map((_, i, arr) => {
+      i = (i + 1) & 0xff;
+      const si = arr[i];
+      const sj = arr[(i + si) & 0xff];
+      return arr[(si + sj) & 0xff];
+    });
+  }
+
+  _getMetaData(): NcmMusicMeta {
+    const metaDataLen = this.view.getUint32(this.offset, true);
+    this.offset += 4;
+    if (metaDataLen === 0) return {};
+
+    const cipherText = new Uint8Array(this.raw, this.offset, metaDataLen).map((data) => data ^ 0x63);
+    this.offset += metaDataLen;
+
+    WordArray.create();
+    const plainText = AES.decrypt(
+      // @ts-ignore
+      {
+        ciphertext: Base64.parse(
+          // @ts-ignore
+          WordArray.create(cipherText.slice(22)).toString(EncUTF8),
+        ),
+      },
+      META_KEY,
+      { mode: ModeECB, padding: PKCS7 },
+    ).toString(EncUTF8);
+
+    const labelIndex = plainText.indexOf(':');
+    let result: NcmMusicMeta;
+    if (plainText.slice(0, labelIndex) === 'dj') {
+      const tmp: NcmDjMeta = JSON.parse(plainText.slice(labelIndex + 1));
+      result = tmp.mainMusic;
+    } else {
+      result = JSON.parse(plainText.slice(labelIndex + 1));
+    }
+    if (result.albumPic) {
+      result.albumPic = result.albumPic.replace('http://', 'https://') + '?param=500y500';
+    }
+    return result;
+  }
+
+  _getAudio(keyBox: Uint8Array): Uint8Array {
+    this.offset += this.view.getUint32(this.offset + 5, true) + 13;
+    const audioData = new Uint8Array(this.raw, this.offset);
+    let lenAudioData = audioData.length;
+    for (let cur = 0; cur < lenAudioData; ++cur) audioData[cur] ^= keyBox[cur & 0xff];
+    return audioData;
+  }
+
+  async _buildMeta() {
+    if (!this.oriMeta) throw Error('invalid sequence');
+
+    const info = GetMetaFromFile(this.filename, this.oriMeta.musicName);
+
+    // build artists
+    let artists: string[] = [];
+    if (typeof this.oriMeta.artist === 'string') {
+      // v3.0: artist 现在可能是字符串了?
+      artists.push(this.oriMeta.artist);
+    } else if (Array.isArray(this.oriMeta.artist)) {
+      this.oriMeta.artist.forEach((artist) => {
+        if (typeof artist === 'string') {
+          artists.push(artist);
+        } else if (Array.isArray(artist) && artist[0] && typeof artist[0] === 'string') {
+          artists.push(artist[0]);
+        }
+      });
+    }
+
+    if (artists.length === 0 && info.artist) {
+      artists = info.artist
+        .split(',')
+        .map((val) => val.trim())
+        .filter((val) => val != '');
+    }
+
+    if (this.oriMeta.albumPic)
+      try {
+        this.image = await GetImageFromURL(this.oriMeta.albumPic);
+        while (this.image && this.image.buffer.byteLength >= 1 << 24) {
+          let img = await jimp.read(Buffer.from(this.image.buffer));
+          await img.resize(Math.round(img.getHeight() / 2), jimp.AUTO);
+          this.image.buffer = await img.getBufferAsync('image/jpeg');
+        }
+      } catch (e) {
+        console.log('fetch cover image failed', e);
+      }
+
+    this.newMeta = { title: info.title, artists, album: this.oriMeta.album, picture: this.image?.buffer };
+  }
+
+  async _writeMeta() {
+    if (!this.audio || !this.newMeta) throw Error('invalid sequence');
+
+    if (!this.blob) this.blob = new Blob([this.audio], { type: this.mime });
+    const ori = await metaParseBlob(this.blob);
+
+    let shouldWrite = !ori.common.album && !ori.common.artists && !ori.common.title;
+    if (shouldWrite || this.newMeta.picture) {
+      if (this.format === 'mp3') {
+        this.audio = WriteMetaToMp3(Buffer.from(this.audio), this.newMeta, ori);
+      } else if (this.format === 'flac') {
+        this.audio = WriteMetaToFlac(Buffer.from(this.audio), this.newMeta, ori);
+      } else {
+        console.info(`writing meta for ${this.format} is not being supported for now`);
+        return;
+      }
+      this.blob = new Blob([this.audio], { type: this.mime });
+    }
+  }
+
+  gatherResult(): DecryptResult {
+    if (!this.newMeta || !this.blob) throw Error('bad sequence');
+    return {
+      title: this.newMeta.title,
+      artist: this.newMeta.artists?.join('; '),
+      ext: this.format,
+      album: this.newMeta.album,
+      picture: this.image?.url,
+      file: URL.createObjectURL(this.blob),
+      blob: this.blob,
+      mime: this.mime,
+    };
+  }
+
+  async decrypt() {
+    const keyBox = this._getKeyBox();
+    this.oriMeta = this._getMetaData();
+    this.audio = this._getAudio(keyBox);
+    this.format = this.oriMeta.format || SniffAudioExt(this.audio);
+    this.mime = AudioMimeType[this.format];
+
+    try {
+      await this._buildMeta();
+      await this._writeMeta();
+    } catch (e) {
+      console.warn('build/write meta failed, skip.', e);
+    }
+
+    return this.gatherResult();
+  }
+}

src/decrypt/ncmcache.ts

@@ -0,0 +1,28 @@
+import { AudioMimeType, GetArrayBuffer, GetCoverFromFile, GetMetaFromFile, SniffAudioExt } from '@/decrypt/utils';
+
+import { DecryptResult } from '@/decrypt/entity';
+
+import { parseBlob as metaParseBlob } from 'music-metadata-browser';
+
+export async function Decrypt(file: Blob, raw_filename: string, raw_ext: string): Promise<DecryptResult> {
+  const buffer = new Uint8Array(await GetArrayBuffer(file));
+  let length = buffer.length;
+  for (let i = 0; i < length; i++) {
+    buffer[i] ^= 163;
+  }
+  const ext = SniffAudioExt(buffer, raw_ext);
+  if (ext !== raw_ext) file = new Blob([buffer], { type: AudioMimeType[ext] });
+  const tag = await metaParseBlob(file);
+  const { title, artist } = GetMetaFromFile(raw_filename, tag.common.title, String(tag.common.artists || tag.common.artist || ""));
+
+  return {
+    title,
+    artist,
+    ext,
+    album: tag.common.album,
+    picture: GetCoverFromFile(tag),
+    file: URL.createObjectURL(file),
+    blob: file,
+    mime: AudioMimeType[ext],
+  };
+}

src/decrypt/qmc.js

@@ -1,162 +0,0 @@
-import {
-    AudioMimeType,
-    DetectAudioExt,
-    GetArrayBuffer,
-    GetFileInfo,
-    GetMetaCoverURL,
-    GetWebImage,
-    IXAREA_API_ENDPOINT,
-    WriteMp3Meta
-} from "./util";
-import {QmcMaskCreate58, QmcMaskDetectMflac, QmcMaskDetectMgg, QmcMaskGetDefault} from "./qmcMask";
-import {fromByteArray as Base64Encode, toByteArray as Base64Decode} from 'base64-js'
-
-const MetaFlac = require('metaflac-js');
-
-const ID3Writer = require("browser-id3-writer");
-
-const iconv = require('iconv-lite');
-const decode = iconv.decode
-
-const musicMetadata = require("music-metadata-browser");
-
-const HandlerMap = {
-    "mgg": {handler: QmcMaskDetectMgg, ext: "ogg", detect: true},
-    "mflac": {handler: QmcMaskDetectMflac, ext: "flac", detect: true},
-    "qmc0": {handler: QmcMaskGetDefault, ext: "mp3", detect: false},
-    "qmc2": {handler: QmcMaskGetDefault, ext: "ogg", detect: false},
-    "qmc3": {handler: QmcMaskGetDefault, ext: "mp3", detect: false},
-    "qmcogg": {handler: QmcMaskGetDefault, ext: "ogg", detect: false},
-    "qmcflac": {handler: QmcMaskGetDefault, ext: "flac", detect: false},
-    "bkcmp3": {handler: QmcMaskGetDefault, ext: "mp3", detect: false},
-    "bkcflac": {handler: QmcMaskGetDefault, ext: "flac", detect: false},
-    "tkm": {handler: QmcMaskGetDefault, ext: "m4a", detect: false},
-    "666c6163": {handler: QmcMaskGetDefault, ext: "flac", detect: false},
-    "6d7033": {handler: QmcMaskGetDefault, ext: "mp3", detect: false},
-    "6f6767": {handler: QmcMaskGetDefault, ext: "ogg", detect: false},
-    "6d3461": {handler: QmcMaskGetDefault, ext: "m4a", detect: false},
-    "776176": {handler: QmcMaskGetDefault, ext: "wav", detect: false}
-};
-
-export async function Decrypt(file, raw_filename, raw_ext) {
-    if (!(raw_ext in HandlerMap)) return {status: false, message: "File type is incorrect!"};
-    const handler = HandlerMap[raw_ext];
-
-    const fileData = new Uint8Array(await GetArrayBuffer(file));
-    let audioData, seed, keyData;
-    if (handler.detect) {
-        const keyLen = new DataView(fileData.slice(fileData.length - 4).buffer).getUint32(0, true)
-        const keyPos = fileData.length - 4 - keyLen;
-        audioData = fileData.slice(0, keyPos);
-        seed = handler.handler(audioData);
-        keyData = fileData.slice(keyPos, keyPos + keyLen);
-        if (seed === undefined) seed = await queryKeyInfo(keyData, raw_filename, raw_ext);
-        if (seed === undefined) return {status: false, message: raw_ext + "格式仅提供实验性支持"};
-    } else {
-        audioData = fileData;
-        seed = handler.handler(audioData);
-    }
-    let musicDecoded = seed.Decrypt(audioData);
-
-    const ext = DetectAudioExt(musicDecoded, handler.ext);
-    const mime = AudioMimeType[ext];
-
-    let musicBlob = new Blob([musicDecoded], {type: mime});
-
-    const musicMeta = await musicMetadata.parseBlob(musicBlob);
-    for (let metaIdx in musicMeta.native) {
-        if (musicMeta.native[metaIdx].some(item => item.id === "TCON" && item.value === "(12)")) {
-            console.warn("The metadata is using gbk encoding")
-            musicMeta.common.artist = decode(musicMeta.common.artist, "gbk");
-            musicMeta.common.title = decode(musicMeta.common.title, "gbk");
-            musicMeta.common.album = decode(musicMeta.common.album, "gbk");
-        }
-    }
-
-    const info = GetFileInfo(musicMeta.common.artist, musicMeta.common.title, raw_filename);
-    if (handler.detect) reportKeyUsage(keyData, seed.Matrix128,
-        info.artist, info.title, musicMeta.common.album, raw_filename, raw_ext);
-
-    let imgUrl = GetMetaCoverURL(musicMeta);
-    if (imgUrl === "") {
-        imgUrl = await queryAlbumCoverImage(info.artist, info.title, musicMeta.common.album);
-        if (imgUrl !== "") {
-            const imageInfo = await GetWebImage(imgUrl);
-            if (imageInfo.url !== "") {
-                imgUrl = imageInfo.url
-                try {
-                    if (ext === "mp3") {
-                        musicDecoded = await WriteMp3Meta(musicDecoded,
-                            info.artist.split(" _ "), info.title, "",
-                            imageInfo.buffer, "Cover", musicMeta)
-                        musicBlob = new Blob([musicDecoded], {type: mime});
-                    } else if (ext === 'flac') {
-                        const writer = new MetaFlac(Buffer.from(musicDecoded))
-                        writer.importPictureFromBuffer(Buffer.from(imageInfo.buffer))
-                        musicDecoded = writer.save()
-                        musicBlob = new Blob([musicDecoded], {type: mime});
-                    } else {
-                        console.info("writing metadata for " + ext + " is not being supported for now")
-                    }
-                } catch (e) {
-                    console.warn("Error while appending cover image to file " + e)
-                }
-            }
-        }
-    }
-    return {
-        status: true,
-        title: info.title,
-        artist: info.artist,
-        ext: ext,
-        album: musicMeta.common.album,
-        picture: imgUrl,
-        file: URL.createObjectURL(musicBlob),
-        mime: mime
-    }
-}
-
-function reportKeyUsage(keyData, maskData, artist, title, album, filename, format) {
-    fetch(IXAREA_API_ENDPOINT + "/qmcmask/usage", {
-        method: "POST",
-        headers: {"Content-Type": "application/json"},
-        body: JSON.stringify({
-            Mask: Base64Encode(new Uint8Array(maskData)), Key: Base64Encode(keyData),
-            Artist: artist, Title: title, Album: album, Filename: filename, Format: format
-        }),
-    }).then().catch()
-}
-
-async function queryKeyInfo(keyData, filename, format) {
-    try {
-        const resp = await fetch(IXAREA_API_ENDPOINT + "/qmcmask/query", {
-            method: "POST",
-            headers: {"Content-Type": "application/json"},
-            body: JSON.stringify({Format: format, Key: Base64Encode(keyData), Filename: filename, Type: 44}),
-        });
-        let data = await resp.json();
-        return QmcMaskCreate58(Base64Decode(data.Matrix44));
-    } catch (e) {
-        console.log(e);
-    }
-}
-
-async function queryAlbumCoverImage(artist, title, album) {
-    const song_query_url = IXAREA_API_ENDPOINT + "/music/qq-cover"
-    try {
-        const params = {Artist: artist, Title: title, Album: album};
-        let _url = song_query_url + "?";
-        for (let pKey in params) {
-            _url += pKey + "=" + encodeURIComponent(params[pKey]) + "&"
-        }
-        const resp = await fetch(_url)
-        if (resp.ok) {
-            let data = await resp.json();
-            return song_query_url + "/" + data.Type + "/" + data.Id
-        }
-
-    } catch (e) {
-        console.log(e);
-    }
-    return "";
-}

src/decrypt/qmc.ts

@@ -0,0 +1,88 @@
+import { AudioMimeType, GetArrayBuffer, SniffAudioExt } from '@/decrypt/utils';
+
+import { DecryptResult } from '@/decrypt/entity';
+import { DecryptQmcWasm } from '@/decrypt/qmc_wasm';
+import { extractQQMusicMeta } from '@/utils/qm_meta';
+
+interface Handler {
+  ext: string;
+  version: number;
+}
+
+export const HandlerMap: { [key: string]: Handler } = {
+  mgg: { ext: 'ogg', version: 2 },
+  mgg0: { ext: 'ogg', version: 2 },
+  mggl: { ext: 'ogg', version: 2 },
+  mgg1: { ext: 'ogg', version: 2 },
+  mflac: { ext: 'flac', version: 2 },
+  mflac0: { ext: 'flac', version: 2 },
+  mmp4: { ext: 'mp4', version: 2 },
+
+  // qmcflac / qmcogg:
+  // 有可能是 v2 加密但混用同一个后缀名。
+  qmcflac: { ext: 'flac', version: 2 },
+  qmcogg: { ext: 'ogg', version: 2 },
+
+  qmc0: { ext: 'mp3', version: 2 },
+  qmc2: { ext: 'ogg', version: 2 },
+  qmc3: { ext: 'mp3', version: 2 },
+  qmc4: { ext: 'ogg', version: 2 },
+  qmc6: { ext: 'ogg', version: 2 },
+  qmc8: { ext: 'ogg', version: 2 },
+  bkcmp3: { ext: 'mp3', version: 1 },
+  bkcm4a: { ext: 'm4a', version: 1 },
+  bkcflac: { ext: 'flac', version: 1 },
+  bkcwav: { ext: 'wav', version: 1 },
+  bkcape: { ext: 'ape', version: 1 },
+  bkcogg: { ext: 'ogg', version: 1 },
+  bkcwma: { ext: 'wma', version: 1 },
+  tkm: { ext: 'm4a', version: 1 },
+  '666c6163': { ext: 'flac', version: 1 },
+  '6d7033': { ext: 'mp3', version: 1 },
+  '6f6767': { ext: 'ogg', version: 1 },
+  '6d3461': { ext: 'm4a', version: 1 },
+  '776176': { ext: 'wav', version: 1 },
+};
+
+export async function Decrypt(file: Blob, raw_filename: string, raw_ext: string): Promise<DecryptResult> {
+  if (!(raw_ext in HandlerMap)) throw `Qmc cannot handle type: ${raw_ext}`;
+  const handler = HandlerMap[raw_ext];
+  let { version } = handler;
+
+  const fileBuffer = await GetArrayBuffer(file);
+  let musicDecoded = new Uint8Array();
+  let musicID: number | string | undefined;
+
+  if (version === 2 && globalThis.WebAssembly) {
+    const v2Decrypted = await DecryptQmcWasm(fileBuffer, raw_ext);
+    // 若 v2 检测失败，降级到 v1 再尝试一次
+    if (v2Decrypted.success) {
+      musicDecoded = v2Decrypted.data;
+      musicID = v2Decrypted.songId;
+      console.log('qmc wasm decoder suceeded');
+    } else {
+      throw new Error(v2Decrypted.error || '(unknown error)');
+    }
+  }
+
+  const ext = SniffAudioExt(musicDecoded, handler.ext);
+  const mime = AudioMimeType[ext];
+
+  const { album, artist, imgUrl, blob, title } = await extractQQMusicMeta(
+    new Blob([musicDecoded], { type: mime }),
+    raw_filename,
+    ext,
+    musicID,
+  );
+
+  return {
+    title: title,
+    artist: artist,
+    ext: ext,
+    album: album,
+    picture: imgUrl,
+    file: URL.createObjectURL(blob),
+    blob: blob,
+    mime: mime,
+  };
+}

src/decrypt/qmcMask.js

@@ -1,273 +0,0 @@
-import {FLAC_HEADER, IsBytesEqual, OGG_HEADER} from "./util"
-
-const QMOggPublicHeader1 = [
-    0x4f, 0x67, 0x67, 0x53, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
-    0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x01, 0x1e, 0x01, 0x76, 0x6f, 0x72,
-    0x62, 0x69, 0x73, 0x00, 0x00, 0x00, 0x00, 0x02, 0x44, 0xac, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0xee, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb8, 0x01, 0x4f, 0x67, 0x67, 0x53, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00,
-    0xff, 0xff, 0xff, 0xff];
-const QMOggPublicHeader2 = [
-    0x03, 0x76, 0x6f, 0x72, 0x62, 0x69, 0x73, 0x2c, 0x00, 0x00, 0x00, 0x58, 0x69, 0x70, 0x68, 0x2e,
-    0x4f, 0x72, 0x67, 0x20, 0x6c, 0x69, 0x62, 0x56, 0x6f, 0x72, 0x62, 0x69, 0x73, 0x20, 0x49, 0x20,
-    0x32, 0x30, 0x31, 0x35, 0x30, 0x31, 0x30, 0x35, 0x20, 0x28, 0xe2, 0x9b, 0x84, 0xe2, 0x9b, 0x84,
-    0xe2, 0x9b, 0x84, 0xe2, 0x9b, 0x84, 0x29, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x54,
-    0x49, 0x54, 0x4c, 0x45, 0x3d];
-const QMOggPublicConf1 = [
-    9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0,
-    0, 0, 9, 9, 9, 9, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9,
-    9, 9, 9, 9, 9, 9, 9, 6, 3, 3, 3, 3, 6, 6, 6, 6,
-    3, 3, 3, 3, 6, 6, 6, 6, 6, 9, 9, 9, 9, 9, 9, 9,
-    9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 9, 9, 9, 9,
-    0, 0, 0, 0];
-const QMOggPublicConf2 = [
-    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-    3, 3, 3, 3, 3, 3, 3, 0, 1, 3, 3, 0, 1, 3, 3, 3,
-    3, 3, 3, 3, 3];
-const QMCDefaultMaskMatrix = [
-    0xde, 0x51, 0xfa, 0xc3, 0x4a, 0xd6, 0xca, 0x90,
-    0x7e, 0x67, 0x5e, 0xf7, 0xd5, 0x52, 0x84, 0xd8,
-    0x47, 0x95, 0xbb, 0xa1, 0xaa, 0xc6, 0x66, 0x23,
-    0x92, 0x62, 0xf3, 0x74, 0xa1, 0x9f, 0xf4, 0xa0,
-    0x1d, 0x3f, 0x5b, 0xf0, 0x13, 0x0e, 0x09, 0x3d,
-    0xf9, 0xbc, 0x00, 0x11];
-
-
-class QmcMask {
-    constructor(matrix, superA, superB) {
-        if (superA === undefined || superB === undefined) {
-            if (matrix.length === 44) {
-                this.Matrix44 = matrix
-                this.generateMask128from44()
-            } else {
-                this.Matrix128 = matrix
-                this.generateMask44from128()
-            }
-            this.generateMask58from128()
-        } else {
-            this.Matrix58 = matrix;
-            this.Super58A = superA;
-            this.Super58B = superB;
-            this.generateMask128from58();
-            this.generateMask44from128()
-        }
-    }
-
-    generateMask128from58() {
-        if (this.Matrix58.length !== 56) throw "incorrect mask58 matrix length";
-
-        let matrix128 = [];
-        for (let rowIdx = 0; rowIdx < 8; rowIdx += 1) {
-            matrix128 = matrix128.concat(
-                [this.Super58A],
-                this.Matrix58.slice(7 * rowIdx, 7 * rowIdx + 7),
-                [this.Super58B],
-                this.Matrix58.slice(56 - 7 - 7 * rowIdx, 56 - 7 * rowIdx).reverse()
-            );
-        }
-        this.Matrix128 = matrix128;
-    }
-
-    generateMask58from128() {
-        if (this.Matrix128.length !== 128) throw "incorrect mask128 length";
-
-        const superA = this.Matrix128[0], superB = this.Matrix128[8];
-        let matrix58 = [];
-
-        for (let rowIdx = 0; rowIdx < 8; rowIdx += 1) {
-            let lenStart = 16 * rowIdx;
-            let lenRightStart = 120 - lenStart;
-            if (this.Matrix128[lenStart] !== superA || this.Matrix128[lenStart + 8] !== superB) {
-                throw "decode mask-128 to mask-58 failed"
-            }
-            let rowLeft = this.Matrix128.slice(lenStart + 1, lenStart + 8);
-            let rowRight = this.Matrix128.slice(lenRightStart + 1, lenRightStart + 8).reverse();
-            if (IsBytesEqual(rowLeft, rowRight)) {
-                matrix58 = matrix58.concat(rowLeft);
-            } else {
-                throw "decode mask-128 to mask-58 failed"
-            }
-        }
-        this.Matrix58 = matrix58;
-        this.Super58A = superA;
-        this.Super58B = superB;
-    }
-
-    generateMask44from128() {
-        if (this.Matrix128.length !== 128) throw "incorrect mask128 matrix length";
-        let mapping = GetConvertMapping()
-        this.Matrix44 = []
-        let idxI44 = 0
-        mapping.forEach(it256 => {
-            let it256Len = it256.length
-            for (let i = 1; i < it256Len; i++) {
-                if (this.Matrix128[it256[0]] !== this.Matrix128[it256[i]]) {
-                    throw "decode mask-128 to mask-44 failed"
-                }
-            }
-            this.Matrix44[idxI44] = this.Matrix128[it256[0]]
-            idxI44++
-        })
-    }
-
-    generateMask128from44() {
-        if (this.Matrix44.length !== 44) throw "incorrect mask length"
-        this.Matrix128 = []
-        let idx44 = 0
-        GetConvertMapping().forEach(it256 => {
-            it256.forEach(m => {
-                this.Matrix128[m] = this.Matrix44[idx44]
-            })
-            idx44++
-        })
-    }
-
-    Decrypt(data) {
-        let dst = data.slice(0);
-        let index = -1;
-        let maskIdx = -1;
-        for (let cur = 0; cur < data.length; cur++) {
-            index++;
-            maskIdx++;
-            if (index === 0x8000 || (index > 0x8000 && (index + 1) % 0x8000 === 0)) {
-                index++;
-                maskIdx++;
-            }
-            if (maskIdx >= 128) maskIdx -= 128;
-            dst[cur] ^= this.Matrix128[maskIdx];
-        }
-        return dst;
-    }
-}
-
-export function QmcMaskGetDefault() {
-    return new QmcMask(QMCDefaultMaskMatrix)
-}
-
-export function QmcMaskDetectMflac(data) {
-    let search_len = Math.min(0x8000, data.length), mask;
-    for (let block_idx = 0; block_idx < search_len; block_idx += 128) {
-        try {
-            mask = new QmcMask(data.slice(block_idx, block_idx + 128));
-            if (IsBytesEqual(FLAC_HEADER, mask.Decrypt(data.slice(0, FLAC_HEADER.length)))) break;
-        } catch (e) {
-        }
-    }
-    return mask;
-}
-
-export function QmcMaskDetectMgg(data) {
-    if (data.length < 0x100) return
-    let matrixConfidence = {};
-    for (let i = 0; i < 44; i++) matrixConfidence[i] = {};
-
-    const page2 = data[0x54] ^ data[0xC] ^ QMOggPublicHeader1[0xC];
-    const spHeader = QmcGenerateOggHeader(page2)
-    const spConf = QmcGenerateOggConf(page2)
-
-    for (let idx128 = 0; idx128 < spHeader.length; idx128++) {
-        if (spConf[idx128] === 0) continue;
-        let idx44 = GetMask44Index(idx128);
-        let _m = data[idx128] ^ spHeader[idx128]
-        let confidence = spConf[idx128];
-        if (_m in matrixConfidence[idx44]) {
-            matrixConfidence[idx44][_m] += confidence
-        } else {
-            matrixConfidence[idx44][_m] = confidence
-        }
-    }
-    let matrix = [];
-    try {
-        for (let i = 0; i < 44; i++)
-            matrix[i] = getMaskConfidenceResult(matrixConfidence[i]);
-    } catch (e) {
-        return;
-    }
-    const mask = new QmcMask(matrix);
-    let dx = mask.Decrypt(data.slice(0, OGG_HEADER.length));
-    if (!IsBytesEqual(OGG_HEADER, dx)) {
-        return;
-    }
-
-    return mask;
-}
-
-export function QmcMaskCreate128(mask128) {
-    return new QmcMask(mask128)
-}
-
-export function QmcMaskCreate58(matrix, superA, superB) {
-    return new QmcMask(matrix, superA, superB)
-}
-
-export function QmcMaskCreate44(mask44) {
-    return new QmcMask(mask44)
-}
-
-/**
- * @param confidence {{}}
- * @returns {number}
- */
-function getMaskConfidenceResult(confidence) {
-    if (confidence.length === 0) throw "can not match at least one key";
-    if (confidence.length > 1) console.warn("There are 2 potential value for the mask!")
-    let result, conf = 0;
-    for (let idx in confidence) {
-        if (confidence[idx] > conf) {
-            result = idx;
-            conf = confidence[idx];
-        }
-    }
-    return parseInt(result)
-}
-
-/**
- * @return {number}
- */
-
-
-const allMapping = [];
-const mask128to44 = [];
-
-(function () {
-    for (let i = 0; i < 128; i++) {
-        let realIdx = (i * i + 27) % 256
-        if (realIdx in allMapping) {
-            allMapping[realIdx].push(i)
-        } else {
-            allMapping[realIdx] = [i]
-        }
-    }
-
-    let idx44 = 0
-    allMapping.forEach(all128 => {
-        all128.forEach(_i128 => {
-            mask128to44[_i128] = idx44
-        })
-        idx44++
-    })
-})();
-
-function GetConvertMapping() {
-    return allMapping;
-}
-
-function GetMask44Index(idx128) {
-    return mask128to44[idx128 % 128]
-}
-
-function QmcGenerateOggHeader(page2) {
-    let spec = [page2, 0xFF]
-    for (let i = 2; i < page2; i++) spec.push(0xFF)
-    spec.push(0xFF)
-    return QMOggPublicHeader1.concat(spec, QMOggPublicHeader2)
-}
-
-function QmcGenerateOggConf(page2) {
-    let specConf = [6, 0]
-    for (let i = 2; i < page2; i++) specConf.push(4)
-    specConf.push(0)
-    return QMOggPublicConf1.concat(specConf, QMOggPublicConf2)
-}

src/decrypt/qmc_wasm.ts

@@ -0,0 +1,75 @@
+import { QmcCrypto } from '@xhacker/qmcwasm/QmcWasmBundle';
+import QmcCryptoModule from '@xhacker/qmcwasm/QmcWasmBundle';
+import { MergeUint8Array } from '@/utils/MergeUint8Array';
+
+// 每次可以处理 2M 的数据
+const DECRYPTION_BUF_SIZE = 2 *1024 * 1024;
+
+export interface QMCDecryptionResult {
+  success: boolean;
+  data: Uint8Array;
+  songId: string | number;
+  error: string;
+}
+
+/**
+ * 解密一个 QMC 加密的文件。
+ *
+ * 如果检测并解密成功，返回解密后的 Uint8Array 数据。
+ * @param  {ArrayBuffer} qmcBlob 读入的文件 Blob
+ */
+export async function DecryptQmcWasm(qmcBlob: ArrayBuffer, ext: string): Promise<QMCDecryptionResult> {
+  const result: QMCDecryptionResult = { success: false, data: new Uint8Array(), songId: 0, error: '' };
+
+  // 初始化模组
+  let QmcCryptoObj: QmcCrypto;
+
+  try {
+    QmcCryptoObj = await QmcCryptoModule();
+  } catch (err: any) {
+    result.error = err?.message || 'wasm 加载失败';
+    return result;
+  }
+  if (!QmcCryptoObj) {
+    result.error = 'wasm 加载失败';
+    return result;
+  }
+
+  // 申请内存块，并文件末端数据到 WASM 的内存堆
+  const qmcBuf = new Uint8Array(qmcBlob);
+  const pQmcBuf = QmcCryptoObj._malloc(DECRYPTION_BUF_SIZE);
+  const preDecDataSize = Math.min(DECRYPTION_BUF_SIZE, qmcBlob.byteLength); // 初始化缓冲区大小
+  QmcCryptoObj.writeArrayToMemory(qmcBuf.slice(-preDecDataSize), pQmcBuf);
+
+  // 进行解密初始化
+  ext = '.' + ext;
+  const tailSize = QmcCryptoObj.preDec(pQmcBuf, preDecDataSize, ext);
+  if (tailSize == -1) {
+    result.error = QmcCryptoObj.getErr();
+    return result;
+  } else {
+    result.songId = QmcCryptoObj.getSongId();
+    result.songId = result.songId == "0" ? 0 : result.songId;
+  }
+
+  const decryptedParts = [];
+  let offset = 0;
+  let bytesToDecrypt = qmcBuf.length - tailSize;
+  while (bytesToDecrypt > 0) {
+    const blockSize = Math.min(bytesToDecrypt, DECRYPTION_BUF_SIZE);
+
+    // 解密一些片段
+    const blockData = new Uint8Array(qmcBuf.slice(offset, offset + blockSize));
+    QmcCryptoObj.writeArrayToMemory(blockData, pQmcBuf);
+    decryptedParts.push(QmcCryptoObj.HEAPU8.slice(pQmcBuf, pQmcBuf + QmcCryptoObj.decBlob(pQmcBuf, blockSize, offset)));
+
+    offset += blockSize;
+    bytesToDecrypt -= blockSize;
+  }
+  QmcCryptoObj._free(pQmcBuf);
+
+  result.data = MergeUint8Array(decryptedParts);
+  result.success = true;
+
+  return result;
+}

src/decrypt/qmccache.ts

@@ -0,0 +1,58 @@
+import {
+  AudioMimeType,
+  GetArrayBuffer,
+  GetCoverFromFile,
+  GetMetaFromFile,
+  SniffAudioExt,
+  SplitFilename,
+} from '@/decrypt/utils';
+
+import { Decrypt as QmcDecrypt, HandlerMap } from '@/decrypt/qmc';
+import { DecryptQmcWasm } from '@/decrypt/qmc_wasm';
+
+import { DecryptResult } from '@/decrypt/entity';
+
+import { parseBlob as metaParseBlob } from 'music-metadata-browser';
+
+export async function Decrypt(file: Blob, raw_filename: string, raw_ext: string): Promise<DecryptResult> {
+  const buffer = await GetArrayBuffer(file);
+
+  let musicDecoded = new Uint8Array();
+  if (globalThis.WebAssembly) {
+    console.log('qmc: using wasm decoder');
+
+    const qmcDecrypted = await DecryptQmcWasm(buffer, raw_ext);
+    // 若 wasm 失败，使用 js 再尝试一次
+    if (qmcDecrypted.success) {
+      musicDecoded = qmcDecrypted.data;
+      console.log('qmc wasm decoder suceeded');
+    } else {
+      throw new Error(qmcDecrypted.error || '(unknown error)');
+    }
+  }
+
+  let ext = SniffAudioExt(musicDecoded, '');
+  const newName = SplitFilename(raw_filename);
+  let audioBlob: Blob;
+  if (ext !== '' || newName.ext === 'mp3') {
+    audioBlob = new Blob([musicDecoded], { type: AudioMimeType[ext] });
+  } else if (newName.ext in HandlerMap) {
+    audioBlob = new Blob([musicDecoded], { type: 'application/octet-stream' });
+    return QmcDecrypt(audioBlob, newName.name, newName.ext);
+  } else {
+    throw '不支持的QQ音乐缓存格式';
+  }
+  const tag = await metaParseBlob(audioBlob);
+  const { title, artist } = GetMetaFromFile(raw_filename, tag.common.title, String(tag.common.artists || tag.common.artist || ""));
+
+  return {
+    title,
+    artist,
+    ext,
+    album: tag.common.album,
+    picture: GetCoverFromFile(tag),
+    file: URL.createObjectURL(audioBlob),
+    blob: audioBlob,
+    mime: AudioMimeType[ext],
+  };
+}

src/decrypt/raw.js

@@ -1,23 +0,0 @@
-const musicMetadata = require("music-metadata-browser");
-import {AudioMimeType, DetectAudioExt, GetArrayBuffer, GetMetaCoverURL, GetFileInfo} from "./util";
-
-export async function Decrypt(file, raw_filename, raw_ext, detect = true) {
-    let ext = raw_ext;
-    if (detect) {
-        const buffer = new Uint8Array(await GetArrayBuffer(file));
-        ext = DetectAudioExt(buffer, raw_ext);
-        if (ext !== raw_ext) file = new Blob([buffer], {type: AudioMimeType[ext]})
-    }
-    const tag = await musicMetadata.parseBlob(file);
-    const info = GetFileInfo(tag.common.artist, tag.common.title, raw_filename);
-    return {
-        status: true,
-        title: info.title,
-        artist: info.artist,
-        ext: ext,
-        album: tag.common.album,
-        picture: GetMetaCoverURL(tag),
-        file: URL.createObjectURL(file),
-        mime: AudioMimeType[ext]
-    }
-}

src/decrypt/raw.ts

@@ -0,0 +1,32 @@
+import { AudioMimeType, GetArrayBuffer, GetCoverFromFile, GetMetaFromFile, SniffAudioExt } from '@/decrypt/utils';
+
+import { DecryptResult } from '@/decrypt/entity';
+
+import { parseBlob as metaParseBlob } from 'music-metadata-browser';
+
+export async function Decrypt(
+  file: Blob,
+  raw_filename: string,
+  raw_ext: string,
+  detect: boolean = true,
+): Promise<DecryptResult> {
+  let ext = raw_ext;
+  if (detect) {
+    const buffer = new Uint8Array(await GetArrayBuffer(file));
+    ext = SniffAudioExt(buffer, raw_ext);
+    if (ext !== raw_ext) file = new Blob([buffer], { type: AudioMimeType[ext] });
+  }
+  const tag = await metaParseBlob(file);
+  const { title, artist } = GetMetaFromFile(raw_filename, tag.common.title, String(tag.common.artists || tag.common.artist || ''));
+
+  return {
+    title,
+    artist,
+    ext,
+    album: tag.common.album,
+    picture: GetCoverFromFile(tag),
+    file: URL.createObjectURL(file),
+    blob: file,
+    mime: AudioMimeType[ext],
+  };
+}

src/decrypt/tm.js

@@ -1,14 +0,0 @@
-import {Decrypt as RawDecrypt} from "./raw";
-import {GetArrayBuffer} from "./util";
-
-const TM_HEADER = [0x00, 0x00, 0x00, 0x20, 0x66, 0x74, 0x79, 0x70];
-
-export async function Decrypt(file, raw_filename) {
-    const fileBuffer = await GetArrayBuffer(file);
-    const audioData = new Uint8Array(fileBuffer);
-    for (let cur = 0; cur < 8; ++cur) {
-        audioData[cur] = TM_HEADER[cur];
-    }
-    const musicData = new Blob([audioData], {type: "audio/mp4"});
-    return await RawDecrypt(musicData, raw_filename, "m4a", false)
-}

src/decrypt/tm.ts

@@ -0,0 +1,14 @@
+import { Decrypt as RawDecrypt } from './raw';
+import { GetArrayBuffer } from '@/decrypt/utils';
+import { DecryptResult } from '@/decrypt/entity';
+
+const TM_HEADER = [0x00, 0x00, 0x00, 0x20, 0x66, 0x74, 0x79, 0x70];
+
+export async function Decrypt(file: File, raw_filename: string): Promise<DecryptResult> {
+  const audioData = new Uint8Array(await GetArrayBuffer(file));
+  for (let cur = 0; cur < 8; ++cur) {
+    audioData[cur] = TM_HEADER[cur];
+  }
+  const musicData = new Blob([audioData], { type: 'audio/mp4' });
+  return await RawDecrypt(musicData, raw_filename, 'm4a', false);
+}

src/decrypt/util.js

@@ -1,125 +0,0 @@
-const ID3Writer = require("browser-id3-writer");
-const musicMetadata = require("music-metadata-browser");
-export const FLAC_HEADER = [0x66, 0x4C, 0x61, 0x43];
-export const MP3_HEADER = [0x49, 0x44, 0x33];
-export const OGG_HEADER = [0x4F, 0x67, 0x67, 0x53];
-export const M4A_HEADER = [0x66, 0x74, 0x79, 0x70];
-export const WMA_HEADER = [
-    0x30, 0x26, 0xB2, 0x75, 0x8E, 0x66, 0xCF, 0x11,
-    0xA6, 0xD9, 0x00, 0xAA, 0x00, 0x62, 0xCE, 0x6C,
-]
-export const WAV_HEADER = [0x52, 0x49, 0x46, 0x46]
-export const AudioMimeType = {
-    mp3: "audio/mpeg",
-    flac: "audio/flac",
-    m4a: "audio/mp4",
-    ogg: "audio/ogg",
-    wma: "audio/x-ms-wma",
-    wav: "audio/x-wav"
-};
-export const IXAREA_API_ENDPOINT = "https://stats.ixarea.com/apis"
-
-// Also a new draft API: blob.arrayBuffer()
-export async function GetArrayBuffer(blobObject) {
-    return await new Promise(resolve => {
-        const reader = new FileReader();
-        reader.onload = (e) => {
-            resolve(e.target.result);
-        };
-        reader.readAsArrayBuffer(blobObject);
-    });
-}
-
-export function GetFileInfo(artist, title, filenameNoExt, separator = "-") {
-    let newArtist = "", newTitle = "";
-    let filenameArray = filenameNoExt.split(separator);
-    if (filenameArray.length > 1) {
-        newArtist = filenameArray[0].trim();
-        newTitle = filenameArray[1].trim();
-    } else if (filenameArray.length === 1) {
-        newTitle = filenameArray[0].trim();
-    }
-
-    if (typeof artist == "string" && artist !== "") newArtist = artist;
-    if (typeof title == "string" && title !== "") newTitle = title;
-    return {artist: newArtist, title: newTitle};
-}
-
-/**
- * @return {string}
- */
-export function GetMetaCoverURL(metadata) {
-    let pic_url = "";
-    if (metadata.common.picture !== undefined && metadata.common.picture.length > 0) {
-        let pic = new Blob([metadata.common.picture[0].data], {type: metadata.common.picture[0].format});
-        pic_url = URL.createObjectURL(pic);
-    }
-    return pic_url;
-}
-
-export function IsBytesEqual(first, second) {
-    // if want wholly check, should length first>=second
-    return first.every((val, idx) => {
-        return val === second[idx];
-    })
-}
-
-/**
- * @return {string}
- */
-export function DetectAudioExt(data, fallbackExt) {
-    if (IsBytesEqual(MP3_HEADER, data.slice(0, MP3_HEADER.length))) return "mp3";
-    if (IsBytesEqual(FLAC_HEADER, data.slice(0, FLAC_HEADER.length))) return "flac";
-    if (IsBytesEqual(OGG_HEADER, data.slice(0, OGG_HEADER.length))) return "ogg";
-    if (IsBytesEqual(M4A_HEADER, data.slice(4, 4 + M4A_HEADER.length))) return "m4a";
-    if (IsBytesEqual(WMA_HEADER, data.slice(0, WMA_HEADER.length))) return "wma";
-    if (IsBytesEqual(WAV_HEADER, data.slice(0, WAV_HEADER.length))) return "wav";
-    return fallbackExt;
-}
-
-
-export async function GetWebImage(pic_url) {
-    try {
-        let resp = await fetch(pic_url);
-        let mime = resp.headers.get("Content-Type");
-        if (mime.startsWith("image/")) {
-            let buf = await resp.arrayBuffer();
-            let objBlob = new Blob([buf], {type: mime});
-            let objUrl = URL.createObjectURL(objBlob);
-            return {"buffer": buf, "src": pic_url, "url": objUrl, "type": mime};
-        }
-    } catch (e) {
-    }
-    return {"buffer": null, "src": pic_url, "url": "", "type": ""}
-}
-
-export async function WriteMp3Meta(audioData, artistList, title, album, pictureData = null, pictureDesc = "Cover", originalMeta = null) {
-    const writer = new ID3Writer(audioData);
-    if (originalMeta !== null) {
-        artistList = originalMeta.common.artists || artistList
-        title = originalMeta.common.title || title
-        album = originalMeta.common.album || album
-        const frames = originalMeta.native['ID3v2.4'] || originalMeta.native['ID3v2.3'] || originalMeta.native['ID3v2.2'] || []
-        frames.forEach(frame => {
-            if (frame.id !== 'TPE1' && frame.id !== 'TIT2' && frame.id !== 'TALB') {
-                try {
-                    writer.setFrame(frame.id, frame.value)
-                } catch (e) {
-                }
-            }
-        })
-    }
-    writer.setFrame('TPE1', artistList)
-        .setFrame('TIT2', title)
-        .setFrame('TALB', album);
-    if (pictureData !== null) {
-        writer.setFrame('APIC', {
-            type: 3,
-            data: pictureData,
-            description: pictureDesc,
-        })
-    }
-    writer.addTag();
-    return writer.arrayBuffer;
-}
-

src/decrypt/utils.ts

@@ -0,0 +1,262 @@
+import { IAudioMetadata } from 'music-metadata-browser';
+import ID3Writer from 'browser-id3-writer';
+import MetaFlac from 'metaflac-js';
+
+export const split_regex = /[ ]?[,;/_、][ ]?/;
+
+export const FLAC_HEADER = [0x66, 0x4c, 0x61, 0x43];
+export const MP3_HEADER = [0x49, 0x44, 0x33];
+export const OGG_HEADER = [0x4f, 0x67, 0x67, 0x53];
+export const M4A_HEADER = [0x66, 0x74, 0x79, 0x70];
+//prettier-ignore
+export const WMA_HEADER = [
+  0x30, 0x26, 0xb2, 0x75, 0x8e, 0x66, 0xcf, 0x11,
+  0xa6, 0xd9, 0x00, 0xaa, 0x00, 0x62, 0xce, 0x6c,
+];
+export const WAV_HEADER = [0x52, 0x49, 0x46, 0x46];
+export const AAC_HEADER = [0xff, 0xf1];
+export const DFF_HEADER = [0x46, 0x52, 0x4d, 0x38];
+
+export const AudioMimeType: { [key: string]: string } = {
+  mp3: 'audio/mpeg',
+  flac: 'audio/flac',
+  m4a: 'audio/mp4',
+  ogg: 'audio/ogg',
+  wma: 'audio/x-ms-wma',
+  wav: 'audio/x-wav',
+  dff: 'audio/x-dff',
+};
+
+export function BytesHasPrefix(data: Uint8Array, prefix: number[]): boolean {
+  if (prefix.length > data.length) return false;
+  return prefix.every((val, idx) => {
+    return val === data[idx];
+  });
+}
+
+export function BytesEqual(a: Uint8Array, b: Uint8Array): boolean {
+  if (a.length !== b.length) return false;
+  return a.every((val, idx) => {
+    return val === b[idx];
+  });
+}
+
+export function SniffAudioExt(data: Uint8Array, fallback_ext: string = 'mp3'): string {
+  if (BytesHasPrefix(data, MP3_HEADER)) return 'mp3';
+  if (BytesHasPrefix(data, FLAC_HEADER)) return 'flac';
+  if (BytesHasPrefix(data, OGG_HEADER)) return 'ogg';
+  if (data.length >= 4 + M4A_HEADER.length && BytesHasPrefix(data.slice(4), M4A_HEADER)) return 'm4a';
+  if (BytesHasPrefix(data, WAV_HEADER)) return 'wav';
+  if (BytesHasPrefix(data, WMA_HEADER)) return 'wma';
+  if (BytesHasPrefix(data, AAC_HEADER)) return 'aac';
+  if (BytesHasPrefix(data, DFF_HEADER)) return 'dff';
+  return fallback_ext;
+}
+
+export function GetArrayBuffer(obj: Blob): Promise<ArrayBuffer> {
+  if (!!obj.arrayBuffer) return obj.arrayBuffer();
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = (e) => {
+      const rs = e.target?.result;
+      if (!rs) {
+        reject('read file failed');
+      } else {
+        resolve(rs as ArrayBuffer);
+      }
+    };
+    reader.readAsArrayBuffer(obj);
+  });
+}
+
+export function GetCoverFromFile(metadata: IAudioMetadata): string {
+  if (metadata.common?.picture && metadata.common.picture.length > 0) {
+    return URL.createObjectURL(
+      new Blob([metadata.common.picture[0].data], { type: metadata.common.picture[0].format }),
+    );
+  }
+  return '';
+}
+
+export interface IMusicMetaBasic {
+  title: string;
+  artist?: string;
+}
+
+export function GetMetaFromFile(
+  filename: string,
+  exist_title?: string,
+  exist_artist?: string,
+  separator = '-',
+): IMusicMetaBasic {
+  const meta: IMusicMetaBasic = { title: exist_title ?? '', artist: exist_artist };
+
+  const items = filename.split(separator);
+  if (items.length > 1) {
+    //由文件名和原metadata共同决定歌手tag(有时从文件名看有多个歌手，而metadata只有一个)
+    if (!meta.artist || meta.artist.split(split_regex).length < items[0].trim().split(split_regex).length) meta.artist = items[0].trim();
+    if (!meta.title) meta.title = items[1].trim();
+  } else if (items.length === 1) {
+    if (!meta.title) meta.title = items[0].trim();
+  }
+  return meta;
+}
+
+export async function GetImageFromURL(
+  src: string,
+): Promise<{ mime: string; buffer: ArrayBuffer; url: string } | undefined> {
+  try {
+    const resp = await fetch(src);
+    const mime = resp.headers.get('Content-Type');
+    if (mime?.startsWith('image/')) {
+      const buffer = await resp.arrayBuffer();
+      const url = URL.createObjectURL(new Blob([buffer], { type: mime }));
+      return { buffer, url, mime };
+    }
+  } catch (e) {
+    console.warn(e);
+  }
+}
+
+export interface IMusicMeta {
+  title: string;
+  artists?: string[];
+  album?: string;
+  albumartist?: string;
+  genre?: string[];
+  picture?: ArrayBuffer;
+  picture_desc?: string;
+}
+
+export function WriteMetaToMp3(audioData: Buffer, info: IMusicMeta, original: IAudioMetadata) {
+  const writer = new ID3Writer(audioData);
+
+  // reserve original data
+  const frames = original.native['ID3v2.4'] || original.native['ID3v2.3'] || original.native['ID3v2.2'] || [];
+  frames.forEach((frame) => {
+    if (frame.id !== 'TPE1' && frame.id !== 'TIT2' && frame.id !== 'TALB') {
+      try {
+        writer.setFrame(frame.id, frame.value);
+      } catch (e) {
+        console.warn(`failed to write ID3 tag '${frame.id}'`);
+      }
+    }
+  });
+
+  const old = original.common;
+  writer
+    .setFrame('TPE1', old?.artists || info.artists || [])
+    .setFrame('TIT2', old?.title || info.title)
+    .setFrame('TALB', old?.album || info.album || '');
+  if (info.picture) {
+    writer.setFrame('APIC', {
+      type: 3,
+      data: info.picture,
+      description: info.picture_desc || '',
+    });
+  }
+  return writer.addTag();
+}
+
+export function WriteMetaToFlac(audioData: Buffer, info: IMusicMeta, original: IAudioMetadata) {
+  const writer = new MetaFlac(audioData);
+  const old = original.common;
+  if (!old.title && !old.album && old.artists) {
+    writer.setTag('TITLE=' + info.title);
+    writer.setTag('ALBUM=' + info.album);
+    if (info.artists) {
+      writer.removeTag('ARTIST');
+      info.artists.forEach((artist) => writer.setTag('ARTIST=' + artist));
+    }
+  }
+
+  if (info.picture) {
+    writer.importPictureFromBuffer(Buffer.from(info.picture));
+  }
+  return writer.save();
+}
+
+export function RewriteMetaToMp3(audioData: Buffer, info: IMusicMeta, original: IAudioMetadata) {
+  const writer = new ID3Writer(audioData);
+
+  // preserve original data
+  const frames = original.native['ID3v2.4'] || original.native['ID3v2.3'] || original.native['ID3v2.2'] || [];
+  frames.forEach((frame) => {
+    if (frame.id !== 'TPE1'
+      && frame.id !== 'TIT2'
+      && frame.id !== 'TALB'
+      && frame.id !== 'TPE2'
+      && frame.id !== 'TCON'
+    ) {
+      try {
+        writer.setFrame(frame.id, frame.value);
+      } catch (e) {
+        throw new Error(`failed to write ID3 tag '${frame.id}'`);
+      }
+    }
+  });
+
+  const old = original.common;
+  writer
+    .setFrame('TPE1', info?.artists || old.artists || [])
+    .setFrame('TIT2', info?.title || old.title)
+    .setFrame('TALB', info?.album || old.album || '')
+    .setFrame('TPE2', info?.albumartist || old.albumartist || '')
+    .setFrame('TCON', info?.genre || old.genre || []);
+  if (info.picture) {
+    writer.setFrame('APIC', {
+      type: 3,
+      data: info.picture,
+      description: info.picture_desc || '',
+    });
+  }
+  return writer.addTag();
+}
+
+export function RewriteMetaToFlac(audioData: Buffer, info: IMusicMeta, original: IAudioMetadata) {
+  const writer = new MetaFlac(audioData);
+  const old = original.common;
+  if (info.title) {
+    if (old.title) {
+      writer.removeTag('TITLE');
+    }
+    writer.setTag('TITLE=' + info.title);
+  }
+  if (info.album) {
+    if (old.album) {
+      writer.removeTag('ALBUM');
+    }
+    writer.setTag('ALBUM=' + info.album);
+  }
+  if (info.albumartist) {
+    if (old.albumartist) {
+      writer.removeTag('ALBUMARTIST');
+    }
+    writer.setTag('ALBUMARTIST=' + info.albumartist);
+  }
+  if (info.artists) {
+    if (old.artists) {
+      writer.removeTag('ARTIST');
+    }
+    info.artists.forEach((artist) => writer.setTag('ARTIST=' + artist));
+  }
+  if (info.genre) {
+    if (old.genre) {
+      writer.removeTag('GENRE');
+    }
+    info.genre.forEach((singlegenre) => writer.setTag('GENRE=' + singlegenre));
+  }
+
+  if (info.picture) {
+    writer.importPictureFromBuffer(Buffer.from(info.picture));
+  }
+  return writer.save();
+}
+
+export function SplitFilename(n: string): { name: string; ext: string } {
+  const pos = n.lastIndexOf('.');
+  return {
+    ext: n.substring(pos + 1).toLowerCase(),
+    name: n.substring(0, pos),
+  };
+}

src/decrypt/ximalaya.ts

@@ -0,0 +1,193 @@
+import { parseBlob as metaParseBlob } from 'music-metadata-browser';
+import { AudioMimeType, SniffAudioExt, GetArrayBuffer, GetMetaFromFile } from './utils';
+import { DecryptResult } from '@/decrypt/entity';
+
+const HandlerMap: Map<string, (data: Uint8Array) => Uint8Array> = new Map([
+  ['x2m', ProcessX2M],
+  ['x3m', ProcessX3M],
+]);
+
+export async function Decrypt(file: File, raw_filename: string, raw_ext: string): Promise<DecryptResult> {
+  const buffer = new Uint8Array(await GetArrayBuffer(file));
+  const handler = HandlerMap.get(raw_ext);
+  if (!handler) throw 'File type is incorrect!';
+  let musicDecoded: Uint8Array = handler(buffer);
+
+  const ext = SniffAudioExt(musicDecoded, 'm4a');
+  const mime = AudioMimeType[ext];
+
+  let musicBlob = new Blob([musicDecoded], { type: mime });
+
+  const musicMeta = await metaParseBlob(musicBlob);
+
+  const info = GetMetaFromFile(raw_filename, musicMeta.common.title, musicMeta.common.artist);
+
+  return {
+    picture: '',
+    title: info.title,
+    artist: info.artist,
+    ext: ext,
+    album: musicMeta.common.album,
+    blob: musicBlob,
+    file: URL.createObjectURL(musicBlob),
+    mime: mime,
+  };
+}
+
+function ProcessX2M(data: Uint8Array) {
+  const x2mHeaderSize = 1024;
+  const x2mKey = [0x78, 0x6d, 0x6c, 0x79];
+  let encryptedHeader = data.slice(0, x2mHeaderSize);
+  for (let idx = 0; idx < x2mHeaderSize; idx++) {
+    let srcIdx = x2mScrambleTable[idx];
+    data[idx] = encryptedHeader[srcIdx] ^ x2mKey[idx % x2mKey.length];
+  }
+  return data;
+}
+
+function ProcessX3M(data: Uint8Array) {
+  const x3mHeaderSize = 1024;
+
+  //prettier-ignore: uint8, size 32(8x4)
+  const x3mKey = [
+    0x33, 0x39, 0x38, 0x39, 0x64, 0x31, 0x31, 0x31, 0x61, 0x61, 0x64, 0x35, 0x36, 0x31, 0x33, 0x39, 0x34, 0x30, 0x66,
+    0x34, 0x66, 0x63, 0x34, 0x34, 0x62, 0x36, 0x33, 0x39, 0x62, 0x32, 0x39, 0x32,
+  ];
+
+  let encryptedHeader = data.slice(0, x3mHeaderSize);
+  for (let dstIdx = 0; dstIdx < x3mHeaderSize; dstIdx++) {
+    let srcIdx = x3mScrambleTable[dstIdx];
+    data[dstIdx] = encryptedHeader[srcIdx] ^ x3mKey[dstIdx % x3mKey.length];
+  }
+  return data;
+}
+
+//prettier-ignore: uint16, size 1024 (64x16)
+const x2mScrambleTable = [
+  0x2a9, 0x2ab, 0x154, 0x2aa, 0x2a8, 0x2ac, 0x153, 0x2a7, 0x2ad, 0x152, 0x2a6, 0x3ff, 0x000, 0x155, 0x2ae, 0x151, 0x2a5,
+  0x3fe, 0x001, 0x156, 0x2af, 0x150, 0x2a4, 0x3fd, 0x002, 0x157, 0x2b0, 0x14f, 0x2a3, 0x3fc, 0x003, 0x158, 0x2b1, 0x14e,
+  0x2a2, 0x3fb, 0x004, 0x159, 0x2b2, 0x14d, 0x2a1, 0x3fa, 0x005, 0x15a, 0x2b3, 0x14c, 0x2a0, 0x3f9, 0x006, 0x15b, 0x2b4,
+  0x14b, 0x29f, 0x3f8, 0x007, 0x15c, 0x2b5, 0x14a, 0x29e, 0x3f7, 0x008, 0x15d, 0x2b6, 0x149, 0x29d, 0x3f6, 0x009, 0x15e,
+  0x2b7, 0x148, 0x29c, 0x3f5, 0x00a, 0x15f, 0x2b8, 0x147, 0x29b, 0x3f4, 0x00b, 0x160, 0x2b9, 0x146, 0x29a, 0x3f3, 0x00c,
+  0x161, 0x2ba, 0x145, 0x299, 0x3f2, 0x00d, 0x162, 0x2bb, 0x144, 0x298, 0x3f1, 0x00e, 0x163, 0x2bc, 0x143, 0x297, 0x3f0,
+  0x00f, 0x164, 0x2bd, 0x142, 0x296, 0x3ef, 0x010, 0x165, 0x2be, 0x141, 0x295, 0x3ee, 0x011, 0x166, 0x2bf, 0x140, 0x294,
+  0x3ed, 0x012, 0x167, 0x2c0, 0x13f, 0x293, 0x3ec, 0x013, 0x168, 0x2c1, 0x13e, 0x292, 0x3eb, 0x014, 0x169, 0x2c2, 0x13d,
+  0x291, 0x3ea, 0x015, 0x16a, 0x2c3, 0x13c, 0x290, 0x3e9, 0x016, 0x16b, 0x2c4, 0x13b, 0x28f, 0x3e8, 0x017, 0x16c, 0x2c5,
+  0x13a, 0x28e, 0x3e7, 0x018, 0x16d, 0x2c6, 0x139, 0x28d, 0x3e6, 0x019, 0x16e, 0x2c7, 0x138, 0x28c, 0x3e5, 0x01a, 0x16f,
+  0x2c8, 0x137, 0x28b, 0x3e4, 0x01b, 0x170, 0x2c9, 0x136, 0x28a, 0x3e3, 0x01c, 0x171, 0x2ca, 0x135, 0x289, 0x3e2, 0x01d,
+  0x172, 0x2cb, 0x134, 0x288, 0x3e1, 0x01e, 0x173, 0x2cc, 0x133, 0x287, 0x3e0, 0x01f, 0x174, 0x2cd, 0x0a9, 0x1fe, 0x357,
+  0x020, 0x175, 0x2ce, 0x0aa, 0x1ff, 0x358, 0x021, 0x176, 0x2cf, 0x0ab, 0x200, 0x359, 0x022, 0x177, 0x2d0, 0x0ac, 0x201,
+  0x35a, 0x023, 0x178, 0x2d1, 0x0ad, 0x202, 0x35b, 0x024, 0x179, 0x2d2, 0x0ae, 0x203, 0x35c, 0x025, 0x17a, 0x2d3, 0x0af,
+  0x204, 0x35d, 0x026, 0x17b, 0x2d4, 0x0b0, 0x205, 0x35e, 0x027, 0x17c, 0x2d5, 0x0b1, 0x206, 0x35f, 0x028, 0x17d, 0x2d6,
+  0x0b2, 0x207, 0x360, 0x029, 0x17e, 0x2d7, 0x0b3, 0x208, 0x361, 0x02a, 0x17f, 0x2d8, 0x0b4, 0x209, 0x362, 0x02b, 0x180,
+  0x2d9, 0x0b5, 0x20a, 0x363, 0x02c, 0x181, 0x2da, 0x0b6, 0x20b, 0x364, 0x02d, 0x182, 0x2db, 0x0b7, 0x20c, 0x365, 0x02e,
+  0x183, 0x2dc, 0x0b8, 0x20d, 0x366, 0x02f, 0x184, 0x2dd, 0x0b9, 0x20e, 0x367, 0x030, 0x185, 0x2de, 0x0ba, 0x20f, 0x368,
+  0x031, 0x186, 0x2df, 0x0bb, 0x210, 0x369, 0x032, 0x187, 0x2e0, 0x0bc, 0x211, 0x36a, 0x033, 0x188, 0x2e1, 0x0bd, 0x212,
+  0x36b, 0x034, 0x189, 0x2e2, 0x0be, 0x213, 0x36c, 0x035, 0x18a, 0x2e3, 0x0bf, 0x214, 0x36d, 0x036, 0x18b, 0x2e4, 0x0c0,
+  0x215, 0x36e, 0x037, 0x18c, 0x2e5, 0x0c1, 0x216, 0x36f, 0x038, 0x18d, 0x2e6, 0x0c2, 0x217, 0x370, 0x039, 0x18e, 0x2e7,
+  0x0c3, 0x218, 0x371, 0x03a, 0x18f, 0x2e8, 0x0c4, 0x219, 0x372, 0x03b, 0x190, 0x2e9, 0x0c5, 0x21a, 0x373, 0x03c, 0x191,
+  0x2ea, 0x0c6, 0x21b, 0x374, 0x03d, 0x192, 0x2eb, 0x0c7, 0x21c, 0x375, 0x03e, 0x193, 0x2ec, 0x0c8, 0x21d, 0x376, 0x03f,
+  0x194, 0x2ed, 0x0c9, 0x21e, 0x377, 0x040, 0x195, 0x2ee, 0x0ca, 0x21f, 0x378, 0x041, 0x196, 0x2ef, 0x0cb, 0x220, 0x379,
+  0x042, 0x197, 0x2f0, 0x0cc, 0x221, 0x37a, 0x043, 0x198, 0x2f1, 0x0cd, 0x222, 0x37b, 0x044, 0x199, 0x2f2, 0x0ce, 0x223,
+  0x37c, 0x045, 0x19a, 0x2f3, 0x0cf, 0x224, 0x37d, 0x046, 0x19b, 0x2f4, 0x0d0, 0x225, 0x37e, 0x047, 0x19c, 0x2f5, 0x0d1,
+  0x226, 0x37f, 0x048, 0x19d, 0x2f6, 0x0d2, 0x227, 0x380, 0x049, 0x19e, 0x2f7, 0x0d3, 0x228, 0x381, 0x04a, 0x19f, 0x2f8,
+  0x0d4, 0x229, 0x382, 0x04b, 0x1a0, 0x2f9, 0x0d5, 0x22a, 0x383, 0x04c, 0x1a1, 0x2fa, 0x0d6, 0x22b, 0x384, 0x04d, 0x1a2,
+  0x2fb, 0x0d7, 0x22c, 0x385, 0x04e, 0x1a3, 0x2fc, 0x0d8, 0x22d, 0x386, 0x04f, 0x1a4, 0x2fd, 0x0d9, 0x22e, 0x387, 0x050,
+  0x1a5, 0x2fe, 0x0da, 0x22f, 0x388, 0x051, 0x1a6, 0x2ff, 0x0db, 0x230, 0x389, 0x052, 0x1a7, 0x300, 0x0dc, 0x231, 0x38a,
+  0x053, 0x1a8, 0x301, 0x0dd, 0x232, 0x38b, 0x054, 0x1a9, 0x302, 0x0de, 0x233, 0x38c, 0x055, 0x1aa, 0x303, 0x0df, 0x234,
+  0x38d, 0x056, 0x1ab, 0x304, 0x0e0, 0x235, 0x38e, 0x057, 0x1ac, 0x305, 0x0e1, 0x236, 0x38f, 0x058, 0x1ad, 0x306, 0x0e2,
+  0x237, 0x390, 0x059, 0x1ae, 0x307, 0x0e3, 0x238, 0x391, 0x05a, 0x1af, 0x308, 0x0e4, 0x239, 0x392, 0x05b, 0x1b0, 0x309,
+  0x0e5, 0x23a, 0x393, 0x05c, 0x1b1, 0x30a, 0x0e6, 0x23b, 0x394, 0x05d, 0x1b2, 0x30b, 0x0e7, 0x23c, 0x395, 0x05e, 0x1b3,
+  0x30c, 0x0e8, 0x23d, 0x396, 0x05f, 0x1b4, 0x30d, 0x0e9, 0x23e, 0x397, 0x060, 0x1b5, 0x30e, 0x0ea, 0x23f, 0x398, 0x061,
+  0x1b6, 0x30f, 0x0eb, 0x240, 0x399, 0x062, 0x1b7, 0x310, 0x0ec, 0x241, 0x39a, 0x063, 0x1b8, 0x311, 0x0ed, 0x242, 0x39b,
+  0x064, 0x1b9, 0x312, 0x0ee, 0x243, 0x39c, 0x065, 0x1ba, 0x313, 0x0ef, 0x244, 0x39d, 0x066, 0x1bb, 0x314, 0x0f0, 0x245,
+  0x39e, 0x067, 0x1bc, 0x315, 0x0f1, 0x246, 0x39f, 0x068, 0x1bd, 0x316, 0x0f2, 0x247, 0x3a0, 0x069, 0x1be, 0x317, 0x0f3,
+  0x248, 0x3a1, 0x06a, 0x1bf, 0x318, 0x0f4, 0x249, 0x3a2, 0x06b, 0x1c0, 0x319, 0x0f5, 0x24a, 0x3a3, 0x06c, 0x1c1, 0x31a,
+  0x0f6, 0x24b, 0x3a4, 0x06d, 0x1c2, 0x31b, 0x0f7, 0x24c, 0x3a5, 0x06e, 0x1c3, 0x31c, 0x0f8, 0x24d, 0x3a6, 0x06f, 0x1c4,
+  0x31d, 0x0f9, 0x24e, 0x3a7, 0x070, 0x1c5, 0x31e, 0x0fa, 0x24f, 0x3a8, 0x071, 0x1c6, 0x31f, 0x0fb, 0x250, 0x3a9, 0x072,
+  0x1c7, 0x320, 0x0fc, 0x251, 0x3aa, 0x073, 0x1c8, 0x321, 0x0fd, 0x252, 0x3ab, 0x074, 0x1c9, 0x322, 0x0fe, 0x253, 0x3ac,
+  0x075, 0x1ca, 0x323, 0x0ff, 0x254, 0x3ad, 0x076, 0x1cb, 0x324, 0x100, 0x255, 0x3ae, 0x077, 0x1cc, 0x325, 0x101, 0x256,
+  0x3af, 0x078, 0x1cd, 0x326, 0x102, 0x257, 0x3b0, 0x079, 0x1ce, 0x327, 0x103, 0x258, 0x3b1, 0x07a, 0x1cf, 0x328, 0x104,
+  0x259, 0x3b2, 0x07b, 0x1d0, 0x329, 0x105, 0x25a, 0x3b3, 0x07c, 0x1d1, 0x32a, 0x106, 0x25b, 0x3b4, 0x07d, 0x1d2, 0x32b,
+  0x107, 0x25c, 0x3b5, 0x07e, 0x1d3, 0x32c, 0x108, 0x25d, 0x3b6, 0x07f, 0x1d4, 0x32d, 0x109, 0x25e, 0x3b7, 0x080, 0x1d5,
+  0x32e, 0x10a, 0x25f, 0x3b8, 0x081, 0x1d6, 0x32f, 0x10b, 0x260, 0x3b9, 0x082, 0x1d7, 0x330, 0x10c, 0x261, 0x3ba, 0x083,
+  0x1d8, 0x331, 0x10d, 0x262, 0x3bb, 0x084, 0x1d9, 0x332, 0x10e, 0x263, 0x3bc, 0x085, 0x1da, 0x333, 0x10f, 0x264, 0x3bd,
+  0x086, 0x1db, 0x334, 0x110, 0x265, 0x3be, 0x087, 0x1dc, 0x335, 0x111, 0x266, 0x3bf, 0x088, 0x1dd, 0x336, 0x112, 0x267,
+  0x3c0, 0x089, 0x1de, 0x337, 0x113, 0x268, 0x3c1, 0x08a, 0x1df, 0x338, 0x114, 0x269, 0x3c2, 0x08b, 0x1e0, 0x339, 0x115,
+  0x26a, 0x3c3, 0x08c, 0x1e1, 0x33a, 0x116, 0x26b, 0x3c4, 0x08d, 0x1e2, 0x33b, 0x117, 0x26c, 0x3c5, 0x08e, 0x1e3, 0x33c,
+  0x118, 0x26d, 0x3c6, 0x08f, 0x1e4, 0x33d, 0x119, 0x26e, 0x3c7, 0x090, 0x1e5, 0x33e, 0x11a, 0x26f, 0x3c8, 0x091, 0x1e6,
+  0x33f, 0x11b, 0x270, 0x3c9, 0x092, 0x1e7, 0x340, 0x11c, 0x271, 0x3ca, 0x093, 0x1e8, 0x341, 0x11d, 0x272, 0x3cb, 0x094,
+  0x1e9, 0x342, 0x11e, 0x273, 0x3cc, 0x095, 0x1ea, 0x343, 0x11f, 0x274, 0x3cd, 0x096, 0x1eb, 0x344, 0x120, 0x275, 0x3ce,
+  0x097, 0x1ec, 0x345, 0x121, 0x276, 0x3cf, 0x098, 0x1ed, 0x346, 0x122, 0x277, 0x3d0, 0x099, 0x1ee, 0x347, 0x123, 0x278,
+  0x3d1, 0x09a, 0x1ef, 0x348, 0x124, 0x279, 0x3d2, 0x09b, 0x1f0, 0x349, 0x125, 0x27a, 0x3d3, 0x09c, 0x1f1, 0x34a, 0x126,
+  0x27b, 0x3d4, 0x09d, 0x1f2, 0x34b, 0x127, 0x27c, 0x3d5, 0x09e, 0x1f3, 0x34c, 0x128, 0x27d, 0x3d6, 0x09f, 0x1f4, 0x34d,
+  0x129, 0x27e, 0x3d7, 0x0a0, 0x1f5, 0x34e, 0x12a, 0x27f, 0x3d8, 0x0a1, 0x1f6, 0x34f, 0x12b, 0x280, 0x3d9, 0x0a2, 0x1f7,
+  0x350, 0x12c, 0x281, 0x3da, 0x0a3, 0x1f8, 0x351, 0x12d, 0x282, 0x3db, 0x0a4, 0x1f9, 0x352, 0x12e, 0x283, 0x3dc, 0x0a5,
+  0x1fa, 0x353, 0x12f, 0x284, 0x3dd, 0x0a6, 0x1fb, 0x354, 0x130, 0x285, 0x3de, 0x0a7, 0x1fc, 0x355, 0x131, 0x286, 0x3df,
+  0x0a8, 0x1fd, 0x356, 0x132,
+];
+
+//prettier-ignore: uint16, size 1024 (64x16)
+const x3mScrambleTable = [
+  0x256, 0x28d, 0x213, 0x307, 0x156, 0x39d, 0x062, 0x170, 0x3ca, 0x035, 0x0ed, 0x2a4, 0x1e4, 0x359, 0x0d3, 0x26b, 0x265,
+  0x274, 0x251, 0x297, 0x202, 0x322, 0x126, 0x32b, 0x117, 0x302, 0x15c, 0x3a8, 0x057, 0x148, 0x380, 0x090, 0x1f6, 0x335,
+  0x10c, 0x2ee, 0x175, 0x3d4, 0x02b, 0x0cc, 0x260, 0x27b, 0x23d, 0x2bb, 0x1b6, 0x3a1, 0x05e, 0x157, 0x39e, 0x061, 0x16f,
+  0x3c6, 0x039, 0x0f7, 0x2b9, 0x1b8, 0x39f, 0x060, 0x166, 0x3b9, 0x046, 0x122, 0x31c, 0x12f, 0x33d, 0x0fc, 0x2ca, 0x1a4,
+  0x3cc, 0x033, 0x0e6, 0x293, 0x209, 0x315, 0x13d, 0x358, 0x0d5, 0x26e, 0x25e, 0x27d, 0x23a, 0x2c0, 0x1b1, 0x3af, 0x050,
+  0x136, 0x346, 0x0ef, 0x2aa, 0x1ce, 0x376, 0x0a0, 0x210, 0x30c, 0x14c, 0x389, 0x082, 0x1db, 0x367, 0x0b9, 0x23e, 0x2ba,
+  0x1b7, 0x3a0, 0x05f, 0x164, 0x3b7, 0x048, 0x125, 0x326, 0x11c, 0x30a, 0x14f, 0x38f, 0x070, 0x1a8, 0x3c7, 0x038, 0x0f5,
+  0x2b5, 0x1bd, 0x393, 0x06c, 0x199, 0x3e1, 0x01e, 0x0b3, 0x22f, 0x2d7, 0x193, 0x3ea, 0x015, 0x09d, 0x20a, 0x314, 0x13e,
+  0x35a, 0x0d2, 0x26a, 0x267, 0x272, 0x253, 0x294, 0x208, 0x319, 0x137, 0x34c, 0x0e7, 0x295, 0x205, 0x31d, 0x12e, 0x33c,
+  0x0fe, 0x2cd, 0x1a0, 0x3d5, 0x02a, 0x0c8, 0x258, 0x286, 0x22a, 0x2dc, 0x18e, 0x3f7, 0x008, 0x07c, 0x1d3, 0x370, 0x0a7,
+  0x21d, 0x2f1, 0x171, 0x3cd, 0x032, 0x0e5, 0x292, 0x20b, 0x313, 0x13f, 0x35c, 0x0d0, 0x266, 0x273, 0x252, 0x296, 0x204,
+  0x31f, 0x12a, 0x332, 0x10f, 0x2f4, 0x16c, 0x3c3, 0x03c, 0x101, 0x2d2, 0x19a, 0x3e0, 0x01f, 0x0b5, 0x233, 0x2c9, 0x1a6,
+  0x3c9, 0x036, 0x0f0, 0x2ab, 0x1cb, 0x37c, 0x095, 0x1fd, 0x328, 0x11a, 0x306, 0x158, 0x3a2, 0x05d, 0x155, 0x39c, 0x063,
+  0x174, 0x3d3, 0x02c, 0x0cf, 0x264, 0x275, 0x24f, 0x299, 0x1fa, 0x32c, 0x115, 0x2ff, 0x15f, 0x3ab, 0x054, 0x143, 0x36c,
+  0x0ad, 0x225, 0x2e5, 0x181, 0x3ef, 0x010, 0x08c, 0x1f1, 0x344, 0x0f3, 0x2af, 0x1c4, 0x386, 0x088, 0x1e3, 0x35b, 0x0d1,
+  0x269, 0x268, 0x26d, 0x25f, 0x27c, 0x23b, 0x2bf, 0x1b2, 0x3ae, 0x051, 0x13b, 0x355, 0x0da, 0x278, 0x248, 0x2a6, 0x1dc,
+  0x365, 0x0c0, 0x246, 0x2a8, 0x1d6, 0x36d, 0x0ac, 0x224, 0x2e8, 0x17e, 0x3eb, 0x014, 0x09c, 0x207, 0x31a, 0x133, 0x341,
+  0x0f8, 0x2bc, 0x1b5, 0x3a3, 0x05c, 0x152, 0x395, 0x06a, 0x18c, 0x3f9, 0x006, 0x07a, 0x1d1, 0x373, 0x0a4, 0x217, 0x2fe,
+  0x160, 0x3ad, 0x052, 0x13c, 0x357, 0x0d7, 0x270, 0x25c, 0x281, 0x235, 0x2c6, 0x1aa, 0x3bc, 0x043, 0x11d, 0x30d, 0x14a,
+  0x384, 0x08a, 0x1e7, 0x353, 0x0dd, 0x284, 0x22e, 0x2d8, 0x192, 0x3ec, 0x013, 0x099, 0x201, 0x323, 0x124, 0x321, 0x127,
+  0x32d, 0x114, 0x2fd, 0x161, 0x3b0, 0x04f, 0x135, 0x343, 0x0f4, 0x2b4, 0x1be, 0x392, 0x06d, 0x19d, 0x3db, 0x024, 0x0be,
+  0x244, 0x2b0, 0x1c2, 0x38a, 0x080, 0x1d9, 0x369, 0x0b6, 0x234, 0x2c8, 0x1a7, 0x3c8, 0x037, 0x0f1, 0x2ad, 0x1c6, 0x383,
+  0x08d, 0x1f2, 0x33b, 0x100, 0x2d1, 0x19b, 0x3de, 0x021, 0x0bb, 0x240, 0x2b6, 0x1bb, 0x399, 0x066, 0x17a, 0x3df, 0x020,
+  0x0b8, 0x23c, 0x2bd, 0x1b4, 0x3a5, 0x05a, 0x150, 0x390, 0x06f, 0x1a5, 0x3cb, 0x034, 0x0ea, 0x29d, 0x1ee, 0x348, 0x0ec,
+  0x2a3, 0x1e5, 0x356, 0x0d8, 0x271, 0x257, 0x289, 0x220, 0x2ec, 0x178, 0x3d9, 0x026, 0x0c2, 0x24b, 0x2a1, 0x1ea, 0x34d,
+  0x0e4, 0x291, 0x20c, 0x312, 0x141, 0x360, 0x0ca, 0x25a, 0x283, 0x230, 0x2d0, 0x19c, 0x3dd, 0x022, 0x0bc, 0x241, 0x2b3,
+  0x1bf, 0x391, 0x06e, 0x1a2, 0x3d1, 0x02e, 0x0d6, 0x26f, 0x25d, 0x27f, 0x237, 0x2c4, 0x1ac, 0x3ba, 0x045, 0x121, 0x318,
+  0x138, 0x34e, 0x0e3, 0x28f, 0x211, 0x30b, 0x14d, 0x38c, 0x073, 0x1c3, 0x387, 0x084, 0x1df, 0x362, 0x0c7, 0x255, 0x28e,
+  0x212, 0x309, 0x153, 0x396, 0x069, 0x18b, 0x3fa, 0x005, 0x079, 0x1d0, 0x374, 0x0a2, 0x215, 0x301, 0x15d, 0x3a9, 0x056,
+  0x147, 0x37a, 0x098, 0x200, 0x324, 0x11f, 0x316, 0x13a, 0x352, 0x0df, 0x288, 0x223, 0x2e9, 0x17d, 0x3e9, 0x016, 0x09e,
+  0x20d, 0x310, 0x144, 0x372, 0x0a5, 0x219, 0x2fa, 0x165, 0x3b8, 0x047, 0x123, 0x31e, 0x12d, 0x338, 0x107, 0x2e0, 0x188,
+  0x3fe, 0x001, 0x075, 0x1c9, 0x37e, 0x093, 0x1f9, 0x32f, 0x112, 0x2f9, 0x167, 0x3be, 0x041, 0x10b, 0x2e7, 0x17f, 0x3ed,
+  0x012, 0x097, 0x1ff, 0x325, 0x11e, 0x311, 0x142, 0x366, 0x0ba, 0x23f, 0x2b8, 0x1b9, 0x39b, 0x064, 0x176, 0x3d6, 0x029,
+  0x0c5, 0x250, 0x298, 0x1fc, 0x329, 0x119, 0x304, 0x15a, 0x3a6, 0x059, 0x14e, 0x38e, 0x071, 0x1ad, 0x3b6, 0x049, 0x128,
+  0x32e, 0x113, 0x2fc, 0x162, 0x3b2, 0x04d, 0x131, 0x33f, 0x0fa, 0x2c2, 0x1af, 0x3b3, 0x04c, 0x130, 0x33e, 0x0fb, 0x2c7,
+  0x1a9, 0x3bd, 0x042, 0x116, 0x300, 0x15e, 0x3aa, 0x055, 0x146, 0x378, 0x09b, 0x206, 0x31b, 0x132, 0x340, 0x0f9, 0x2be,
+  0x1b3, 0x3ac, 0x053, 0x140, 0x35d, 0x0ce, 0x262, 0x279, 0x247, 0x2a7, 0x1d7, 0x36b, 0x0ae, 0x226, 0x2e3, 0x185, 0x3f6,
+  0x009, 0x07d, 0x1d4, 0x36f, 0x0a8, 0x21e, 0x2f0, 0x172, 0x3ce, 0x031, 0x0de, 0x287, 0x228, 0x2df, 0x189, 0x3fd, 0x002,
+  0x076, 0x1ca, 0x37d, 0x094, 0x1fb, 0x32a, 0x118, 0x303, 0x15b, 0x3a7, 0x058, 0x14b, 0x388, 0x083, 0x1dd, 0x364, 0x0c1,
+  0x24a, 0x2a2, 0x1e9, 0x350, 0x0e1, 0x28b, 0x21a, 0x2f8, 0x168, 0x3bf, 0x040, 0x10a, 0x2e6, 0x180, 0x3ee, 0x011, 0x091,
+  0x1f7, 0x334, 0x10d, 0x2ef, 0x173, 0x3cf, 0x030, 0x0dc, 0x280, 0x236, 0x2c5, 0x1ab, 0x3bb, 0x044, 0x120, 0x317, 0x139,
+  0x34f, 0x0e2, 0x28c, 0x218, 0x2fb, 0x163, 0x3b4, 0x04b, 0x12c, 0x337, 0x108, 0x2e2, 0x186, 0x3fc, 0x003, 0x077, 0x1cc,
+  0x37b, 0x096, 0x1fe, 0x327, 0x11b, 0x308, 0x154, 0x397, 0x068, 0x183, 0x3f3, 0x00c, 0x085, 0x1e0, 0x361, 0x0c9, 0x259,
+  0x285, 0x22c, 0x2da, 0x190, 0x3f2, 0x00d, 0x086, 0x1e1, 0x35f, 0x0cb, 0x25b, 0x282, 0x232, 0x2cc, 0x1a1, 0x3d2, 0x02d,
+  0x0d4, 0x26c, 0x263, 0x277, 0x249, 0x2a5, 0x1de, 0x363, 0x0c6, 0x254, 0x290, 0x20e, 0x30f, 0x145, 0x377, 0x09f, 0x20f,
+  0x30e, 0x149, 0x382, 0x08e, 0x1f3, 0x33a, 0x102, 0x2d3, 0x198, 0x3e2, 0x01d, 0x0b2, 0x22d, 0x2d9, 0x191, 0x3f1, 0x00e,
+  0x087, 0x1e2, 0x35e, 0x0cd, 0x261, 0x27a, 0x243, 0x2b1, 0x1c1, 0x38b, 0x07f, 0x1d8, 0x36a, 0x0b4, 0x231, 0x2cf, 0x19e,
+  0x3da, 0x025, 0x0bf, 0x245, 0x2ac, 0x1c7, 0x381, 0x08f, 0x1f5, 0x336, 0x109, 0x2e4, 0x184, 0x3f4, 0x00b, 0x081, 0x1da,
+  0x368, 0x0b7, 0x239, 0x2c1, 0x1b0, 0x3b1, 0x04e, 0x134, 0x342, 0x0f6, 0x2b7, 0x1ba, 0x39a, 0x065, 0x179, 0x3dc, 0x023,
+  0x0bd, 0x242, 0x2b2, 0x1c0, 0x38d, 0x072, 0x1bc, 0x398, 0x067, 0x182, 0x3f0, 0x00f, 0x08b, 0x1e8, 0x351, 0x0e0, 0x28a,
+  0x21c, 0x2f3, 0x16d, 0x3c4, 0x03b, 0x0ff, 0x2ce, 0x19f, 0x3d7, 0x028, 0x0c4, 0x24e, 0x29b, 0x1f0, 0x345, 0x0f2, 0x2ae,
+  0x1c5, 0x385, 0x089, 0x1e6, 0x354, 0x0db, 0x27e, 0x238, 0x2c3, 0x1ae, 0x3b5, 0x04a, 0x12b, 0x333, 0x10e, 0x2f2, 0x16e,
+  0x3c5, 0x03a, 0x0fd, 0x2cb, 0x1a3, 0x3d0, 0x02f, 0x0d9, 0x276, 0x24c, 0x29f, 0x1ec, 0x34a, 0x0e9, 0x29c, 0x1ef, 0x347,
+  0x0ee, 0x2a9, 0x1cf, 0x375, 0x0a1, 0x214, 0x305, 0x159, 0x3a4, 0x05b, 0x151, 0x394, 0x06b, 0x196, 0x3e6, 0x019, 0x0ab,
+  0x222, 0x2ea, 0x17c, 0x3e5, 0x01a, 0x0af, 0x227, 0x2e1, 0x187, 0x3ff, 0x000, 0x074, 0x1c8, 0x37f, 0x092, 0x1f8, 0x331,
+  0x110, 0x2f6, 0x16a, 0x3c1, 0x03e, 0x104, 0x2d5, 0x195, 0x3e7, 0x018, 0x0aa, 0x221, 0x2eb, 0x17b, 0x3e4, 0x01b, 0x0b0,
+  0x229, 0x2dd, 0x18d, 0x3f8, 0x007, 0x07b, 0x1d2, 0x371, 0x0a6, 0x21b, 0x2f5, 0x16b, 0x3c2, 0x03d, 0x103, 0x2d4, 0x197,
+  0x3e3, 0x01c, 0x0b1, 0x22b, 0x2db, 0x18f, 0x3f5, 0x00a, 0x07e, 0x1d5, 0x36e, 0x0a9, 0x21f, 0x2ed, 0x177, 0x3d8, 0x027,
+  0x0c3, 0x24d, 0x29e, 0x1ed, 0x349, 0x0eb, 0x2a0, 0x1eb, 0x34b, 0x0e8, 0x29a, 0x1f4, 0x339, 0x106, 0x2de, 0x18a, 0x3fb,
+  0x004, 0x078, 0x1cd, 0x379, 0x09a, 0x203, 0x320, 0x129, 0x330, 0x111, 0x2f7, 0x169, 0x3c0, 0x03f, 0x105, 0x2d6, 0x194,
+  0x3e8, 0x017, 0x0a3, 0x216,
+];

src/decrypt/xm.js

@@ -1,67 +0,0 @@
-import {AudioMimeType, GetArrayBuffer, GetFileInfo, GetMetaCoverURL, IsBytesEqual} from "./util";
-
-import {Decrypt as RawDecrypt} from "./raw";
-
-const musicMetadata = require("music-metadata-browser");
-const MagicHeader = [0x69, 0x66, 0x6D, 0x74]
-const MagicHeader2 = [0xfe, 0xfe, 0xfe, 0xfe]
-const FileTypeMap = {
-    " WAV": ".wav",
-    "FLAC": ".flac",
-    " MP3": ".mp3",
-    " A4M": ".m4a",
-}
-
-export async function Decrypt(file, raw_filename, raw_ext) {
-    const oriData = new Uint8Array(await GetArrayBuffer(file));
-    if (!IsBytesEqual(MagicHeader, oriData.slice(0, 4)) ||
-        !IsBytesEqual(MagicHeader2, oriData.slice(8, 12))) {
-        if (raw_ext === "xm") {
-            return {status: false, message: "此xm文件已损坏"}
-        } else {
-            return await RawDecrypt(file, raw_filename, raw_ext, true)
-        }
-    }
-
-    let typeText = (new TextDecoder()).decode(oriData.slice(4, 8))
-    if (!FileTypeMap.hasOwnProperty(typeText)) {
-        return {status: false, message: "未知的xm文件类型"}
-    }
-
-    let key = oriData[0xf]
-    let dataOffset = oriData[0xc] | oriData[0xd] << 8 | oriData[0xe] << 16
-    let audioData = oriData.slice(0x10);
-    let lenAudioData = audioData.length;
-    for (let cur = dataOffset; cur < lenAudioData; ++cur)
-        audioData[cur] = (audioData[cur] - key) ^ 0xff;
-
-    const ext = FileTypeMap[typeText];
-    const mime = AudioMimeType[ext];
-    let musicBlob = new Blob([audioData], {type: mime});
-
-    const musicMeta = await musicMetadata.parseBlob(musicBlob);
-    if (ext === "wav") {
-        //todo:未知的编码方式
-        console.log(musicMeta.common)
-        musicMeta.common.album = "";
-        musicMeta.common.artist = "";
-        musicMeta.common.title = "";
-    }
-    let _sep = raw_filename.indexOf("_") === -1 ? "-" : "_"
-    const info = GetFileInfo(musicMeta.common.artist, musicMeta.common.title, raw_filename, _sep);
-
-    const imgUrl = GetMetaCoverURL(musicMeta);
-
-    return {
-        status: true,
-        title: info.title,
-        artist: info.artist,
-        ext: ext,
-        album: musicMeta.common.album,
-        picture: imgUrl,
-        file: URL.createObjectURL(musicBlob),
-        mime: mime,
-        rawExt: "xm"
-    }
-}
-

src/decrypt/xm.ts

@@ -0,0 +1,67 @@
+import { Decrypt as RawDecrypt } from '@/decrypt/raw';
+import { DecryptResult } from '@/decrypt/entity';
+import { AudioMimeType, BytesHasPrefix, GetArrayBuffer, GetCoverFromFile, GetMetaFromFile } from '@/decrypt/utils';
+
+import { parseBlob as metaParseBlob } from 'music-metadata-browser';
+
+const MagicHeader = [0x69, 0x66, 0x6d, 0x74];
+const MagicHeader2 = [0xfe, 0xfe, 0xfe, 0xfe];
+const FileTypeMap: { [key: string]: string } = {
+  ' WAV': '.wav',
+  FLAC: '.flac',
+  ' MP3': '.mp3',
+  ' A4M': '.m4a',
+};
+
+export async function Decrypt(file: File, raw_filename: string, raw_ext: string): Promise<DecryptResult> {
+  const oriData = new Uint8Array(await GetArrayBuffer(file));
+  if (!BytesHasPrefix(oriData, MagicHeader) || !BytesHasPrefix(oriData.slice(8, 12), MagicHeader2)) {
+    if (raw_ext === 'xm') {
+      throw Error('此xm文件已损坏');
+    } else {
+      return await RawDecrypt(file, raw_filename, raw_ext, true);
+    }
+  }
+
+  let typeText = new TextDecoder().decode(oriData.slice(4, 8));
+  if (!FileTypeMap.hasOwnProperty(typeText)) {
+    throw Error('未知的.xm文件类型');
+  }
+
+  let key = oriData[0xf];
+  let dataOffset = oriData[0xc] | (oriData[0xd] << 8) | (oriData[0xe] << 16);
+  let audioData = oriData.slice(0x10);
+  let lenAudioData = audioData.length;
+  for (let cur = dataOffset; cur < lenAudioData; ++cur) audioData[cur] = (audioData[cur] - key) ^ 0xff;
+
+  const ext = FileTypeMap[typeText];
+  const mime = AudioMimeType[ext];
+  let musicBlob = new Blob([audioData], { type: mime });
+
+  const musicMeta = await metaParseBlob(musicBlob);
+  if (ext === 'wav') {
+    //todo:未知的编码方式
+    console.info(musicMeta.common);
+    musicMeta.common.album = '';
+    musicMeta.common.artist = '';
+    musicMeta.common.title = '';
+  }
+  const { title, artist } = GetMetaFromFile(
+    raw_filename,
+    musicMeta.common.title,
+    String(musicMeta.common.artists || musicMeta.common.artist || ""),
+    raw_filename.indexOf('_') === -1 ? '-' : '_',
+  );
+
+  return {
+    title,
+    artist,
+    ext,
+    mime,
+    album: musicMeta.common.album,
+    picture: GetCoverFromFile(musicMeta),
+    file: URL.createObjectURL(musicBlob),
+    blob: musicBlob,
+    rawExt: 'xm',
+  };
+}

src/extension/popup.js

@@ -1,5 +1,2 @@
-const bs = chrome || browser
-bs.tabs.create({
-    url: bs.runtime.getURL('./index.html')
-}, tab => console.log(tab))
-
+const bs = chrome || browser;
+bs.tabs.create({ url: bs.runtime.getURL('./index.html') }, (tab) => console.log(tab));

src/fix-compatibility.js

@@ -1,25 +0,0 @@
-//TODO: Use other method to fix this
-// !! Only Temporary Solution
-// it seems like that @babel/plugin-proposal-object-rest-spread not working
-// to fix up the compatibility for Edge 18 and some older Chromium
-// now manually edit the dependency files
-
-const fs = require('fs');
-const filePath = "./node_modules/file-type/core.js";
-const regReplace = /{\s*([a-zA-Z0-9:,\s]*),\s*\.\.\.([a-zA-Z0-9]*)\s*};/m;
-if (fs.existsSync(filePath)) {
-    console.log("File Found!");
-    let data = fs.readFileSync(filePath).toString();
-    const regResult = regReplace.exec(data);
-    if (regResult != null) {
-        data = data.replace(regResult[0],
-            "Object.assign({ " + regResult[1] + " }, " + regResult[2] + ");"
-        );
-        fs.writeFileSync(filePath, data);
-        console.log("Object rest spread in file-type fixed!");
-    } else {
-        console.log("No fix needed.");
-    }
-} else {
-    console.log("File Not Found!");
-}

src/main.js

@@ -1,47 +0,0 @@
-import Vue from 'vue'
-import App from './App.vue'
-import './registerServiceWorker'
-import {
-    Button,
-    Checkbox,
-    Col,
-    Container,
-    Footer,
-    Icon,
-    Image,
-    Link,
-    Main,
-    Notification,
-    Progress,
-    Radio,
-    Row,
-    Table,
-    TableColumn,
-    Tooltip,
-    Upload
-} from 'element-ui';
-import 'element-ui/lib/theme-chalk/base.css';
-
-Vue.use(Link);
-Vue.use(Image);
-Vue.use(Button);
-Vue.use(Table);
-Vue.use(TableColumn);
-Vue.use(Main);
-Vue.use(Footer);
-Vue.use(Container);
-Vue.use(Icon);
-Vue.use(Row);
-Vue.use(Col);
-Vue.use(Upload);
-Vue.use(Checkbox);
-Vue.use(Radio);
-Vue.use(Tooltip);
-Vue.use(Progress);
-Vue.prototype.$notify = Notification;
-
-Vue.config.productionTip = false;
-document.getElementById("loader-source").remove()
-new Vue({
-    render: h => h(App),
-}).$mount('#app');

src/main.ts

@@ -0,0 +1,56 @@
+import Vue from 'vue';
+import App from '@/App.vue';
+import '@/registerServiceWorker';
+import {
+  Button,
+  Checkbox,
+  Col,
+  Container,
+  Dialog,
+  Form,
+  FormItem,
+  Footer,
+  Icon,
+  Image,
+  Input,
+  Link,
+  Main,
+  Notification,
+  Progress,
+  Radio,
+  Row,
+  Table,
+  TableColumn,
+  Tooltip,
+  Upload,
+  MessageBox,
+} from 'element-ui';
+import 'element-ui/lib/theme-chalk/base.css';
+
+Vue.use(Link);
+Vue.use(Image);
+Vue.use(Button);
+Vue.use(Dialog);
+Vue.use(Form);
+Vue.use(FormItem);
+Vue.use(Input);
+Vue.use(Table);
+Vue.use(TableColumn);
+Vue.use(Main);
+Vue.use(Footer);
+Vue.use(Container);
+Vue.use(Icon);
+Vue.use(Row);
+Vue.use(Col);
+Vue.use(Upload);
+Vue.use(Checkbox);
+Vue.use(Radio);
+Vue.use(Tooltip);
+Vue.use(Progress);
+Vue.prototype.$notify = Notification;
+Vue.prototype.$confirm = MessageBox.confirm;
+
+Vue.config.productionTip = false;
+new Vue({
+  render: (h) => h(App),
+}).$mount('#app');

src/registerServiceWorker.js

@@ -1,31 +1,30 @@
 /* eslint-disable no-console */
 
-import {register} from 'register-service-worker'
+import { register } from 'register-service-worker';
 
-if (process.env.NODE_ENV === 'production' && window.location.protocol === "https:") {
-
-    register(`${process.env.BASE_URL}service-worker.js`, {
-        ready() {
-            console.log('App is being served from cache by a service worker.')
-        },
-        registered() {
-            console.log('Service worker has been registered.')
-        },
-        cached() {
-            console.log('Content has been cached for offline use.')
-        },
-        updatefound() {
-            console.log('New content is downloading.')
-        },
-        updated() {
-            console.log('New content is available.');
-            window.location.reload();
-        },
-        offline() {
-            console.log('No internet connection found. App is running in offline mode.')
-        },
-        error(error) {
-            console.error('Error during service worker registration:', error)
-        }
-    })
+if (process.env.NODE_ENV === 'production' && window.location.protocol === 'https:') {
+  register(`${process.env.BASE_URL}service-worker.js`, {
+    ready() {
+      console.log('App is being served from cache by a service worker.');
+    },
+    registered() {
+      console.log('Service worker has been registered.');
+    },
+    cached() {
+      console.log('Content has been cached for offline use.');
+    },
+    updatefound() {
+      console.log('New content is downloading.');
+    },
+    updated() {
+      console.log('New content is available.');
+      window.location.reload();
+    },
+    offline() {
+      console.log('No internet connection found. App is running in offline mode.');
+    },
+    error(error) {
+      console.error('Error during service worker registration:', error);
+    },
+  });
 }

src/scss/_dark-mode.scss

@@ -1,7 +1,5 @@
 /*
- * name:    样式 - 夜间模式
- * author:  @KyleBing
- * date:    2020-11-24
+ * 样式 - 暗黑模式
  */
 
 @media (prefers-color-scheme: dark) {
@@ -12,155 +10,57 @@
     background-color: $dark-bg;
   }
 
-  // FORM
-  .el-radio{
-    &__label{
-      color: $dark-text-main;
-    }
-    &__input{
-      color: $dark-text-info;
-      .el-radio__inner{
-        border-color: $dark-border;
-        background-color: $dark-btn-bg;
-      }
-    }
-
-    &.is-checked{
-      .el-radio__inner{
-        background-color: $blue;
-      }
-      .el-radio__label{
-        font-weight: bold;
-      }
-    }
-  }
-
-  .el-checkbox.is-bordered{
-    border-color: $dark-border;
-    .el-checkbox__inner{
-      background-color: $dark-btn-bg;
-      border-color: $dark-border;
-    }
-    &:hover{
-      border-color: $dark-border-highlight;
-      .el-checkbox__inner{
-        background-color: $dark-btn-bg-highlight;
-        border-color: $dark-border-highlight;
-      }
-      .el-checkbox__label{
-        color: $dark-text-info;
-      }
-    }
-    &.is-checked{
-      background-color: $blue;
-      .el-checkbox__inner{
-        border-color: $dark-btn-bg-highlight;
-      }
-      .el-checkbox__label{
-        color: white;
-        font-weight: bold;
-      }
-    }
-  }
-
-
-
-  // BUTTON
-  .el-button{
-    background-color: $dark-btn-bg;
-    border-color: $dark-border;
-    color: $dark-text-main;
-
-    &:active{
-      transform: translateY(2px);
-    }
-
-    &--default{
-      &.is-plain {
-        background-color: $dark-btn-bg;
-        &:hover {
-          background-color: $blue;
-          border-color: $blue;
-          color: white;
-        }
-      }
-    }
-    &--danger{
-      &.is-plain{
-        border-color: $dark-border;
-        background-color: $dark-btn-bg;
-        &:hover{
-          background-color: $red;
-          border-color: $red;
-        }
-      }
-    }
-  }
-
-  // 文件拖放区
-  .el-upload__tip{
-    color: $dark-text-info;
-  }
-  .el-upload-dragger{
-    background-color: $dark-uploader-bg;
-    border-color: $dark-border;
-    .el-upload__text{
-      color: $dark-text-info;
-    }
-    &:hover{
-      background: $dark-uploader-bg-highlight;
-      border-color: $dark-border-highlight;
-    }
-  }
-
-  //TABLE
-  .el-table{
-    background-color: $dark-bg-td;
-    &:before{ // 去除表格末尾的横线
-      content: none;
-    }
-    &__header{
-      th{
-        border-bottom-color: $dark-border !important;
-      }
-    }
-    th{
-      background-color: $dark-bg-th;
-      color: $dark-text-info;
-    }
-    td{
-      border-bottom-color: $dark-border !important;
-    }
-    tr{
-      background-color: $dark-bg-td;
-      color: $dark-text-main;
+  // 编辑歌曲信息
+  .music-cover{
+    i{
       &:hover{
-        td{
-          background-color: $dark-bg-th !important;
-        }
+        color: $color-checkbox;
+      }
+    }
+    .el-image{
+      border: 1px solid $dark-border;
+    }
+  }
+  .edit-item{
+    .label{
+    }
+    .value{
+    }
+    .input{
+      input{
+        background-color: transparent !important;
+        border-bottom: 1px solid $dark-border;
+      }
+    }
+    i{
+      &:hover{
+        color: $color-checkbox;
       }
     }
   }
 
 
-  // LINKS
-  a{
-    text-decoration: none;
-    color: darken($dark-color-link, 15%);
-    &:hover{
-      color: $dark-color-link;
+  // footer
+  #app-footer {
+    a {
+      color: lighten($text-comment, 5%);
+      &:hover{
+        color: $color-link;
+      }
     }
   }
 
-  // ALERT
-  .el-notification{
-    background-color: $dark-btn-bg-highlight;
-    border-color: $dark-border;
-    &__title{
-      color: white;
+  // 自定义样式
+  // 首页弹窗提示信息的 更新信息 面板
+  .update-info{
+    border: 1px solid $dark-btn-bg !important;
+    .update-title{
+      color: $dark-text-main;
+      background-color: $dark-btn-bg !important;
     }
-    &__content{
+    .update-content{
       color: $dark-text-info;
+      padding: 10px;
     }
   }
 }

src/scss/_element-ui-overwrite.scss

@@ -0,0 +1,291 @@
+$color-checkbox: $blue;
+$color-border-el: #DCDFE6;
+
+$btn-radius: 6px;
+
+/* FORM */
+// checkbox
+.el-checkbox.is-bordered{
+  @include border-radius($btn-radius) ;
+  &:hover{
+    border-color: $color-checkbox;
+    .el-checkbox__label{
+      color: $color-checkbox;
+    }
+  }
+  .el-checkbox__input.is-focus{
+    .el-checkbox__inner{
+      border-color: $color-border-el;
+    }
+  }
+  &.is-checked{
+    background-color: $color-checkbox;
+    .el-checkbox__label{
+      color: white;
+    }
+    .el-checkbox__inner{
+      border-color: white;
+      background-color: white;
+      &:after{
+        border-color: $color-checkbox;
+      }
+    }
+  }
+}
+
+// el-button
+.el-button{
+  @include border-radius($btn-radius) ;
+}
+
+// upload
+.el-upload-dragger{
+  &:hover{
+    background-color: transparentize($color-checkbox, 0.9);
+  }
+}
+.el-upload__tip{
+  text-align: center;
+  color: $text-comment;
+}
+
+
+// dialog
+.el-dialog{
+  @include border-radius(5px);
+  &.el-dialog--center{
+    .el-dialog__body{
+      padding: 25px 25px 15px;
+    }
+    .el-dialog__footer{
+      padding: 10px 20px 30px;
+    }
+  }
+}
+
+
+
+@media (prefers-color-scheme: dark) {
+
+  // FORM
+  .el-radio{
+    &__label{
+      color: $dark-text-main;
+    }
+    &__input{
+      color: $dark-text-info;
+      .el-radio__inner{
+        border-color: $dark-border;
+        background-color: $dark-btn-bg;
+      }
+    }
+
+    &.is-checked{
+      .el-radio__inner{
+        background-color: $blue;
+      }
+      .el-radio__label{
+        font-weight: bold;
+      }
+    }
+  }
+
+  .el-checkbox.is-bordered{
+    border-color: $dark-border;
+    color: $dark-text-main;
+    background-color: $dark-btn-bg;
+    .el-checkbox__inner{
+      background-color: $dark-btn-bg-highlight;
+      border-color: $dark-border-highlight;
+    }
+    &:hover{
+      border-color: $dark-border-highlight;
+      .el-checkbox__inner{
+        background-color: $dark-btn-bg-highlight;
+        border-color: $dark-border-highlight;
+      }
+      .el-checkbox__label{
+        color: $dark-text-info;
+      }
+    }
+    &.is-checked{
+      background-color: $blue;
+      .el-checkbox__inner{
+        border-color: white;
+      }
+      .el-checkbox__label{
+        color: white;
+        font-weight: bold;
+      }
+      &:hover{
+        border-color: $blue;
+        .el-checkbox__inner{
+          background-color: white;
+        }
+      }
+    }
+  }
+
+
+
+  // BUTTON
+  .el-button{
+    background-color: $dark-btn-bg;
+    border-color: $dark-border;
+    color: $dark-text-main;
+
+    &:active{
+      transform: translateY(2px);
+    }
+
+    &--default{
+      &.is-plain {
+        background-color: $dark-btn-bg;
+        &:hover {
+          background-color: $blue;
+          border-color: $blue;
+          color: white;
+        }
+      }
+      &.is-circle {
+        background-color: $dark-blue;
+        border-color: $dark-blue;
+        &:hover {
+          background-color: $blue;
+          border-color: $blue;
+          color: white;
+        }
+      }
+    }
+
+    &--success{
+      &.is-plain {
+        background-color: $dark-btn-bg;
+        &:hover {
+          background-color: $green;
+          border-color: $green;
+          color: white;
+        }
+      }
+      &.is-circle {
+        background-color: $dark-green;
+        border-color: $dark-green;
+        &:hover {
+          background-color: $green;
+          border-color: $green;
+          color: white;
+        }
+      }
+    }
+    &--danger{
+      &.is-plain{
+        border-color: $dark-border;
+        background-color: $dark-btn-bg;
+        &:hover{
+          background-color: $red;
+          border-color: $red;
+        }
+      }
+      &.is-circle {
+        background-color: $dark-red;
+        border-color: $dark-red;
+        &:hover {
+          background-color: $red;
+          border-color: $red;
+          color: white;
+        }
+      }
+    }
+  }
+
+  // 文件拖放区
+  .el-upload__tip{
+    color: $dark-text-info;
+  }
+  .el-upload-dragger{
+    background-color: $dark-uploader-bg;
+    border-color: $dark-border;
+    .el-upload__text{
+      color: $dark-text-info;
+    }
+    &:hover{
+      background: $dark-uploader-bg-highlight;
+      border-color: $dark-border-highlight;
+    }
+  }
+
+  // TABLE
+  .el-table{
+    background-color: $dark-bg-td;
+    &:before{ // 去除表格末尾的横线
+      content: none;
+    }
+    &__header{
+      th{
+        border-bottom-color: $dark-border !important;
+      }
+    }
+    th.el-table__cell{
+      background-color: $dark-bg-th;
+      color: $dark-text-info;
+    }
+    td{
+      border-bottom-color: $dark-border !important;
+    }
+    tr{
+      background-color: $dark-bg-td;
+      color: $dark-text-main;
+      &:hover{
+        td{
+          background-color: $dark-bg-th !important;
+        }
+      }
+    }
+  }
+
+
+  // ALERT
+  .el-notification{
+    background-color: $dark-btn-bg-highlight;
+    border-color: $dark-border;
+    &__title{
+      color: white;
+    }
+    &__content{
+      color: $dark-text-info;
+    }
+  }
+
+  // DIALOG
+  .el-dialog{
+    background-color: $dark-dialog-bg;
+    .el-dialog__header{
+      .el-dialog__title{
+        color: $dark-text-main;
+      }
+    }
+    .el-dialog__body{
+      color: $dark-text-main;
+      .el-input{
+        .el-input__inner{
+          border-color: $dark-border;
+          color: $dark-text-main;
+          background-color: $dark-btn-bg;
+        }
+        .el-input__suffix{
+          .el-input__suffix-inner{
+          }
+        }
+        .el-input__count{
+          .el-input__count-inner{
+            background-color: transparent;
+          }
+        }
+      }
+    }
+    .item-desc{
+      color: $dark-text-info;
+    }
+  }
+
+}

src/scss/_gaps.scss

@@ -3,7 +3,7 @@
  */
 
 $gap: 5px;
-@for $item from 1 through 7 {
+@for $item from 0 through 8 {
   .mt-#{$item} { margin-top     : $gap * $item !important;}
   .mb-#{$item} { margin-bottom  : $gap * $item !important;}
   .ml-#{$item} { margin-left    : $gap * $item !important;}
@@ -15,4 +15,4 @@ $gap: 5px;
   .pl-#{$item} { padding-left   : $gap * $item !important;}
   .pr-#{$item} { padding-right  : $gap * $item !important;}
    .p-#{$item} { padding        : $gap * $item !important;}
-}
+}

src/scss/_normal.scss

@@ -1,38 +0,0 @@
-body{
-  font-family: $font-family;
-  font-size: $fz-main;
-  -webkit-font-smoothing: antialiased;
-  -moz-osx-font-smoothing: grayscale;
-}
-
-#app {
-  text-align: center;
-  color: $text-main;
-  padding-top: 30px;
-}
-
-#app-footer a {
-  padding-left: 0.2em;
-  padding-right: 0.2em;
-}
-
-#app-footer {
-  text-align: center;
-  font-size: small;
-}
-
-#app-control {
-  padding-top: 1em;
-  padding-bottom: 1em;
-}
-
-audio{
-  margin-bottom: 15px; // 播放控件与表格间隔
-}
-
-a{
-  color: darken($color-link, 15%);
-  &:hover{
-    color: $color-link;
-  }
-}

src/scss/_utility.scss

@@ -0,0 +1,73 @@
+// box-shadow
+@mixin box-shadow($value...){
+  -webkit-box-shadow:  $value;
+  -moz-box-shadow:  $value;
+  box-shadow:  $value;
+}
+
+// border-radius
+@mixin border-radius($corner...){
+  -webkit-border-radius: $corner;
+  -moz-border-radius: $corner;
+  border-radius: $corner;
+}
+
+@mixin clearfix(){
+  &:after{
+    content: '';
+    display: block;
+    clear: both;
+    visibility: hidden;
+  }
+}
+
+@mixin transform($value){
+  -webkit-transform: $value;
+  -moz-transform: $value;
+  -ms-transform: $value;
+  -o-transform: $value;
+  transform: $value;
+}
+
+@mixin transition($value...){
+  -webkit-transition: $value;
+  -moz-transition: $value;
+  -ms-transition: $value;
+  -o-transition: $value;
+  transition: $value;
+}
+
+@mixin animation($value){
+  animation: $value;
+  -webkit-animation: $value;
+}
+
+@mixin linear-gradient($direct, $colors){
+  background: linear-gradient($direct, $colors);
+  background: -webkit-linear-gradient($direct, $colors);
+  background: -moz-linear-gradient($direct, $colors);
+}
+
+@mixin backdrop-filter($value){
+  backdrop-filter: $value ;
+  -webkit-backdrop-filter: $value;
+}
+
+
+/*
+  Extension
+*/
+
+.unselectable {
+  -webkit-user-select: none;
+  -moz-user-select: none;
+  -ms-user-select: none;
+  user-select: none;
+}
+
+.btn-like{
+  cursor: pointer;
+  &:active{
+    @include transform(translateY(2px))
+  }
+}

src/scss/_variables.scss

@@ -3,15 +3,16 @@ $blue      : #409EFF;
 $red       : #F56C6C;
 $green     : #85ce61;
 
-// TEXT
-$text-main : #2C3E50;
-$color-link: $blue;
+// TEXT COLOR
+$text-main      : #2C3E50;
+$text-copyright : #777;
+$text-comment   : #999;
+$color-link     : $blue;
 
+// FONT SIZE
 $fz-main: 14px;
-
-$font-family: "Helvetica Neue", Helvetica, "PingFang SC",
-"Hiragino Sans GB", "Microsoft YaHei", "微软雅黑", Arial, sans-serif;
-
+$fz-mini-title: 13px;
+$fz-mini-content: 12px;
 
 // DARK MODE
 $dark-border                : lighten(black, 25%);
@@ -20,9 +21,14 @@ $dark-bg                    : lighten(black, 10%);
 $dark-text-main             : lighten(black, 90%);
 $dark-text-info             : lighten(black, 60%);
 $dark-uploader-bg           : lighten(black, 13%);
+$dark-dialog-bg             : lighten(black, 15%);
 $dark-uploader-bg-highlight : lighten(black, 18%);
 $dark-btn-bg                : lighten(black, 20%);
 $dark-btn-bg-highlight      : lighten(black, 30%);
 $dark-bg-th                 : lighten(black, 18%);
 $dark-bg-td                 : lighten(black, 13%);
-$dark-color-link            : $green;
+$dark-color-link            : $green;
+
+$dark-blue      : darken(desaturate($blue, 40%), 30%);
+$dark-red       : darken(desaturate($red, 50%), 30%);
+$dark-green     : darken(desaturate($green, 30%), 30%);

src/scss/unlock-music.scss

@@ -1,5 +1,144 @@
 @import "variables";
+@import "utility";
 @import "gaps";
+@import "element-ui-overwrite";
 
-@import "normal";
-@import "dark-mode"; // dark-mode 放在 normal 后面，以获得更高优先级
+// MAIN CONTENT
+body{
+  margin: 0;
+  padding: 0;
+  border: 0;
+  box-sizing: border-box;
+  font-family: "PingFang SC", "微软雅黑", "Helvetica Neue", Helvetica, "PingFang SC", "Hiragino Sans GB", "Microsoft YaHei", Arial, sans-serif;
+  font-size: $fz-main;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}
+
+#app {
+  text-align: center;
+  color: $text-main;
+  padding: 30px;
+}
+
+// 音频文件操作
+#app-control {
+  margin-top: 20px;
+}
+
+// 音频播放
+audio{
+  margin-top: 20px;
+}
+
+.table-content{
+  margin-top: 20px;
+}
+
+// 编辑歌曲信息
+.music-cover{
+  margin-bottom: 20px;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  flex-flow: column nowrap;
+  i{
+    margin-top: 10px;
+    @extend .btn-like;
+    &:hover{
+      color: $color-checkbox;
+    }
+  }
+  .el-image{
+    padding: 5px;
+    @include border-radius(5px);
+    border: 1px solid $color-border-el;
+    width: 150px;
+    height: 150px;
+  }
+}
+.edit-item{
+  display: flex;
+  justify-content: flex-start;
+  align-items: center;
+  .label{
+    font-weight: bold;
+    width: 80px;
+    text-align: right;
+    flex-shrink: 0;
+  }
+  .value{
+    padding: 5px 0;
+    height: 20px;
+    line-height: 20px;
+    margin-left: 10px;
+    overflow: hidden;
+    white-space: nowrap;
+    text-overflow: ellipsis;
+  }
+  .input{
+    margin-left: 10px;
+    input{
+      font-family: inherit;
+      height: 30px;
+      line-height: 20px;
+      @include border-radius(0);
+      border: none;
+      border-bottom: 1px solid $color-border-el;
+      padding: 5px 5px;
+    }
+  }
+  i{
+    margin-left: 10px;
+    @extend .btn-like;
+    &:hover{
+      color: $color-checkbox;
+    }
+  }
+}
+
+.tip{
+  margin-top: 20px;
+  color: $text-comment;
+  font-size: $fz-mini-content;
+  a{
+    color: inherit;
+  }
+}
+
+// footer
+#app-footer {
+  margin-top: 40px;
+  text-align: center;
+  color: $text-copyright;
+  line-height: 1.3;
+  font-size: $fz-mini-content;
+  a {
+    padding-left: 0.2rem;
+    padding-right: 0.2rem;
+    color: darken($text-copyright, 10%);
+    &:hover{
+      color: $color-link;
+    }
+  }
+}
+
+// 首页弹窗提示信息的 更新信息 面板
+.update-info{
+  @include border-radius(8px);
+  overflow: hidden;
+  border: 1px solid $color-border-el;
+  margin: 10px 0;
+  .update-title{
+    font-size: $fz-mini-title;
+    padding: 3px 10px;
+    background-color: $color-border-el;
+  }
+  .update-content{
+    font-size: $fz-mini-content;
+    line-height: 1.5;
+    padding: 5px 8px;
+  }
+}
+
+@import "dark-mode"; // dark-mode 放在 normal 后面，以获得更高优先级

src/shims-browser-id3-writer.d.ts

@@ -0,0 +1,23 @@
+declare module 'browser-id3-writer' {
+  export default class ID3Writer {
+    constructor(buffer: Buffer | ArrayBuffer);
+
+    setFrame(name: string, value: string | object | string[]);
+
+    addTag(): Uint8Array;
+  }
+}
+
+declare module 'metaflac-js' {
+  export default class Metaflac {
+    constructor(buffer: Buffer);
+
+    setTag(field: string);
+
+    removeTag(name: string);
+
+    importPictureFromBuffer(picture: Buffer);
+
+    save(): Buffer;
+  }
+}

src/shims-fs.d.ts

@@ -0,0 +1,54 @@
+export interface FileSystemGetFileOptions {
+  create?: boolean;
+}
+
+interface FileSystemCreateWritableOptions {
+  keepExistingData?: boolean;
+}
+
+interface FileSystemRemoveOptions {
+  recursive?: boolean;
+}
+
+interface FileSystemFileHandle {
+  getFile(): Promise<File>;
+
+  createWritable(options?: FileSystemCreateWritableOptions): Promise<FileSystemWritableFileStream>;
+}
+
+enum WriteCommandType {
+  write = 'write',
+  seek = 'seek',
+  truncate = 'truncate',
+}
+
+interface WriteParams {
+  type: WriteCommandType;
+  size?: number;
+  position?: number;
+  data: BufferSource | Blob | string;
+}
+
+type FileSystemWriteChunkType = BufferSource | Blob | string | WriteParams;
+
+interface FileSystemWritableFileStream extends WritableStream {
+  write(data: FileSystemWriteChunkType): Promise<undefined>;
+
+  seek(position: number): Promise<undefined>;
+
+  truncate(size: number): Promise<undefined>;
+
+  close(): Promise<undefined>; // should be implemented in WritableStream
+}
+
+export declare interface FileSystemDirectoryHandle {
+  getFileHandle(name: string, options?: FileSystemGetFileOptions): Promise<FileSystemFileHandle>;
+
+  removeEntry(name: string, options?: FileSystemRemoveOptions): Promise<undefined>;
+}
+
+declare global {
+  interface Window {
+    showDirectoryPicker?(): Promise<FileSystemDirectoryHandle>;
+  }
+}

src/shims-tsx.d.ts

@@ -0,0 +1,15 @@
+import Vue, { VNode } from 'vue';
+
+declare global {
+  namespace JSX {
+    // tslint:disable no-empty-interface
+    interface Element extends VNode {}
+
+    // tslint:disable no-empty-interface
+    interface ElementClass extends Vue {}
+
+    interface IntrinsicElements {
+      [elem: string]: any;
+    }
+  }
+}

src/shims-vue.d.ts

@@ -0,0 +1,4 @@
+declare module '*.vue' {
+  import Vue from 'vue';
+  export default Vue;
+}

src/utils/MergeUint8Array.ts

@@ -0,0 +1,15 @@
+export function MergeUint8Array(array: Uint8Array[]): Uint8Array {
+  let length = 0;
+  array.forEach((item) => {
+    length += item.length;
+  });
+
+  let mergedArray = new Uint8Array(length);
+  let offset = 0;
+  array.forEach((item) => {
+    mergedArray.set(item, offset);
+    offset += item.length;
+  });
+
+  return mergedArray;
+}

src/utils/__mocks__/qm_meta.ts

@@ -0,0 +1 @@
+export const extractQQMusicMeta = jest.fn();

src/utils/__mocks__/storage.ts

@@ -0,0 +1,4 @@
+export const storage = {
+  loadJooxUUID: jest.fn(),
+  saveJooxUUID: jest.fn(),
+};

src/utils/api.ts

@@ -0,0 +1,113 @@
+export const IXAREA_API_ENDPOINT = 'https://um-api.ixarea.com';
+
+export interface UpdateInfo {
+  Found: boolean;
+  HttpsFound: boolean;
+  Version: string;
+  URL: string;
+  Detail: string;
+}
+
+export async function checkUpdate(version: string): Promise<UpdateInfo> {
+  const resp = await fetch(IXAREA_API_ENDPOINT + '/music/app-version', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ Version: version }),
+  });
+  return await resp.json();
+}
+
+export interface CoverInfo {
+  Id: string;
+  Type: number;
+}
+
+export async function queryAlbumCover(title: string, artist?: string, album?: string): Promise<CoverInfo> {
+  const endpoint = IXAREA_API_ENDPOINT + '/music/qq-cover';
+  const params = new URLSearchParams([
+    ['Title', title],
+    ['Artist', artist ?? ''],
+    ['Album', album ?? ''],
+  ]);
+  const resp = await fetch(`${endpoint}?${params.toString()}`);
+  return await resp.json();
+}
+
+export interface TrackInfo {
+  id: number;
+  type: number;
+  mid: string;
+  name: string;
+  title: string;
+  subtitle: string;
+  singer: {
+    id: number;
+    mid: string;
+    name: string;
+    title: string;
+    type: number;
+    uin: number;
+  }[];
+  album: {
+    id: number;
+    mid: string;
+    name: string;
+    title: string;
+    subtitle: string;
+    time_public: string;
+    pmid: string;
+  };
+  interval: number;
+  index_cd: number;
+  index_album: number;
+}
+
+export interface SongItemInfo {
+  title: string;
+  content: {
+    value: string;
+  }[];
+}
+
+export interface SongInfoResponse {
+  info: {
+    company: SongItemInfo;
+    genre: SongItemInfo;
+    intro: SongItemInfo;
+    lan: SongItemInfo;
+    pub_time: SongItemInfo;
+  };
+  extras: {
+    name: string;
+    transname: string;
+    subtitle: string;
+    from: string;
+    wikiurl: string;
+  };
+  track_info: TrackInfo;
+}
+
+export interface RawQMBatchResponse<T> {
+  code: number;
+  ts: number;
+  start_ts: number;
+  traceid: string;
+  req_1: {
+    code: number;
+    data: T;
+  };
+}
+
+export async function querySongInfoById(id: string | number): Promise<SongInfoResponse> {
+  const url = `${IXAREA_API_ENDPOINT}/meta/qq-music-raw/${id}`;
+  const result: RawQMBatchResponse<SongInfoResponse> = await fetch(url).then((r) => r.json());
+  if (result.code === 0 && result.req_1.code === 0) {
+    return result.req_1.data;
+  }
+
+  throw new Error('请求信息失败');
+}
+
+export function getQMImageURLFromPMID(pmid: string, type = 1): string {
+  return `${IXAREA_API_ENDPOINT}/music/qq-cover/${type}/${pmid}`;
+}

src/utils/qm_meta.ts

@@ -0,0 +1,156 @@
+import { IAudioMetadata, parseBlob as metaParseBlob } from 'music-metadata-browser';
+import iconv from 'iconv-lite';
+
+import {
+  GetCoverFromFile,
+  GetImageFromURL,
+  GetMetaFromFile,
+  WriteMetaToFlac,
+  WriteMetaToMp3,
+  AudioMimeType,
+  split_regex,
+} from '@/decrypt/utils';
+import { getQMImageURLFromPMID, queryAlbumCover, querySongInfoById } from '@/utils/api';
+
+interface MetaResult {
+  title: string;
+  artist: string;
+  album: string;
+  imgUrl: string;
+  blob: Blob;
+}
+
+const fromGBK = (text?: string) => iconv.decode(new Buffer(text || ''), 'gbk');
+
+/**
+ *
+ * @param musicBlob 音乐文件（解密后）
+ * @param name 文件名
+ * @param ext 原始后缀名
+ * @param id 曲目 ID（<code>number</code>类型或纯数字组成的字符串）
+ * @returns Promise
+ */
+export async function extractQQMusicMeta(
+  musicBlob: Blob,
+  name: string,
+  ext: string,
+  id?: number | string,
+): Promise<MetaResult> {
+  const musicMeta = await metaParseBlob(musicBlob);
+  for (let metaIdx in musicMeta.native) {
+    if (!musicMeta.native.hasOwnProperty(metaIdx)) continue;
+    if (musicMeta.native[metaIdx].some((item) => item.id === 'TCON' && item.value === '(12)')) {
+      console.warn('try using gbk encoding to decode meta');
+      musicMeta.common.artist = '';
+      if (!musicMeta.common.artists) {
+        musicMeta.common.artist = fromGBK(musicMeta.common.artist);
+      }
+      else {
+        musicMeta.common.artist = musicMeta.common.artists.map(fromGBK).join();
+      }
+      musicMeta.common.title = fromGBK(musicMeta.common.title);
+      musicMeta.common.album = fromGBK(musicMeta.common.album);
+    }
+  }
+
+  if (id && id !== '0') {
+    try {
+      return await fetchMetadataFromSongId(id, ext, musicMeta, musicBlob);
+    } catch (e) {
+      console.warn('在线获取曲目信息失败，回退到本地 meta 提取', e);
+    }
+  }
+
+  const info = GetMetaFromFile(name, musicMeta.common.title, musicMeta.common.artist);
+  info.artist = info.artist || '';
+
+  let imageURL = GetCoverFromFile(musicMeta);
+  if (!imageURL) {
+    imageURL = await getCoverImage(info.title, info.artist, musicMeta.common.album);
+  }
+
+  return {
+    title: info.title,
+    artist: info.artist,
+    album: musicMeta.common.album || '',
+    imgUrl: imageURL,
+    blob: await writeMetaToAudioFile({
+      title: info.title,
+      artists: info.artist.split(split_regex),
+      ext,
+      imageURL,
+      musicMeta,
+      blob: musicBlob,
+    }),
+  };
+}
+
+async function fetchMetadataFromSongId(
+  id: number | string,
+  ext: string,
+  musicMeta: IAudioMetadata,
+  blob: Blob,
+): Promise<MetaResult> {
+  const info = await querySongInfoById(id);
+  const imageURL = getQMImageURLFromPMID(info.track_info.album.pmid);
+  const artists = info.track_info.singer.map((singer) => singer.name);
+
+  return {
+    title: info.track_info.title,
+    artist: artists.join(','),
+    album: info.track_info.album.name,
+    imgUrl: imageURL,
+
+    blob: await writeMetaToAudioFile({
+      title: info.track_info.title,
+      artists,
+      ext,
+      imageURL,
+      musicMeta,
+      blob,
+    }),
+  };
+}
+
+async function getCoverImage(title: string, artist?: string, album?: string): Promise<string> {
+  try {
+    const data = await queryAlbumCover(title, artist, album);
+    return getQMImageURLFromPMID(data.Id, data.Type);
+  } catch (e) {
+    console.warn(e);
+  }
+  return '';
+}
+
+interface NewAudioMeta {
+  title: string;
+  artists: string[];
+  ext: string;
+
+  musicMeta: IAudioMetadata;
+
+  blob: Blob;
+  imageURL: string;
+}
+
+async function writeMetaToAudioFile(info: NewAudioMeta): Promise<Blob> {
+  try {
+    const imageInfo = await GetImageFromURL(info.imageURL);
+    if (!imageInfo) {
+      console.warn('获取图像失败');
+    }
+    const newMeta = { picture: imageInfo?.buffer, title: info.title, artists: info.artists };
+    const buffer = Buffer.from(await info.blob.arrayBuffer());
+    const mime = AudioMimeType[info.ext] || AudioMimeType.mp3;
+    if (info.ext === 'mp3') {
+      return new Blob([WriteMetaToMp3(buffer, newMeta, info.musicMeta)], { type: mime });
+    } else if (info.ext === 'flac') {
+      return new Blob([WriteMetaToFlac(buffer, newMeta, info.musicMeta)], { type: mime });
+    } else {
+      console.info('writing metadata for ' + info.ext + ' is not being supported for now');
+    }
+  } catch (e) {
+    console.warn('Error while appending cover image to file ' + e);
+  }
+  return info.blob;
+}

src/utils/storage.ts

@@ -0,0 +1,3 @@
+import storageFactory from './storage/StorageFactory';
+
+export const storage = storageFactory();

src/utils/storage/BaseStorage.ts

@@ -0,0 +1,17 @@
+export const KEY_PREFIX = 'um.conf.';
+const KEY_JOOX_UUID = `${KEY_PREFIX}joox.uuid`;
+
+export default abstract class BaseStorage {
+  protected abstract save<T>(name: string, value: T): Promise<void>;
+  protected abstract load<T>(name: string, defaultValue: T): Promise<T>;
+  public abstract getAll(): Promise<Record<string, any>>;
+  public abstract setAll(obj: Record<string, any>): Promise<void>;
+
+  public saveJooxUUID(uuid: string): Promise<void> {
+    return this.save(KEY_JOOX_UUID, uuid);
+  }
+
+  public loadJooxUUID(defaultValue: string = ''): Promise<string> {
+    return this.load(KEY_JOOX_UUID, defaultValue);
+  }
+}

src/utils/storage/BrowserNativeStorage.ts

@@ -0,0 +1,43 @@
+import BaseStorage, { KEY_PREFIX } from './BaseStorage';
+
+export default class BrowserNativeStorage extends BaseStorage {
+  public static get works() {
+    return typeof localStorage !== 'undefined' && localStorage.getItem;
+  }
+
+  protected async load<T>(name: string, defaultValue: T): Promise<T> {
+    const result = localStorage.getItem(name);
+    if (result === null) {
+      return defaultValue;
+    }
+    try {
+      return JSON.parse(result);
+    } catch {
+      return defaultValue;
+    }
+  }
+
+  protected async save<T>(name: string, value: T): Promise<void> {
+    localStorage.setItem(name, JSON.stringify(value));
+  }
+
+  public async getAll(): Promise<Record<string, any>> {
+    const result = {};
+    for (const [key, value] of Object.entries(localStorage)) {
+      if (key.startsWith(KEY_PREFIX)) {
+        try {
+          Object.assign(result, { [key]: JSON.parse(value) });
+        } catch {
+          // ignored
+        }
+      }
+    }
+    return result;
+  }
+
+  public async setAll(obj: Record<string, any>): Promise<void> {
+    for (const [key, value] of Object.entries(obj)) {
+      await this.save(key, value);
+    }
+  }
+}

src/utils/storage/ChromeExtensionStorage.ts

@@ -0,0 +1,47 @@
+import BaseStorage, { KEY_PREFIX } from './BaseStorage';
+
+declare var chrome: any;
+
+export default class ChromeExtensionStorage extends BaseStorage {
+  static get works(): boolean {
+    return typeof chrome !== 'undefined' && Boolean(chrome?.storage?.local?.set);
+  }
+
+  protected async load<T>(name: string, defaultValue: T): Promise<T> {
+    return new Promise((resolve) => {
+      chrome.storage.local.get({ [name]: defaultValue }, (result: any) => {
+        if (Object.prototype.hasOwnProperty.call(result, name)) {
+          resolve(result[name]);
+        } else {
+          resolve(defaultValue);
+        }
+      });
+    });
+  }
+
+  protected async save<T>(name: string, value: T): Promise<void> {
+    return new Promise((resolve) => {
+      chrome.storage.local.set({ [name]: value }, resolve);
+    });
+  }
+
+  public async getAll(): Promise<Record<string, any>> {
+    return new Promise((resolve) => {
+      chrome.storage.local.get(null, (obj: Record<string, any>) => {
+        const result: Record<string, any> = {};
+        for (const [key, value] of Object.entries(obj)) {
+          if (key.startsWith(KEY_PREFIX)) {
+            result[key] = value;
+          }
+        }
+        resolve(result);
+      });
+    });
+  }
+
+  public async setAll(obj: Record<string, any>): Promise<void> {
+    return new Promise((resolve) => {
+      chrome.storage.local.set(obj, resolve);
+    });
+  }
+}

src/utils/storage/InMemoryStorage.ts

@@ -0,0 +1,32 @@
+import BaseStorage from './BaseStorage';
+
+export default class InMemoryStorage extends BaseStorage {
+  private values = new Map<string, any>();
+  protected async load<T>(name: string, defaultValue: T): Promise<T> {
+    if (this.values.has(name)) {
+      return this.values.get(name);
+    }
+
+    return defaultValue;
+  }
+
+  protected async save<T>(name: string, value: T): Promise<void> {
+    this.values.set(name, value);
+  }
+
+  public async getAll(): Promise<Record<string, any>> {
+    const result = {};
+    this.values.forEach((value, key) => {
+      Object.assign(result, {
+        [key]: value,
+      });
+    });
+    return result;
+  }
+
+  public async setAll(obj: Record<string, any>): Promise<void> {
+    for (const [key, value] of Object.entries(obj)) {
+      this.values.set(key, value);
+    }
+  }
+}

src/utils/storage/StorageFactory.ts

@@ -0,0 +1,13 @@
+import BaseStorage from './BaseStorage';
+import BrowserNativeStorage from './BrowserNativeStorage';
+import ChromeExtensionStorage from './ChromeExtensionStorage';
+import InMemoryStorage from './InMemoryStorage';
+
+export default function storageFactory(): BaseStorage {
+  if (ChromeExtensionStorage.works) {
+    return new ChromeExtensionStorage();
+  } else if (BrowserNativeStorage.works) {
+    return new BrowserNativeStorage();
+  }
+  return new InMemoryStorage();
+}

src/utils/utils.ts

@@ -0,0 +1,80 @@
+import { DecryptResult } from '@/decrypt/entity';
+import { FileSystemDirectoryHandle } from '@/shims-fs';
+
+export enum FilenamePolicy {
+  ArtistAndTitle,
+  TitleOnly,
+  TitleAndArtist,
+  SameAsOriginal,
+}
+
+export const FilenamePolicies: { key: FilenamePolicy; text: string }[] = [
+  { key: FilenamePolicy.ArtistAndTitle, text: '歌手-歌曲名' },
+  { key: FilenamePolicy.TitleOnly, text: '歌曲名' },
+  { key: FilenamePolicy.TitleAndArtist, text: '歌曲名-歌手' },
+  { key: FilenamePolicy.SameAsOriginal, text: '同源文件名' },
+];
+
+export function GetDownloadFilename(data: DecryptResult, policy: FilenamePolicy): string {
+  switch (policy) {
+    case FilenamePolicy.TitleOnly:
+      return `${data.title}.${data.ext}`;
+    case FilenamePolicy.TitleAndArtist:
+      return `${data.title} - ${data.artist}.${data.ext}`;
+    case FilenamePolicy.SameAsOriginal:
+      return `${data.rawFilename}.${data.ext}`;
+    default:
+    case FilenamePolicy.ArtistAndTitle:
+      return `${data.artist} - ${data.title}.${data.ext}`;
+  }
+}
+
+export async function DirectlyWriteFile(data: DecryptResult, policy: FilenamePolicy, dir: FileSystemDirectoryHandle) {
+  let filename = GetDownloadFilename(data, policy);
+  // prevent filename exist
+  try {
+    await dir.getFileHandle(filename);
+    filename = `${new Date().getTime()} - ${filename}`;
+  } catch (e) {}
+  const file = await dir.getFileHandle(filename, { create: true });
+  const w = await file.createWritable();
+  await w.write(data.blob);
+  await w.close();
+}
+
+export function DownloadBlobMusic(data: DecryptResult, policy: FilenamePolicy) {
+  const a = document.createElement('a');
+  a.href = data.file;
+  a.download = GetDownloadFilename(data, policy);
+  document.body.append(a);
+  a.click();
+  a.remove();
+}
+
+export function RemoveBlobMusic(data: DecryptResult) {
+  URL.revokeObjectURL(data.file);
+  if (data.picture?.startsWith('blob:')) {
+    URL.revokeObjectURL(data.picture);
+  }
+}
+
+export class DecryptQueue {
+  private readonly pending: (() => Promise<void>)[];
+
+  constructor() {
+    this.pending = [];
+  }
+
+  queue(fn: () => Promise<void>) {
+    this.pending.push(fn);
+    this.consume();
+  }
+
+  private consume() {
+    const fn = this.pending.shift();
+    if (fn)
+      fn()
+        .then(() => this.consume)
+        .catch(console.error);
+  }
+}

src/utils/worker.ts

@@ -0,0 +1,4 @@
+import { expose } from 'threads/worker';
+import { Decrypt } from '@/decrypt';
+
+expose(Decrypt);

src/view/Home.vue

@@ -0,0 +1,264 @@
+<template>
+  <div>
+    <file-selector @error="showFail" @success="showSuccess" />
+
+    <div id="app-control">
+      <el-row class="mb-3">
+        <span>歌曲命名格式：</span>
+        <el-radio v-for="k in FilenamePolicies" :key="k.key" v-model="filename_policy" :label="k.key">
+          {{ k.text }}
+        </el-radio>
+      </el-row>
+      <el-row>
+        <edit-dialog
+          :show="showEditDialog"
+          :picture="editing_data.picture"
+          :title="editing_data.title"
+          :artist="editing_data.artist"
+          :album="editing_data.album"
+          :albumartist="editing_data.albumartist"
+          :genre="editing_data.genre"
+          @cancel="showEditDialog = false"
+          @ok="handleEdit"
+        ></edit-dialog>
+        <config-dialog :show="showConfigDialog" @done="showConfigDialog = false"></config-dialog>
+        <el-tooltip class="item" effect="dark" placement="top">
+          <div slot="content">
+            <span> 部分解密方案需要设定解密参数。 </span>
+          </div>
+          <el-button icon="el-icon-s-tools" plain @click="showConfigDialog = true">解密设定</el-button>
+        </el-tooltip>
+        <el-button icon="el-icon-download" plain @click="handleDownloadAll">下载全部</el-button>
+        <el-button icon="el-icon-delete" plain type="danger" @click="handleDeleteAll">清除全部</el-button>
+
+        <el-tooltip class="item" effect="dark" placement="top-start">
+          <div slot="content">
+            <span v-if="instant_save">工作模式: {{ dir ? '写入本地文件系统' : '调用浏览器下载' }}</span>
+            <span v-else>
+              当您使用此工具进行大量文件解锁的时候，建议开启此选项。<br />
+              开启后，解锁结果将不会存留于浏览器中，防止内存不足。
+            </span>
+          </div>
+          <el-checkbox v-model="instant_save" type="success" border class="ml-2">立即保存</el-checkbox>
+        </el-tooltip>
+      </el-row>
+    </div>
+
+    <audio :autoplay="playing_auto" :src="playing_url" controls />
+
+    <PreviewTable
+      class="table-content"
+      :policy="filename_policy"
+      :table-data="tableData"
+      @download="saveFile"
+      @edit="editFile"
+      @play="changePlaying" />
+  </div>
+</template>
+
+<script>
+import FileSelector from '@/component/FileSelector';
+import PreviewTable from '@/component/PreviewTable';
+import ConfigDialog from '@/component/ConfigDialog';
+import EditDialog from '@/component/EditDialog';
+
+import { DownloadBlobMusic, FilenamePolicy, FilenamePolicies, RemoveBlobMusic, DirectlyWriteFile } from '@/utils/utils';
+import { GetImageFromURL, RewriteMetaToMp3, RewriteMetaToFlac, AudioMimeType, split_regex } from '@/decrypt/utils';
+import { parseBlob as metaParseBlob } from 'music-metadata-browser';
+
+export default {
+  name: 'Home',
+  components: {
+    FileSelector,
+    PreviewTable,
+    ConfigDialog,
+    EditDialog,
+  },
+  data() {
+    return {
+      showConfigDialog: false,
+      showEditDialog: false,
+      editing_data: { picture: '', title: '', artist: '', album: '', albumartist: '', genre: '' },
+      tableData: [],
+      playing_url: '',
+      playing_auto: false,
+      filename_policy: FilenamePolicy.ArtistAndTitle,
+      instant_save: false,
+      FilenamePolicies,
+      dir: null,
+    };
+  },
+  watch: {
+    instant_save(val) {
+      if (val) this.showDirectlySave();
+    },
+  },
+  methods: {
+    async showSuccess(data) {
+      if (this.instant_save) {
+        await this.saveFile(data);
+        RemoveBlobMusic(data);
+      } else {
+        this.tableData.push(data);
+        this.$notify.success({
+          title: '解锁成功',
+          message: '成功解锁 ' + data.title,
+          duration: 3000,
+        });
+      }
+      if (process.env.NODE_ENV === 'production') {
+        let _rp_data = [data.title, data.artist, data.album];
+        window._paq.push(['trackEvent', 'Unlock', data.rawExt + ',' + data.mime, JSON.stringify(_rp_data)]);
+      }
+    },
+    showFail(errInfo, filename) {
+      console.error(errInfo, filename);
+      this.$notify.error({
+        title: '出现问题',
+        message:
+          errInfo +
+          '，' +
+          filename +
+          '，参考<a target="_blank" href="https://git.unlock-music.dev/um/web/wiki/使用提示">使用提示</a>',
+        dangerouslyUseHTMLString: true,
+        duration: 6000,
+      });
+      if (process.env.NODE_ENV === 'production') {
+        window._paq.push(['trackEvent', 'Error', String(errInfo), filename]);
+      }
+    },
+    changePlaying(url) {
+      this.playing_url = url;
+      this.playing_auto = true;
+    },
+    handleDeleteAll() {
+      this.tableData.forEach((value) => {
+        RemoveBlobMusic(value);
+      });
+      this.tableData = [];
+    },
+    handleDecryptionConfig() {
+      this.showConfigDialog = true;
+    },
+    handleDownloadAll() {
+      let index = 0;
+      let c = setInterval(() => {
+        if (index < this.tableData.length) {
+          this.saveFile(this.tableData[index]);
+          index++;
+        } else {
+          clearInterval(c);
+        }
+      }, 300);
+    },
+    async handleEdit(data) {
+      this.showEditDialog = false;
+      URL.revokeObjectURL(this.editing_data.file);
+      if (data.picture) {
+        URL.revokeObjectURL(this.editing_data.picture);
+        this.editing_data.picture = URL.createObjectURL(data.picture);
+      }
+      this.editing_data.title = data.title;
+      this.editing_data.artist = data.artist;
+      this.editing_data.album = data.album;
+      let writeSuccess = true;
+      let notifyMsg = '成功修改 ' + this.editing_data.title;
+      try {
+        const musicMeta = await metaParseBlob(new Blob([this.editing_data.blob], { type: mime }));
+        let imageInfo = undefined;
+        if (this.editing_data.picture !== '') {
+          imageInfo = await GetImageFromURL(this.editing_data.picture);
+          if (!imageInfo) {
+            console.warn('获取图像失败', this.editing_data.picture);
+          }
+        }
+        const newMeta = {
+          picture: imageInfo?.buffer,
+          title: data.title,
+          artists: data.artist.split(split_regex),
+          album: data.album,
+          albumartist: data.albumartist,
+          genre: data.genre.split(split_regex),
+        };
+        const buffer = Buffer.from(await this.editing_data.blob.arrayBuffer());
+        const mime = AudioMimeType[this.editing_data.ext] || AudioMimeType.mp3;
+        if (this.editing_data.ext === 'mp3') {
+          this.editing_data.blob = new Blob([RewriteMetaToMp3(buffer, newMeta, musicMeta)], { type: mime });
+        } else if (this.editing_data.ext === 'flac') {
+          this.editing_data.blob = new Blob([RewriteMetaToFlac(buffer, newMeta, musicMeta)], { type: mime });
+        } else {
+          writeSuccess = undefined;
+          notifyMsg = this.editing_data.ext + '类型文件暂时不支持修改音乐标签';
+        }
+      } catch (e) {
+        writeSuccess = false;
+        notifyMsg = '修改' + this.editing_data.title + '未能完成。在写入新的元数据时发生错误：' + e;
+      }
+      this.editing_data.file = URL.createObjectURL(this.editing_data.blob);
+      if (writeSuccess === true) {
+        this.$notify.success({
+          title: '修改成功',
+          message: notifyMsg,
+          duration: 3000,
+        });
+      } else if (writeSuccess === false) {
+        this.$notify.error({
+          title: '修改失败',
+          message: notifyMsg,
+          duration: 3000,
+        });
+      } else {
+        this.$notify.warning({
+          title: '修改取消',
+          message: notifyMsg,
+          duration: 3000,
+        });
+      }
+    },
+
+    async editFile(data) {
+      this.editing_data = data;
+      const musicMeta = await metaParseBlob(this.editing_data.blob);
+      this.editing_data.albumartist = musicMeta.common.albumartist || '';
+      this.editing_data.genre = musicMeta.common.genre?.toString() || '';
+      this.showEditDialog = true;
+    },
+    async saveFile(data) {
+      if (this.dir) {
+        await DirectlyWriteFile(data, this.filename_policy, this.dir);
+        this.$notify({
+          title: '保存成功',
+          message: data.title,
+          position: 'top-left',
+          type: 'success',
+          duration: 3000,
+        });
+      } else {
+        DownloadBlobMusic(data, this.filename_policy);
+      }
+    },
+    async showDirectlySave() {
+      if (!window.showDirectoryPicker) return;
+      try {
+        await this.$confirm('您的浏览器支持文件直接保存到磁盘，是否使用？', '新特性提示', {
+          confirmButtonText: '使用',
+          cancelButtonText: '不使用',
+          type: 'warning',
+          center: true,
+        });
+      } catch (e) {
+        console.log(e);
+        return;
+      }
+      try {
+        this.dir = await window.showDirectoryPicker();
+        const test_filename = '__unlock_music_write_test.txt';
+        await this.dir.getFileHandle(test_filename, { create: true });
+        await this.dir.removeEntry(test_filename);
+      } catch (e) {
+        console.error(e);
+      }
+    },
+  },
+};
+</script>

testdata/mflac0_rc4_key.bin

@@ -0,0 +1 @@
+dRzX3p5ZYqAlp7lLSs9Zr0rw1iEZy23bB670x4ch2w97x14Zwpk1UXbKU4C2sOS7uZ0NB5QM7ve9GnSrr2JHxP74hVNONwVV77CdOOVb807317KvtI5Yd6h08d0c5W88rdV46C235YGDjUSZj5314YTzy0b6vgh4102P7E273r911Nl464XV83Hr00rkAHkk791iMGSJH95GztN28u2Nv5s9Xx38V69o4a8aIXxbx0g1EM0623OEtbtO9zsqCJfj6MhU7T8iVS6M3q19xhq6707E6r7wzPO6Yp4BwBmgg4F95Lfl0vyF7YO6699tb5LMnr7iFx29o98hoh3O3Rd8h9Juu8P1wG7vdnO5YtRlykhUluYQblNn7XwjBJ53HAyKVraWN5dG7pv7OMl1s0RykPh0p23qfYzAAMkZ1M422pEd07TA9OCKD1iybYxWH06xj6A8mzmcnYGT9P1a5Ytg2EF5LG3IknL2r3AUz99Y751au6Cr401mfAWK68WyEBe5

testdata/mflac0_rc4_key_raw.bin

@@ -0,0 +1 @@
+ZFJ6WDNwNVrjEJZB1o6QjkQV2ZbHSw/2Eb00q1+4z9SVWYyFWO1PcSQrJ5326ubLklmk2ab3AEyIKNUu8DFoAoAc9dpzpTmc+pdkBHjM/bW2jWx+dCyC8vMTHE+DHwaK14UEEGW47ZXMDi7PRCQ2Jpm/oXVdHTIlyrc+bRmKfMith0L2lFQ+nW8CCjV6ao5ydwkZhhNOmRdrCDcUXSJH9PveYwra9/wAmGKWSs9nemuMWKnbjp1PkcxNQexicirVTlLX7PVgRyFyzNyUXgu+R2S4WTmLwjd8UsOyW/dc2mEoYt+vY2lq1X4hFBtcQGOAZDeC+mxrN0EcW8tjS6P4TjOjiOKNMxIfMGSWkSKL3H7z5K7nR1AThW20H2bP/LcpsdaL0uZ/js1wFGpdIfFx9rnLC78itL0WwDleIqp9TBMX/NwakGgIPIbjBwfgyD8d8XKYuLEscIH0ZGdjsadB5XjybgdE3ppfeFEcQiqpnodlTaQRm3KDIF9ATClP0mTl8XlsSojsZ468xseS1Ib2iinx/0SkK3UtJDwp8DH3/+ELisgXd69Bf0pve7wbrQzzMUs9/Ogvvo6ULsIkQfApJ8cSegDYklzGXiLNH7hZYnXDLLSNejD7NvQouULSmGsBbGzhZ5If0NP/6AhSbpzqWLDlabTDgeWWnFeZpBnlK6SMxo+YFFk1Y0XLKsd69+jj