lakutata 2.0.94 → 2.0.96

package/vendor/Package.internal.132.cjs

@@ -1,97 +1,899 @@
-/* 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("path");
+const e = require("./Package.internal.133.cjs");
 
-const r = require("fs");
+const t = require("./Package.internal.8.cjs");
 
-const t = e => e && e.__esModule ? e : {
-    default: e
+const i = require("./Package.internal.60.cjs");
+
+const s = e.lodashExports;
+
+const r = i.combinations;
+
+const n = {
+    or: function(e, t) {
+        e.anyOf = s.map(t.peers, e => ({
+            required: [ e ]
+        }));
+    },
+    and: function(e, t) {
+        e.oneOf = [ {
+            required: t.peers
+        } ];
+        e.oneOf.push({
+            allOf: s.map(t.peers, e => ({
+                not: {
+                    required: [ e ]
+                }
+            }))
+        });
+    },
+    nand: function(e, t) {
+        e.not = {
+            required: t.peers
+        };
+    },
+    xor: function(e, t) {
+        e.if = {
+            propertyNames: {
+                enum: t.peers
+            },
+            minProperties: 2
+        };
+        e.then = false;
+        e.else = {
+            oneOf: s.map(t.peers, e => ({
+                required: [ e ]
+            }))
+        };
+    },
+    oxor: function(e, t) {
+        e.oneOf = s.map(t.peers, e => ({
+            required: [ e ]
+        }));
+        e.oneOf.push({
+            not: {
+                oneOf: s.map(r(t.peers, 1, 2), e => ({
+                    required: e
+                }))
+            }
+        });
+    },
+    with: function(e, t) {
+        e.dependentRequired = e.dependentRequired || {};
+        e.dependentRequired[t.key] = t.peers;
+    },
+    without: function(e, t) {
+        e.if = {
+            required: [ t.key ]
+        };
+        e.then = {
+            not: {
+                anyOf: s.map(t.peers, e => ({
+                    required: [ e ]
+                }))
+            }
+        };
+    }
 };
 
-const i = t(e);
+function a(e) {
+    return typeof e === "object" && e !== null && Object.keys(e).length === 1 && e.override === true;
+}
 
-const n = t(r);
+let o = class JoiJsonSchemaParser {
+    constructor(e = {}) {
+        this.$schema = e.$schema || "http://json-schema.org/draft-07/schema#";
+        this.includeSchemaDialect = e.includeSchemaDialect || false;
+        this.childrenFieldName = this._getChildrenFieldName();
+        this.optionsFieldName = this._getOptionsFieldName();
+        this.ruleArgFieldName = this._getRuleArgFieldName();
+        this.enumFieldName = this._getEnumFieldName();
+        this.allowUnknownFlagName = this._getAllowUnknownFlagName();
+        this.inheritedPreferences = [];
+        if (e.logicalOpParser === false) {
+            this.logicalOpParser = {};
+        } else {
+            this.logicalOpParser = s.merge({}, n, e.logicalOpParser);
+        }
+    }
+    parse(e, t = {}, i = 0) {
+        let r = {};
+        const n = this._pushInheritiedPreferences(e);
+        if (this._getPresence(e) === "forbidden") {
+            if (n) {
+                this._popInheritiedPreferences();
+            }
+            r.not = {};
+            return r;
+        }
+        this._setBasicProperties(r, e);
+        this._setNumberFieldProperties(r, e);
+        this._setBinaryFieldProperties(r, e);
+        this._setStringFieldProperties(r, e);
+        this._setDateFieldProperties(r, e);
+        this._setArrayFieldProperties(r, e, t, i);
+        this._setObjectProperties(r, e, t, i);
+        this._setAlternativesProperties(r, e, t, i);
+        this._setConditionProperties(r, e, t, i, "whens");
+        this._setMetaProperties(r, e);
+        this._setLinkFieldProperties(r, e);
+        this._setConst(r, e);
+        this._setAnyProperties(r, e, t, i);
+        this._addNullTypeIfNullable(r, e);
+        if (!s.isEmpty(e.shared)) {
+            s.forEach(e.shared, e => {
+                this.parse(e, t, i);
+            });
+        }
+        this._copyMetasToSchema(e, r);
+        const a = s.get(e, "flags.id");
+        if (a) {
+            t[a] = r;
+            r = {
+                $ref: `${this._getLocalSchemaBasePath()}/${a}`
+            };
+        }
+        if (i === 0 && !s.isEmpty(t)) {
+            s.set(r, `${this._getLocalSchemaBasePath().replace("#/", "").replace(/\//, ".")}`, t);
+        }
+        if (this.includeSchemaDialect && i === 0 && this.$schema) {
+            r.$schema = this.$schema;
+        }
+        if (n) {
+            this._popInheritiedPreferences();
+        }
+        return r;
+    }
+    _pushInheritiedPreferences(e) {
+        if (e.preferences) {
+            this.inheritedPreferences.push(s.merge({}, this._getInheritedPreferences(), e.preferences));
+            return true;
+        }
+        return false;
+    }
+    _popInheritiedPreferences() {
+        this.inheritedPreferences.pop();
+    }
+    _getInheritedPreferences() {
+        return this.inheritedPreferences[this.inheritedPreferences.length - 1] || {};
+    }
+    _isIfThenElseSupported() {
+        return true;
+    }
+    _getChildrenFieldName() {
+        return "keys";
+    }
+    _getOptionsFieldName() {
+        return "preferences";
+    }
+    _getRuleArgFieldName() {
+        return "args";
+    }
+    _getEnumFieldName() {
+        return "allow";
+    }
+    _getAllowUnknownFlagName() {
+        return "unknown";
+    }
+    _getLocalSchemaBasePath() {
+        return "#/$defs";
+    }
+    _getFieldDescription(e) {
+        return s.get(e, "flags.description");
+    }
+    _getFieldType(e) {
+        let t = e.type;
+        if (t === "number" && !s.isEmpty(e.rules) && e.rules[0].name === "integer") {
+            t = "integer";
+        }
+        return t;
+    }
+    _addNullTypeIfNullable(e, t) {
+        if (e.const === null) {
+            return;
+        }
+        const i = s.get(t, this.enumFieldName);
+        if (Array.isArray(i) && i.includes(null)) {
+            if (Array.isArray(e.type)) {
+                if (!e.type.includes("null")) {
+                    e.type.push("null");
+                }
+            } else if (e.type) {
+                e.type = [ e.type, "null" ];
+            } else {
+                e.type = "null";
+            }
+        }
+    }
+    _getFieldExample(e) {
+        return s.get(e, "examples");
+    }
+    _getPresence(e) {
+        const t = s.get(e, "flags.presence");
+        if (t !== undefined) {
+            return t;
+        }
+        const i = e[this.optionsFieldName] || this._getInheritedPreferences();
+        return s.get(i, "presence");
+    }
+    _isRequired(e) {
+        const t = this._getPresence(e);
+        return t === "required";
+    }
+    _getDefaultValue(e) {
+        return s.get(e, "flags.default");
+    }
+    _getEnum(e) {
+        const t = e[this.enumFieldName];
+        const i = t ? s.filter(t, e => !a(e)) : t;
+        if (e.flags && e.flags.only && s.size(i) > 1) {
+            return s.uniq(i);
+        }
+    }
+    _getUnknown(e) {
+        const t = s.get(e, `flags.${this.allowUnknownFlagName}`);
+        if (t !== undefined) {
+            return t;
+        }
+        const i = e[this.optionsFieldName] || this._getInheritedPreferences();
+        return s.get(i, "allowUnknown") || false;
+    }
+    _setIfNotEmpty(e, t, i) {
+        if (i !== null && i !== undefined) {
+            e[t] = i;
+        }
+    }
+    _setBasicProperties(e, t) {
+        this._setIfNotEmpty(e, "type", this._getFieldType(t));
+        this._setIfNotEmpty(e, "examples", this._getFieldExample(t));
+        this._setIfNotEmpty(e, "description", this._getFieldDescription(t));
+        this._setIfNotEmpty(e, "default", this._getDefaultValue(t));
+        this._setIfNotEmpty(e, "enum", this._getEnum(t));
+        if (t.invalid && t.invalid.length > 0) {
+            e.not = {
+                type: e.type,
+                enum: t.invalid
+            };
+        }
+    }
+    _setBinaryFieldProperties(e, t) {
+        if (e.type !== "binary") {
+            return;
+        }
+        e.type = "string";
+        if (t.flags && t.flags.encoding) {
+            e.contentEncoding = t.flags.encoding;
+        }
+        e.format = "binary";
+    }
+    _setObjectProperties(e, t, i, r) {
+        if (e.type !== "object") {
+            return;
+        }
+        e.properties = {};
+        e.required = [];
+        e.additionalProperties = this._getUnknown(t);
+        s.map(t[this.childrenFieldName], (t, s) => {
+            const n = this.parse(t, i, r + 1);
+            if (this._isRequired(t)) {
+                e.required.push(s);
+            }
+            e.properties[s] = n;
+        });
+        if (t.patterns) {
+            s.each(t.patterns, t => {
+                if (typeof t.rule !== "object" || typeof t.regex === "undefined") {
+                    return;
+                }
+                e.properties[t.regex] = this.parse(t.rule, i, r + 1);
+                e.patternProperties = e.patternProperties || {};
+                let s = t.regex;
+                s = s.indexOf("/") === 0 ? s.substring(1) : s;
+                s = s.lastIndexOf("/") > -1 ? s.substring(0, s.length - 1) : s;
+                e.patternProperties[s] = e.properties[t.regex];
+            });
+        }
+        if (s.isEmpty(e.required)) {
+            delete e.required;
+        }
+        this._setObjectDependencies(e, t);
+    }
+    _setObjectDependencies(e, t) {
+        if (!s.isArray(t.dependencies) || t.dependencies.length === 0) {
+            return;
+        }
+        if (t.dependencies.length === 1) {
+            this._setDependencySubSchema(e, t.dependencies[0]);
+        } else {
+            const i = s.remove(t.dependencies, e => e.rel === "with");
+            e.allOf = s.compact(s.map(t.dependencies, e => {
+                const t = this._setDependencySubSchema({}, e);
+                if (s.isEmpty(t)) {
+                    return null;
+                }
+                return t;
+            }));
+            s.each(i, t => {
+                this._setDependencySubSchema(e, t);
+            });
+            if (e.allOf.length === 0) {
+                delete e.allOf;
+            }
+        }
+    }
+    _setDependencySubSchema(e, t) {
+        const i = this.logicalOpParser[t.rel];
+        if (typeof i !== "function") {
+            return e;
+        }
+        i(e, t);
+        return e;
+    }
+    _setNumberFieldProperties(e, t) {
+        if (e.type !== "number" && e.type !== "integer") {
+            return;
+        }
+        const i = this.ruleArgFieldName;
+        s.each(t.rules, t => {
+            const s = t[i];
+            switch (t.name) {
+              case "max":
+                e.maximum = s.limit;
+                break;
 
-var s = i.default;
+              case "min":
+                e.minimum = s.limit;
+                break;
 
-var c = n.default;
+              case "greater":
+                e.exclusiveMinimum = s.limit;
+                e.minimum = s.limit;
+                break;
 
-var o = parseInt("0777", 8);
+              case "less":
+                e.exclusiveMaximum = s.limit;
+                e.maximum = s.limit;
+                break;
 
-exports.mkdirpClassic = a.mkdirp = a.mkdirP = a;
+              case "multiple":
+                e.multipleOf = s.base;
+                break;
 
-function a(e, r, t, i) {
-    if (typeof r === "function") {
-        t = r;
-        r = {};
-    } else if (!r || typeof r !== "object") {
-        r = {
-            mode: r
-        };
+              case "sign":
+                if (t.args.sign === "positive") {
+                    e.exclusiveMinimum = 0;
+                } else if (t.args.sign === "negative") {
+                    e.exclusiveMaximum = 0;
+                }
+                break;
+            }
+        });
+    }
+    _setStringFieldProperties(e, t) {
+        if (e.type !== "string") {
+            return;
+        }
+        if (t.flags && t.flags.encoding) {
+            e.contentEncoding = t.flags.encoding;
+        }
+        const i = this.ruleArgFieldName;
+        s.forEach(t.rules, t => {
+            switch (t.name) {
+              case "min":
+                e.minLength = t[i].limit;
+                break;
+
+              case "max":
+                e.maxLength = t[i].limit;
+                break;
+
+              case "email":
+                e.format = "email";
+                break;
+
+              case "hostname":
+                e.format = "hostname";
+                break;
+
+              case "uri":
+                e.format = "uri";
+                break;
+
+              case "ip":
+                const r = t[i].options.version;
+                if (!s.isEmpty(r)) {
+                    if (r.length === 1) {
+                        e.format = r[0];
+                    } else {
+                        e.oneOf = s.map(r, e => ({
+                            format: e
+                        }));
+                    }
+                } else {
+                    e.format = "ipv4";
+                }
+                break;
+
+              case "pattern":
+                let n = t[i].regex;
+                let a = n.indexOf("/");
+                if (a === 0) {
+                    n = n.replace("/", "");
+                }
+                a = n.lastIndexOf("/") === n.length - 1;
+                if (a > -1) {
+                    n = n.replace(/\/$/, "");
+                }
+                e.pattern = n;
+                break;
+
+              case "isoDate":
+                e.format = "date-time";
+                break;
+
+              case "isoDuration":
+                e.format = "duration";
+                break;
+
+              case "uuid":
+              case "guid":
+                e.format = "uuid";
+                break;
+            }
+        });
+    }
+    _setArrayFieldProperties(e, t, i, r) {
+        if (e.type !== "array") {
+            return;
+        }
+        const n = this.ruleArgFieldName;
+        s.each(t.rules, t => {
+            const s = t[n];
+            switch (t.name) {
+              case "max":
+                e.maxItems = s.limit;
+                break;
+
+              case "min":
+                e.minItems = s.limit;
+                break;
+
+              case "length":
+                e.maxItems = s.limit;
+                e.minItems = s.limit;
+                break;
+
+              case "unique":
+                e.uniqueItems = true;
+                break;
+
+              case "has":
+                e.contains = this.parse(s.schema, i, r + 1);
+                break;
+            }
+        });
+        if (!t.items) {
+            e.items = {};
+            return;
+        }
+        if (t.items.length === 1) {
+            e.items = this.parse(t.items[0], i, r + 1);
+        } else {
+            e.items = {
+                anyOf: s.map(t.items, e => this.parse(e, i, r + 1))
+            };
+        }
     }
-    var n = r.mode;
-    var f = r.fs || c;
-    if (n === undefined) {
-        n = o & ~process.umask();
-    }
-    if (!i) i = null;
-    var u = t || function() {};
-    e = s.resolve(e);
-    f.mkdir(e, n, function(t) {
-        if (!t) {
-            i = i || e;
-            return u(null, i);
-        }
-        switch (t.code) {
-          case "ENOENT":
-            a(s.dirname(e), r, function(t, i) {
-                if (t) u(t, i); else a(e, r, u, i);
+    _setDateFieldProperties(e, t) {
+        if (e.type !== "date") {
+            return;
+        }
+        if (t.flags && t.flags.format !== "iso") {
+            e.type = "integer";
+        } else {
+            e.type = "string";
+            e.format = "date-time";
+        }
+    }
+    _setAlternativesProperties(e, t, i, r) {
+        if (e.type !== "alternatives" || t.matches.length === 0) {
+            return;
+        }
+        if (t.matches[0].schema) {
+            let n = "anyOf";
+            if (t.flags && t.flags.match === "one") {
+                n = "oneOf";
+            } else if (t.flags && t.flags.match === "all") {
+                n = "allOf";
+            }
+            e[n] = s.map(t.matches, e => this.parse(e.schema, i, r + 1));
+            if (e[n].length === 1) {
+                s.merge(e, e[n][0]);
+                delete e[n];
+            }
+        } else {
+            this._setConditionProperties(e, t, i, r, "matches", "anyOf");
+        }
+        if (e.type === "alternatives") {
+            delete e.type;
+        }
+    }
+    _setConditionProperties(e, t, i, r, n, a = "allOf") {
+        if (!t[n] || t[n].length === 0) {
+            return;
+        }
+        let o = this._isIfThenElseSupported();
+        const l = s.remove(t.metas, e => typeof e["if-style"] !== undefined);
+        if (o && l.length > 0 && l[0]["if-style"] === false) {
+            o = false;
+        }
+        if (t[n].length > 1) {
+            e[a] = s.map(t[n], e => this._setConditionSchema(o, {}, e, i, r + 1));
+        } else {
+            this._setConditionSchema(o, e, t[n][0], i, r + 1);
+        }
+    }
+    _setConditionSchema(e, t, i, s, r) {
+        if (!i.is && !i.switch) {
+            return;
+        }
+        if (i.switch) {
+            this._parseSwitchCondition(e, t, i, s, r);
+        } else {
+            if (e) {
+                this._parseIfThenElseCondition(t, i, s, r);
+            } else {
+                this._setConditionCompositionStyle(t, i, s, r);
+            }
+        }
+        return t;
+    }
+    _parseIfThenElseCondition(e, t, i, s) {
+        if (t.ref) {
+            return this._setConditionCompositionStyle(e, t, i, s);
+        }
+        e.if = this.parse(t.is, i, s);
+        if (t.then) {
+            e.then = this.parse(t.then, i, s);
+        }
+        if (t.otherwise) {
+            e.else = this.parse(t.otherwise, i, s);
+        }
+        return e;
+    }
+    _parseSwitchCondition(e, t, i, r, n) {
+        const a = [];
+        for (const t of i.switch) {
+            if (e && !i.ref) {
+                const e = this._parseIfThenElseCondition({}, t, r, n + 1);
+                a.push(e);
+            } else {
+                if (t.then) {
+                    a.push(this.parse(t.then, r, n + 1));
+                }
+                if (t.otherwise) {
+                    a.push(this.parse(t.otherwise, r, n + 1));
+                }
+            }
+        }
+        if (a.length > 1) {
+            t.anyOf = a;
+        } else {
+            s.merge(t, oneOf[0]);
+        }
+    }
+    _setConditionCompositionStyle(e, t, i, r) {
+        if (t.ref) {
+            const n = e.oneOf || [];
+            if (t.then) {
+                n.push(this.parse(t.then, i, r + 1));
+            }
+            if (t.otherwise) {
+                n.push(this.parse(t.otherwise, i, r + 1));
+            }
+            if (n.length > 1) {
+                e.oneOf = n;
+            } else {
+                s.merge(e, n[0]);
+            }
+        } else {
+            if (t.is && t.then && t.otherwise) {
+                e.allOf = [ {
+                    anyOf: [ {
+                        not: this.parse(t.is, i, r + 1)
+                    }, this.parse(t.then, i, r + 1) ]
+                }, {
+                    anyOf: [ this.parse(t.is, i, r + 1), this.parse(t.otherwise, i, r + 1) ]
+                } ];
+            } else if (t.is && t.then) {
+                e.anyOf = [ {
+                    not: this.parse(t.is, i, r + 1)
+                }, this.parse(t.then, i, r + 1) ];
+            }
+        }
+        return e;
+    }
+    _setConst(e, t) {
+        const i = t[this.enumFieldName];
+        const r = i ? s.filter(i, e => !a(e)) : i;
+        if (t.flags && t.flags.only && s.size(r) === 1) {
+            e.const = r[0];
+            delete e.type;
+        }
+    }
+    _setAnyProperties(e) {
+        if (e.type !== "any") {
+            return;
+        }
+        e.type = [ "array", "boolean", "number", "object", "string", "null" ];
+    }
+    _setMetaProperties(e, t) {
+        s.forEach(t.metas, t => {
+            if (t.contentMediaType) {
+                e.contentMediaType = t.contentMediaType;
+            }
+            if (t.format) {
+                e.format = t.format;
+            }
+            if (t.title) {
+                e.title = t.title;
+            }
+        });
+    }
+    _setLinkFieldProperties(e, t) {
+        if (e.type !== "link") {
+            return;
+        }
+        if (s.get(t, "link.ref.type") === "local") {
+            e.$ref = `${this._getLocalSchemaBasePath()}/${t.link.ref.path.join("/")}`;
+            delete e.type;
+        }
+    }
+    _copyMetasToSchema(e, t) {
+        if (!s.isEmpty(e.metas)) {
+            s.each(e.metas, e => {
+                s.each(e, (e, i) => {
+                    if (this._isKnownMetaKey(i)) {
+                        t[i] = e;
+                    }
+                });
             });
-            break;
+        }
+    }
+    _isKnownMetaKey(e) {
+        return false;
+    }
+};
+
+var l = o;
+
+const p = e.lodashExports;
+
+const c = l;
+
+let m = class JoiJsonDraftSchemaParser extends c {
+    constructor(e = {}) {
+        super(p.merge({
+            $schema: "http://json-schema.org/draft-04/schema#",
+            logicalOpParser: {
+                xor: null,
+                with: function(e, t) {
+                    e.dependencies = e.dependencies || {};
+                    e.dependencies[t.key] = t.peers;
+                },
+                without: null
+            }
+        }, e));
+    }
+    _isIfThenElseSupported() {
+        return false;
+    }
+    _setNumberFieldProperties(e, t) {
+        super._setNumberFieldProperties(e, t);
+        if (typeof e.exclusiveMinimum !== "undefined") {
+            e.minimum = e.exclusiveMinimum;
+            e.exclusiveMinimum = true;
+        }
+        if (typeof e.exclusiveMaximum !== "undefined") {
+            e.maximum = e.exclusiveMaximum;
+            e.exclusiveMaximum = true;
+        }
+        if (typeof e.minimum !== "undefined" && e.minimum === e.exclusiveMinimum) {
+            e.exclusiveMinimum = true;
+        }
+        if (typeof e.maximum !== "undefined" && e.maximum === e.exclusiveMaximum) {
+            e.exclusiveMaximum = true;
+        }
+    }
+    _getLocalSchemaBasePath() {
+        return "#/definitions";
+    }
+    _setArrayFieldProperties(e, t, i, s) {
+        super._setArrayFieldProperties(e, t, i, s);
+        delete e.contains;
+    }
+    _setConst(e, t) {
+        super._setConst(e, t);
+        if (typeof e.const !== "undefined") {
+            if (e.const === null) {
+                e.type = "null";
+            } else if (p.isArray(e.const)) {
+                e.type = "array";
+            } else {
+                e.type = typeof e.const;
+                if (e.type === "number" && Number.isInteger(e.const)) {
+                    e.type = "integer";
+                }
+            }
+            e.enum = [ e.const ];
+            delete e.const;
+        }
+    }
+};
+
+var u = m;
+
+const f = e.lodashExports;
 
-          default:
-            f.stat(e, function(e, r) {
-                if (e || !r.isDirectory()) u(t, i); else u(null, i);
+const h = u;
+
+let d = class JoiOpenApiSchemaParser extends h {
+    constructor(e = {}) {
+        super(f.merge({
+            logicalOpParser: {
+                xor: null,
+                with: null,
+                without: null
+            }
+        }, e));
+        this.$schema = undefined;
+    }
+    parse(e, t = {}, i = 0) {
+        const s = super.parse(e, t, i);
+        const r = f.pickBy(s, (e, t) => y(t));
+        if (i === 0 && !f.isEmpty(t)) {
+            r.schemas = t;
+        }
+        if (s.const) {
+            r.enum = [ s.const ];
+        }
+        return r;
+    }
+    _isIfThenElseSupported() {
+        return false;
+    }
+    _getLocalSchemaBasePath() {
+        return "#/components/schemas";
+    }
+    _setBasicProperties(e, t) {
+        super._setBasicProperties(e, t);
+        if (!f.isEmpty(e.examples)) {
+            e.example = e.examples[0];
+        }
+    }
+    _addNullTypeIfNullable(e, t) {
+        super._addNullTypeIfNullable(e, t);
+        if (e.type === "null") {
+            delete e.type;
+            e.nullable = true;
+        } else if (f.isArray(e.type) && e.type.includes("null")) {
+            f.remove(e.type, e => e === "null");
+            e.nullable = true;
+            if (e.type.length === 1) {
+                e.type = e.type[0];
+            }
+        }
+        if (f.isArray(e.type)) {
+            e.anyOf = e.anyOf || [];
+            f.forEach(e.type, t => {
+                const i = f.some(e.anyOf, e => e.type === t);
+                if (!i) {
+                    const i = {
+                        type: t
+                    };
+                    if (t === "array") {
+                        i.items = {};
+                    }
+                    e.anyOf.push(i);
+                }
             });
-            break;
+            delete e.type;
         }
-    });
+    }
+    _isKnownMetaKey(e) {
+        return g(e);
+    }
+};
+
+function g(e) {
+    return e.startsWith("x-") || e === "deprecated" || e === "readOnly" || e === "writeOnly";
 }
 
-a.sync = function e(r, t, i) {
-    if (!t || typeof t !== "object") {
-        t = {
-            mode: t
-        };
+function y(e) {
+    const t = new Set([ "$ref", "title", "multipleOf", "maximum", "exclusiveMaximum", "minimum", "exclusiveMinimum", "maxLength", "minLength", "pattern", "maxItems", "minItems", "uniqueItems", "maxProperties", "minProperties", "required", "enum", "description", "format", "default", "type", "allOf", "oneOf", "anyOf", "not", "items", "properties", "additionalProperties", "example", "nullable" ]);
+    return t.has(e) || g(e);
+}
+
+var _ = d;
+
+const P = e.lodashExports;
+
+const x = l;
+
+let O = class JoiJsonDraftSchemaParser extends x {
+    constructor(e = {}) {
+        super(P.merge({
+            $schema: "https://json-schema.org/draft/2019-09/schema"
+        }, e));
     }
-    var n = t.mode;
-    var a = t.fs || c;
-    if (n === undefined) {
-        n = o & ~process.umask();
-    }
-    if (!i) i = null;
-    r = s.resolve(r);
-    try {
-        a.mkdirSync(r, n);
-        i = i || r;
-    } catch (n) {
-        switch (n.code) {
-          case "ENOENT":
-            i = e(s.dirname(r), t, i);
-            e(r, t, i);
-            break;
-
-          default:
-            var f;
-            try {
-                f = a.statSync(r);
-            } catch (e) {
-                throw n;
-            }
-            if (!f.isDirectory()) throw n;
-            break;
-        }
-    }
-    return i;
+    _isKnownMetaKey(e) {
+        return e === "deprecated" || e === "readOnly" || e === "writeOnly";
+    }
+};
+
+var b = O;
+
+const w = e.lodashExports;
+
+const F = b;
+
+let N = class JoiOpenApiSchemaParser extends F {
+    constructor(e = {}) {
+        super(e);
+        this.$schema = undefined;
+    }
+    parse(e, t = {}, i = 0) {
+        const s = super.parse(e, t, i);
+        if (i === 0 && !w.isEmpty(t)) {
+            s.schemas = t;
+        }
+        delete s.components;
+        return s;
+    }
+    _getLocalSchemaBasePath() {
+        return "#/components/schemas";
+    }
+    _isKnownMetaKey(e) {
+        return e.startsWith("x-") || e === "deprecated" || e === "readOnly" || e === "writeOnly";
+    }
+};
+
+var k = N;
+
+const E = l;
+
+const S = _;
+
+const v = k;
+
+const I = b;
+
+const M = u;
+
+const q = {
+    "json-draft-2019-09": I,
+    "json-draft-04": M,
+    json: E,
+    "open-api": S,
+    "open-api-3.1": v
 };
+
+function A(e, t = "json", i = {}, s = {}) {
+    if (typeof e.describe !== "function") {
+        throw new Error("Not an joi object.");
+    }
+    const r = e.describe();
+    const n = q[t];
+    if (!n) {
+        throw new Error(`No parser is registered for ${t}`);
+    }
+    return new n(s).parse(r, i);
+}
+
+var C = A;
+
+const j = t.getDefaultExportFromCjs(C);
+
+exports.parse = j;