lakutata 2.0.94 → 2.0.96

package/vendor/Package.internal.23.cjs

@@ -1,150 +1,228 @@
-/* Build Date: Mon Nov 24 2025 00:55:42 GMT+0800 (China Standard Time) */
+/* Build Date: Mon Nov 24 2025 18:02:01 GMT+0800 (China Standard Time) */
 "use strict";
 
-const e = require("./Package.internal.24.cjs");
+const e = require("./Package.internal.8.cjs");
 
-const r = require("path");
+exports.lib = {};
 
-const n = require("module");
+var t = {};
 
-const t = e => e && e.__esModule ? e : {
-    default: e
-};
+Object.defineProperty(t, "__esModule", {
+    value: true
+});
 
-const o = t(r);
-
-const i = t(n);
-
-var a;
-
-var s;
-
-function u() {
-    if (s) return a;
-    s = 1;
-    var r = o.default;
-    var n = i.default.globalPaths;
-    var t;
-    if ("win32" === process.platform) {
-        t = r.dirname(process.execPath);
-    } else {
-        t = r.dirname(r.dirname(process.execPath));
-    }
-    var u = r.resolve(t, "lib", "node_modules");
-    var c = r.sep;
-    var f = "function" === typeof __webpack_require__ || "function" === typeof __non_webpack_require__ ? __non_webpack_require__ : e.commonjsRequire;
-    const p = function(e) {
-        const r = c + ".pnpm";
-        for (const t of n) {
-            if (-1 !== t.indexOf(r) && -1 !== e.indexOf(r)) {
-                return true;
-            }
-        }
-        return false;
-    };
-    const l = function(e) {
-        const r = c + "node_modules";
-        if (-1 !== e.indexOf(r)) {
-            const n = e.split(r);
-            if (n.length) {
-                return n[0];
-            }
+(function(i) {
+    var r = e.commonjsGlobal && e.commonjsGlobal.__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];
+                }
+            };
         }
-        return null;
+        Object.defineProperty(e, r, a);
+    } : function(e, t, i, r) {
+        if (r === undefined) r = i;
+        e[r] = t[i];
+    });
+    var a = e.commonjsGlobal && e.commonjsGlobal.__exportStar || function(e, t) {
+        for (var i in e) if (i !== "default" && !Object.prototype.hasOwnProperty.call(t, i)) r(t, e, i);
     };
-    a = function e(t) {
-        if (process.env.APP_ROOT_PATH) {
-            return r.resolve(process.env.APP_ROOT_PATH);
-        }
-        if (process.versions.pnp) {
-            try {
-                var o = f("pnpapi");
-                return o.getPackageInformation(o.topLevel).packageLocation;
-            } catch (e) {}
-        }
-        if ("undefined" !== typeof window && window.process && "renderer" === window.process.type) {
-            try {
-                var i = f("electron").remote;
-                return i.require("app-root-path").path;
-            } catch (e) {}
-        }
-        if (process.env.LAMBDA_TASK_ROOT && process.env.AWS_EXECUTION_ENV) {
-            return process.env.LAMBDA_TASK_ROOT;
-        }
-        var a = r.resolve(t);
-        var s = false;
-        var v = null;
-        if (p(a)) {
-            v = l(a);
-            if (v) {
-                return v;
+    Object.defineProperty(i, "__esModule", {
+        value: true
+    });
+    i.extendJoi = i.joiBigint = void 0;
+    a(t, i);
+    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 {}
             }
-        }
-        n.forEach(function(e) {
-            if (!s && 0 === a.indexOf(e)) {
-                s = true;
-            }
-        });
-        if (!s) {
-            v = l(a);
-        }
-        if (s || null == v) {
-            if (f.main) {
-                v = r.dirname(f.main.filename);
-            } else {
-                v = r.dirname(process.argv[1]);
+            return {
+                value: e
+            };
+        },
+        validate(e, t) {
+            if (!n(e)) {
+                return {
+                    value: e,
+                    errors: t.error("bigint.base")
+                };
             }
-        }
-        if (s && -1 !== v.indexOf(u) && v.length - 4 === v.indexOf(c + "bin")) {
-            v = v.slice(0, -4);
-        }
-        return v;
-    };
-    return a;
-}
-
-var c;
-
-var f;
-
-function p() {
-    if (f) return c;
-    f = 1;
-    c = function(r) {
-        var n = o.default;
-        var t = u();
-        var i = t(r);
-        var a = {
-            resolve: function(e) {
-                return n.join(i, e);
+        },
+        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"
+                } ]
             },
-            require: function(r) {
-                return e.commonjsRequire(a.resolve(r));
+            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"
+                } ]
             },
-            toString: function() {
-                return i;
+            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"
+                } ]
             },
-            setPath: function(e) {
-                i = n.resolve(e);
-                a.path = i;
+            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"
+                } ]
             },
-            path: i
-        };
-        return a;
-    };
-    return c;
-}
-
-var l;
-
-var v;
-
-function _() {
-    if (v) return l;
-    v = 1;
-    var e = p();
-    l = e(__dirname);
-    return l;
-}
-
-exports.requireAppRootPath = _;
+            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");
+                }
+            },
+            port: {
+                method() {
+                    return this.$_addRule({
+                        name: "port"
+                    });
+                },
+                validate(e, t) {
+                    return e >= 0n && e <= 65535n ? e : t.error("bigint.port");
+                }
+            },
+            positive: {
+                method() {
+                    return this.$_addRule({
+                        name: "positive"
+                    });
+                },
+                validate(e, t) {
+                    return e > 0n ? e : t.error("bigint.positive");
+                }
+            },
+            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"'
+                } ]
+            }
+        }
+    });
+    i.joiBigint = s;
+    const l = e => e.extend(i.joiBigint);
+    i.extendJoi = l;
+})(exports.lib);