@laisuk/opencc-fmmseg-wasm 0.3.3 → 0.3.5

package/README.md

@@ -21,6 +21,7 @@ Features:
 * Traditional Chinese regional variants
 * Japanese Shinjitai conversion support
 * Chinese script detection (`zho_check`)
+* Optional CJK Compatibility Ideograph normalization
 * In-memory Office / EPUB document conversion
 * Zero-dependency Node.js CLI
 
@@ -162,6 +163,41 @@ cc.convert("汉字", false);
 
 ---
 
+### normalizeCompat
+
+Normalize Unicode CJK Compatibility Ideographs before conversion.
+
+```javascript
+cc.normalizeCompat(text)
+```
+
+Parameters:
+
+* `text`: input string
+
+Returns:
+
+* normalized string
+
+Example:
+
+```javascript
+const cc = new OpenccWasm("t2s");
+
+const input = "天龍八部書裡的喬峰是契丹人";
+const normalized = cc.normalizeCompat(input);
+
+console.log(normalized);
+// 天龍八部書裡的喬峰是契丹人
+
+console.log(cc.convert(normalized, false));
+// 天龙八部书里的乔峰是契丹人
+```
+
+This is an optional pre-conversion pass for text that contains compatibility ideographs from Unicode compatibility ranges. Unmapped characters are preserved unchanged. Normal OpenCC conversion does not automatically run this pass, so call it explicitly when compatibility normalization is desired.
+
+---
+
 ### detofu
 
 Replace tofu-risk rare CJK extension characters with display-compatible fallbacks.
