lakutata 2.0.95 → 2.0.96

package/vendor/Package.internal.162.cjs

@@ -1,90 +1,605 @@
-/* Build Date: Mon Nov 24 2025 17:58:53 GMT+0800 (China Standard Time) */
+/* Build Date: Mon Nov 24 2025 18:02:01 GMT+0800 (China Standard Time) */
 "use strict";
 
-const r = require("./Package.internal.81.cjs");
+var n = {
+    exports: {}
+};
 
-const e = require("./Package.internal.80.cjs");
+n.exports;
 
-var t = r.onceExports;
+(function(n, t) {
+    const {hasOwnProperty: e} = Object.prototype;
+    const r = y();
+    r.configure = y;
+    r.stringify = r;
+    r.default = r;
+    t.stringify = r;
+    t.configure = y;
+    n.exports = r;
+    const i = /[\u0000-\u001f\u0022\u005c\ud800-\udfff]/;
+    function u(n) {
+        if (n.length < 5e3 && !i.test(n)) {
+            return `"${n}"`;
+        }
+        return JSON.stringify(n);
+    }
+    function f(n, t) {
+        if (n.length > 200 || t) {
+            return n.sort(t);
+        }
+        for (let t = 1; t < n.length; t++) {
+            const e = n[t];
+            let r = t;
+            while (r !== 0 && n[r - 1] > e) {
+                n[r] = n[r - 1];
+                r--;
+            }
+            n[r] = e;
+        }
+        return n;
+    }
+    const o = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Object.getPrototypeOf(new Int8Array)), Symbol.toStringTag).get;
+    function l(n) {
+        return o.call(n) !== undefined && n.length !== 0;
+    }
+    function c(n, t, e) {
+        if (n.length < e) {
+            e = n.length;
+        }
+        const r = t === "," ? "" : " ";
+        let i = `"0":${r}${n[0]}`;
+        for (let u = 1; u < e; u++) {
+            i += `${t}"${u}":${r}${n[u]}`;
+        }
+        return i;
+    }
+    function s(n) {
+        if (e.call(n, "circularValue")) {
+            const t = n.circularValue;
+            if (typeof t === "string") {
+                return `"${t}"`;
+            }
+            if (t == null) {
+                return t;
+            }
+            if (t === Error || t === TypeError) {
+                return {
+                    toString() {
+                        throw new TypeError("Converting circular structure to JSON");
+                    }
+                };
+            }
+            throw new TypeError('The "circularValue" argument must be of type string or the value null or undefined');
+        }
+        return '"[Circular]"';
+    }
+    function a(n) {
+        let t;
+        if (e.call(n, "deterministic")) {
+            t = n.deterministic;
+            if (typeof t !== "boolean" && typeof t !== "function") {
+                throw new TypeError('The "deterministic" argument must be of type boolean or comparator function');
+            }
+        }
+        return t === undefined ? true : t;
+    }
+    function g(n, t) {
+        let r;
+        if (e.call(n, t)) {
+            r = n[t];
+            if (typeof r !== "boolean") {
+                throw new TypeError(`The "${t}" argument must be of type boolean`);
+            }
+        }
+        return r === undefined ? true : r;
+    }
+    function d(n, t) {
+        let r;
+        if (e.call(n, t)) {
+            r = n[t];
+            if (typeof r !== "number") {
+                throw new TypeError(`The "${t}" argument must be of type number`);
+            }
+            if (!Number.isInteger(r)) {
+                throw new TypeError(`The "${t}" argument must be an integer`);
+            }
+            if (r < 1) {
+                throw new RangeError(`The "${t}" argument must be >= 1`);
+            }
+        }
+        return r === undefined ? Infinity : r;
+    }
+    function h(n) {
+        if (n === 1) {
+            return "1 item";
+        }
+        return `${n} items`;
+    }
+    function p(n) {
+        const t = new Set;
+        for (const e of n) {
+            if (typeof e === "string" || typeof e === "number") {
+                t.add(String(e));
+            }
+        }
+        return t;
+    }
+    function $(n) {
+        if (e.call(n, "strict")) {
+            const t = n.strict;
+            if (typeof t !== "boolean") {
+                throw new TypeError('The "strict" argument must be of type boolean');
+            }
+            if (t) {
+                return n => {
+                    let t = `Object can not safely be stringified. Received type ${typeof n}`;
+                    if (typeof n !== "function") t += ` (${n.toString()})`;
+                    throw new Error(t);
+                };
+            }
+        }
+    }
+    function y(n) {
+        n = {
+            ...n
+        };
+        const t = $(n);
+        if (t) {
+            if (n.bigint === undefined) {
+                n.bigint = false;
+            }
+            if (!("circularValue" in n)) {
+                n.circularValue = Error;
+            }
+        }
+        const e = s(n);
+        const r = g(n, "bigint");
+        const i = a(n);
+        const o = typeof i === "function" ? i : undefined;
+        const y = d(n, "maximumDepth");
+        const b = d(n, "maximumBreadth");
+        function m(n, c, s, a, g, d) {
+            let p = c[n];
+            if (typeof p === "object" && p !== null && typeof p.toJSON === "function") {
+                p = p.toJSON(n);
+            }
+            p = a.call(c, n, p);
+            switch (typeof p) {
+              case "string":
+                return u(p);
 
-var n = e.endOfStream;
+              case "object":
+                {
+                    if (p === null) {
+                        return "null";
+                    }
+                    if (s.indexOf(p) !== -1) {
+                        return e;
+                    }
+                    let n = "";
+                    let t = ",";
+                    const r = d;
+                    if (Array.isArray(p)) {
+                        if (p.length === 0) {
+                            return "[]";
+                        }
+                        if (y < s.length + 1) {
+                            return '"[Array]"';
+                        }
+                        s.push(p);
+                        if (g !== "") {
+                            d += g;
+                            n += `\n${d}`;
+                            t = `,\n${d}`;
+                        }
+                        const e = Math.min(p.length, b);
+                        let i = 0;
+                        for (;i < e - 1; i++) {
+                            const e = m(String(i), p, s, a, g, d);
+                            n += e !== undefined ? e : "null";
+                            n += t;
+                        }
+                        const u = m(String(i), p, s, a, g, d);
+                        n += u !== undefined ? u : "null";
+                        if (p.length - 1 > b) {
+                            const e = p.length - b - 1;
+                            n += `${t}"... ${h(e)} not stringified"`;
+                        }
+                        if (g !== "") {
+                            n += `\n${r}`;
+                        }
+                        s.pop();
+                        return `[${n}]`;
+                    }
+                    let c = Object.keys(p);
+                    const $ = c.length;
+                    if ($ === 0) {
+                        return "{}";
+                    }
+                    if (y < s.length + 1) {
+                        return '"[Object]"';
+                    }
+                    let S = "";
+                    let O = "";
+                    if (g !== "") {
+                        d += g;
+                        t = `,\n${d}`;
+                        S = " ";
+                    }
+                    const w = Math.min($, b);
+                    if (i && !l(p)) {
+                        c = f(c, o);
+                    }
+                    s.push(p);
+                    for (let e = 0; e < w; e++) {
+                        const r = c[e];
+                        const i = m(r, p, s, a, g, d);
+                        if (i !== undefined) {
+                            n += `${O}${u(r)}:${S}${i}`;
+                            O = t;
+                        }
+                    }
+                    if ($ > b) {
+                        const e = $ - b;
+                        n += `${O}"...":${S}"${h(e)} not stringified"`;
+                        O = t;
+                    }
+                    if (g !== "" && O.length > 1) {
+                        n = `\n${d}${n}\n${r}`;
+                    }
+                    s.pop();
+                    return `{${n}}`;
+                }
 
-var a;
+              case "number":
+                return isFinite(p) ? String(p) : t ? t(p) : "null";
 
-try {
-    a = require("fs");
-} catch (r) {}
+              case "boolean":
+                return p === true ? "true" : "false";
 
-var i = function() {};
+              case "undefined":
+                return undefined;
 
-var o = typeof process === "undefined" ? false : /^v?\.0/.test(process.version);
+              case "bigint":
+                if (r) {
+                    return String(p);
+                }
 
-var u = function(r) {
-    return typeof r === "function";
-};
+              default:
+                return t ? t(p) : undefined;
+            }
+        }
+        function S(n, i, f, o, l, c) {
+            if (typeof i === "object" && i !== null && typeof i.toJSON === "function") {
+                i = i.toJSON(n);
+            }
+            switch (typeof i) {
+              case "string":
+                return u(i);
 
-var f = function(r) {
-    if (!o) return false;
-    if (!a) return false;
-    return (r instanceof (a.ReadStream || i) || r instanceof (a.WriteStream || i)) && u(r.close);
-};
+              case "object":
+                {
+                    if (i === null) {
+                        return "null";
+                    }
+                    if (f.indexOf(i) !== -1) {
+                        return e;
+                    }
+                    const n = c;
+                    let t = "";
+                    let r = ",";
+                    if (Array.isArray(i)) {
+                        if (i.length === 0) {
+                            return "[]";
+                        }
+                        if (y < f.length + 1) {
+                            return '"[Array]"';
+                        }
+                        f.push(i);
+                        if (l !== "") {
+                            c += l;
+                            t += `\n${c}`;
+                            r = `,\n${c}`;
+                        }
+                        const e = Math.min(i.length, b);
+                        let u = 0;
+                        for (;u < e - 1; u++) {
+                            const n = S(String(u), i[u], f, o, l, c);
+                            t += n !== undefined ? n : "null";
+                            t += r;
+                        }
+                        const s = S(String(u), i[u], f, o, l, c);
+                        t += s !== undefined ? s : "null";
+                        if (i.length - 1 > b) {
+                            const n = i.length - b - 1;
+                            t += `${r}"... ${h(n)} not stringified"`;
+                        }
+                        if (l !== "") {
+                            t += `\n${n}`;
+                        }
+                        f.pop();
+                        return `[${t}]`;
+                    }
+                    f.push(i);
+                    let s = "";
+                    if (l !== "") {
+                        c += l;
+                        r = `,\n${c}`;
+                        s = " ";
+                    }
+                    let a = "";
+                    for (const n of o) {
+                        const e = S(n, i[n], f, o, l, c);
+                        if (e !== undefined) {
+                            t += `${a}${u(n)}:${s}${e}`;
+                            a = r;
+                        }
+                    }
+                    if (l !== "" && a.length > 1) {
+                        t = `\n${c}${t}\n${n}`;
+                    }
+                    f.pop();
+                    return `{${t}}`;
+                }
 
-var c = function(r) {
-    return r.setHeader && u(r.abort);
-};
+              case "number":
+                return isFinite(i) ? String(i) : t ? t(i) : "null";
 
-var s = function(r, e, a, o) {
-    o = t(o);
-    var s = false;
-    r.on("close", function() {
-        s = true;
-    });
-    n(r, {
-        readable: e,
-        writable: a
-    }, function(r) {
-        if (r) return o(r);
-        s = true;
-        o();
-    });
-    var v = false;
-    return function(e) {
-        if (s) return;
-        if (v) return;
-        v = true;
-        if (f(r)) return r.close(i);
-        if (c(r)) return r.abort();
-        if (u(r.destroy)) return r.destroy();
-        o(e || new Error("stream was destroyed"));
-    };
-};
+              case "boolean":
+                return i === true ? "true" : "false";
 
-var v = function(r) {
-    r();
-};
+              case "undefined":
+                return undefined;
 
-var l = function(r, e) {
-    return r.pipe(e);
-};
+              case "bigint":
+                if (r) {
+                    return String(i);
+                }
 
-var p = function() {
-    var r = Array.prototype.slice.call(arguments);
-    var e = u(r[r.length - 1] || i) && r.pop() || i;
-    if (Array.isArray(r[0])) r = r[0];
-    if (r.length < 2) throw new Error("pump requires two streams per minimum");
-    var t;
-    var n = r.map(function(a, i) {
-        var o = i < r.length - 1;
-        var u = i > 0;
-        return s(a, o, u, function(r) {
-            if (!t) t = r;
-            if (r) n.forEach(v);
-            if (o) return;
-            n.forEach(v);
-            e(t);
-        });
-    });
-    return r.reduce(l);
-};
+              default:
+                return t ? t(i) : undefined;
+            }
+        }
+        function O(n, s, a, g, d) {
+            switch (typeof s) {
+              case "string":
+                return u(s);
+
+              case "object":
+                {
+                    if (s === null) {
+                        return "null";
+                    }
+                    if (typeof s.toJSON === "function") {
+                        s = s.toJSON(n);
+                        if (typeof s !== "object") {
+                            return O(n, s, a, g, d);
+                        }
+                        if (s === null) {
+                            return "null";
+                        }
+                    }
+                    if (a.indexOf(s) !== -1) {
+                        return e;
+                    }
+                    const t = d;
+                    if (Array.isArray(s)) {
+                        if (s.length === 0) {
+                            return "[]";
+                        }
+                        if (y < a.length + 1) {
+                            return '"[Array]"';
+                        }
+                        a.push(s);
+                        d += g;
+                        let n = `\n${d}`;
+                        const e = `,\n${d}`;
+                        const r = Math.min(s.length, b);
+                        let i = 0;
+                        for (;i < r - 1; i++) {
+                            const t = O(String(i), s[i], a, g, d);
+                            n += t !== undefined ? t : "null";
+                            n += e;
+                        }
+                        const u = O(String(i), s[i], a, g, d);
+                        n += u !== undefined ? u : "null";
+                        if (s.length - 1 > b) {
+                            const t = s.length - b - 1;
+                            n += `${e}"... ${h(t)} not stringified"`;
+                        }
+                        n += `\n${t}`;
+                        a.pop();
+                        return `[${n}]`;
+                    }
+                    let r = Object.keys(s);
+                    const p = r.length;
+                    if (p === 0) {
+                        return "{}";
+                    }
+                    if (y < a.length + 1) {
+                        return '"[Object]"';
+                    }
+                    d += g;
+                    const $ = `,\n${d}`;
+                    let m = "";
+                    let S = "";
+                    let w = Math.min(p, b);
+                    if (l(s)) {
+                        m += c(s, $, b);
+                        r = r.slice(s.length);
+                        w -= s.length;
+                        S = $;
+                    }
+                    if (i) {
+                        r = f(r, o);
+                    }
+                    a.push(s);
+                    for (let n = 0; n < w; n++) {
+                        const t = r[n];
+                        const e = O(t, s[t], a, g, d);
+                        if (e !== undefined) {
+                            m += `${S}${u(t)}: ${e}`;
+                            S = $;
+                        }
+                    }
+                    if (p > b) {
+                        const n = p - b;
+                        m += `${S}"...": "${h(n)} not stringified"`;
+                        S = $;
+                    }
+                    if (S !== "") {
+                        m = `\n${d}${m}\n${t}`;
+                    }
+                    a.pop();
+                    return `{${m}}`;
+                }
+
+              case "number":
+                return isFinite(s) ? String(s) : t ? t(s) : "null";
+
+              case "boolean":
+                return s === true ? "true" : "false";
+
+              case "undefined":
+                return undefined;
+
+              case "bigint":
+                if (r) {
+                    return String(s);
+                }
+
+              default:
+                return t ? t(s) : undefined;
+            }
+        }
+        function w(n, s, a) {
+            switch (typeof s) {
+              case "string":
+                return u(s);
+
+              case "object":
+                {
+                    if (s === null) {
+                        return "null";
+                    }
+                    if (typeof s.toJSON === "function") {
+                        s = s.toJSON(n);
+                        if (typeof s !== "object") {
+                            return w(n, s, a);
+                        }
+                        if (s === null) {
+                            return "null";
+                        }
+                    }
+                    if (a.indexOf(s) !== -1) {
+                        return e;
+                    }
+                    let t = "";
+                    const r = s.length !== undefined;
+                    if (r && Array.isArray(s)) {
+                        if (s.length === 0) {
+                            return "[]";
+                        }
+                        if (y < a.length + 1) {
+                            return '"[Array]"';
+                        }
+                        a.push(s);
+                        const n = Math.min(s.length, b);
+                        let e = 0;
+                        for (;e < n - 1; e++) {
+                            const n = w(String(e), s[e], a);
+                            t += n !== undefined ? n : "null";
+                            t += ",";
+                        }
+                        const r = w(String(e), s[e], a);
+                        t += r !== undefined ? r : "null";
+                        if (s.length - 1 > b) {
+                            const n = s.length - b - 1;
+                            t += `,"... ${h(n)} not stringified"`;
+                        }
+                        a.pop();
+                        return `[${t}]`;
+                    }
+                    let g = Object.keys(s);
+                    const d = g.length;
+                    if (d === 0) {
+                        return "{}";
+                    }
+                    if (y < a.length + 1) {
+                        return '"[Object]"';
+                    }
+                    let p = "";
+                    let $ = Math.min(d, b);
+                    if (r && l(s)) {
+                        t += c(s, ",", b);
+                        g = g.slice(s.length);
+                        $ -= s.length;
+                        p = ",";
+                    }
+                    if (i) {
+                        g = f(g, o);
+                    }
+                    a.push(s);
+                    for (let n = 0; n < $; n++) {
+                        const e = g[n];
+                        const r = w(e, s[e], a);
+                        if (r !== undefined) {
+                            t += `${p}${u(e)}:${r}`;
+                            p = ",";
+                        }
+                    }
+                    if (d > b) {
+                        const n = d - b;
+                        t += `${p}"...":"${h(n)} not stringified"`;
+                    }
+                    a.pop();
+                    return `{${t}}`;
+                }
+
+              case "number":
+                return isFinite(s) ? String(s) : t ? t(s) : "null";
+
+              case "boolean":
+                return s === true ? "true" : "false";
+
+              case "undefined":
+                return undefined;
+
+              case "bigint":
+                if (r) {
+                    return String(s);
+                }
+
+              default:
+                return t ? t(s) : undefined;
+            }
+        }
+        function j(n, t, e) {
+            if (arguments.length > 1) {
+                let r = "";
+                if (typeof e === "number") {
+                    r = " ".repeat(Math.min(e, 10));
+                } else if (typeof e === "string") {
+                    r = e.slice(0, 10);
+                }
+                if (t != null) {
+                    if (typeof t === "function") {
+                        return m("", {
+                            "": n
+                        }, [], t, r, "");
+                    }
+                    if (Array.isArray(t)) {
+                        return S("", n, [], p(t), r, "");
+                    }
+                }
+                if (r.length !== 0) {
+                    return O("", n, [], r, "");
+                }
+            }
+            return w("", n, []);
+        }
+        return j;
+    }
+})(n, n.exports);
 
-exports.pump_1 = p;
+exports.safeStableStringifyExports = n.exports;