lakutata 2.0.95 → 2.0.97

package/vendor/Package.internal.157.cjs

@@ -1,543 +0,0 @@
-/* Build Date: Mon Nov 24 2025 17:58:53 GMT+0800 (China Standard Time) */
-"use strict";
-
-const e = require("./Package.internal.8.cjs");
-
-const t = require("events");
-
-const r = require("worker_threads");
-
-const s = require("path");
-
-const i = require("url");
-
-const n = require("buffer");
-
-const o = require("assert");
-
-const a = e => e && e.__esModule ? e : {
-    default: e
-};
-
-const f = a(t);
-
-const u = a(r);
-
-const l = a(s);
-
-const c = a(i);
-
-const h = a(n);
-
-const d = a(o);
-
-var m = "3.1.0";
-
-const w = {
-    version: m
-};
-
-var g;
-
-var b;
-
-function k() {
-    if (b) return g;
-    b = 1;
-    const e = 1e3;
-    function t(t, r, s, i, n) {
-        const o = Date.now() + i;
-        let a = Atomics.load(t, r);
-        if (a === s) {
-            n(null, "ok");
-            return;
-        }
-        let f = a;
-        const u = i => {
-            if (Date.now() > o) {
-                n(null, "timed-out");
-            } else {
-                setTimeout(() => {
-                    f = a;
-                    a = Atomics.load(t, r);
-                    if (a === f) {
-                        u(i >= e ? e : i * 2);
-                    } else {
-                        if (a === s) n(null, "ok"); else n(null, "not-equal");
-                    }
-                }, i);
-            }
-        };
-        u(1);
-    }
-    function r(t, r, s, i, n) {
-        const o = Date.now() + i;
-        let a = Atomics.load(t, r);
-        if (a !== s) {
-            n(null, "ok");
-            return;
-        }
-        const f = i => {
-            if (Date.now() > o) {
-                n(null, "timed-out");
-            } else {
-                setTimeout(() => {
-                    a = Atomics.load(t, r);
-                    if (a !== s) {
-                        n(null, "ok");
-                    } else {
-                        f(i >= e ? e : i * 2);
-                    }
-                }, i);
-            }
-        };
-        f(1);
-    }
-    g = {
-        wait: t,
-        waitDiff: r
-    };
-    return g;
-}
-
-var y;
-
-var A;
-
-function E() {
-    if (A) return y;
-    A = 1;
-    const e = 4;
-    const t = 8;
-    y = {
-        WRITE_INDEX: e,
-        READ_INDEX: t
-    };
-    return y;
-}
-
-var D;
-
-var _;
-
-function R() {
-    if (_) return D;
-    _ = 1;
-    const {version: t} = w;
-    const {EventEmitter: r} = f.default;
-    const {Worker: s} = u.default;
-    const {join: i} = l.default;
-    const {pathToFileURL: n} = c.default;
-    const {wait: o} = k();
-    const {WRITE_INDEX: a, READ_INDEX: m} = E();
-    const g = h.default;
-    const b = d.default;
-    const y = Symbol("kImpl");
-    const A = g.constants.MAX_STRING_LENGTH;
-    class FakeWeakRef {
-        constructor(e) {
-            this._value = e;
-        }
-        deref() {
-            return this._value;
-        }
-    }
-    class FakeFinalizationRegistry {
-        register() {}
-        unregister() {}
-    }
-    const R = process.env.NODE_V8_COVERAGE ? FakeFinalizationRegistry : e.commonjsGlobal.FinalizationRegistry || FakeFinalizationRegistry;
-    const p = process.env.NODE_V8_COVERAGE ? FakeWeakRef : e.commonjsGlobal.WeakRef || FakeWeakRef;
-    const v = new R(e => {
-        if (e.exited) {
-            return;
-        }
-        e.terminate();
-    });
-    function x(e, r) {
-        const {filename: o, workerData: a} = r;
-        const f = "__bundlerPathsOverrides" in globalThis ? globalThis.__bundlerPathsOverrides : {};
-        const u = f["thread-stream-worker"] || i(__dirname, "lib", "worker.js");
-        const l = new s(u, {
-            ...r.workerOpts,
-            trackUnmanagedFds: false,
-            workerData: {
-                filename: o.indexOf("file://") === 0 ? o : n(o).href,
-                dataBuf: e[y].dataBuf,
-                stateBuf: e[y].stateBuf,
-                workerData: {
-                    $context: {
-                        threadStreamVersion: t
-                    },
-                    ...a
-                }
-            }
-        });
-        l.stream = new FakeWeakRef(e);
-        l.on("message", S);
-        l.on("exit", F);
-        v.register(e, l);
-        return l;
-    }
-    function T(e) {
-        b(!e[y].sync);
-        if (e[y].needDrain) {
-            e[y].needDrain = false;
-            e.emit("drain");
-        }
-    }
-    function B(e) {
-        const t = Atomics.load(e[y].state, a);
-        let r = e[y].data.length - t;
-        if (r > 0) {
-            if (e[y].buf.length === 0) {
-                e[y].flushing = false;
-                if (e[y].ending) {
-                    O(e);
-                } else if (e[y].needDrain) {
-                    process.nextTick(T, e);
-                }
-                return;
-            }
-            let t = e[y].buf.slice(0, r);
-            let s = Buffer.byteLength(t);
-            if (s <= r) {
-                e[y].buf = e[y].buf.slice(r);
-                q(e, t, B.bind(null, e));
-            } else {
-                e.flush(() => {
-                    if (e.destroyed) {
-                        return;
-                    }
-                    Atomics.store(e[y].state, m, 0);
-                    Atomics.store(e[y].state, a, 0);
-                    while (s > e[y].data.length) {
-                        r = r / 2;
-                        t = e[y].buf.slice(0, r);
-                        s = Buffer.byteLength(t);
-                    }
-                    e[y].buf = e[y].buf.slice(r);
-                    q(e, t, B.bind(null, e));
-                });
-            }
-        } else if (r === 0) {
-            if (t === 0 && e[y].buf.length === 0) {
-                return;
-            }
-            e.flush(() => {
-                Atomics.store(e[y].state, m, 0);
-                Atomics.store(e[y].state, a, 0);
-                B(e);
-            });
-        } else {
-            N(e, new Error("overwritten"));
-        }
-    }
-    function S(e) {
-        const t = this.stream.deref();
-        if (t === undefined) {
-            this.exited = true;
-            this.terminate();
-            return;
-        }
-        switch (e.code) {
-          case "READY":
-            this.stream = new p(t);
-            t.flush(() => {
-                t[y].ready = true;
-                t.emit("ready");
-            });
-            break;
-
-          case "ERROR":
-            N(t, e.err);
-            break;
-
-          case "EVENT":
-            if (Array.isArray(e.args)) {
-                t.emit(e.name, ...e.args);
-            } else {
-                t.emit(e.name, e.args);
-            }
-            break;
-
-          case "WARNING":
-            process.emitWarning(e.err);
-            break;
-
-          default:
-            N(t, new Error("this should not happen: " + e.code));
-        }
-    }
-    function F(e) {
-        const t = this.stream.deref();
-        if (t === undefined) {
-            return;
-        }
-        v.unregister(t);
-        t.worker.exited = true;
-        t.worker.off("exit", F);
-        N(t, e !== 0 ? new Error("the worker thread exited") : null);
-    }
-    class ThreadStream extends r {
-        constructor(e = {}) {
-            super();
-            if (e.bufferSize < 4) {
-                throw new Error("bufferSize must at least fit a 4-byte utf-8 char");
-            }
-            this[y] = {};
-            this[y].stateBuf = new SharedArrayBuffer(128);
-            this[y].state = new Int32Array(this[y].stateBuf);
-            this[y].dataBuf = new SharedArrayBuffer(e.bufferSize || 4 * 1024 * 1024);
-            this[y].data = Buffer.from(this[y].dataBuf);
-            this[y].sync = e.sync || false;
-            this[y].ending = false;
-            this[y].ended = false;
-            this[y].needDrain = false;
-            this[y].destroyed = false;
-            this[y].flushing = false;
-            this[y].ready = false;
-            this[y].finished = false;
-            this[y].errored = null;
-            this[y].closed = false;
-            this[y].buf = "";
-            this.worker = x(this, e);
-            this.on("message", (e, t) => {
-                this.worker.postMessage(e, t);
-            });
-        }
-        write(e) {
-            if (this[y].destroyed) {
-                I(this, new Error("the worker has exited"));
-                return false;
-            }
-            if (this[y].ending) {
-                I(this, new Error("the worker is ending"));
-                return false;
-            }
-            if (this[y].flushing && this[y].buf.length + e.length >= A) {
-                try {
-                    W(this);
-                    this[y].flushing = true;
-                } catch (e) {
-                    N(this, e);
-                    return false;
-                }
-            }
-            this[y].buf += e;
-            if (this[y].sync) {
-                try {
-                    W(this);
-                    return true;
-                } catch (e) {
-                    N(this, e);
-                    return false;
-                }
-            }
-            if (!this[y].flushing) {
-                this[y].flushing = true;
-                setImmediate(B, this);
-            }
-            this[y].needDrain = this[y].data.length - this[y].buf.length - Atomics.load(this[y].state, a) <= 0;
-            return !this[y].needDrain;
-        }
-        end() {
-            if (this[y].destroyed) {
-                return;
-            }
-            this[y].ending = true;
-            O(this);
-        }
-        flush(e) {
-            if (this[y].destroyed) {
-                if (typeof e === "function") {
-                    process.nextTick(e, new Error("the worker has exited"));
-                }
-                return;
-            }
-            const t = Atomics.load(this[y].state, a);
-            o(this[y].state, m, t, Infinity, (t, r) => {
-                if (t) {
-                    N(this, t);
-                    process.nextTick(e, t);
-                    return;
-                }
-                if (r === "not-equal") {
-                    this.flush(e);
-                    return;
-                }
-                process.nextTick(e);
-            });
-        }
-        flushSync() {
-            if (this[y].destroyed) {
-                return;
-            }
-            W(this);
-            z(this);
-        }
-        unref() {
-            this.worker.unref();
-        }
-        ref() {
-            this.worker.ref();
-        }
-        get ready() {
-            return this[y].ready;
-        }
-        get destroyed() {
-            return this[y].destroyed;
-        }
-        get closed() {
-            return this[y].closed;
-        }
-        get writable() {
-            return !this[y].destroyed && !this[y].ending;
-        }
-        get writableEnded() {
-            return this[y].ending;
-        }
-        get writableFinished() {
-            return this[y].finished;
-        }
-        get writableNeedDrain() {
-            return this[y].needDrain;
-        }
-        get writableObjectMode() {
-            return false;
-        }
-        get writableErrored() {
-            return this[y].errored;
-        }
-    }
-    function I(e, t) {
-        setImmediate(() => {
-            e.emit("error", t);
-        });
-    }
-    function N(e, t) {
-        if (e[y].destroyed) {
-            return;
-        }
-        e[y].destroyed = true;
-        if (t) {
-            e[y].errored = t;
-            I(e, t);
-        }
-        if (!e.worker.exited) {
-            e.worker.terminate().catch(() => {}).then(() => {
-                e[y].closed = true;
-                e.emit("close");
-            });
-        } else {
-            setImmediate(() => {
-                e[y].closed = true;
-                e.emit("close");
-            });
-        }
-    }
-    function q(e, t, r) {
-        const s = Atomics.load(e[y].state, a);
-        const i = Buffer.byteLength(t);
-        e[y].data.write(t, s);
-        Atomics.store(e[y].state, a, s + i);
-        Atomics.notify(e[y].state, a);
-        r();
-        return true;
-    }
-    function O(e) {
-        if (e[y].ended || !e[y].ending || e[y].flushing) {
-            return;
-        }
-        e[y].ended = true;
-        try {
-            e.flushSync();
-            let t = Atomics.load(e[y].state, m);
-            Atomics.store(e[y].state, a, -1);
-            Atomics.notify(e[y].state, a);
-            let r = 0;
-            while (t !== -1) {
-                Atomics.wait(e[y].state, m, t, 1e3);
-                t = Atomics.load(e[y].state, m);
-                if (t === -2) {
-                    N(e, new Error("end() failed"));
-                    return;
-                }
-                if (++r === 10) {
-                    N(e, new Error("end() took too long (10s)"));
-                    return;
-                }
-            }
-            process.nextTick(() => {
-                e[y].finished = true;
-                e.emit("finish");
-            });
-        } catch (t) {
-            N(e, t);
-        }
-    }
-    function W(e) {
-        const t = () => {
-            if (e[y].ending) {
-                O(e);
-            } else if (e[y].needDrain) {
-                process.nextTick(T, e);
-            }
-        };
-        e[y].flushing = false;
-        while (e[y].buf.length !== 0) {
-            const r = Atomics.load(e[y].state, a);
-            let s = e[y].data.length - r;
-            if (s === 0) {
-                z(e);
-                Atomics.store(e[y].state, m, 0);
-                Atomics.store(e[y].state, a, 0);
-                continue;
-            } else if (s < 0) {
-                throw new Error("overwritten");
-            }
-            let i = e[y].buf.slice(0, s);
-            let n = Buffer.byteLength(i);
-            if (n <= s) {
-                e[y].buf = e[y].buf.slice(s);
-                q(e, i, t);
-            } else {
-                z(e);
-                Atomics.store(e[y].state, m, 0);
-                Atomics.store(e[y].state, a, 0);
-                while (n > e[y].buf.length) {
-                    s = s / 2;
-                    i = e[y].buf.slice(0, s);
-                    n = Buffer.byteLength(i);
-                }
-                e[y].buf = e[y].buf.slice(s);
-                q(e, i, t);
-            }
-        }
-    }
-    function z(e) {
-        if (e[y].flushing) {
-            throw new Error("unable to flush while flushing");
-        }
-        const t = Atomics.load(e[y].state, a);
-        let r = 0;
-        while (true) {
-            const s = Atomics.load(e[y].state, m);
-            if (s === -2) {
-                throw Error("_flushSync failed");
-            }
-            if (s !== t) {
-                Atomics.wait(e[y].state, m, s, 1e3);
-            } else {
-                break;
-            }
-            if (++r === 10) {
-                throw new Error("_flushSync took too long (10s)");
-            }
-        }
-    }
-    D = ThreadStream;
-    return D;
-}
-
-exports.requireThreadStream = R;