@@ -387,7 +423,9 @@ const cc = OpenccWasm.newWithCustomDicts("s2t", [
 `Override` replaces the selected slot before inserting the provided pairs. It is powerful and should be used only when
 the caller intentionally wants to discard built-in entries for that slot.
 
-Custom dictionary specs use strict canonical `DictSlot` names:
+Custom dictionary specs identify the target dictionary slot by `DictSlot` name. Slot names are trimmed and normalized
+case-insensitively for the known slots, so `"stphrases"`, `" STPhrases "`, and `"STPhrases"` all select
+`STPhrases`. Canonical names are recommended in TypeScript code and docs:
 
 ```text
 STPhrases
@@ -406,15 +444,15 @@ HKVariants
 HKVariantsPhrases
 HKVariantsRev
 HKVariantsRevPhrases
-JPShinjitaiCharacters
-JPShinjitaiPhrases
-JPVariants
-JPVariantsRev
+JPSCharacters
+JPSCharactersRev
+JPSPhrases
 STPunctuations
 TSPunctuations
 ```
 
-Suffixes such as `.txt` are not accepted. Use `"STPhrases"`, not `"STPhrases.txt"`.
+Suffixes such as `.txt` are not accepted, even though case and surrounding whitespace are normalized. Use
+`"STPhrases"` or `"stphrases"`, not `"STPhrases.txt"`.
 
 Merge contract:
 
@@ -447,15 +485,17 @@ docx, xlsx, pptx, odt, ods, odp, epub
 File size is limited by available browser or Node.js memory, but there is no upload or server-side limit. Font
 preservation is supported with the `keepFont` option.
 
+Use the instance method when possible. It reuses the converter configuration and any custom dictionaries already held by
+the `OpenccWasm` instance.
+
 ```javascript
-convert_office_bytes(inputBytes, format, config, punctuation, keepFont)
+cc.convertOfficeBytes(inputBytes, format, punctuation, keepFont)
 ```
 
 Parameters:
 
 * `inputBytes`: `Uint8Array` document bytes
 * `format`: `docx`, `xlsx`, `pptx`, `odt`, `ods`, `odp`, or `epub`
-* `config`: OpenCC config string, such as `"s2t"`
 * `punctuation`: whether to convert punctuation variants
 * `keepFont`: whether to preserve font declarations where supported
 
@@ -463,20 +503,26 @@ Returns:
 
 * converted output bytes
 
+The older free function remains available for compatibility:
+
+```javascript
+convert_office_bytes(inputBytes, format, config, punctuation, keepFont)
+```
+
 ### Browser Office Example
 
 ```javascript
-import init, {convert_office_bytes} from "@laisuk/opencc-fmmseg-wasm";
+import init, {OpenccWasm} from "@laisuk/opencc-fmmseg-wasm";
 
 await init();
 
+const cc = new OpenccWasm("s2t");
 const file = document.querySelector("input[type=file]").files[0];
 const inputBytes = new Uint8Array(await file.arrayBuffer());
 
-const outputBytes = convert_office_bytes(
+const outputBytes = cc.convertOfficeBytes(
     inputBytes,
     "docx",
-    "s2t",
     true,
     true
 );
@@ -496,16 +542,16 @@ URL.revokeObjectURL(a.href);
 
 ```javascript
 import fs from "fs";
-import init, {convert_office_bytes} from "@laisuk/opencc-fmmseg-wasm";
+import init, {OpenccWasm} from "@laisuk/opencc-fmmseg-wasm";
 
 await init();
 
+const cc = new OpenccWasm("s2t");
 const inputBytes = fs.readFileSync("input.docx");
 
-const outputBytes = convert_office_bytes(
+const outputBytes = cc.convertOfficeBytes(
     inputBytes,
     "docx",
-    "s2t",
     true,
     true
 );
@@ -574,6 +620,18 @@ The package includes a zero-dependency Node.js CLI:
 opencc-fmmseg convert -i input.txt -o output.txt -c s2t -p
 opencc-fmmseg convert -i input.txt -o output.txt -c t2s -p --detofu all
 echo "别随便录影侵犯个人隐私权" | opencc-fmmseg convert -c s2hkp
+echo "天龍八部書裡的喬峰是契丹人" | opencc-fmmseg convert -c t2s --norm-compat
+// 天龙八部书里的乔峰是契丹人
+echo "這個細路哥很靈活" | opencc-fmmseg convert -c hk2sp --custom-dict hkphrasesrev:append:my_hk_dict.txt  
+// 这个小男孩很灵活
+```
+
+my_hk_dict.txt:
+
+```
+# Custom Dictionary
+
+細路哥	小男孩
 ```
 
 ```bash
@@ -583,15 +641,23 @@ opencc-fmmseg office -i input.docx -o output.docx -c s2t -p --keep-font
 ### Text Conversion Options
 
 ```text
--i, --input <file>          Input text file
--o, --output <file>         Output text file
--c, --config <conversion>   Conversion config
+-i, --input <file>          Input text file; stdin if omitted
+-o, --output <file>         Output text file; stdout if omitted
+-c, --config <conversion>   Conversion config (default: s2t)
 -p, --punct                 Enable punctuation conversion
 --detofu [level]            Replace tofu-risk rare CJK extension chars after conversion
                               level: all | ext-b | ext-c | ext-d | ext-e | ext-f | ext-g | ext-h | ext-i
                               default when omitted value: all
---in-enc <encoding>         Input encoding
---out-enc <encoding>        Output encoding
+--keep-ids                  Preserve complete IDS expressions during conversion (default: false)
+-n, --norm-compat           Normalize CJK Compatibility Ideographs before conversion (default: false)
+-D, --custom-dict <slot:mode:file>
+                            Load a custom dictionary.
+                            May be specified multiple times.
+                            Examples:
+                              --custom-dict hkphrasesrev:append:my_hk_dict.txt
+                              --custom-dict stphrases:override:terms.txt
+--in-enc <encoding>         Input encoding (default: utf8)
+--out-enc <encoding>        Output encoding (default: utf8)
 ```
 
 Supported conversion configs:
@@ -606,12 +672,18 @@ tw2s, tw2sp, tw2t, tw2tp, hk2s, hk2sp, hk2t, jp2t, t2jp
 ```text
 -i, --input <file>          Input Office / EPUB file
 -o, --output <file>         Output file
--c, --config <conversion>   Conversion config
+-c, --config <conversion>   Conversion config (default: s2t)
 -p, --punct                 Enable punctuation conversion
---format <format>           docx | xlsx | pptx | odt | ods | odp | epub
---auto-ext                  Append extension to output if missing
---keep-font                 Preserve font-family information
+-f, --format <format>       docx | xlsx | pptx | odt | ods | odp | epub
+-F, --convert-filename      Convert generated output filename stem (default: false)
+--keep-font                 Preserve font-family information (default)
 --no-keep-font              Do not preserve font-family information
+--custom-dict <slot:mode:file>
+                            Load a custom dictionary.
+                            May be specified multiple times.
+                            Examples:
+                              --custom-dict hkphrasesrev:append:my_hk_dict.txt
+                              --custom-dict stphrases:override:terms.txt
 ```
 
 For `office`, the format is inferred from the input file extension when `--format` is omitted.

package/bin/opencc.js

@@ -6,8 +6,7 @@ import process from "process";
 
 import init, {
     OpenccWasm,
-    DetofuLevelWasm,
-    convert_office_bytes
+    DetofuLevelWasm
 } from "../opencc_fmmseg_wasm.js";
 
 const OFFICE_FORMATS = new Set([
@@ -58,6 +57,13 @@ Convert options:
                               level: all | ext-b | ext-c | ext-d | ext-e | ext-f | ext-g | ext-h | ext-i
                               default when omitted value: all
   --keep-ids                  Preserve complete IDS expressions during conversion (default: false)
+  -n, --norm-compat           Normalize CJK Compatibility Ideographs before conversion (default: false)
+  -D, --custom-dict <slot:mode:file>
+                              Load a custom dictionary.
+                              May be specified multiple times.
+                              Examples:
+                                --custom-dict hkphrasesrev:append:my_hk_dict.txt
+                                --custom-dict stphrases:override:terms.txt
   --in-enc <encoding>         Input encoding (default: utf8)
   --out-enc <encoding>        Output encoding (default: utf8)
 
@@ -70,10 +76,16 @@ Office options:
   -o, --output <file>         Output file
   -c, --config <conversion>   Conversion config (default: s2t)
   -p, --punct                 Enable punctuation conversion
-  --format <format>           docx | xlsx | pptx | odt | ods | odp | epub
-  --auto-ext                  Append extension to output if missing
+  -f, --format <format>       docx | xlsx | pptx | odt | ods | odp | epub
+  -F, --convert-filename      Convert generated output filename stem (default: false)
   --keep-font                 Preserve font-family information (default)
   --no-keep-font              Do not preserve font-family information
+  --custom-dict <slot:mode:file>
+                              Load a custom dictionary.
+                              May be specified multiple times.
+                              Examples:
+                                --custom-dict hkphrasesrev:append:my_hk_dict.txt
+                                --custom-dict stphrases:override:terms.txt
 
 General options:
   -h, --help                  Show help
@@ -85,9 +97,12 @@ Examples:
   echo "别随便录影侵犯个人隐私权" | npx opencc-fmmseg convert -c s2hkp
   npx opencc-fmmseg convert -i a.txt -o b.txt -c t2s --detofu
   npx opencc-fmmseg convert -i a.txt -o b.txt -c t2s --detofu ext-c
+  echo "⿰氵漢" | npx opencc-fmmseg convert -c t2s
+  echo "⿰氵漢" | npx opencc-fmmseg convert -c t2s --keep-ids
 
   npx opencc-fmmseg office -i a.docx -o b.docx -c s2t -p
-  npx opencc-fmmseg office -i a.epub -c s2tw --auto-ext
+  npx opencc-fmmseg office -i a.epub -c s2tw
+  npx opencc-fmmseg office -i 软件手册.docx -c s2t --convert-filename
 `);
 }
 
@@ -112,6 +127,97 @@ function getArg(args, shortName, longName, defaultValue = null) {
     return defaultValue;
 }
 
+function getArgs(args, shortName, longName) {
+    const values = [];
+    const candidates = [];
+
+    if (shortName) candidates.push(shortName);
+    if (longName) candidates.push(longName);
+
+    if (candidates.length === 0) return values;
+
+    for (let i = 0; i < args.length; i++) {
+        if (candidates.includes(args[i]) && i + 1 < args.length) {
+            values.push(args[i + 1]);
+            i++;
+        }
+    }
+
+    return values;
+}
+
+function parseCustomDictSpec(value) {
+    const first = value.indexOf(":");
+    const second = value.indexOf(":", first + 1);
+
+    if (first < 0 || second < 0) {
+        throw new Error(
+            `Invalid custom dictionary specification: ${value}\n` +
+            "Expected: <slot>:<append|override>:<file>"
+        );
+    }
+
+    const slot = value.substring(0, first).trim();
+    const mode = value.substring(first + 1, second).trim();
+    const file = value.substring(second + 1).trim();
+
+    if (!slot) throw new Error("Custom dictionary slot is empty.");
+    if (!mode) throw new Error("Custom dictionary mode is empty.");
+    if (!file) throw new Error("Custom dictionary file is empty.");
+
+    return {
+        slot,
+        mode,
+        pairs: loadCustomDictPairs(file)
+    };
+}
+
+function loadCustomDictPairs(file) {
+    if (!fs.existsSync(file)) {
+        throw new Error(`Custom dictionary file not found: ${file}`);
+    }
+
+    const text = fs.readFileSync(file, "utf8");
+    const lines = text.split(/\r?\n/);
+    const pairs = [];
+
+    for (let i = 0; i < lines.length; i++) {
+        let line = lines[i].replace(/\r$/, "");
+
+        if (i === 0 && line.charCodeAt(0) === 0xfeff) {
+            line = line.slice(1);
+        }
+
+        line = line.trimEnd();
+
+        if (!line || line.startsWith("#")) {
+            continue;
+        }
+
+        const tab = line.indexOf("\t");
+
+        if (tab < 0) {
+            throw new Error(
+                `Invalid custom dictionary file ${file}:${i + 1}: missing TAB separator`
+            );
+        }
+
+        const source = line.substring(0, tab);
+        const values = line.substring(tab + 1).trim().split(/\s+/);
+        const target = values[0] || "";
+
+        if (!source || !target) {
+            throw new Error(
+                `Invalid custom dictionary file ${file}:${i + 1}: empty source or target`
+            );
+        }
+
+        pairs.push([source, target]);
+    }
+
+    return pairs;
+}
+
 function hasFlag(args, shortName, longName) {
     return (
         (shortName && args.includes(shortName)) ||
@@ -167,24 +273,20 @@ function inferOfficeFormat(inputFile, explicitFormat) {
     return ext;
 }
 
-function makeDefaultOfficeOutput(inputFile, officeFormat, autoExt) {
+function makeDefaultOfficeOutput(inputFile, officeFormat, convertFilename, cc, config, punct) {
     const parsed = path.parse(inputFile);
-    const ext = autoExt && OFFICE_FORMATS.has(officeFormat)
-        ? `.${officeFormat}`
-        : parsed.ext;
+    const stem = convertFilename
+        ? cc.convert(parsed.name, punct)
+        : parsed.name;
 
     return path.join(
         parsed.dir || process.cwd(),
-        `${parsed.name}_converted${ext}`
+        `${stem}_converted.${officeFormat}`
     );
 }
 
-function applyAutoExt(outputFile, officeFormat, autoExt) {
-    if (!autoExt || path.extname(outputFile)) {
-        return outputFile;
-    }
-
-    if (!OFFICE_FORMATS.has(officeFormat)) {
+function applyOutputExtension(outputFile, officeFormat) {
+    if (path.extname(outputFile)) {
         return outputFile;
     }
 
@@ -249,6 +351,9 @@ async function runConvert(args) {
     const outEnc = getArg(args, null, "--out-enc", "utf8");
     const punct = hasFlag(args, "-p", "--punct");
     const keepIds = hasFlag(args, null, "--keep-ids");
+    const normCompat = hasFlag(args, "-n", "--norm-compat");
+    const customDicts = getArgs(args, "-D", "--custom-dict")
+        .map(parseCustomDictSpec);
 
     const detofuIndex = args.indexOf("--detofu");
     const detofuEnabled = detofuIndex !== -1;
@@ -266,7 +371,10 @@ async function runConvert(args) {
 
     await ensureWasmInitialized();
 
-    const cc = new OpenccWasm(config);
+    // const cc = new OpenccWasm(config);
+    const cc = customDicts.length === 0
+        ? new OpenccWasm(config)
+        : OpenccWasm.newWithCustomDicts(config, customDicts);
 
     if (keepIds) {
         cc.setPreserveIds(true);
@@ -277,7 +385,12 @@ async function runConvert(args) {
         console.error("Input text to convert, <Ctrl+Z>/<Ctrl+D> to submit:");
     }
 
-    const inputText = readInputText(input, inEnc);
+    let inputText = readInputText(input, inEnc);
+
+    if (normCompat) {
+        inputText = cc.normalizeCompat(inputText);
+    }
+
     let outputText = cc.convert(inputText, punct);
 
     if (detofuEnabled) {
@@ -295,11 +408,12 @@ async function runConvert(args) {
         }
 
         const suffixParts = [];
+        if (normCompat) suffixParts.push("normalized");
         if (detofuEnabled) suffixParts.push("detofu");
         if (keepIds) suffixParts.push("keep-ids");
 
         const suffix = suffixParts.length ? `, ${suffixParts.join(", ")}` : "";
-        console.error(`Conversion completed (${config}${suffix}): ${inFrom} -> ${outTo}`);
+        console.error(`Conversion completed (${cc.getConfig()}${suffix}): ${inFrom} -> ${outTo}`);
     }
 }
 
@@ -307,10 +421,12 @@ async function runOffice(args) {
     const input = getArg(args, "-i", "--input");
     let output = getArg(args, "-o", "--output");
     const config = getArg(args, "-c", "--config", "s2t");
-    const explicitFormat = getArg(args, null, "--format");
+    const explicitFormat = getArg(args, "-f", "--format");
     const punct = hasFlag(args, "-p", "--punct");
-    const autoExt = hasFlag(args, null, "--auto-ext");
+    const convertFilename = hasFlag(args, "-F", "--convert-filename");
     const keepFont = !hasFlag(args, null, "--no-keep-font");
+    const customDicts = getArgs(args, "-D", "--custom-dict")
+        .map(parseCustomDictSpec);
 
     if (!input) {
         throw new Error("Input file is missing.");
@@ -322,18 +438,23 @@ async function runOffice(args) {
 
     const officeFormat = inferOfficeFormat(input, explicitFormat);
 
+    await ensureWasmInitialized();
+
+    // const cc = new OpenccWasm(config);
+    const cc = customDicts.length === 0
+        ? new OpenccWasm(config)
+        : OpenccWasm.newWithCustomDicts(config, customDicts);
+
     if (!output) {
-        output = makeDefaultOfficeOutput(input, officeFormat, autoExt);
+        output = makeDefaultOfficeOutput(input, officeFormat, convertFilename, cc, config, punct);
         console.error(`Output file not specified. Using: ${output}`);
     } else {
-        output = applyAutoExt(output, officeFormat, autoExt);
+        output = applyOutputExtension(output, officeFormat);
     }
 
-    await ensureWasmInitialized();
-
     const inputBytes = fs.readFileSync(input);
 
-    const outputBytes = convert_office_bytes(
+    const outputBytes = cc.convertOfficeBytes(
         inputBytes,
         officeFormat,
         config,
@@ -343,7 +464,7 @@ async function runOffice(args) {
 
     fs.writeFileSync(output, outputBytes);
 
-    console.error(`Conversion completed (${config}, ${officeFormat}): ${input} -> ${output}`);
+    console.error(`Conversion completed (${cc.getConfig()}, ${officeFormat}): ${input} -> ${output}`);
 }
 
 async function main() {

package/opencc_fmmseg_wasm.d.ts

@@ -38,6 +38,7 @@ export class OpenccWasm {
     [Symbol.dispose](): void;
     convert(text: string, punctuation: boolean): string;
     convertDetofu(text: string, punctuation: boolean, level: DetofuLevelWasm): string;
+    convertOfficeBytes(input: Uint8Array, format: string, punctuation: boolean, keep_font: boolean): Uint8Array;
     debugPing(): string;
     detofu(text: string, level: DetofuLevelWasm): string;
     getConfig(): string;
@@ -48,6 +49,7 @@ export class OpenccWasm {
     constructor(config?: string | null);
     static newWithCustomDicts(config: string | null | undefined, specs: any): OpenccWasm;
     static newWithEnum(config?: OpenccConfigWasm | null): OpenccWasm;
+    normalizeCompat(text: string): string;
     setConfig(config: string): boolean;
     setConfigEnum(config: OpenccConfigWasm): void;
     setPreserveIds(value: boolean): void;
@@ -65,6 +67,7 @@ export interface InitOutput {
     readonly convert_office_bytes: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number, number, number];
     readonly openccwasm_convert: (a: number, b: number, c: number, d: number) => [number, number];
     readonly openccwasm_convertDetofu: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+    readonly openccwasm_convertOfficeBytes: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number, number];
     readonly openccwasm_debugPing: (a: number) => [number, number];
     readonly openccwasm_detofu: (a: number, b: number, c: number, d: number) => [number, number];
     readonly openccwasm_getConfig: (a: number) => [number, number];
@@ -75,6 +78,7 @@ export interface InitOutput {
     readonly openccwasm_new: (a: number, b: number) => [number, number, number];
     readonly openccwasm_newWithCustomDicts: (a: number, b: number, c: any) => [number, number, number];
     readonly openccwasm_newWithEnum: (a: number) => [number, number, number];
+    readonly openccwasm_normalizeCompat: (a: number, b: number, c: number) => [number, number];
     readonly openccwasm_setConfig: (a: number, b: number, c: number) => number;
     readonly openccwasm_setConfigEnum: (a: number, b: number) => void;
     readonly openccwasm_setPreserveIds: (a: number, b: number) => void;

package/opencc_fmmseg_wasm.js

@@ -94,6 +94,26 @@ export class OpenccWasm {
             wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
         }
     }
+    /**
+     * @param {Uint8Array} input
+     * @param {string} format
+     * @param {boolean} punctuation
+     * @param {boolean} keep_font
+     * @returns {Uint8Array}
+     */
+    convertOfficeBytes(input, format, punctuation, keep_font) {
+        const ptr0 = passArray8ToWasm0(input, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(format, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.openccwasm_convertOfficeBytes(this.__wbg_ptr, ptr0, len0, ptr1, len1, punctuation, keep_font);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v3;
+    }
     /**
      * @returns {string}
      */
@@ -215,6 +235,24 @@ export class OpenccWasm {
         }
         return OpenccWasm.__wrap(ret[0]);
     }
+    /**
+     * @param {string} text
+     * @returns {string}
+     */
+    normalizeCompat(text) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.openccwasm_normalizeCompat(this.__wbg_ptr, ptr0, len0);
+            deferred2_0 = ret[0];
+            deferred2_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
     /**
      * @param {string} config
      * @returns {boolean}
@@ -291,7 +329,7 @@ export function convert_office_bytes(input, format, config, punctuation, keep_fo
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
-        __wbg_Error_ef53bc310eb298a0: function(arg0, arg1) {
+        __wbg_Error_92b29b0548f8b746: function(arg0, arg1) {
             const ret = Error(getStringFromWasm0(arg0, arg1));
             return ret;
         },
@@ -302,46 +340,46 @@ function __wbg_get_imports() {
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        __wbg___wbindgen_boolean_get_1a45e2c38d4d41b9: function(arg0) {
+        __wbg___wbindgen_boolean_get_fa956cfa2d1bd751: function(arg0) {
             const v = arg0;
             const ret = typeof(v) === 'boolean' ? v : undefined;
             return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
         },
-        __wbg___wbindgen_debug_string_0accd80f45e5faa2: function(arg0, arg1) {
+        __wbg___wbindgen_debug_string_c25d447a39f5578f: function(arg0, arg1) {
             const ret = debugString(arg1);
             const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
             const len1 = WASM_VECTOR_LEN;
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        __wbg___wbindgen_in_70a403a56e771704: function(arg0, arg1) {
+        __wbg___wbindgen_in_aca499c5de7ff5e5: function(arg0, arg1) {
             const ret = arg0 in arg1;
             return ret;
         },
-        __wbg___wbindgen_is_function_754e9f305ff6029e: function(arg0) {
+        __wbg___wbindgen_is_function_1ff95bcc5517c252: function(arg0) {
             const ret = typeof(arg0) === 'function';
             return ret;
         },
-        __wbg___wbindgen_is_object_56732c2bc353f41d: function(arg0) {
+        __wbg___wbindgen_is_object_a27215656b807791: function(arg0) {
             const val = arg0;
             const ret = typeof(val) === 'object' && val !== null;
             return ret;
         },
-        __wbg___wbindgen_is_undefined_67b456be8673d3d7: function(arg0) {
+        __wbg___wbindgen_is_undefined_c05833b95a3cf397: function(arg0) {
             const ret = arg0 === undefined;
             return ret;
         },
-        __wbg___wbindgen_jsval_loose_eq_2c56564c75129511: function(arg0, arg1) {
+        __wbg___wbindgen_jsval_loose_eq_db4c3b15f63fc170: function(arg0, arg1) {
             const ret = arg0 == arg1;
             return ret;
         },
-        __wbg___wbindgen_number_get_9bb1761122181af2: function(arg0, arg1) {
+        __wbg___wbindgen_number_get_394265ed1e1b84ee: function(arg0, arg1) {
             const obj = arg1;
             const ret = typeof(obj) === 'number' ? obj : undefined;
             getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
         },
-        __wbg___wbindgen_string_get_72bdf95d3ae505b1: function(arg0, arg1) {
+        __wbg___wbindgen_string_get_b0ca35b86a603356: function(arg0, arg1) {
             const obj = arg1;
             const ret = typeof(obj) === 'string' ? obj : undefined;
             var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -349,22 +387,22 @@ function __wbg_get_imports() {
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        __wbg___wbindgen_throw_1506f2235d1bdba0: function(arg0, arg1) {
+        __wbg___wbindgen_throw_344f42d3211c4765: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
-        __wbg_call_8a89609d89f6608a: function() { return handleError(function (arg0, arg1) {
+        __wbg_call_8a2dd23819f8a60a: function() { return handleError(function (arg0, arg1) {
             const ret = arg0.call(arg1);
             return ret;
         }, arguments); },
-        __wbg_done_60cf307fcc680536: function(arg0) {
+        __wbg_done_89b2b13e91a60321: function(arg0) {
             const ret = arg0.done;
             return ret;
         },
-        __wbg_get_1f8f054ddbaa7db2: function() { return handleError(function (arg0, arg1) {
+        __wbg_get_c7eb1f358a7654df: function() { return handleError(function (arg0, arg1) {
             const ret = Reflect.get(arg0, arg1);
             return ret;
         }, arguments); },
-        __wbg_get_unchecked_33f6e5c9e2f2d6b2: function(arg0, arg1) {
+        __wbg_get_unchecked_6e0ad6d2a41b06f6: function(arg0, arg1) {
             const ret = arg0[arg1 >>> 0];
             return ret;
         },
@@ -372,7 +410,7 @@ function __wbg_get_imports() {
             const ret = arg0[arg1];
             return ret;
         },
-        __wbg_instanceof_ArrayBuffer_8f49811467741499: function(arg0) {
+        __wbg_instanceof_ArrayBuffer_4480b9e0068a8adb: function(arg0) {
             let result;
             try {
                 result = arg0 instanceof ArrayBuffer;
@@ -382,7 +420,7 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
-        __wbg_instanceof_Uint8Array_86f30649f63ef9c2: function(arg0) {
+        __wbg_instanceof_Uint8Array_309b927aaf7a3fc7: function(arg0) {
             let result;
             try {
                 result = arg0 instanceof Uint8Array;
@@ -392,38 +430,38 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
-        __wbg_isArray_67c2c9c4313f4448: function(arg0) {
+        __wbg_isArray_0677c962b281d01a: function(arg0) {
             const ret = Array.isArray(arg0);
             return ret;
         },
-        __wbg_iterator_8732428d309e270e: function() {
+        __wbg_iterator_6f722e4a93058b71: function() {
             const ret = Symbol.iterator;
             return ret;
         },
-        __wbg_length_4a591ecaa01354d9: function(arg0) {
+        __wbg_length_1f0964f4a5e2c6d8: function(arg0) {
             const ret = arg0.length;
             return ret;
         },
-        __wbg_length_66f1a4b2e9026940: function(arg0) {
+        __wbg_length_370319915dc99107: function(arg0) {
             const ret = arg0.length;
             return ret;
         },
-        __wbg_new_578aeef4b6b94378: function(arg0) {
+        __wbg_new_cd45aabdf6073e84: function(arg0) {
             const ret = new Uint8Array(arg0);
             return ret;
         },
-        __wbg_next_9e03acdf51c4960d: function(arg0) {
+        __wbg_next_6dbf2c0ac8cde20f: function(arg0) {
             const ret = arg0.next;
             return ret;
         },
-        __wbg_next_eb8ca7351fa27906: function() { return handleError(function (arg0) {
+        __wbg_next_71f2aa1cb3d1e37e: function() { return handleError(function (arg0) {
             const ret = arg0.next();
             return ret;
         }, arguments); },
-        __wbg_prototypesetcall_3249fc62a0fafa30: function(arg0, arg1, arg2) {
+        __wbg_prototypesetcall_4770620bbe4688a0: function(arg0, arg1, arg2) {
             Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
         },
-        __wbg_value_f3625092ee4b37f4: function(arg0) {
+        __wbg_value_a5d5488a9589444a: function(arg0) {
             const ret = arg0.value;
             return ret;
         },

package/package.json

@@ -2,7 +2,7 @@
   "name": "@laisuk/opencc-fmmseg-wasm",
   "type": "module",
   "description": "WebAssembly bindings for opencc-fmmseg, a high-performance OpenCC-compatible Simplified/Traditional Chinese converter.",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "license": "MIT",
   "repository": {
     "type": "git",