lakutata 2.0.94 → 2.0.96

package/vendor/Package.internal.19.mjs

@@ -1,228 +1,438 @@
-/* Build Date: Mon Nov 24 2025 00:55:42 GMT+0800 (China Standard Time) */
-import { c as e } from "./Package.internal.8.mjs";
-
-var t = {};
-
-var i = {};
-
-Object.defineProperty(i, "__esModule", {
-    value: true
-});
-
-(function(t) {
-    var r = e && e.__createBinding || (Object.create ? function(e, t, i, r) {
-        if (r === undefined) r = i;
-        var a = Object.getOwnPropertyDescriptor(t, i);
-        if (!a || ("get" in a ? !t.__esModule : a.writable || a.configurable)) {
-            a = {
-                enumerable: true,
-                get: function() {
-                    return t[i];
+/* Build Date: Mon Nov 24 2025 18:02:01 GMT+0800 (China Standard Time) */
+function e(t) {
+    if (t === null || typeof t !== "object") {
+        return t;
+    }
+    if (t instanceof Date) {
+        return new Date(t.getTime());
+    }
+    if (t instanceof Array) {
+        const n = [];
+        for (let o = 0; o < t.length; o++) {
+            n[o] = e(t[o]);
+        }
+        return n;
+    }
+    if (typeof t === "object") {
+        const n = Object.create(Object.getPrototypeOf(t));
+        for (const o in t) {
+            if (Object.prototype.hasOwnProperty.call(t, o)) {
+                n[o] = e(t[o]);
+            }
+        }
+        return n;
+    }
+    return t;
+}
+
+function t(e) {
+    const t = [];
+    let n = "";
+    let o = false;
+    let r = false;
+    let f = "";
+    for (let i = 0; i < e.length; i++) {
+        const l = e[i];
+        if (!o && l === ".") {
+            if (n) {
+                t.push(n);
+                n = "";
+            }
+        } else if (l === "[") {
+            if (n) {
+                t.push(n);
+                n = "";
+            }
+            o = true;
+        } else if (l === "]" && o) {
+            t.push(n);
+            n = "";
+            o = false;
+            r = false;
+        } else if ((l === '"' || l === "'") && o) {
+            if (!r) {
+                r = true;
+                f = l;
+            } else if (l === f) {
+                r = false;
+                f = "";
+            } else {
+                n += l;
+            }
+        } else {
+            n += l;
+        }
+    }
+    if (n) {
+        t.push(n);
+    }
+    return t;
+}
+
+function n(e, t, n) {
+    let o = e;
+    for (let e = 0; e < t.length - 1; e++) {
+        const n = t[e];
+        if (typeof o !== "object" || o === null || !(n in o)) {
+            return false;
+        }
+        if (typeof o[n] !== "object" || o[n] === null) {
+            return false;
+        }
+        o = o[n];
+    }
+    const r = t[t.length - 1];
+    if (r === "*") {
+        if (Array.isArray(o)) {
+            for (let e = 0; e < o.length; e++) {
+                o[e] = n;
+            }
+        } else if (typeof o === "object" && o !== null) {
+            for (const e in o) {
+                if (Object.prototype.hasOwnProperty.call(o, e)) {
+                    o[e] = n;
                 }
-            };
+            }
         }
-        Object.defineProperty(e, r, a);
-    } : function(e, t, i, r) {
-        if (r === undefined) r = i;
-        e[r] = t[i];
-    });
-    var a = e && e.__exportStar || function(e, t) {
-        for (var i in e) if (i !== "default" && !Object.prototype.hasOwnProperty.call(t, i)) r(t, e, i);
-    };
-    Object.defineProperty(t, "__esModule", {
-        value: true
-    });
-    t.extendJoi = t.joiBigint = void 0;
-    a(i, t);
-    const n = e => typeof e === "bigint";
-    const s = e => ({
-        type: "bigint",
-        messages: {
-            "bigint.base": "{{#label}} must be a bigint",
-            "bigint.greater": "{{#label}} must be greater than {{#limit}}",
-            "bigint.less": "{{#label}} must be less than {{#limit}}",
-            "bigint.max": "{{#label}} must be less than or equal to {{#limit}}",
-            "bigint.min": "{{#label}} must be greater than or equal to {{#limit}}",
-            "bigint.multiple": "{{#label}} must be a multiple of {{#base}}",
-            "bigint.negative": "{{#label}} must be a negative number",
-            "bigint.port": "{{#label}} must be a valid port",
-            "bigint.positive": "{{#label}} must be a positive number"
-        },
-        coerce(e, t) {
-            if (typeof e === "string" || typeof e === "number" && Number.isInteger(e)) {
-                try {
-                    return {
-                        value: BigInt(e)
-                    };
-                } catch {}
-            }
-            return {
-                value: e
-            };
-        },
-        validate(e, t) {
-            if (!n(e)) {
-                return {
-                    value: e,
-                    errors: t.error("bigint.base")
-                };
-            }
-        },
-        rules: {
-            greater: {
-                method(e) {
-                    return this.$_addRule({
-                        name: "greater",
-                        args: {
-                            limit: e
-                        }
-                    });
-                },
-                validate(e, t, {limit: i}) {
-                    return e > i ? e : t.error("bigint.greater", {
-                        limit: i.toString()
-                    });
-                },
-                args: [ {
-                    name: "limit",
-                    assert: n,
-                    message: "must be a bigint"
-                } ]
-            },
-            less: {
-                method(e) {
-                    return this.$_addRule({
-                        name: "less",
-                        args: {
-                            limit: e
-                        }
-                    });
-                },
-                validate(e, t, {limit: i}) {
-                    return e < i ? e : t.error("bigint.less", {
-                        limit: i.toString()
-                    });
-                },
-                args: [ {
-                    name: "limit",
-                    assert: n,
-                    message: "must be a bigint"
-                } ]
-            },
-            max: {
-                method(e) {
-                    return this.$_addRule({
-                        name: "max",
-                        args: {
-                            limit: e
-                        }
-                    });
-                },
-                validate(e, t, {limit: i}) {
-                    return e <= i ? e : t.error("bigint.max", {
-                        limit: i.toString()
-                    });
-                },
-                args: [ {
-                    name: "limit",
-                    assert: n,
-                    message: "must be a bigint"
-                } ]
-            },
-            min: {
-                method(e) {
-                    return this.$_addRule({
-                        name: "min",
-                        args: {
-                            limit: e
-                        }
-                    });
-                },
-                validate(e, t, {limit: i}) {
-                    return e >= i ? e : t.error("bigint.min", {
-                        limit: i.toString()
-                    });
-                },
-                args: [ {
-                    name: "limit",
-                    assert: n,
-                    message: "must be a bigint"
-                } ]
-            },
-            multiple: {
-                method(e) {
-                    return this.$_addRule({
-                        name: "multiple",
-                        args: {
-                            base: e
-                        }
-                    });
-                },
-                validate(e, t, {base: i}) {
-                    return e >= i && e % i === 0n ? e : t.error("bigint.multiple", {
-                        base: i.toString()
-                    });
-                },
-                args: [ {
-                    name: "base",
-                    assert: n,
-                    message: "must be a bigint"
-                } ],
-                multi: true
-            },
-            negative: {
-                method() {
-                    return this.$_addRule({
-                        name: "negative"
-                    });
-                },
-                validate(e, t) {
-                    return e < 0n ? e : t.error("bigint.negative");
+    } else {
+        if (typeof o === "object" && o !== null && r in o && Object.prototype.hasOwnProperty.call(o, r)) {
+            o[r] = n;
+        }
+    }
+    return true;
+}
+
+function o(e, t) {
+    let n = e;
+    for (let e = 0; e < t.length - 1; e++) {
+        const o = t[e];
+        if (typeof n !== "object" || n === null || !(o in n)) {
+            return false;
+        }
+        if (typeof n[o] !== "object" || n[o] === null) {
+            return false;
+        }
+        n = n[o];
+    }
+    const o = t[t.length - 1];
+    if (o === "*") {
+        if (Array.isArray(n)) {
+            for (let e = 0; e < n.length; e++) {
+                n[e] = undefined;
+            }
+        } else if (typeof n === "object" && n !== null) {
+            for (const e in n) {
+                if (Object.prototype.hasOwnProperty.call(n, e)) {
+                    delete n[e];
+                }
+            }
+        }
+    } else {
+        if (typeof n === "object" && n !== null && o in n && Object.prototype.hasOwnProperty.call(n, o)) {
+            delete n[o];
+        }
+    }
+    return true;
+}
+
+const r = Symbol("PATH_NOT_FOUND");
+
+function f(e, t) {
+    let n = e;
+    for (const e of t) {
+        if (n === null || n === undefined) {
+            return r;
+        }
+        if (typeof n !== "object" || n === null) {
+            return r;
+        }
+        if (!(e in n)) {
+            return r;
+        }
+        n = n[e];
+    }
+    return n;
+}
+
+function i(e, t) {
+    let n = e;
+    for (const e of t) {
+        if (n === null || n === undefined) {
+            return undefined;
+        }
+        if (typeof n !== "object" || n === null) {
+            return undefined;
+        }
+        n = n[e];
+    }
+    return n;
+}
+
+function l(e, i, l, c = false) {
+    for (const u of i) {
+        const i = t(u);
+        if (i.includes("*")) {
+            s(e, i, l, u, c);
+        } else {
+            if (c) {
+                o(e, i);
+            } else {
+                const t = f(e, i);
+                if (t === r) {
+                    continue;
+                }
+                const o = typeof l === "function" ? l(t, i) : l;
+                n(e, i, o);
+            }
+        }
+    }
+}
+
+function s(e, t, n, o, r = false) {
+    const f = t.indexOf("*");
+    if (f === t.length - 1) {
+        const o = t.slice(0, -1);
+        let f = e;
+        for (const e of o) {
+            if (f === null || f === undefined) return;
+            if (typeof f !== "object" || f === null) return;
+            f = f[e];
+        }
+        if (Array.isArray(f)) {
+            if (r) {
+                for (let e = 0; e < f.length; e++) {
+                    f[e] = undefined;
+                }
+            } else {
+                for (let e = 0; e < f.length; e++) {
+                    const t = [ ...o, e.toString() ];
+                    const r = typeof n === "function" ? n(f[e], t) : n;
+                    f[e] = r;
+                }
+            }
+        } else if (typeof f === "object" && f !== null) {
+            if (r) {
+                const e = [];
+                for (const t in f) {
+                    if (Object.prototype.hasOwnProperty.call(f, t)) {
+                        e.push(t);
+                    }
                 }
-            },
-            port: {
-                method() {
-                    return this.$_addRule({
-                        name: "port"
-                    });
-                },
-                validate(e, t) {
-                    return e >= 0n && e <= 65535n ? e : t.error("bigint.port");
+                for (const t of e) {
+                    delete f[t];
                 }
-            },
-            positive: {
-                method() {
-                    return this.$_addRule({
-                        name: "positive"
-                    });
-                },
-                validate(e, t) {
-                    return e > 0n ? e : t.error("bigint.positive");
+            } else {
+                for (const e in f) {
+                    const t = [ ...o, e ];
+                    const r = typeof n === "function" ? n(f[e], t) : n;
+                    f[e] = r;
                 }
-            },
-            sign: {
-                method(e) {
-                    return this.$_addRule({
-                        name: "sign",
-                        args: {
-                            sign: e
-                        }
-                    });
-                },
-                validate(e, t, {sign: i}) {
-                    return i === "negative" && e < 0n || i === "positive" && e > 0n ? e : t.error(`bigint.${i}`);
-                },
-                args: [ {
-                    name: "sign",
-                    assert: e => [ "negative", "positive" ].includes(e),
-                    message: 'must be "negative" or "positive"'
-                } ]
-            }
-        }
-    });
-    t.joiBigint = s;
-    const l = e => e.extend(t.joiBigint);
-    t.extendJoi = l;
-})(t);
-
-export { t as l };
+            }
+        }
+    } else {
+        c(e, t, n, f, o, r);
+    }
+}
+
+function c(e, t, r, f, l, c = false) {
+    const u = t.slice(0, f);
+    const a = t.slice(f + 1);
+    const p = [];
+    function y(e, t) {
+        if (t === u.length) {
+            if (Array.isArray(e)) {
+                for (let n = 0; n < e.length; n++) {
+                    p[t] = n.toString();
+                    y(e[n], t + 1);
+                }
+            } else if (typeof e === "object" && e !== null) {
+                for (const n in e) {
+                    p[t] = n;
+                    y(e[n], t + 1);
+                }
+            }
+        } else if (t < u.length) {
+            const n = u[t];
+            if (e && typeof e === "object" && e !== null && n in e) {
+                p[t] = n;
+                y(e[n], t + 1);
+            }
+        } else {
+            if (a.includes("*")) {
+                const n = typeof r === "function" ? (e, n) => {
+                    const o = [ ...p.slice(0, t), ...n ];
+                    return r(e, o);
+                } : r;
+                s(e, a, n, l, c);
+            } else {
+                if (c) {
+                    o(e, a);
+                } else {
+                    const o = typeof r === "function" ? r(i(e, a), [ ...p.slice(0, t), ...a ]) : r;
+                    n(e, a, o);
+                }
+            }
+        }
+    }
+    if (u.length === 0) {
+        y(e, 0);
+    } else {
+        let t = e;
+        for (let e = 0; e < u.length; e++) {
+            const n = u[e];
+            if (t === null || t === undefined) return;
+            if (typeof t !== "object" || t === null) return;
+            t = t[n];
+            p[e] = n;
+        }
+        if (t !== null && t !== undefined) {
+            y(t, u.length);
+        }
+    }
+}
+
+function u(e) {
+    if (e.length === 0) {
+        return null;
+    }
+    const n = new Map;
+    for (const o of e) {
+        const e = t(o);
+        let r = n;
+        for (let t = 0; t < e.length; t++) {
+            const n = e[t];
+            if (!r.has(n)) {
+                r.set(n, new Map);
+            }
+            r = r.get(n);
+        }
+    }
+    return n;
+}
+
+function a(e, t) {
+    if (!t) {
+        return e;
+    }
+    function n(e, t, o = 0) {
+        if (!t || t.size === 0) {
+            return e;
+        }
+        if (e === null || typeof e !== "object") {
+            return e;
+        }
+        if (e instanceof Date) {
+            return new Date(e.getTime());
+        }
+        if (Array.isArray(e)) {
+            const o = [];
+            for (let r = 0; r < e.length; r++) {
+                const f = r.toString();
+                if (t.has(f) || t.has("*")) {
+                    o[r] = n(e[r], t.get(f) || t.get("*"));
+                } else {
+                    o[r] = e[r];
+                }
+            }
+            return o;
+        }
+        const r = Object.create(Object.getPrototypeOf(e));
+        for (const o in e) {
+            if (Object.prototype.hasOwnProperty.call(e, o)) {
+                if (t.has(o) || t.has("*")) {
+                    r[o] = n(e[o], t.get(o) || t.get("*"));
+                } else {
+                    r[o] = e[o];
+                }
+            }
+        }
+        return r;
+    }
+    return n(e, t);
+}
+
+function p(e) {
+    if (typeof e !== "string") {
+        throw new Error("Paths must be (non-empty) strings");
+    }
+    if (e === "") {
+        throw new Error("Invalid redaction path ()");
+    }
+    if (e.includes("..")) {
+        throw new Error(`Invalid redaction path (${e})`);
+    }
+    if (e.includes(",")) {
+        throw new Error(`Invalid redaction path (${e})`);
+    }
+    let t = 0;
+    let n = false;
+    let o = "";
+    for (let r = 0; r < e.length; r++) {
+        const f = e[r];
+        if ((f === '"' || f === "'") && t > 0) {
+            if (!n) {
+                n = true;
+                o = f;
+            } else if (f === o) {
+                n = false;
+                o = "";
+            }
+        } else if (f === "[" && !n) {
+            t++;
+        } else if (f === "]" && !n) {
+            t--;
+            if (t < 0) {
+                throw new Error(`Invalid redaction path (${e})`);
+            }
+        }
+    }
+    if (t !== 0) {
+        throw new Error(`Invalid redaction path (${e})`);
+    }
+}
+
+function y(e) {
+    if (!Array.isArray(e)) {
+        throw new TypeError("paths must be an array");
+    }
+    for (const t of e) {
+        p(t);
+    }
+}
+
+function h(t = {}) {
+    const {paths: n = [], censor: o = "[REDACTED]", serialize: r = JSON.stringify, strict: f = true, remove: i = false} = t;
+    y(n);
+    const s = u(n);
+    return function t(c) {
+        if (f && (c === null || typeof c !== "object")) {
+            if (c === null || c === undefined) {
+                return r ? r(c) : c;
+            }
+            if (typeof c !== "object") {
+                return r ? r(c) : c;
+            }
+        }
+        const u = a(c, s);
+        const p = c;
+        let y = o;
+        if (typeof o === "function") {
+            y = o;
+        }
+        l(u, n, y, i);
+        if (r === false) {
+            u.restore = function() {
+                return e(p);
+            };
+            return u;
+        }
+        if (typeof r === "function") {
+            return r(u);
+        }
+        return JSON.stringify(u);
+    };
+}
+
+var d = h;
+
+export { d as r };