@dan-uni/dan-any-plugin-detaolu 0.0.2

package/dist/index.js

@@ -0,0 +1,732 @@
+/*! For license information please see index.js.LICENSE.txt */
+import { UniDM, UniDMTools, UniPool } from "@dan-uni/dan-any";
+import fs_extra from "fs-extra";
+var Module = function(moduleArg = {}) {
+    var moduleRtn;
+    var f = moduleArg, g, m = new Promise((a)=>{
+        g = a;
+    });
+    '_begin_chunk _check_similar _begin_index_lock _malloc _memory ___indirect_function_table onRuntimeInitialized'.split(' ').forEach((a)=>{
+        Object.getOwnPropertyDescriptor(m, a) || Object.defineProperty(m, a, {
+            get: ()=>q('You are getting ' + a + ' on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js'),
+            set: ()=>q('You are setting ' + a + ' on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js')
+        });
+    });
+    var r = (a)=>console.log(a), t = (a)=>console.error(a);
+    r = ()=>{};
+    t = (a)=>{
+        console.error(a);
+        throw Error('wasm error: ' + a);
+    };
+    function v(a, b) {
+        if (!a) throw b;
+    }
+    function q(a) {
+        throw Error(a);
+    }
+    var B, C, D, E;
+    function H() {
+        var a = E.buffer;
+        new Int8Array(a);
+        B = new Int16Array(a);
+        C = new Uint8Array(a);
+        new Uint16Array(a);
+        new Int32Array(a);
+        D = new Uint32Array(a);
+        new Float32Array(a);
+        new Float64Array(a);
+        new BigInt64Array(a);
+        new BigUint64Array(a);
+    }
+    v(Math.imul, 'This browser does not support Math.imul(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill');
+    v(Math.fround, 'This browser does not support Math.fround(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill');
+    v(Math.clz32, 'This browser does not support Math.clz32(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill');
+    v(Math.trunc, 'This browser does not support Math.trunc(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill');
+    var I = new Int16Array(1), J = new Int8Array(I.buffer);
+    I[0] = 25459;
+    if (115 !== J[0] || 99 !== J[1]) throw 'Runtime error: expected the system to be little-endian! (Run with -sSUPPORT_BIG_ENDIAN to bypass)';
+    if (f.ENVIRONMENT) throw Error('Module.ENVIRONMENT has been deprecated. To force the environment, use the ENVIRONMENT compile-time option (for example, -sENVIRONMENT=web or -sENVIRONMENT=node)');
+    function K(a) {
+        return 'FS_createPath' === a || 'FS_createDataFile' === a || 'FS_createPreloadedFile' === a || 'FS_unlink' === a || 'addRunDependency' === a || 'FS_createLazyFile' === a || 'FS_createDevice' === a || 'removeRunDependency' === a;
+    }
+    function L(a, b) {
+        'undefined' == typeof globalThis || Object.getOwnPropertyDescriptor(globalThis, a) || Object.defineProperty(globalThis, a, {
+            configurable: !0,
+            get () {
+                b();
+            }
+        });
+    }
+    function M(a, b) {
+        L(a, ()=>{
+            N(`\`${a}\` is not longer defined by emscripten. ${b}`);
+        });
+    }
+    M('buffer', 'Please use HEAP8.buffer or wasmMemory.buffer');
+    M('asm', 'Please use wasmExports instead');
+    function O(a) {
+        Object.getOwnPropertyDescriptor(f, a) || Object.defineProperty(f, a, {
+            configurable: !0,
+            get () {
+                var b = `'${a}' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the Emscripten FAQ)`;
+                K(a) && (b += '. Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you');
+                q(b);
+            }
+        });
+    }
+    var N = (a)=>{
+        N.g || (N.g = {});
+        N.g[a] || (N.g[a] = 1, t(a));
+    }, P = 'undefined' != typeof TextDecoder ? new TextDecoder() : void 0, R = [
+        null,
+        [],
+        []
+    ], S = {
+        _abort_js: ()=>q('native code called abort()'),
+        emscripten_resize_heap: (a)=>{
+            var b = C.length;
+            a >>>= 0;
+            v(a > b);
+            if (268435456 < a) return t(`Cannot enlarge memory, requested ${a} bytes, but the limit is 268435456 bytes!`), !1;
+            for(var c = 1; 4 >= c; c *= 2){
+                var h = b * (1 + 1 / c);
+                h = Math.min(h, a + 100663296);
+                var k = Math, n = k.min;
+                h = Math.max(a, h);
+                v(65536, 'alignment argument is required');
+                k = n.call(k, 268435456, 65536 * Math.ceil(h / 65536));
+                a: {
+                    n = k;
+                    h = E.buffer;
+                    var F = (n - h.byteLength + 65535) / 65536 | 0;
+                    try {
+                        E.grow(F);
+                        H();
+                        var w = 1;
+                        break a;
+                    } catch (x) {
+                        t(`growMemory: Attempted to grow heap from ${h.byteLength} bytes to ${n} bytes, but got error: ${x}`);
+                    }
+                    w = void 0;
+                }
+                if (w) return !0;
+            }
+            t(`Failed to grow the heap from ${b} bytes to ${k} bytes, not enough memory!`);
+            return !1;
+        },
+        fd_close: ()=>{
+            q('fd_close called without SYSCALLS_REQUIRE_FILESYSTEM');
+        },
+        fd_seek: function() {
+            return 70;
+        },
+        fd_write: (a, b, c, h)=>{
+            for(var k = 0, n = 0; n < c; n++){
+                var F = D[b >> 2], w = D[b + 4 >> 2];
+                b += 8;
+                for(var x = 0; x < w; x++){
+                    var y = a, e = C[F + x], z = R[y];
+                    v(z);
+                    if (0 === e || 10 === e) {
+                        y = 1 === y ? r : t;
+                        e = z;
+                        for(var l = 0, p = l + NaN, u = l; e[u] && !(u >= p);)++u;
+                        if (16 < u - l && e.buffer && P) e = P.decode(e.subarray(l, u));
+                        else {
+                            for(p = ''; l < u;){
+                                var d = e[l++];
+                                if (128 & d) {
+                                    var G = 63 & e[l++];
+                                    if (192 == (224 & d)) p += String.fromCharCode((31 & d) << 6 | G);
+                                    else {
+                                        var Q = 63 & e[l++];
+                                        if (224 == (240 & d)) d = (15 & d) << 12 | G << 6 | Q;
+                                        else {
+                                            if (240 != (248 & d)) {
+                                                var V = N;
+                                                var A = d;
+                                                v('number' == typeof A);
+                                                A = '0x' + (A >>> 0).toString(16).padStart(8, '0');
+                                                V('Invalid UTF-8 leading byte ' + A + ' encountered when deserializing a UTF-8 string in wasm memory to a JS string!');
+                                            }
+                                            d = (7 & d) << 18 | G << 12 | Q << 6 | 63 & e[l++];
+                                        }
+                                        65536 > d ? p += String.fromCharCode(d) : (d -= 65536, p += String.fromCharCode(55296 | d >> 10, 56320 | 1023 & d));
+                                    }
+                                } else p += String.fromCharCode(d);
+                            }
+                            e = p;
+                        }
+                        y(e);
+                        z.length = 0;
+                    } else z.push(e);
+                }
+                k += w;
+            }
+            D[h >> 2] = k;
+            return 0;
+        }
+    };
+    f.stringToUTF16 = (a, b, c)=>{
+        v(0 == b % 2, 'Pointer passed to stringToUTF16 must be aligned to two bytes!');
+        v('number' == typeof c, 'stringToUTF16(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!');
+        c ??= 2147483647;
+        if (2 > c) return 0;
+        c -= 2;
+        var h = b;
+        c = c < 2 * a.length ? c / 2 : a.length;
+        for(var k = 0; k < c; ++k)B[b >> 1] = a.charCodeAt(k), b += 2;
+        B[b >> 1] = 0;
+        return b - h;
+    };
+    "writeI53ToI64 writeI53ToI64Clamped writeI53ToI64Signaling writeI53ToU64Clamped writeI53ToU64Signaling readI53FromI64 readI53FromU64 convertI32PairToI53 convertI32PairToI53Checked convertU32PairToI53 stackSave stackRestore stackAlloc getTempRet0 setTempRet0 zeroMemory strError inetPton4 inetNtop4 inetPton6 inetNtop6 readSockaddr writeSockaddr emscriptenLog readEmAsmArgs jstoi_q getExecutableName listenOnce autoResumeAudioContext getDynCaller dynCall callUserCallback asmjsMangle asyncLoad mmapAlloc HandleAllocator getNativeTypeSize STACK_SIZE STACK_ALIGN POINTER_SIZE ASSERTIONS getCFunc ccall cwrap uleb128Encode sigToWasmTypes generateFuncType convertJsFunctionToWasm getEmptyTableSlot updateTableMap getFunctionAddress addFunction removeFunction reallyNegative unSign strLen reSign formatString setValue getValue stringToUTF8Array stringToUTF8 lengthBytesUTF8 intArrayFromString intArrayToString AsciiToString stringToAscii UTF16ToString lengthBytesUTF16 UTF32ToString stringToUTF32 lengthBytesUTF32 stringToNewUTF8 stringToUTF8OnStack writeArrayToMemory registerKeyEventCallback maybeCStringToJsString findEventTarget getBoundingClientRect fillMouseEventData registerMouseEventCallback registerWheelEventCallback registerUiEventCallback registerFocusEventCallback fillDeviceOrientationEventData registerDeviceOrientationEventCallback fillDeviceMotionEventData registerDeviceMotionEventCallback screenOrientation fillOrientationChangeEventData registerOrientationChangeEventCallback fillFullscreenChangeEventData registerFullscreenChangeEventCallback JSEvents_requestFullscreen JSEvents_resizeCanvasForFullscreen registerRestoreOldStyle hideEverythingExceptGivenElement restoreHiddenElements setLetterbox softFullscreenResizeWebGLRenderTarget doRequestFullscreen fillPointerlockChangeEventData registerPointerlockChangeEventCallback registerPointerlockErrorEventCallback requestPointerLock fillVisibilityChangeEventData registerVisibilityChangeEventCallback registerTouchEventCallback fillGamepadEventData registerGamepadEventCallback registerBeforeUnloadEventCallback fillBatteryEventData battery registerBatteryEventCallback setCanvasElementSize getCanvasElementSize jsStackTrace getCallstack convertPCtoSourceLocation getEnvStrings checkWasiClock wasiRightsToMuslOFlags wasiOFlagsToMuslOFlags initRandomFill randomFill safeSetTimeout setImmediateWrapped safeRequestAnimationFrame clearImmediateWrapped polyfillSetImmediate registerPostMainLoop registerPreMainLoop getPromise makePromise idsToPromises makePromiseCallback isLeapYear ydayFromDate arraySum addDays getSocketFromFD getSocketAddress ALLOC_NORMAL ALLOC_STACK allocate writeStringToMemory writeAsciiToMemory setErrNo demangle stackTrace".split(' ').forEach(function(a) {
+        L(a, ()=>{
+            var b = `\`${a}\` is a library symbol and not included by default; add it to your library.js __deps or to DEFAULT_LIBRARY_FUNCS_TO_INCLUDE on the command line`, c = a;
+            c.startsWith('_') || (c = '$' + a);
+            b += ` (e.g. -sDEFAULT_LIBRARY_FUNCS_TO_INCLUDE='${c}')`;
+            K(a) && (b += '. Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you');
+            N(b);
+        });
+        O(a);
+    });
+    'run addOnPreRun addOnInit addOnPreMain addOnExit addOnPostRun addRunDependency removeRunDependency out err callMain abort wasmMemory wasmExports HEAPF32 HEAPF64 HEAP_DATA_VIEW HEAP8 HEAPU8 HEAP16 HEAPU16 HEAP32 HEAPU32 HEAP64 HEAPU64 writeStackCookie checkStackCookie INT53_MAX INT53_MIN bigintToI53Checked ptrToString getHeapMax growMemory ENV ERRNO_CODES DNS Protocols Sockets timers warnOnce readEmAsmArgsArray jstoi_s alignMemory wasmTable noExitRuntime freeTableIndexes functionsInTableMap PATH PATH_FS UTF8Decoder UTF8ArrayToString UTF8ToString UTF16Decoder JSEvents specialHTMLTargets findCanvasEventTarget currentFullscreenStrategy restoreOldWindowedStyle UNWIND_CACHE promiseMap MONTH_DAYS_REGULAR MONTH_DAYS_LEAP MONTH_DAYS_REGULAR_CUMULATIVE MONTH_DAYS_LEAP_CUMULATIVE SYSCALLS allocateUTF8 allocateUTF8OnStack print printErr'.split(' ').forEach(O);
+    var T, U, W = {
+        env: S,
+        wasi_snapshot_preview1: S
+    };
+    if (!f.wasm) throw "Must load WebAssembly Module in to variable Module.wasm before adding compiled output .js script to the DOM";
+    WebAssembly.instantiate(f.wasm, W).then((a)=>{
+        a = a.instance.exports;
+        f._begin_chunk = a.begin_chunk;
+        f._begin_index_lock = a.begin_index_lock;
+        f._check_similar = a.check_similar;
+        f._malloc = a.malloc;
+        T = a.emscripten_stack_init;
+        U = a.emscripten_stack_get_end;
+        E = a.memory;
+        v(E);
+        H();
+        T();
+        var b = U();
+        v(0 == (3 & b));
+        0 == b && (b += 4);
+        D[b >> 2] = 34821223;
+        D[b + 4 >> 2] = 2310721022;
+        a.__wasm_call_ctors();
+        g(f);
+        r('ready() called, and INVOKE_RUN=0. The runtime is now ready for you to call run() to invoke application _main(). You can also override ready() in a --pre-js file to get this signal as a callback');
+    }, (a)=>{
+        console.error(a);
+    });
+    moduleRtn = m;
+    for (const a of Object.keys(f))a in moduleArg || Object.defineProperty(moduleArg, a, {
+        configurable: !0,
+        get () {
+            q(`Access to module property ('${a}') is no longer possible via the module constructor argument; Instead, use the result of the module constructor.`);
+        }
+    });
+    return moduleRtn;
+};
+const similarity_gen = Module;
+let similarity_stub_module = null;
+let ptr_buf;
+const MAX_STRING_LEN = 16005;
+async function similarity_stub_init(wasm_module) {
+    similarity_stub_module = await similarity_gen({
+        wasm: wasm_module
+    });
+    ptr_buf = similarity_stub_module._malloc(2 * MAX_STRING_LEN + 7);
+    if (ptr_buf % 2) ptr_buf++;
+}
+function begin_chunk(config) {
+    try {
+        similarity_stub_module._begin_chunk(ptr_buf, config.MAX_DIST, config.MAX_COSINE, config.TRIM_PINYIN, config.CROSS_MODE);
+    } catch (error) {
+        throw new Error(`wasm error (begin_chunk):\n${error}`);
+    }
+}
+function begin_index_lock() {
+    try {
+        similarity_stub_module._begin_index_lock();
+    } catch (error) {
+        throw new Error(`wasm error (begin_index_lock):\n${error}`);
+    }
+}
+function detect_similarity(str, mode, index_l, S) {
+    try {
+        similarity_stub_module.stringToUTF16(str, ptr_buf, 2 * MAX_STRING_LEN);
+    } catch (error) {
+        throw new Error(`wasm error (write str buf): ${str}\n${error}`);
+    }
+    let ret;
+    try {
+        ret = similarity_stub_module._check_similar(mode, index_l);
+    } catch (error) {
+        throw new Error(`wasm error (similar): ${str}\n${error}`);
+    }
+    if (0 === ret) return null;
+    ret >>>= 0;
+    const reason = ret >>> 30;
+    const dist = ret >>> 19 & 2047;
+    const idx_diff = 524287 & ret;
+    let reason_str;
+    if (0 === reason) {
+        S.combined_identical++;
+        reason_str = '==';
+    } else if (1 === reason) {
+        S.combined_edit_distance++;
+        reason_str = `\u{2264}${dist}`;
+    } else if (3 === reason) {
+        S.combined_cosine_distance++;
+        reason_str = `${dist}%`;
+    } else if (2 === reason) {
+        S.combined_pinyin_distance++;
+        reason_str = `P\u{2264}${dist}`;
+    } else throw new Error(`similarity wasm returned unknown reason: ${ret}`);
+    return {
+        reason: reason_str,
+        idx_diff
+    };
+}
+var _computedKey;
+class Stats {
+    combined_identical = 0;
+    combined_edit_distance = 0;
+    combined_pinyin_distance = 0;
+    combined_cosine_distance = 0;
+    deleted_blacklist = 0;
+    deleted_blacklist_each = {};
+    ignored_whitelist = 0;
+    ignored_type = 0;
+    num_taolu_matched = 0;
+}
+_computedKey = Symbol.iterator;
+class Queue {
+    storage;
+    index_l;
+    index_r;
+    constructor(init = []){
+        this.storage = {
+            ...init
+        };
+        this.index_l = 0;
+        this.index_r = init.length;
+    }
+    push(item) {
+        this.storage[this.index_r++] = item;
+    }
+    pop() {
+        delete this.storage[this.index_l++];
+    }
+    peek() {
+        if (this.index_l === this.index_r) return null;
+        return this.storage[this.index_l];
+    }
+    size() {
+        return this.index_r - this.index_l;
+    }
+    [_computedKey]() {
+        const self = this;
+        let index = self.index_l;
+        return {
+            next () {
+                if (index >= self.index_r) return {
+                    done: true,
+                    value: void 0
+                };
+                return {
+                    done: false,
+                    value: self.storage[index++]
+                };
+            }
+        };
+    }
+}
+/**
+ * @author: xmcp(代码主要逻辑来源)
+ * @see: https://github.com/xmcp/pakku.js
+ * @license: GPL-3.0
+ * 本文件内代码来源见上，经部分修改，并整合config注释
+ */ const DEFAULT_CONFIG = {
+    THRESHOLD: 30,
+    MAX_DIST: 5,
+    MAX_COSINE: 45,
+    TRIM_PINYIN: true,
+    TRIM_ENDING: true,
+    TRIM_SPACE: true,
+    TRIM_WIDTH: true,
+    FORCELIST: [
+        [
+            '^23{2,}$',
+            '23333'
+        ],
+        [
+            '^6{3,}$',
+            '66666'
+        ]
+    ],
+    WHITELIST: [],
+    BLACKLIST: [],
+    CROSS_MODE: true,
+    PROC_TYPE7: true,
+    PROC_TYPE4: true,
+    PROC_POOL1: false
+};
+const ENDING_CHARS = new Set(".\u3002,\uFF0C/?\uFF1F!\uFF01\u2026~\uFF5E@^\u3001+=-_\u2642\u2640 ");
+const WIDTH_TABLE = new Map(Object.entries({
+    "\u3000": ' ',
+    "\uFF11": '1',
+    "\uFF12": '2',
+    "\uFF13": '3',
+    "\uFF14": '4',
+    "\uFF15": '5',
+    "\uFF16": '6',
+    "\uFF17": '7',
+    "\uFF18": '8',
+    "\uFF19": '9',
+    "\uFF10": '0',
+    '!': "\uFF01",
+    "\uFF20": '@',
+    "\uFF03": '#',
+    "\uFF04": '$',
+    "\uFF05": '%',
+    "\uFF3E": '^',
+    "\uFF06": '&',
+    "\uFF0A": '*',
+    "\uFF08": '(',
+    "\uFF09": ')',
+    "\uFF0D": '-',
+    "\uFF1D": '=',
+    "\uFF3F": '_',
+    "\uFF0B": '+',
+    "\uFF3B": '[',
+    "\uFF3D": ']',
+    "\uFF5B": '{',
+    "\uFF5D": '}',
+    ';': "\uFF1B",
+    "\uFF07": "'",
+    ':': "\uFF1A",
+    "\uFF02": '"',
+    ',': "\uFF0C",
+    "\uFF0E": '.',
+    "\uFF0F": '/',
+    "\uFF1C": '<',
+    "\uFF1E": '>',
+    '?': "\uFF1F",
+    "\uFF3C": '\\',
+    "\uFF5C": '|',
+    "\uFF40": '`',
+    "\uFF5E": '~',
+    ｑ: 'q',
+    ｗ: 'w',
+    ｅ: 'e',
+    ｒ: 'r',
+    ｔ: 't',
+    ｙ: 'y',
+    ｕ: 'u',
+    ｉ: 'i',
+    ｏ: 'o',
+    ｐ: 'p',
+    ａ: 'a',
+    ｓ: 's',
+    ｄ: 'd',
+    ｆ: 'f',
+    ｇ: 'g',
+    ｈ: 'h',
+    ｊ: 'j',
+    ｋ: 'k',
+    ｌ: 'l',
+    ｚ: 'z',
+    ｘ: 'x',
+    ｃ: 'c',
+    ｖ: 'v',
+    ｂ: 'b',
+    ｎ: 'n',
+    ｍ: 'm',
+    Ｑ: 'Q',
+    Ｗ: 'W',
+    Ｅ: 'E',
+    Ｒ: 'R',
+    Ｔ: 'T',
+    Ｙ: 'Y',
+    Ｕ: 'U',
+    Ｉ: 'I',
+    Ｏ: 'O',
+    Ｐ: 'P',
+    Ａ: 'A',
+    Ｓ: 'S',
+    Ｄ: 'D',
+    Ｆ: 'F',
+    Ｇ: 'G',
+    Ｈ: 'H',
+    Ｊ: 'J',
+    Ｋ: 'K',
+    Ｌ: 'L',
+    Ｚ: 'Z',
+    Ｘ: 'X',
+    Ｃ: 'C',
+    Ｖ: 'V',
+    Ｂ: 'B',
+    Ｎ: 'N',
+    Ｍ: 'M'
+}));
+const detaolu = (inp, config)=>{
+    const TRIM_ENDING = config.TRIM_ENDING;
+    const TRIM_SPACE = config.TRIM_SPACE;
+    const TRIM_WIDTH = config.TRIM_WIDTH;
+    const FORCELIST = (config?.FORCELIST ?? DEFAULT_CONFIG.FORCELIST).map(([pattern, repl])=>[
+            new RegExp(pattern, 'gi'),
+            repl
+        ]);
+    let len = inp.length;
+    let text = '';
+    if (TRIM_ENDING) {
+        while(ENDING_CHARS.has(inp.charAt(len - 1)))len--;
+        if (0 === len) len = inp.length;
+    }
+    if (TRIM_WIDTH) for(let i = 0; i < len; i++){
+        const c = inp.charAt(i);
+        text += WIDTH_TABLE.get(c) || c;
+    }
+    else text = inp.slice(0, len);
+    if (TRIM_SPACE) text = text.replaceAll(/[ \u3000]+/g, ' ').replaceAll(/([\u3000-\u9FFF\uFF00-\uFFEF]) (?=[\u3000-\u9FFF\uFF00-\uFFEF])/g, '$1');
+    for (const taolu of FORCELIST)if (taolu[0].test(text)) {
+        text = text.replace(taolu[0], taolu[1]);
+        return [
+            true,
+            text
+        ];
+    }
+    return [
+        false,
+        text
+    ];
+};
+const whitelisted = (text, config)=>{
+    const WHITELIST = (config?.WHITELIST ?? DEFAULT_CONFIG.WHITELIST).map((x)=>new RegExp(x[0], 'i'));
+    if (0 === WHITELIST.length) return false;
+    return WHITELIST.some((re)=>re.test(text));
+};
+const blacklisted = (text, config)=>{
+    const BLACKLIST = (config?.BLACKLIST ?? DEFAULT_CONFIG.BLACKLIST).map((x)=>x[0] ? new RegExp(x[1]) : x[1].toLowerCase());
+    if (0 === BLACKLIST.length) return null;
+    {
+        const lower = text.toLowerCase();
+        for (const pattern of BLACKLIST){
+            const matched = 'string' == typeof pattern ? lower.includes(pattern) : pattern.test(text);
+            if (matched) return 'string' == typeof pattern ? ` ${pattern}` : ` /${pattern.source}/`;
+        }
+        return null;
+    }
+};
+function extract_special_danmu(text) {
+    try {
+        text = JSON.parse(text)[4];
+    } catch  {}
+    return text;
+}
+function trim_dispstr(text) {
+    return text.replaceAll(/([\r\n\t])/g, '').trim();
+}
+function select_median_length(strs) {
+    if (1 === strs.length) return strs[0];
+    const sorted = strs.sort((a, b)=>a.length - b.length);
+    const mid = Math.floor(sorted.length / 2);
+    return sorted[mid];
+}
+async function load_wasm(wasm_mod) {
+    await similarity_stub_init(wasm_mod ?? await fs_extra.readFile(new URL('./similarity-gen.wasm', import.meta.url)));
+}
+async function merge(chunk, config = DEFAULT_CONFIG) {
+    await load_wasm();
+    begin_chunk(config);
+    const ret = {
+        clusters: [],
+        stats: new Stats()
+    };
+    function apply_single_cluster(idx, obj, desc) {
+        ret.clusters.push({
+            peers_ptr: [
+                [
+                    idx,
+                    'IGN'
+                ]
+            ],
+            desc: [
+                desc
+            ],
+            chosen_str: obj.content,
+            danuni_count: 1,
+            danuni_dans: [
+                obj
+            ]
+        });
+    }
+    function apply_cluster(irs) {
+        if (1 === irs.length) ret.clusters.push({
+            peers_ptr: irs.map((ir)=>[
+                    ir.idx,
+                    ir.sim_reason
+                ]),
+            desc: [],
+            chosen_str: irs[0].obj.content,
+            danuni_count: irs.length,
+            danuni_dans: irs.map((ir)=>ir.obj)
+        });
+        else {
+            const text_cnts = new Map();
+            let most_texts = [], most_cnt = 0;
+            for (const ir of irs){
+                const text = ir.str;
+                const cnt = 1 + (text_cnts.get(text) || 0);
+                text_cnts.set(text, cnt);
+                if (cnt > most_cnt) {
+                    most_texts = [
+                        text
+                    ];
+                    most_cnt = cnt;
+                } else if (cnt === most_cnt) most_texts.push(text);
+            }
+            const most_text = select_median_length(most_texts);
+            ret.clusters.push({
+                peers_ptr: irs.map((ir)=>[
+                        ir.idx,
+                        ir.sim_reason
+                    ]),
+                desc: most_cnt > 1 ? [
+                    `\u{91C7}\u{7528}\u{4E86}\u{51FA}\u{73B0} ${most_cnt} \u{6B21}\u{7684}\u{6587}\u{672C}`
+                ] : [],
+                chosen_str: most_text,
+                danuni_count: most_cnt,
+                danuni_dans: irs.map((ir)=>ir.obj)
+            });
+        }
+    }
+    function obj_to_ir(objs, s) {
+        return objs.map((obj, idx)=>{
+            if (!config.PROC_POOL1 && 1 === obj.pool) {
+                if (s) {
+                    s.ignored_type++;
+                    apply_single_cluster(idx, obj, "\u5DF2\u5FFD\u7565\u5B57\u5E55\u5F39\u5E55\uFF0C\u53EF\u4EE5\u5728\u9009\u9879\u4E2D\u4FEE\u6539");
+                }
+                return null;
+            }
+            if (!config.PROC_TYPE7 && 4 === obj.mode) {
+                if (s) {
+                    s.ignored_type++;
+                    apply_single_cluster(idx, obj, "\u5DF2\u5FFD\u7565\u7279\u6B8A\u5F39\u5E55\uFF0C\u53EF\u4EE5\u5728\u9009\u9879\u4E2D\u4FEE\u6539");
+                }
+                return null;
+            }
+            if (!config.PROC_TYPE4 && 1 === obj.mode) {
+                if (s) {
+                    s.ignored_type++;
+                    apply_single_cluster(idx, obj, "\u5DF2\u5FFD\u7565\u5E95\u90E8\u5F39\u5E55\uFF0C\u53EF\u4EE5\u5728\u9009\u9879\u4E2D\u4FEE\u6539");
+                }
+                return null;
+            }
+            const disp_str = trim_dispstr(4 === obj.mode && '[' === obj.content[0] ? extract_special_danmu(obj.content) : obj.content);
+            if (4 !== obj.mode) {
+                const matched = blacklisted(disp_str, config);
+                if (matched) {
+                    if (s) {
+                        s.deleted_blacklist++;
+                        s.deleted_blacklist_each[matched] = (s.deleted_blacklist_each[matched] || 0) + 1;
+                    }
+                    return null;
+                }
+            }
+            if (whitelisted(disp_str, config)) {
+                if (s) {
+                    s.ignored_whitelist++;
+                    apply_single_cluster(idx, obj, "\u547D\u4E2D\u767D\u540D\u5355");
+                }
+                return null;
+            }
+            const [matched_taolu, detaolued] = detaolu(disp_str, config);
+            if (matched_taolu && s) s.num_taolu_matched++;
+            return {
+                obj,
+                str: detaolued,
+                idx,
+                sim_reason: 'ORIG'
+            };
+        }).filter((obj)=>null !== obj);
+    }
+    const danmus = obj_to_ir(chunk.objs, ret.stats);
+    const nearby_danmus = new Queue();
+    const THRESHOLD_MS = (config?.THRESHOLD ?? DEFAULT_CONFIG.THRESHOLD) * 1000;
+    for (const dm of danmus){
+        while(true){
+            const peeked = nearby_danmus.peek();
+            if (null === peeked || dm.obj.time_ms - peeked[0].obj.time_ms <= THRESHOLD_MS) break;
+            apply_cluster(peeked);
+            nearby_danmus.pop();
+        }
+        const sim = detect_similarity(dm.str, dm.obj.mode, nearby_danmus.index_l, ret.stats);
+        if (null !== sim) {
+            const candidate = nearby_danmus.storage[nearby_danmus.index_r - sim.idx_diff];
+            dm.sim_reason = sim.reason;
+            candidate.push(dm);
+        } else nearby_danmus.push([
+            dm
+        ]);
+    }
+    begin_index_lock();
+    for (const candidate of nearby_danmus)apply_cluster(candidate);
+    return ret;
+}
+const pakku_js = merge;
+async function src_detaolu(that, config) {
+    const p = await pakku_js({
+        objs: that.dans.map((d)=>({
+                time_ms: 1000 * d.progress,
+                mode: d.mode,
+                content: d.content,
+                pool: d.pool,
+                danuni_dan: d
+            }))
+    }, config);
+    const selected = p.clusters.map((p)=>{
+        if (1 === p.danuni_dans.length) return p.danuni_dans[0].danuni_dan;
+        {
+            const dans = p.danuni_dans, pool = new UniPool(dans.map((d)=>d.danuni_dan));
+            function isAllBottomMode(p) {
+                return p.dans.every((d)=>d.mode === UniDMTools.Modes.Bottom);
+            }
+            const progess = pool.dans.map((d)=>d.progress);
+            return UniDM.create({
+                SOID: pool.shared.SOID ?? pool.dans[0].SOID,
+                progress: dans[0].danuni_dan.progress,
+                mode: pool.shared.mode ?? (isAllBottomMode(pool) ? UniDMTools.Modes.Bottom : UniDMTools.Modes.Top),
+                fontsize: dans.length > 0 ? 36 : 25,
+                color: pool.shared.color ?? pool.most.color,
+                senderID: 'detaolu[bot]@dan-any',
+                content: p.chosen_str,
+                weight: 10,
+                pool: pool.shared.pool ?? pool.most.pool,
+                attr: [
+                    'Protect'
+                ],
+                platform: pool.shared.platform ?? pool.most.platform,
+                extra: {
+                    danuni: {
+                        merge: {
+                            count: p.danuni_count,
+                            duration: Math.max(...progess) - Math.min(...progess),
+                            senders: pool.dans.filter((d)=>d.content === p.chosen_str).map((d)=>d.senderID),
+                            taolu_count: pool.dans.length,
+                            taolu_senders: pool.dans.map((d)=>d.senderID)
+                        }
+                    }
+                }
+            });
+        }
+    });
+    return new UniPool(selected);
+}
+function detaolu_constructor(config) {
+    return (that)=>src_detaolu(that, config);
+}
+const src = detaolu_constructor;
+export { src as default };