@astrale-os/kernel-dsl 0.2.0-beta.1 → 0.2.0-beta.11

package/dist/v1/language/value/profile/meta-schema.compiled.js

@@ -0,0 +1,2079 @@
+/* Generated by scripts/generate-value-schema-meta-validator.mjs. */
+/* oxlint-disable */
+// @ts-nocheck -- Ajv standalone output is JavaScript with generated function properties.
+"use strict";
+export const validate = validate20;
+export default validate20;
+const schema31 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://schemas.astrale.ai/dsl/v1/value-schema", "$vocabulary": {}, "allOf": [{ "$ref": "https://json-schema.org/draft/2020-12/schema" }], "properties": { "fullMatch": { "type": "string" }, "x-astrale-path": { "type": "object" } } };
+const schema0 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://json-schema.org/draft/2020-12/schema", "$vocabulary": { "https://json-schema.org/draft/2020-12/vocab/core": true, "https://json-schema.org/draft/2020-12/vocab/applicator": true, "https://json-schema.org/draft/2020-12/vocab/unevaluated": true, "https://json-schema.org/draft/2020-12/vocab/validation": true, "https://json-schema.org/draft/2020-12/vocab/meta-data": true, "https://json-schema.org/draft/2020-12/vocab/format-annotation": true, "https://json-schema.org/draft/2020-12/vocab/content": true }, "$dynamicAnchor": "meta", "title": "Core and Validation specifications meta-schema", "allOf": [{ "$ref": "meta/core" }, { "$ref": "meta/applicator" }, { "$ref": "meta/unevaluated" }, { "$ref": "meta/validation" }, { "$ref": "meta/meta-data" }, { "$ref": "meta/format-annotation" }, { "$ref": "meta/content" }], "type": ["object", "boolean"], "$comment": "This meta-schema also defines keywords that have appeared in previous drafts in order to prevent incompatible extensions as they remain in common use.", "properties": { "definitions": { "$comment": "\"definitions\" has been replaced by \"$defs\".", "type": "object", "additionalProperties": { "$dynamicRef": "#meta" }, "deprecated": true, "default": {} }, "dependencies": { "$comment": "\"dependencies\" has been split and replaced by \"dependentSchemas\" and \"dependentRequired\" in order to serve their differing semantics.", "type": "object", "additionalProperties": { "anyOf": [{ "$dynamicRef": "#meta" }, { "$ref": "meta/validation#/$defs/stringArray" }] }, "deprecated": true, "default": {} }, "$recursiveAnchor": { "$comment": "\"$recursiveAnchor\" has been replaced by \"$dynamicAnchor\".", "$ref": "meta/core#/$defs/anchorString", "deprecated": true }, "$recursiveRef": { "$comment": "\"$recursiveRef\" has been replaced by \"$dynamicRef\".", "$ref": "meta/core#/$defs/uriReferenceString", "deprecated": true } } };
+const schema23 = { "type": "array", "items": { "type": "string" }, "uniqueItems": true, "default": [] };
+const schema5 = { "type": "string", "pattern": "^[A-Za-z_][-A-Za-z0-9._]*$" };
+const schema2 = { "type": "string", "format": "uri-reference" };
+const schema1 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://json-schema.org/draft/2020-12/meta/core", "$vocabulary": { "https://json-schema.org/draft/2020-12/vocab/core": true }, "$dynamicAnchor": "meta", "title": "Core vocabulary meta-schema", "type": ["object", "boolean"], "properties": { "$id": { "$ref": "#/$defs/uriReferenceString", "$comment": "Non-empty fragments not allowed.", "pattern": "^[^#]*#?$" }, "$schema": { "$ref": "#/$defs/uriString" }, "$ref": { "$ref": "#/$defs/uriReferenceString" }, "$anchor": { "$ref": "#/$defs/anchorString" }, "$dynamicRef": { "$ref": "#/$defs/uriReferenceString" }, "$dynamicAnchor": { "$ref": "#/$defs/anchorString" }, "$vocabulary": { "type": "object", "propertyNames": { "$ref": "#/$defs/uriString" }, "additionalProperties": { "type": "boolean" } }, "$comment": { "type": "string" }, "$defs": { "type": "object", "additionalProperties": { "$dynamicRef": "#meta" } } }, "$defs": { "anchorString": { "type": "string", "pattern": "^[A-Za-z_][-A-Za-z0-9._]*$" }, "uriString": { "type": "string", "format": "uri" }, "uriReferenceString": { "type": "string", "format": "uri-reference" } } };
+const schema3 = { "type": "string", "format": "uri" };
+const pattern0 = new RegExp("^[^#]*#?$", "u");
+const pattern1 = new RegExp("^[A-Za-z_][-A-Za-z0-9._]*$", "u");
+function validate1(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+    /*# sourceURL="https://json-schema.org/draft/2020-12/meta/core" */ ;
+    let vErrors = null;
+    let errors = 0;
+    const evaluated0 = validate1.evaluated;
+    if (evaluated0.dynamicProps) {
+        evaluated0.props = undefined;
+    }
+    if (evaluated0.dynamicItems) {
+        evaluated0.items = undefined;
+    }
+    if ((!(data && typeof data == "object" && !Array.isArray(data))) && (typeof data !== "boolean")) {
+        const err0 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: schema1.type }, message: "must be object,boolean" };
+        if (vErrors === null) {
+            vErrors = [err0];
+        }
+        else {
+            vErrors.push(err0);
+        }
+        errors++;
+    }
+    if (!dynamicAnchors.meta) {
+        dynamicAnchors.meta = validate1;
+    }
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+        if (data.$id !== undefined) {
+            let data0 = data.$id;
+            if (!(typeof data0 === "string")) {
+                const err1 = { instancePath: instancePath + "/$id", schemaPath: "#/$defs/uriReferenceString/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                if (vErrors === null) {
+                    vErrors = [err1];
+                }
+                else {
+                    vErrors.push(err1);
+                }
+                errors++;
+            }
+            if (typeof data0 === "string") {
+                if (!pattern0.test(data0)) {
+                    const err2 = { instancePath: instancePath + "/$id", schemaPath: "#/properties/%24id/pattern", keyword: "pattern", params: { pattern: "^[^#]*#?$" }, message: "must match pattern \"" + "^[^#]*#?$" + "\"" };
+                    if (vErrors === null) {
+                        vErrors = [err2];
+                    }
+                    else {
+                        vErrors.push(err2);
+                    }
+                    errors++;
+                }
+            }
+        }
+        if (data.$schema !== undefined) {
+            if (!(typeof data.$schema === "string")) {
+                const err3 = { instancePath: instancePath + "/$schema", schemaPath: "#/$defs/uriString/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                if (vErrors === null) {
+                    vErrors = [err3];
+                }
+                else {
+                    vErrors.push(err3);
+                }
+                errors++;
+            }
+        }
+        if (data.$ref !== undefined) {
+            if (!(typeof data.$ref === "string")) {
+                const err4 = { instancePath: instancePath + "/$ref", schemaPath: "#/$defs/uriReferenceString/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                if (vErrors === null) {
+                    vErrors = [err4];
+                }
+                else {
+                    vErrors.push(err4);
+                }
+                errors++;
+            }
+        }
+        if (data.$anchor !== undefined) {
+            let data3 = data.$anchor;
+            if (typeof data3 === "string") {
+                if (!pattern1.test(data3)) {
+                    const err5 = { instancePath: instancePath + "/$anchor", schemaPath: "#/$defs/anchorString/pattern", keyword: "pattern", params: { pattern: "^[A-Za-z_][-A-Za-z0-9._]*$" }, message: "must match pattern \"" + "^[A-Za-z_][-A-Za-z0-9._]*$" + "\"" };
+                    if (vErrors === null) {
+                        vErrors = [err5];
+                    }
+                    else {
+                        vErrors.push(err5);
+                    }
+                    errors++;
+                }
+            }
+            else {
+                const err6 = { instancePath: instancePath + "/$anchor", schemaPath: "#/$defs/anchorString/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                if (vErrors === null) {
+                    vErrors = [err6];
+                }
+                else {
+                    vErrors.push(err6);
+                }
+                errors++;
+            }
+        }
+        if (data.$dynamicRef !== undefined) {
+            if (!(typeof data.$dynamicRef === "string")) {
+                const err7 = { instancePath: instancePath + "/$dynamicRef", schemaPath: "#/$defs/uriReferenceString/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                if (vErrors === null) {
+                    vErrors = [err7];
+                }
+                else {
+                    vErrors.push(err7);
+                }
+                errors++;
+            }
+        }
+        if (data.$dynamicAnchor !== undefined) {
+            let data5 = data.$dynamicAnchor;
+            if (typeof data5 === "string") {
+                if (!pattern1.test(data5)) {
+                    const err8 = { instancePath: instancePath + "/$dynamicAnchor", schemaPath: "#/$defs/anchorString/pattern", keyword: "pattern", params: { pattern: "^[A-Za-z_][-A-Za-z0-9._]*$" }, message: "must match pattern \"" + "^[A-Za-z_][-A-Za-z0-9._]*$" + "\"" };
+                    if (vErrors === null) {
+                        vErrors = [err8];
+                    }
+                    else {
+                        vErrors.push(err8);
+                    }
+                    errors++;
+                }
+            }
+            else {
+                const err9 = { instancePath: instancePath + "/$dynamicAnchor", schemaPath: "#/$defs/anchorString/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                if (vErrors === null) {
+                    vErrors = [err9];
+                }
+                else {
+                    vErrors.push(err9);
+                }
+                errors++;
+            }
+        }
+        if (data.$vocabulary !== undefined) {
+            let data6 = data.$vocabulary;
+            if (data6 && typeof data6 == "object" && !Array.isArray(data6)) {
+                for (const key0 in data6) {
+                    const _errs22 = errors;
+                    if (!(typeof key0 === "string")) {
+                        const err10 = { instancePath: instancePath + "/$vocabulary", schemaPath: "#/$defs/uriString/type", keyword: "type", params: { type: "string" }, message: "must be string", propertyName: key0 };
+                        if (vErrors === null) {
+                            vErrors = [err10];
+                        }
+                        else {
+                            vErrors.push(err10);
+                        }
+                        errors++;
+                    }
+                    var valid7 = _errs22 === errors;
+                    if (!valid7) {
+                        const err11 = { instancePath: instancePath + "/$vocabulary", schemaPath: "#/properties/%24vocabulary/propertyNames", keyword: "propertyNames", params: { propertyName: key0 }, message: "property name must be valid" };
+                        if (vErrors === null) {
+                            vErrors = [err11];
+                        }
+                        else {
+                            vErrors.push(err11);
+                        }
+                        errors++;
+                    }
+                }
+                for (const key1 in data6) {
+                    if (typeof data6[key1] !== "boolean") {
+                        const err12 = { instancePath: instancePath + "/$vocabulary/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/properties/%24vocabulary/additionalProperties/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" };
+                        if (vErrors === null) {
+                            vErrors = [err12];
+                        }
+                        else {
+                            vErrors.push(err12);
+                        }
+                        errors++;
+                    }
+                }
+            }
+            else {
+                const err13 = { instancePath: instancePath + "/$vocabulary", schemaPath: "#/properties/%24vocabulary/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                if (vErrors === null) {
+                    vErrors = [err13];
+                }
+                else {
+                    vErrors.push(err13);
+                }
+                errors++;
+            }
+        }
+        if (data.$comment !== undefined) {
+            if (typeof data.$comment !== "string") {
+                const err14 = { instancePath: instancePath + "/$comment", schemaPath: "#/properties/%24comment/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                if (vErrors === null) {
+                    vErrors = [err14];
+                }
+                else {
+                    vErrors.push(err14);
+                }
+                errors++;
+            }
+        }
+        if (data.$defs !== undefined) {
+            let data9 = data.$defs;
+            if (data9 && typeof data9 == "object" && !Array.isArray(data9)) {
+                for (const key2 in data9) {
+                    let data10 = data9[key2];
+                    let _v0 = dynamicAnchors.meta;
+                    if (_v0) {
+                        if (!(_v0(data10, { instancePath: instancePath + "/$defs/" + key2.replace(/~/g, "~0").replace(/\//g, "~1"), parentData: data9, parentDataProperty: key2, rootData, dynamicAnchors }))) {
+                            vErrors = vErrors === null ? _v0.errors : vErrors.concat(_v0.errors);
+                            errors = vErrors.length;
+                        }
+                        else {
+                            var props0 = _v0.evaluated.props;
+                            var items0 = _v0.evaluated.items;
+                        }
+                    }
+                    else {
+                        if (!(validate1(data10, { instancePath: instancePath + "/$defs/" + key2.replace(/~/g, "~0").replace(/\//g, "~1"), parentData: data9, parentDataProperty: key2, rootData, dynamicAnchors }))) {
+                            vErrors = vErrors === null ? validate1.errors : vErrors.concat(validate1.errors);
+                            errors = vErrors.length;
+                        }
+                        else {
+                            var props1 = validate1.evaluated.props;
+                            if (props0 !== true && props1 !== undefined) {
+                                if (props1 === true) {
+                                    props0 = true;
+                                }
+                                else {
+                                    props0 = props0 || {};
+                                    Object.assign(props0, props1);
+                                }
+                            }
+                            var items1 = validate1.evaluated.items;
+                            if (items0 !== true && items1 !== undefined) {
+                                items0 = items1 === true ? true : items0 > items1 ? items0 : items1;
+                            }
+                        }
+                    }
+                }
+            }
+            else {
+                const err15 = { instancePath: instancePath + "/$defs", schemaPath: "#/properties/%24defs/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                if (vErrors === null) {
+                    vErrors = [err15];
+                }
+                else {
+                    vErrors.push(err15);
+                }
+                errors++;
+            }
+        }
+    }
+    validate1.errors = vErrors;
+    return errors === 0;
+}
+validate1.evaluated = { "props": { "$id": true, "$schema": true, "$ref": true, "$anchor": true, "$dynamicRef": true, "$dynamicAnchor": true, "$vocabulary": true, "$comment": true, "$defs": true }, "dynamicProps": false, "dynamicItems": false };
+const schema9 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://json-schema.org/draft/2020-12/meta/applicator", "$vocabulary": { "https://json-schema.org/draft/2020-12/vocab/applicator": true }, "$dynamicAnchor": "meta", "title": "Applicator vocabulary meta-schema", "type": ["object", "boolean"], "properties": { "prefixItems": { "$ref": "#/$defs/schemaArray" }, "items": { "$dynamicRef": "#meta" }, "contains": { "$dynamicRef": "#meta" }, "additionalProperties": { "$dynamicRef": "#meta" }, "properties": { "type": "object", "additionalProperties": { "$dynamicRef": "#meta" }, "default": {} }, "patternProperties": { "type": "object", "additionalProperties": { "$dynamicRef": "#meta" }, "propertyNames": { "format": "regex" }, "default": {} }, "dependentSchemas": { "type": "object", "additionalProperties": { "$dynamicRef": "#meta" }, "default": {} }, "propertyNames": { "$dynamicRef": "#meta" }, "if": { "$dynamicRef": "#meta" }, "then": { "$dynamicRef": "#meta" }, "else": { "$dynamicRef": "#meta" }, "allOf": { "$ref": "#/$defs/schemaArray" }, "anyOf": { "$ref": "#/$defs/schemaArray" }, "oneOf": { "$ref": "#/$defs/schemaArray" }, "not": { "$dynamicRef": "#meta" } }, "$defs": { "schemaArray": { "type": "array", "minItems": 1, "items": { "$dynamicRef": "#meta" } } } };
+const schema10 = { "type": "array", "minItems": 1, "items": { "$dynamicRef": "#meta" } };
+function validate4(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+    let vErrors = null;
+    let errors = 0;
+    const evaluated0 = validate4.evaluated;
+    if (evaluated0.dynamicProps) {
+        evaluated0.props = undefined;
+    }
+    if (evaluated0.dynamicItems) {
+        evaluated0.items = undefined;
+    }
+    if (Array.isArray(data)) {
+        if (data.length < 1) {
+            const err0 = { instancePath, schemaPath: "#/minItems", keyword: "minItems", params: { limit: 1 }, message: "must NOT have fewer than 1 items" };
+            if (vErrors === null) {
+                vErrors = [err0];
+            }
+            else {
+                vErrors.push(err0);
+            }
+            errors++;
+        }
+        const len0 = data.length;
+        for (let i0 = 0; i0 < len0; i0++) {
+            let data0 = data[i0];
+            let _v0 = dynamicAnchors.meta;
+            if (_v0) {
+                if (!(_v0(data0, { instancePath: instancePath + "/" + i0, parentData: data, parentDataProperty: i0, rootData, dynamicAnchors }))) {
+                    vErrors = vErrors === null ? _v0.errors : vErrors.concat(_v0.errors);
+                    errors = vErrors.length;
+                }
+                else {
+                    var props0 = _v0.evaluated.props;
+                    var items0 = _v0.evaluated.items;
+                }
+            }
+            else {
+                if (!(validate4(data0, { instancePath: instancePath + "/" + i0, parentData: data, parentDataProperty: i0, rootData, dynamicAnchors }))) {
+                    vErrors = vErrors === null ? validate4.errors : vErrors.concat(validate4.errors);
+                    errors = vErrors.length;
+                }
+                else {
+                    var props1 = validate4.evaluated.props;
+                    if (props0 !== true && props1 !== undefined) {
+                        if (props1 === true) {
+                            props0 = true;
+                        }
+                        else {
+                            props0 = props0 || {};
+                            Object.assign(props0, props1);
+                        }
+                    }
+                    var items1 = validate4.evaluated.items;
+                    if (items0 !== true && items1 !== undefined) {
+                        items0 = items1 === true ? true : items0 > items1 ? items0 : items1;
+                    }
+                }
+            }
+        }
+    }
+    else {
+        const err1 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+        if (vErrors === null) {
+            vErrors = [err1];
+        }
+        else {
+            vErrors.push(err1);
+        }
+        errors++;
+    }
+    validate4.errors = vErrors;
+    return errors === 0;
+}
+validate4.evaluated = { "items": true, "dynamicProps": false, "dynamicItems": false };
+function validate3(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+    /*# sourceURL="https://json-schema.org/draft/2020-12/meta/applicator" */ ;
+    let vErrors = null;
+    let errors = 0;
+    const evaluated0 = validate3.evaluated;
+    if (evaluated0.dynamicProps) {
+        evaluated0.props = undefined;
+    }
+    if (evaluated0.dynamicItems) {
+        evaluated0.items = undefined;
+    }
+    if ((!(data && typeof data == "object" && !Array.isArray(data))) && (typeof data !== "boolean")) {
+        const err0 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: schema9.type }, message: "must be object,boolean" };
+        if (vErrors === null) {
+            vErrors = [err0];
+        }
+        else {
+            vErrors.push(err0);
+        }
+        errors++;
+    }
+    if (!dynamicAnchors.meta) {
+        dynamicAnchors.meta = validate3;
+    }
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+        if (data.prefixItems !== undefined) {
+            if (!(validate4(data.prefixItems, { instancePath: instancePath + "/prefixItems", parentData: data, parentDataProperty: "prefixItems", rootData, dynamicAnchors }))) {
+                vErrors = vErrors === null ? validate4.errors : vErrors.concat(validate4.errors);
+                errors = vErrors.length;
+            }
+        }
+        if (data.items !== undefined) {
+            let data1 = data.items;
+            let _v0 = dynamicAnchors.meta;
+            if (_v0) {
+                if (!(_v0(data1, { instancePath: instancePath + "/items", parentData: data, parentDataProperty: "items", rootData, dynamicAnchors }))) {
+                    vErrors = vErrors === null ? _v0.errors : vErrors.concat(_v0.errors);
+                    errors = vErrors.length;
+                }
+                else {
+                    var props0 = _v0.evaluated.props;
+                    var items0 = _v0.evaluated.items;
+                }
+            }
+            else {
+                if (!(validate3(data1, { instancePath: instancePath + "/items", parentData: data, parentDataProperty: "items", rootData, dynamicAnchors }))) {
+                    vErrors = vErrors === null ? validate3.errors : vErrors.concat(validate3.errors);
+                    errors = vErrors.length;
+                }
+                else {
+                    var props1 = validate3.evaluated.props;
+                    if (props0 !== true && props1 !== undefined) {
+                        if (props1 === true) {
+                            props0 = true;
+                        }
+                        else {
+                            props0 = props0 || {};
+                            Object.assign(props0, props1);
+                        }
+                    }
+                    var items1 = validate3.evaluated.items;
+                    if (items0 !== true && items1 !== undefined) {
+                        items0 = items1 === true ? true : items0 > items1 ? items0 : items1;
+                    }
+                }
+            }
+        }
+        if (data.contains !== undefined) {
+            let data2 = data.contains;
+            let _v1 = dynamicAnchors.meta;
+            if (_v1) {
+                if (!(_v1(data2, { instancePath: instancePath + "/contains", parentData: data, parentDataProperty: "contains", rootData, dynamicAnchors }))) {
+                    vErrors = vErrors === null ? _v1.errors : vErrors.concat(_v1.errors);
+                    errors = vErrors.length;
+                }
+                else {
+                    var props2 = _v1.evaluated.props;
+                    var items2 = _v1.evaluated.items;
+                }
+            }
+            else {
+                if (!(validate3(data2, { instancePath: instancePath + "/contains", parentData: data, parentDataProperty: "contains", rootData, dynamicAnchors }))) {
+                    vErrors = vErrors === null ? validate3.errors : vErrors.concat(validate3.errors);
+                    errors = vErrors.length;
+                }
+                else {
+                    var props3 = validate3.evaluated.props;
+                    if (props2 !== true && props3 !== undefined) {
+                        if (props3 === true) {
+                            props2 = true;
+                        }
+                        else {
+                            props2 = props2 || {};
+                            Object.assign(props2, props3);
+                        }
+                    }
+                    var items3 = validate3.evaluated.items;
+                    if (items2 !== true && items3 !== undefined) {
+                        items2 = items3 === true ? true : items2 > items3 ? items2 : items3;
+                    }
+                }
+            }
+        }
+        if (data.additionalProperties !== undefined) {
+            let data3 = data.additionalProperties;
+            let _v2 = dynamicAnchors.meta;
+            if (_v2) {
+                if (!(_v2(data3, { instancePath: instancePath + "/additionalProperties", parentData: data, parentDataProperty: "additionalProperties", rootData, dynamicAnchors }))) {
+                    vErrors = vErrors === null ? _v2.errors : vErrors.concat(_v2.errors);
+                    errors = vErrors.length;
+                }
+                else {
+                    var props4 = _v2.evaluated.props;
+                    var items4 = _v2.evaluated.items;
+                }
+            }
+            else {
+                if (!(validate3(data3, { instancePath: instancePath + "/additionalProperties", parentData: data, parentDataProperty: "additionalProperties", rootData, dynamicAnchors }))) {
+                    vErrors = vErrors === null ? validate3.errors : vErrors.concat(validate3.errors);
+                    errors = vErrors.length;
+                }
+                else {
+                    var props5 = validate3.evaluated.props;
+                    if (props4 !== true && props5 !== undefined) {
+                        if (props5 === true) {
+                            props4 = true;
+                        }
+                        else {
+                            props4 = props4 || {};
+                            Object.assign(props4, props5);
+                        }
+                    }
+                    var items5 = validate3.evaluated.items;
+                    if (items4 !== true && items5 !== undefined) {
+                        items4 = items5 === true ? true : items4 > items5 ? items4 : items5;
+                    }
+                }
+            }
+        }
+        if (data.properties !== undefined) {
+            let data4 = data.properties;
+            if (data4 && typeof data4 == "object" && !Array.isArray(data4)) {
+                for (const key0 in data4) {
+                    let data5 = data4[key0];
+                    let _v3 = dynamicAnchors.meta;
+                    if (_v3) {
+                        if (!(_v3(data5, { instancePath: instancePath + "/properties/" + key0.replace(/~/g, "~0").replace(/\//g, "~1"), parentData: data4, parentDataProperty: key0, rootData, dynamicAnchors }))) {
+                            vErrors = vErrors === null ? _v3.errors : vErrors.concat(_v3.errors);
+                            errors = vErrors.length;
+                        }
+                        else {
+                            var props6 = _v3.evaluated.props;
+                            var items6 = _v3.evaluated.items;
+                        }
+                    }
+                    else {
+                        if (!(validate3(data5, { instancePath: instancePath + "/properties/" + key0.replace(/~/g, "~0").replace(/\//g, "~1"), parentData: data4, parentDataProperty: key0, rootData, dynamicAnchors }))) {
+                            vErrors = vErrors === null ? validate3.errors : vErrors.concat(validate3.errors);
+                            errors = vErrors.length;
+                        }
+                        else {
+                            var props7 = validate3.evaluated.props;
+                            if (props6 !== true && props7 !== undefined) {
+                                if (props7 === true) {
+                                    props6 = true;
+                                }
+                                else {
+                                    props6 = props6 || {};
+                                    Object.assign(props6, props7);
+                                }
+                            }
+                            var items7 = validate3.evaluated.items;
+                            if (items6 !== true && items7 !== undefined) {
+                                items6 = items7 === true ? true : items6 > items7 ? items6 : items7;
+                            }
+                        }
+                    }
+                }
+            }
+            else {
+                const err1 = { instancePath: instancePath + "/properties", schemaPath: "#/properties/properties/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                if (vErrors === null) {
+                    vErrors = [err1];
+                }
+                else {
+                    vErrors.push(err1);
+                }
+                errors++;
+            }
+        }
+        if (data.patternProperties !== undefined) {
+            let data6 = data.patternProperties;
+            if (data6 && typeof data6 == "object" && !Array.isArray(data6)) {
+                for (const key1 in data6) {
+                    const _errs11 = errors;
+                    var valid2 = _errs11 === errors;
+                    if (!valid2) {
+                        const err2 = { instancePath: instancePath + "/patternProperties", schemaPath: "#/properties/patternProperties/propertyNames", keyword: "propertyNames", params: { propertyName: key1 }, message: "property name must be valid" };
+                        if (vErrors === null) {
+                            vErrors = [err2];
+                        }
+                        else {
+                            vErrors.push(err2);
+                        }
+                        errors++;
+                    }
+                }
+                for (const key2 in data6) {
+                    let data7 = data6[key2];
+                    let _v4 = dynamicAnchors.meta;
+                    if (_v4) {
+                        if (!(_v4(data7, { instancePath: instancePath + "/patternProperties/" + key2.replace(/~/g, "~0").replace(/\//g, "~1"), parentData: data6, parentDataProperty: key2, rootData, dynamicAnchors }))) {
+                            vErrors = vErrors === null ? _v4.errors : vErrors.concat(_v4.errors);
+                            errors = vErrors.length;
+                        }
+                        else {
+                            var props8 = _v4.evaluated.props;
+                            var items8 = _v4.evaluated.items;
+                        }
+                    }
+                    else {
+                        if (!(validate3(data7, { instancePath: instancePath + "/patternProperties/" + key2.replace(/~/g, "~0").replace(/\//g, "~1"), parentData: data6, parentDataProperty: key2, rootData, dynamicAnchors }))) {
+                            vErrors = vErrors === null ? validate3.errors : vErrors.concat(validate3.errors);
+                            errors = vErrors.length;
+                        }
+                        else {
+                            var props9 = validate3.evaluated.props;
+                            if (props8 !== true && props9 !== undefined) {
+                                if (props9 === true) {
+                                    props8 = true;
+                                }
+                                else {
+                                    props8 = props8 || {};
+                                    Object.assign(props8, props9);
+                                }
+                            }
+                            var items9 = validate3.evaluated.items;
+                            if (items8 !== true && items9 !== undefined) {
+                                items8 = items9 === true ? true : items8 > items9 ? items8 : items9;
+                            }
+                        }
+                    }
+                }
+            }
+            else {
+                const err3 = { instancePath: instancePath + "/patternProperties", schemaPath: "#/properties/patternProperties/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                if (vErrors === null) {
+                    vErrors = [err3];
+                }
+                else {
+                    vErrors.push(err3);
+                }
+                errors++;
+            }
+        }
+        if (data.dependentSchemas !== undefined) {
+            let data8 = data.dependentSchemas;
+            if (data8 && typeof data8 == "object" && !Array.isArray(data8)) {
+                for (const key3 in data8) {
+                    let data9 = data8[key3];
+                    let _v5 = dynamicAnchors.meta;
+                    if (_v5) {
+                        if (!(_v5(data9, { instancePath: instancePath + "/dependentSchemas/" + key3.replace(/~/g, "~0").replace(/\//g, "~1"), parentData: data8, parentDataProperty: key3, rootData, dynamicAnchors }))) {
+                            vErrors = vErrors === null ? _v5.errors : vErrors.concat(_v5.errors);
+                            errors = vErrors.length;
+                        }
+                        else {
+                            var props10 = _v5.evaluated.props;
+                            var items10 = _v5.evaluated.items;
+                        }
+                    }
+                    else {
+                        if (!(validate3(data9, { instancePath: instancePath + "/dependentSchemas/" + key3.replace(/~/g, "~0").replace(/\//g, "~1"), parentData: data8, parentDataProperty: key3, rootData, dynamicAnchors }))) {
+                            vErrors = vErrors === null ? validate3.errors : vErrors.concat(validate3.errors);
+                            errors = vErrors.length;
+                        }
+                        else {
+                            var props11 = validate3.evaluated.props;
+                            if (props10 !== true && props11 !== undefined) {
+                                if (props11 === true) {
+                                    props10 = true;
+                                }
+                                else {
+                                    props10 = props10 || {};
+                                    Object.assign(props10, props11);
+                                }
+                            }
+                            var items11 = validate3.evaluated.items;
+                            if (items10 !== true && items11 !== undefined) {
+                                items10 = items11 === true ? true : items10 > items11 ? items10 : items11;
+                            }
+                        }
+                    }
+                }
+            }
+            else {
+                const err4 = { instancePath: instancePath + "/dependentSchemas", schemaPath: "#/properties/dependentSchemas/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                if (vErrors === null) {
+                    vErrors = [err4];
+                }
+                else {
+                    vErrors.push(err4);
+                }
+                errors++;
+            }
+        }
+        if (data.propertyNames !== undefined) {
+            let data10 = data.propertyNames;
+            let _v6 = dynamicAnchors.meta;
+            if (_v6) {
+                if (!(_v6(data10, { instancePath: instancePath + "/propertyNames", parentData: data, parentDataProperty: "propertyNames", rootData, dynamicAnchors }))) {
+                    vErrors = vErrors === null ? _v6.errors : vErrors.concat(_v6.errors);
+                    errors = vErrors.length;
+                }
+                else {
+                    var props12 = _v6.evaluated.props;
+                    var items12 = _v6.evaluated.items;
+                }
+            }
+            else {
+                if (!(validate3(data10, { instancePath: instancePath + "/propertyNames", parentData: data, parentDataProperty: "propertyNames", rootData, dynamicAnchors }))) {
+                    vErrors = vErrors === null ? validate3.errors : vErrors.concat(validate3.errors);
+                    errors = vErrors.length;
+                }
+                else {
+                    var props13 = validate3.evaluated.props;
+                    if (props12 !== true && props13 !== undefined) {
+                        if (props13 === true) {
+                            props12 = true;
+                        }
+                        else {
+                            props12 = props12 || {};
+                            Object.assign(props12, props13);
+                        }
+                    }
+                    var items13 = validate3.evaluated.items;
+                    if (items12 !== true && items13 !== undefined) {
+                        items12 = items13 === true ? true : items12 > items13 ? items12 : items13;
+                    }
+                }
+            }
+        }
+        if (data.if !== undefined) {
+            let data11 = data.if;
+            let _v7 = dynamicAnchors.meta;
+            if (_v7) {
+                if (!(_v7(data11, { instancePath: instancePath + "/if", parentData: data, parentDataProperty: "if", rootData, dynamicAnchors }))) {
+                    vErrors = vErrors === null ? _v7.errors : vErrors.concat(_v7.errors);
+                    errors = vErrors.length;
+                }
+                else {
+                    var props14 = _v7.evaluated.props;
+                    var items14 = _v7.evaluated.items;
+                }
+            }
+            else {
+                if (!(validate3(data11, { instancePath: instancePath + "/if", parentData: data, parentDataProperty: "if", rootData, dynamicAnchors }))) {
+                    vErrors = vErrors === null ? validate3.errors : vErrors.concat(validate3.errors);
+                    errors = vErrors.length;
+                }
+                else {
+                    var props15 = validate3.evaluated.props;
+                    if (props14 !== true && props15 !== undefined) {
+                        if (props15 === true) {
+                            props14 = true;
+                        }
+                        else {
+                            props14 = props14 || {};
+                            Object.assign(props14, props15);
+                        }
+                    }
+                    var items15 = validate3.evaluated.items;
+                    if (items14 !== true && items15 !== undefined) {
+                        items14 = items15 === true ? true : items14 > items15 ? items14 : items15;
+                    }
+                }
+            }
+        }
+        if (data.then !== undefined) {
+            let data12 = data.then;
+            let _v8 = dynamicAnchors.meta;
+            if (_v8) {
+                if (!(_v8(data12, { instancePath: instancePath + "/then", parentData: data, parentDataProperty: "then", rootData, dynamicAnchors }))) {
+                    vErrors = vErrors === null ? _v8.errors : vErrors.concat(_v8.errors);
+                    errors = vErrors.length;
+                }
+                else {
+                    var props16 = _v8.evaluated.props;
+                    var items16 = _v8.evaluated.items;
+                }
+            }
+            else {
+                if (!(validate3(data12, { instancePath: instancePath + "/then", parentData: data, parentDataProperty: "then", rootData, dynamicAnchors }))) {
+                    vErrors = vErrors === null ? validate3.errors : vErrors.concat(validate3.errors);
+                    errors = vErrors.length;
+                }
+                else {
+                    var props17 = validate3.evaluated.props;
+                    if (props16 !== true && props17 !== undefined) {
+                        if (props17 === true) {
+                            props16 = true;
+                        }
+                        else {
+                            props16 = props16 || {};
+                            Object.assign(props16, props17);
+                        }
+                    }
+                    var items17 = validate3.evaluated.items;
+                    if (items16 !== true && items17 !== undefined) {
+                        items16 = items17 === true ? true : items16 > items17 ? items16 : items17;
+                    }
+                }
+            }
+        }
+        if (data.else !== undefined) {
+            let data13 = data.else;
+            let _v9 = dynamicAnchors.meta;
+            if (_v9) {
+                if (!(_v9(data13, { instancePath: instancePath + "/else", parentData: data, parentDataProperty: "else", rootData, dynamicAnchors }))) {
+                    vErrors = vErrors === null ? _v9.errors : vErrors.concat(_v9.errors);
+                    errors = vErrors.length;
+                }
+                else {
+                    var props18 = _v9.evaluated.props;
+                    var items18 = _v9.evaluated.items;
+                }
+            }
+            else {
+                if (!(validate3(data13, { instancePath: instancePath + "/else", parentData: data, parentDataProperty: "else", rootData, dynamicAnchors }))) {
+                    vErrors = vErrors === null ? validate3.errors : vErrors.concat(validate3.errors);
+                    errors = vErrors.length;
+                }
+                else {
+                    var props19 = validate3.evaluated.props;
+                    if (props18 !== true && props19 !== undefined) {
+                        if (props19 === true) {
+                            props18 = true;
+                        }
+                        else {
+                            props18 = props18 || {};
+                            Object.assign(props18, props19);
+                        }
+                    }
+                    var items19 = validate3.evaluated.items;
+                    if (items18 !== true && items19 !== undefined) {
+                        items18 = items19 === true ? true : items18 > items19 ? items18 : items19;
+                    }
+                }
+            }
+        }
+        if (data.allOf !== undefined) {
+            if (!(validate4(data.allOf, { instancePath: instancePath + "/allOf", parentData: data, parentDataProperty: "allOf", rootData, dynamicAnchors }))) {
+                vErrors = vErrors === null ? validate4.errors : vErrors.concat(validate4.errors);
+                errors = vErrors.length;
+            }
+        }
+        if (data.anyOf !== undefined) {
+            if (!(validate4(data.anyOf, { instancePath: instancePath + "/anyOf", parentData: data, parentDataProperty: "anyOf", rootData, dynamicAnchors }))) {
+                vErrors = vErrors === null ? validate4.errors : vErrors.concat(validate4.errors);
+                errors = vErrors.length;
+            }
+        }
+        if (data.oneOf !== undefined) {
+            if (!(validate4(data.oneOf, { instancePath: instancePath + "/oneOf", parentData: data, parentDataProperty: "oneOf", rootData, dynamicAnchors }))) {
+                vErrors = vErrors === null ? validate4.errors : vErrors.concat(validate4.errors);
+                errors = vErrors.length;
+            }
+        }
+        if (data.not !== undefined) {
+            let data17 = data.not;
+            let _v10 = dynamicAnchors.meta;
+            if (_v10) {
+                if (!(_v10(data17, { instancePath: instancePath + "/not", parentData: data, parentDataProperty: "not", rootData, dynamicAnchors }))) {
+                    vErrors = vErrors === null ? _v10.errors : vErrors.concat(_v10.errors);
+                    errors = vErrors.length;
+                }
+                else {
+                    var props20 = _v10.evaluated.props;
+                    var items20 = _v10.evaluated.items;
+                }
+            }
+            else {
+                if (!(validate3(data17, { instancePath: instancePath + "/not", parentData: data, parentDataProperty: "not", rootData, dynamicAnchors }))) {
+                    vErrors = vErrors === null ? validate3.errors : vErrors.concat(validate3.errors);
+                    errors = vErrors.length;
+                }
+                else {
+                    var props21 = validate3.evaluated.props;
+                    if (props20 !== true && props21 !== undefined) {
+                        if (props21 === true) {
+                            props20 = true;
+                        }
+                        else {
+                            props20 = props20 || {};
+                            Object.assign(props20, props21);
+                        }
+                    }
+                    var items21 = validate3.evaluated.items;
+                    if (items20 !== true && items21 !== undefined) {
+                        items20 = items21 === true ? true : items20 > items21 ? items20 : items21;
+                    }
+                }
+            }
+        }
+    }
+    validate3.errors = vErrors;
+    return errors === 0;
+}
+validate3.evaluated = { "props": { "prefixItems": true, "items": true, "contains": true, "additionalProperties": true, "properties": true, "patternProperties": true, "dependentSchemas": true, "propertyNames": true, "if": true, "then": true, "else": true, "allOf": true, "anyOf": true, "oneOf": true, "not": true }, "dynamicProps": false, "dynamicItems": false };
+const schema11 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://json-schema.org/draft/2020-12/meta/unevaluated", "$vocabulary": { "https://json-schema.org/draft/2020-12/vocab/unevaluated": true }, "$dynamicAnchor": "meta", "title": "Unevaluated applicator vocabulary meta-schema", "type": ["object", "boolean"], "properties": { "unevaluatedItems": { "$dynamicRef": "#meta" }, "unevaluatedProperties": { "$dynamicRef": "#meta" } } };
+function validate10(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+    /*# sourceURL="https://json-schema.org/draft/2020-12/meta/unevaluated" */ ;
+    let vErrors = null;
+    let errors = 0;
+    const evaluated0 = validate10.evaluated;
+    if (evaluated0.dynamicProps) {
+        evaluated0.props = undefined;
+    }
+    if (evaluated0.dynamicItems) {
+        evaluated0.items = undefined;
+    }
+    if ((!(data && typeof data == "object" && !Array.isArray(data))) && (typeof data !== "boolean")) {
+        const err0 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: schema11.type }, message: "must be object,boolean" };
+        if (vErrors === null) {
+            vErrors = [err0];
+        }
+        else {
+            vErrors.push(err0);
+        }
+        errors++;
+    }
+    if (!dynamicAnchors.meta) {
+        dynamicAnchors.meta = validate10;
+    }
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+        if (data.unevaluatedItems !== undefined) {
+            let data0 = data.unevaluatedItems;
+            let _v0 = dynamicAnchors.meta;
+            if (_v0) {
+                if (!(_v0(data0, { instancePath: instancePath + "/unevaluatedItems", parentData: data, parentDataProperty: "unevaluatedItems", rootData, dynamicAnchors }))) {
+                    vErrors = vErrors === null ? _v0.errors : vErrors.concat(_v0.errors);
+                    errors = vErrors.length;
+                }
+                else {
+                    var props0 = _v0.evaluated.props;
+                    var items0 = _v0.evaluated.items;
+                }
+            }
+            else {
+                if (!(validate10(data0, { instancePath: instancePath + "/unevaluatedItems", parentData: data, parentDataProperty: "unevaluatedItems", rootData, dynamicAnchors }))) {
+                    vErrors = vErrors === null ? validate10.errors : vErrors.concat(validate10.errors);
+                    errors = vErrors.length;
+                }
+                else {
+                    var props1 = validate10.evaluated.props;
+                    if (props0 !== true && props1 !== undefined) {
+                        if (props1 === true) {
+                            props0 = true;
+                        }
+                        else {
+                            props0 = props0 || {};
+                            Object.assign(props0, props1);
+                        }
+                    }
+                    var items1 = validate10.evaluated.items;
+                    if (items0 !== true && items1 !== undefined) {
+                        items0 = items1 === true ? true : items0 > items1 ? items0 : items1;
+                    }
+                }
+            }
+        }
+        if (data.unevaluatedProperties !== undefined) {
+            let data1 = data.unevaluatedProperties;
+            let _v1 = dynamicAnchors.meta;
+            if (_v1) {
+                if (!(_v1(data1, { instancePath: instancePath + "/unevaluatedProperties", parentData: data, parentDataProperty: "unevaluatedProperties", rootData, dynamicAnchors }))) {
+                    vErrors = vErrors === null ? _v1.errors : vErrors.concat(_v1.errors);
+                    errors = vErrors.length;
+                }
+                else {
+                    var props2 = _v1.evaluated.props;
+                    var items2 = _v1.evaluated.items;
+                }
+            }
+            else {
+                if (!(validate10(data1, { instancePath: instancePath + "/unevaluatedProperties", parentData: data, parentDataProperty: "unevaluatedProperties", rootData, dynamicAnchors }))) {
+                    vErrors = vErrors === null ? validate10.errors : vErrors.concat(validate10.errors);
+                    errors = vErrors.length;
+                }
+                else {
+                    var props3 = validate10.evaluated.props;
+                    if (props2 !== true && props3 !== undefined) {
+                        if (props3 === true) {
+                            props2 = true;
+                        }
+                        else {
+                            props2 = props2 || {};
+                            Object.assign(props2, props3);
+                        }
+                    }
+                    var items3 = validate10.evaluated.items;
+                    if (items2 !== true && items3 !== undefined) {
+                        items2 = items3 === true ? true : items2 > items3 ? items2 : items3;
+                    }
+                }
+            }
+        }
+    }
+    validate10.errors = vErrors;
+    return errors === 0;
+}
+validate10.evaluated = { "props": { "unevaluatedItems": true, "unevaluatedProperties": true }, "dynamicProps": false, "dynamicItems": false };
+const schema12 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://json-schema.org/draft/2020-12/meta/validation", "$vocabulary": { "https://json-schema.org/draft/2020-12/vocab/validation": true }, "$dynamicAnchor": "meta", "title": "Validation vocabulary meta-schema", "type": ["object", "boolean"], "properties": { "type": { "anyOf": [{ "$ref": "#/$defs/simpleTypes" }, { "type": "array", "items": { "$ref": "#/$defs/simpleTypes" }, "minItems": 1, "uniqueItems": true }] }, "const": true, "enum": { "type": "array", "items": true }, "multipleOf": { "type": "number", "exclusiveMinimum": 0 }, "maximum": { "type": "number" }, "exclusiveMaximum": { "type": "number" }, "minimum": { "type": "number" }, "exclusiveMinimum": { "type": "number" }, "maxLength": { "$ref": "#/$defs/nonNegativeInteger" }, "minLength": { "$ref": "#/$defs/nonNegativeIntegerDefault0" }, "pattern": { "type": "string", "format": "regex" }, "maxItems": { "$ref": "#/$defs/nonNegativeInteger" }, "minItems": { "$ref": "#/$defs/nonNegativeIntegerDefault0" }, "uniqueItems": { "type": "boolean", "default": false }, "maxContains": { "$ref": "#/$defs/nonNegativeInteger" }, "minContains": { "$ref": "#/$defs/nonNegativeInteger", "default": 1 }, "maxProperties": { "$ref": "#/$defs/nonNegativeInteger" }, "minProperties": { "$ref": "#/$defs/nonNegativeIntegerDefault0" }, "required": { "$ref": "#/$defs/stringArray" }, "dependentRequired": { "type": "object", "additionalProperties": { "$ref": "#/$defs/stringArray" } } }, "$defs": { "nonNegativeInteger": { "type": "integer", "minimum": 0 }, "nonNegativeIntegerDefault0": { "$ref": "#/$defs/nonNegativeInteger", "default": 0 }, "simpleTypes": { "enum": ["array", "boolean", "integer", "null", "number", "object", "string"] }, "stringArray": { "type": "array", "items": { "type": "string" }, "uniqueItems": true, "default": [] } } };
+const schema13 = { "enum": ["array", "boolean", "integer", "null", "number", "object", "string"] };
+const schema15 = { "type": "integer", "minimum": 0 };
+import { equal as func0 } from "../../../../value/index.js";
+function validate12(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+    /*# sourceURL="https://json-schema.org/draft/2020-12/meta/validation" */ ;
+    let vErrors = null;
+    let errors = 0;
+    const evaluated0 = validate12.evaluated;
+    if (evaluated0.dynamicProps) {
+        evaluated0.props = undefined;
+    }
+    if (evaluated0.dynamicItems) {
+        evaluated0.items = undefined;
+    }
+    if ((!(data && typeof data == "object" && !Array.isArray(data))) && (typeof data !== "boolean")) {
+        const err0 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: schema12.type }, message: "must be object,boolean" };
+        if (vErrors === null) {
+            vErrors = [err0];
+        }
+        else {
+            vErrors.push(err0);
+        }
+        errors++;
+    }
+    if (!dynamicAnchors.meta) {
+        dynamicAnchors.meta = validate12;
+    }
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+        if (data.type !== undefined) {
+            let data0 = data.type;
+            const _errs2 = errors;
+            let valid1 = false;
+            const _errs3 = errors;
+            if (!(((((((data0 === "array") || (data0 === "boolean")) || (data0 === "integer")) || (data0 === "null")) || (data0 === "number")) || (data0 === "object")) || (data0 === "string"))) {
+                const err1 = { instancePath: instancePath + "/type", schemaPath: "#/$defs/simpleTypes/enum", keyword: "enum", params: { allowedValues: schema13.enum }, message: "must be equal to one of the allowed values" };
+                if (vErrors === null) {
+                    vErrors = [err1];
+                }
+                else {
+                    vErrors.push(err1);
+                }
+                errors++;
+            }
+            var _valid0 = _errs3 === errors;
+            valid1 = valid1 || _valid0;
+            const _errs5 = errors;
+            if (Array.isArray(data0)) {
+                if (data0.length < 1) {
+                    const err2 = { instancePath: instancePath + "/type", schemaPath: "#/properties/type/anyOf/1/minItems", keyword: "minItems", params: { limit: 1 }, message: "must NOT have fewer than 1 items" };
+                    if (vErrors === null) {
+                        vErrors = [err2];
+                    }
+                    else {
+                        vErrors.push(err2);
+                    }
+                    errors++;
+                }
+                const len0 = data0.length;
+                for (let i0 = 0; i0 < len0; i0++) {
+                    let data1 = data0[i0];
+                    if (!(((((((data1 === "array") || (data1 === "boolean")) || (data1 === "integer")) || (data1 === "null")) || (data1 === "number")) || (data1 === "object")) || (data1 === "string"))) {
+                        const err3 = { instancePath: instancePath + "/type/" + i0, schemaPath: "#/$defs/simpleTypes/enum", keyword: "enum", params: { allowedValues: schema13.enum }, message: "must be equal to one of the allowed values" };
+                        if (vErrors === null) {
+                            vErrors = [err3];
+                        }
+                        else {
+                            vErrors.push(err3);
+                        }
+                        errors++;
+                    }
+                }
+                let i1 = data0.length;
+                let j0;
+                if (i1 > 1) {
+                    outer0: for (; i1--;) {
+                        for (j0 = i1; j0--;) {
+                            if (func0(data0[i1], data0[j0])) {
+                                const err4 = { instancePath: instancePath + "/type", schemaPath: "#/properties/type/anyOf/1/uniqueItems", keyword: "uniqueItems", params: { i: i1, j: j0 }, message: "must NOT have duplicate items (items ## " + j0 + " and " + i1 + " are identical)" };
+                                if (vErrors === null) {
+                                    vErrors = [err4];
+                                }
+                                else {
+                                    vErrors.push(err4);
+                                }
+                                errors++;
+                                break outer0;
+                            }
+                        }
+                    }
+                }
+            }
+            else {
+                const err5 = { instancePath: instancePath + "/type", schemaPath: "#/properties/type/anyOf/1/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+                if (vErrors === null) {
+                    vErrors = [err5];
+                }
+                else {
+                    vErrors.push(err5);
+                }
+                errors++;
+            }
+            var _valid0 = _errs5 === errors;
+            valid1 = valid1 || _valid0;
+            if (!valid1) {
+                const err6 = { instancePath: instancePath + "/type", schemaPath: "#/properties/type/anyOf", keyword: "anyOf", params: {}, message: "must match a schema in anyOf" };
+                if (vErrors === null) {
+                    vErrors = [err6];
+                }
+                else {
+                    vErrors.push(err6);
+                }
+                errors++;
+            }
+            else {
+                errors = _errs2;
+                if (vErrors !== null) {
+                    if (_errs2) {
+                        vErrors.length = _errs2;
+                    }
+                    else {
+                        vErrors = null;
+                    }
+                }
+            }
+        }
+        if (data.enum !== undefined) {
+            if (!(Array.isArray(data.enum))) {
+                const err7 = { instancePath: instancePath + "/enum", schemaPath: "#/properties/enum/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+                if (vErrors === null) {
+                    vErrors = [err7];
+                }
+                else {
+                    vErrors.push(err7);
+                }
+                errors++;
+            }
+        }
+        if (data.multipleOf !== undefined) {
+            let data3 = data.multipleOf;
+            if (typeof data3 == "number") {
+                if (data3 <= 0 || isNaN(data3)) {
+                    const err8 = { instancePath: instancePath + "/multipleOf", schemaPath: "#/properties/multipleOf/exclusiveMinimum", keyword: "exclusiveMinimum", params: { comparison: ">", limit: 0 }, message: "must be > 0" };
+                    if (vErrors === null) {
+                        vErrors = [err8];
+                    }
+                    else {
+                        vErrors.push(err8);
+                    }
+                    errors++;
+                }
+            }
+            else {
+                const err9 = { instancePath: instancePath + "/multipleOf", schemaPath: "#/properties/multipleOf/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                if (vErrors === null) {
+                    vErrors = [err9];
+                }
+                else {
+                    vErrors.push(err9);
+                }
+                errors++;
+            }
+        }
+        if (data.maximum !== undefined) {
+            if (!(typeof data.maximum == "number")) {
+                const err10 = { instancePath: instancePath + "/maximum", schemaPath: "#/properties/maximum/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                if (vErrors === null) {
+                    vErrors = [err10];
+                }
+                else {
+                    vErrors.push(err10);
+                }
+                errors++;
+            }
+        }
+        if (data.exclusiveMaximum !== undefined) {
+            if (!(typeof data.exclusiveMaximum == "number")) {
+                const err11 = { instancePath: instancePath + "/exclusiveMaximum", schemaPath: "#/properties/exclusiveMaximum/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                if (vErrors === null) {
+                    vErrors = [err11];
+                }
+                else {
+                    vErrors.push(err11);
+                }
+                errors++;
+            }
+        }
+        if (data.minimum !== undefined) {
+            if (!(typeof data.minimum == "number")) {
+                const err12 = { instancePath: instancePath + "/minimum", schemaPath: "#/properties/minimum/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                if (vErrors === null) {
+                    vErrors = [err12];
+                }
+                else {
+                    vErrors.push(err12);
+                }
+                errors++;
+            }
+        }
+        if (data.exclusiveMinimum !== undefined) {
+            if (!(typeof data.exclusiveMinimum == "number")) {
+                const err13 = { instancePath: instancePath + "/exclusiveMinimum", schemaPath: "#/properties/exclusiveMinimum/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                if (vErrors === null) {
+                    vErrors = [err13];
+                }
+                else {
+                    vErrors.push(err13);
+                }
+                errors++;
+            }
+        }
+        if (data.maxLength !== undefined) {
+            let data8 = data.maxLength;
+            if (!((typeof data8 == "number") && (!(data8 % 1) && !isNaN(data8)))) {
+                const err14 = { instancePath: instancePath + "/maxLength", schemaPath: "#/$defs/nonNegativeInteger/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
+                if (vErrors === null) {
+                    vErrors = [err14];
+                }
+                else {
+                    vErrors.push(err14);
+                }
+                errors++;
+            }
+            if (typeof data8 == "number") {
+                if (data8 < 0 || isNaN(data8)) {
+                    const err15 = { instancePath: instancePath + "/maxLength", schemaPath: "#/$defs/nonNegativeInteger/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
+                    if (vErrors === null) {
+                        vErrors = [err15];
+                    }
+                    else {
+                        vErrors.push(err15);
+                    }
+                    errors++;
+                }
+            }
+        }
+        if (data.minLength !== undefined) {
+            let data9 = data.minLength;
+            if (!((typeof data9 == "number") && (!(data9 % 1) && !isNaN(data9)))) {
+                const err16 = { instancePath: instancePath + "/minLength", schemaPath: "#/$defs/nonNegativeIntegerDefault0/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
+                if (vErrors === null) {
+                    vErrors = [err16];
+                }
+                else {
+                    vErrors.push(err16);
+                }
+                errors++;
+            }
+            if (typeof data9 == "number") {
+                if (data9 < 0 || isNaN(data9)) {
+                    const err17 = { instancePath: instancePath + "/minLength", schemaPath: "#/$defs/nonNegativeIntegerDefault0/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
+                    if (vErrors === null) {
+                        vErrors = [err17];
+                    }
+                    else {
+                        vErrors.push(err17);
+                    }
+                    errors++;
+                }
+            }
+        }
+        if (data.pattern !== undefined) {
+            if (!(typeof data.pattern === "string")) {
+                const err18 = { instancePath: instancePath + "/pattern", schemaPath: "#/properties/pattern/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                if (vErrors === null) {
+                    vErrors = [err18];
+                }
+                else {
+                    vErrors.push(err18);
+                }
+                errors++;
+            }
+        }
+        if (data.maxItems !== undefined) {
+            let data11 = data.maxItems;
+            if (!((typeof data11 == "number") && (!(data11 % 1) && !isNaN(data11)))) {
+                const err19 = { instancePath: instancePath + "/maxItems", schemaPath: "#/$defs/nonNegativeInteger/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
+                if (vErrors === null) {
+                    vErrors = [err19];
+                }
+                else {
+                    vErrors.push(err19);
+                }
+                errors++;
+            }
+            if (typeof data11 == "number") {
+                if (data11 < 0 || isNaN(data11)) {
+                    const err20 = { instancePath: instancePath + "/maxItems", schemaPath: "#/$defs/nonNegativeInteger/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
+                    if (vErrors === null) {
+                        vErrors = [err20];
+                    }
+                    else {
+                        vErrors.push(err20);
+                    }
+                    errors++;
+                }
+            }
+        }
+        if (data.minItems !== undefined) {
+            let data12 = data.minItems;
+            if (!((typeof data12 == "number") && (!(data12 % 1) && !isNaN(data12)))) {
+                const err21 = { instancePath: instancePath + "/minItems", schemaPath: "#/$defs/nonNegativeIntegerDefault0/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
+                if (vErrors === null) {
+                    vErrors = [err21];
+                }
+                else {
+                    vErrors.push(err21);
+                }
+                errors++;
+            }
+            if (typeof data12 == "number") {
+                if (data12 < 0 || isNaN(data12)) {
+                    const err22 = { instancePath: instancePath + "/minItems", schemaPath: "#/$defs/nonNegativeIntegerDefault0/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
+                    if (vErrors === null) {
+                        vErrors = [err22];
+                    }
+                    else {
+                        vErrors.push(err22);
+                    }
+                    errors++;
+                }
+            }
+        }
+        if (data.uniqueItems !== undefined) {
+            if (typeof data.uniqueItems !== "boolean") {
+                const err23 = { instancePath: instancePath + "/uniqueItems", schemaPath: "#/properties/uniqueItems/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" };
+                if (vErrors === null) {
+                    vErrors = [err23];
+                }
+                else {
+                    vErrors.push(err23);
+                }
+                errors++;
+            }
+        }
+        if (data.maxContains !== undefined) {
+            let data14 = data.maxContains;
+            if (!((typeof data14 == "number") && (!(data14 % 1) && !isNaN(data14)))) {
+                const err24 = { instancePath: instancePath + "/maxContains", schemaPath: "#/$defs/nonNegativeInteger/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
+                if (vErrors === null) {
+                    vErrors = [err24];
+                }
+                else {
+                    vErrors.push(err24);
+                }
+                errors++;
+            }
+            if (typeof data14 == "number") {
+                if (data14 < 0 || isNaN(data14)) {
+                    const err25 = { instancePath: instancePath + "/maxContains", schemaPath: "#/$defs/nonNegativeInteger/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
+                    if (vErrors === null) {
+                        vErrors = [err25];
+                    }
+                    else {
+                        vErrors.push(err25);
+                    }
+                    errors++;
+                }
+            }
+        }
+        if (data.minContains !== undefined) {
+            let data15 = data.minContains;
+            if (!((typeof data15 == "number") && (!(data15 % 1) && !isNaN(data15)))) {
+                const err26 = { instancePath: instancePath + "/minContains", schemaPath: "#/$defs/nonNegativeInteger/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
+                if (vErrors === null) {
+                    vErrors = [err26];
+                }
+                else {
+                    vErrors.push(err26);
+                }
+                errors++;
+            }
+            if (typeof data15 == "number") {
+                if (data15 < 0 || isNaN(data15)) {
+                    const err27 = { instancePath: instancePath + "/minContains", schemaPath: "#/$defs/nonNegativeInteger/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
+                    if (vErrors === null) {
+                        vErrors = [err27];
+                    }
+                    else {
+                        vErrors.push(err27);
+                    }
+                    errors++;
+                }
+            }
+        }
+        if (data.maxProperties !== undefined) {
+            let data16 = data.maxProperties;
+            if (!((typeof data16 == "number") && (!(data16 % 1) && !isNaN(data16)))) {
+                const err28 = { instancePath: instancePath + "/maxProperties", schemaPath: "#/$defs/nonNegativeInteger/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
+                if (vErrors === null) {
+                    vErrors = [err28];
+                }
+                else {
+                    vErrors.push(err28);
+                }
+                errors++;
+            }
+            if (typeof data16 == "number") {
+                if (data16 < 0 || isNaN(data16)) {
+                    const err29 = { instancePath: instancePath + "/maxProperties", schemaPath: "#/$defs/nonNegativeInteger/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
+                    if (vErrors === null) {
+                        vErrors = [err29];
+                    }
+                    else {
+                        vErrors.push(err29);
+                    }
+                    errors++;
+                }
+            }
+        }
+        if (data.minProperties !== undefined) {
+            let data17 = data.minProperties;
+            if (!((typeof data17 == "number") && (!(data17 % 1) && !isNaN(data17)))) {
+                const err30 = { instancePath: instancePath + "/minProperties", schemaPath: "#/$defs/nonNegativeIntegerDefault0/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
+                if (vErrors === null) {
+                    vErrors = [err30];
+                }
+                else {
+                    vErrors.push(err30);
+                }
+                errors++;
+            }
+            if (typeof data17 == "number") {
+                if (data17 < 0 || isNaN(data17)) {
+                    const err31 = { instancePath: instancePath + "/minProperties", schemaPath: "#/$defs/nonNegativeIntegerDefault0/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
+                    if (vErrors === null) {
+                        vErrors = [err31];
+                    }
+                    else {
+                        vErrors.push(err31);
+                    }
+                    errors++;
+                }
+            }
+        }
+        if (data.required !== undefined) {
+            let data18 = data.required;
+            if (Array.isArray(data18)) {
+                const len1 = data18.length;
+                for (let i2 = 0; i2 < len1; i2++) {
+                    if (typeof data18[i2] !== "string") {
+                        const err32 = { instancePath: instancePath + "/required/" + i2, schemaPath: "#/$defs/stringArray/items/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                        if (vErrors === null) {
+                            vErrors = [err32];
+                        }
+                        else {
+                            vErrors.push(err32);
+                        }
+                        errors++;
+                    }
+                }
+                let i3 = data18.length;
+                let j1;
+                if (i3 > 1) {
+                    const indices0 = {};
+                    for (; i3--;) {
+                        let item0 = data18[i3];
+                        if (typeof item0 !== "string") {
+                            continue;
+                        }
+                        if (typeof indices0[item0] == "number") {
+                            j1 = indices0[item0];
+                            const err33 = { instancePath: instancePath + "/required", schemaPath: "#/$defs/stringArray/uniqueItems", keyword: "uniqueItems", params: { i: i3, j: j1 }, message: "must NOT have duplicate items (items ## " + j1 + " and " + i3 + " are identical)" };
+                            if (vErrors === null) {
+                                vErrors = [err33];
+                            }
+                            else {
+                                vErrors.push(err33);
+                            }
+                            errors++;
+                            break;
+                        }
+                        indices0[item0] = i3;
+                    }
+                }
+            }
+            else {
+                const err34 = { instancePath: instancePath + "/required", schemaPath: "#/$defs/stringArray/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+                if (vErrors === null) {
+                    vErrors = [err34];
+                }
+                else {
+                    vErrors.push(err34);
+                }
+                errors++;
+            }
+        }
+        if (data.dependentRequired !== undefined) {
+            let data20 = data.dependentRequired;
+            if (data20 && typeof data20 == "object" && !Array.isArray(data20)) {
+                for (const key0 in data20) {
+                    let data21 = data20[key0];
+                    if (Array.isArray(data21)) {
+                        const len2 = data21.length;
+                        for (let i4 = 0; i4 < len2; i4++) {
+                            if (typeof data21[i4] !== "string") {
+                                const err35 = { instancePath: instancePath + "/dependentRequired/" + key0.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + i4, schemaPath: "#/$defs/stringArray/items/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                                if (vErrors === null) {
+                                    vErrors = [err35];
+                                }
+                                else {
+                                    vErrors.push(err35);
+                                }
+                                errors++;
+                            }
+                        }
+                        let i5 = data21.length;
+                        let j2;
+                        if (i5 > 1) {
+                            const indices1 = {};
+                            for (; i5--;) {
+                                let item1 = data21[i5];
+                                if (typeof item1 !== "string") {
+                                    continue;
+                                }
+                                if (typeof indices1[item1] == "number") {
+                                    j2 = indices1[item1];
+                                    const err36 = { instancePath: instancePath + "/dependentRequired/" + key0.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/$defs/stringArray/uniqueItems", keyword: "uniqueItems", params: { i: i5, j: j2 }, message: "must NOT have duplicate items (items ## " + j2 + " and " + i5 + " are identical)" };
+                                    if (vErrors === null) {
+                                        vErrors = [err36];
+                                    }
+                                    else {
+                                        vErrors.push(err36);
+                                    }
+                                    errors++;
+                                    break;
+                                }
+                                indices1[item1] = i5;
+                            }
+                        }
+                    }
+                    else {
+                        const err37 = { instancePath: instancePath + "/dependentRequired/" + key0.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/$defs/stringArray/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+                        if (vErrors === null) {
+                            vErrors = [err37];
+                        }
+                        else {
+                            vErrors.push(err37);
+                        }
+                        errors++;
+                    }
+                }
+            }
+            else {
+                const err38 = { instancePath: instancePath + "/dependentRequired", schemaPath: "#/properties/dependentRequired/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                if (vErrors === null) {
+                    vErrors = [err38];
+                }
+                else {
+                    vErrors.push(err38);
+                }
+                errors++;
+            }
+        }
+    }
+    validate12.errors = vErrors;
+    return errors === 0;
+}
+validate12.evaluated = { "props": { "type": true, "const": true, "enum": true, "multipleOf": true, "maximum": true, "exclusiveMaximum": true, "minimum": true, "exclusiveMinimum": true, "maxLength": true, "minLength": true, "pattern": true, "maxItems": true, "minItems": true, "uniqueItems": true, "maxContains": true, "minContains": true, "maxProperties": true, "minProperties": true, "required": true, "dependentRequired": true }, "dynamicProps": false, "dynamicItems": false };
+const schema25 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://json-schema.org/draft/2020-12/meta/meta-data", "$vocabulary": { "https://json-schema.org/draft/2020-12/vocab/meta-data": true }, "$dynamicAnchor": "meta", "title": "Meta-data vocabulary meta-schema", "type": ["object", "boolean"], "properties": { "title": { "type": "string" }, "description": { "type": "string" }, "default": true, "deprecated": { "type": "boolean", "default": false }, "readOnly": { "type": "boolean", "default": false }, "writeOnly": { "type": "boolean", "default": false }, "examples": { "type": "array", "items": true } } };
+function validate14(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+    /*# sourceURL="https://json-schema.org/draft/2020-12/meta/meta-data" */ ;
+    let vErrors = null;
+    let errors = 0;
+    const evaluated0 = validate14.evaluated;
+    if (evaluated0.dynamicProps) {
+        evaluated0.props = undefined;
+    }
+    if (evaluated0.dynamicItems) {
+        evaluated0.items = undefined;
+    }
+    if ((!(data && typeof data == "object" && !Array.isArray(data))) && (typeof data !== "boolean")) {
+        const err0 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: schema25.type }, message: "must be object,boolean" };
+        if (vErrors === null) {
+            vErrors = [err0];
+        }
+        else {
+            vErrors.push(err0);
+        }
+        errors++;
+    }
+    if (!dynamicAnchors.meta) {
+        dynamicAnchors.meta = validate14;
+    }
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+        if (data.title !== undefined) {
+            if (typeof data.title !== "string") {
+                const err1 = { instancePath: instancePath + "/title", schemaPath: "#/properties/title/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                if (vErrors === null) {
+                    vErrors = [err1];
+                }
+                else {
+                    vErrors.push(err1);
+                }
+                errors++;
+            }
+        }
+        if (data.description !== undefined) {
+            if (typeof data.description !== "string") {
+                const err2 = { instancePath: instancePath + "/description", schemaPath: "#/properties/description/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                if (vErrors === null) {
+                    vErrors = [err2];
+                }
+                else {
+                    vErrors.push(err2);
+                }
+                errors++;
+            }
+        }
+        if (data.deprecated !== undefined) {
+            if (typeof data.deprecated !== "boolean") {
+                const err3 = { instancePath: instancePath + "/deprecated", schemaPath: "#/properties/deprecated/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" };
+                if (vErrors === null) {
+                    vErrors = [err3];
+                }
+                else {
+                    vErrors.push(err3);
+                }
+                errors++;
+            }
+        }
+        if (data.readOnly !== undefined) {
+            if (typeof data.readOnly !== "boolean") {
+                const err4 = { instancePath: instancePath + "/readOnly", schemaPath: "#/properties/readOnly/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" };
+                if (vErrors === null) {
+                    vErrors = [err4];
+                }
+                else {
+                    vErrors.push(err4);
+                }
+                errors++;
+            }
+        }
+        if (data.writeOnly !== undefined) {
+            if (typeof data.writeOnly !== "boolean") {
+                const err5 = { instancePath: instancePath + "/writeOnly", schemaPath: "#/properties/writeOnly/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" };
+                if (vErrors === null) {
+                    vErrors = [err5];
+                }
+                else {
+                    vErrors.push(err5);
+                }
+                errors++;
+            }
+        }
+        if (data.examples !== undefined) {
+            if (!(Array.isArray(data.examples))) {
+                const err6 = { instancePath: instancePath + "/examples", schemaPath: "#/properties/examples/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+                if (vErrors === null) {
+                    vErrors = [err6];
+                }
+                else {
+                    vErrors.push(err6);
+                }
+                errors++;
+            }
+        }
+    }
+    validate14.errors = vErrors;
+    return errors === 0;
+}
+validate14.evaluated = { "props": { "title": true, "description": true, "default": true, "deprecated": true, "readOnly": true, "writeOnly": true, "examples": true }, "dynamicProps": false, "dynamicItems": false };
+const schema26 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://json-schema.org/draft/2020-12/meta/format-annotation", "$vocabulary": { "https://json-schema.org/draft/2020-12/vocab/format-annotation": true }, "$dynamicAnchor": "meta", "title": "Format vocabulary meta-schema for annotation results", "type": ["object", "boolean"], "properties": { "format": { "type": "string" } } };
+function validate16(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+    /*# sourceURL="https://json-schema.org/draft/2020-12/meta/format-annotation" */ ;
+    let vErrors = null;
+    let errors = 0;
+    const evaluated0 = validate16.evaluated;
+    if (evaluated0.dynamicProps) {
+        evaluated0.props = undefined;
+    }
+    if (evaluated0.dynamicItems) {
+        evaluated0.items = undefined;
+    }
+    if ((!(data && typeof data == "object" && !Array.isArray(data))) && (typeof data !== "boolean")) {
+        const err0 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: schema26.type }, message: "must be object,boolean" };
+        if (vErrors === null) {
+            vErrors = [err0];
+        }
+        else {
+            vErrors.push(err0);
+        }
+        errors++;
+    }
+    if (!dynamicAnchors.meta) {
+        dynamicAnchors.meta = validate16;
+    }
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+        if (data.format !== undefined) {
+            if (typeof data.format !== "string") {
+                const err1 = { instancePath: instancePath + "/format", schemaPath: "#/properties/format/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                if (vErrors === null) {
+                    vErrors = [err1];
+                }
+                else {
+                    vErrors.push(err1);
+                }
+                errors++;
+            }
+        }
+    }
+    validate16.errors = vErrors;
+    return errors === 0;
+}
+validate16.evaluated = { "props": { "format": true }, "dynamicProps": false, "dynamicItems": false };
+const schema27 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://json-schema.org/draft/2020-12/meta/content", "$vocabulary": { "https://json-schema.org/draft/2020-12/vocab/content": true }, "$dynamicAnchor": "meta", "title": "Content vocabulary meta-schema", "type": ["object", "boolean"], "properties": { "contentEncoding": { "type": "string" }, "contentMediaType": { "type": "string" }, "contentSchema": { "$dynamicRef": "#meta" } } };
+function validate18(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+    /*# sourceURL="https://json-schema.org/draft/2020-12/meta/content" */ ;
+    let vErrors = null;
+    let errors = 0;
+    const evaluated0 = validate18.evaluated;
+    if (evaluated0.dynamicProps) {
+        evaluated0.props = undefined;
+    }
+    if (evaluated0.dynamicItems) {
+        evaluated0.items = undefined;
+    }
+    if ((!(data && typeof data == "object" && !Array.isArray(data))) && (typeof data !== "boolean")) {
+        const err0 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: schema27.type }, message: "must be object,boolean" };
+        if (vErrors === null) {
+            vErrors = [err0];
+        }
+        else {
+            vErrors.push(err0);
+        }
+        errors++;
+    }
+    if (!dynamicAnchors.meta) {
+        dynamicAnchors.meta = validate18;
+    }
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+        if (data.contentEncoding !== undefined) {
+            if (typeof data.contentEncoding !== "string") {
+                const err1 = { instancePath: instancePath + "/contentEncoding", schemaPath: "#/properties/contentEncoding/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                if (vErrors === null) {
+                    vErrors = [err1];
+                }
+                else {
+                    vErrors.push(err1);
+                }
+                errors++;
+            }
+        }
+        if (data.contentMediaType !== undefined) {
+            if (typeof data.contentMediaType !== "string") {
+                const err2 = { instancePath: instancePath + "/contentMediaType", schemaPath: "#/properties/contentMediaType/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                if (vErrors === null) {
+                    vErrors = [err2];
+                }
+                else {
+                    vErrors.push(err2);
+                }
+                errors++;
+            }
+        }
+        if (data.contentSchema !== undefined) {
+            let data2 = data.contentSchema;
+            let _v0 = dynamicAnchors.meta;
+            if (_v0) {
+                if (!(_v0(data2, { instancePath: instancePath + "/contentSchema", parentData: data, parentDataProperty: "contentSchema", rootData, dynamicAnchors }))) {
+                    vErrors = vErrors === null ? _v0.errors : vErrors.concat(_v0.errors);
+                    errors = vErrors.length;
+                }
+                else {
+                    var props0 = _v0.evaluated.props;
+                    var items0 = _v0.evaluated.items;
+                }
+            }
+            else {
+                if (!(validate18(data2, { instancePath: instancePath + "/contentSchema", parentData: data, parentDataProperty: "contentSchema", rootData, dynamicAnchors }))) {
+                    vErrors = vErrors === null ? validate18.errors : vErrors.concat(validate18.errors);
+                    errors = vErrors.length;
+                }
+                else {
+                    var props1 = validate18.evaluated.props;
+                    if (props0 !== true && props1 !== undefined) {
+                        if (props1 === true) {
+                            props0 = true;
+                        }
+                        else {
+                            props0 = props0 || {};
+                            Object.assign(props0, props1);
+                        }
+                    }
+                    var items1 = validate18.evaluated.items;
+                    if (items0 !== true && items1 !== undefined) {
+                        items0 = items1 === true ? true : items0 > items1 ? items0 : items1;
+                    }
+                }
+            }
+        }
+    }
+    validate18.errors = vErrors;
+    return errors === 0;
+}
+validate18.evaluated = { "props": { "contentEncoding": true, "contentMediaType": true, "contentSchema": true }, "dynamicProps": false, "dynamicItems": false };
+function validate0(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+    /*# sourceURL="https://json-schema.org/draft/2020-12/schema" */ ;
+    let vErrors = null;
+    let errors = 0;
+    const evaluated0 = validate0.evaluated;
+    if (evaluated0.dynamicProps) {
+        evaluated0.props = undefined;
+    }
+    if (evaluated0.dynamicItems) {
+        evaluated0.items = undefined;
+    }
+    if ((!(data && typeof data == "object" && !Array.isArray(data))) && (typeof data !== "boolean")) {
+        const err0 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: schema0.type }, message: "must be object,boolean" };
+        if (vErrors === null) {
+            vErrors = [err0];
+        }
+        else {
+            vErrors.push(err0);
+        }
+        errors++;
+    }
+    if (!dynamicAnchors.meta) {
+        dynamicAnchors.meta = validate0;
+    }
+    if (!(validate1(data, { instancePath, parentData, parentDataProperty, rootData, dynamicAnchors }))) {
+        vErrors = vErrors === null ? validate1.errors : vErrors.concat(validate1.errors);
+        errors = vErrors.length;
+    }
+    if (!(validate3(data, { instancePath, parentData, parentDataProperty, rootData, dynamicAnchors }))) {
+        vErrors = vErrors === null ? validate3.errors : vErrors.concat(validate3.errors);
+        errors = vErrors.length;
+    }
+    if (!(validate10(data, { instancePath, parentData, parentDataProperty, rootData, dynamicAnchors }))) {
+        vErrors = vErrors === null ? validate10.errors : vErrors.concat(validate10.errors);
+        errors = vErrors.length;
+    }
+    if (!(validate12(data, { instancePath, parentData, parentDataProperty, rootData, dynamicAnchors }))) {
+        vErrors = vErrors === null ? validate12.errors : vErrors.concat(validate12.errors);
+        errors = vErrors.length;
+    }
+    if (!(validate14(data, { instancePath, parentData, parentDataProperty, rootData, dynamicAnchors }))) {
+        vErrors = vErrors === null ? validate14.errors : vErrors.concat(validate14.errors);
+        errors = vErrors.length;
+    }
+    if (!(validate16(data, { instancePath, parentData, parentDataProperty, rootData, dynamicAnchors }))) {
+        vErrors = vErrors === null ? validate16.errors : vErrors.concat(validate16.errors);
+        errors = vErrors.length;
+    }
+    if (!(validate18(data, { instancePath, parentData, parentDataProperty, rootData, dynamicAnchors }))) {
+        vErrors = vErrors === null ? validate18.errors : vErrors.concat(validate18.errors);
+        errors = vErrors.length;
+    }
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+        if (data.definitions !== undefined) {
+            let data0 = data.definitions;
+            if (data0 && typeof data0 == "object" && !Array.isArray(data0)) {
+                for (const key0 in data0) {
+                    let data1 = data0[key0];
+                    let _v0 = dynamicAnchors.meta;
+                    if (_v0) {
+                        if (!(_v0(data1, { instancePath: instancePath + "/definitions/" + key0.replace(/~/g, "~0").replace(/\//g, "~1"), parentData: data0, parentDataProperty: key0, rootData, dynamicAnchors }))) {
+                            vErrors = vErrors === null ? _v0.errors : vErrors.concat(_v0.errors);
+                            errors = vErrors.length;
+                        }
+                        else {
+                            var props0 = _v0.evaluated.props;
+                            var items0 = _v0.evaluated.items;
+                        }
+                    }
+                    else {
+                        if (!(validate0(data1, { instancePath: instancePath + "/definitions/" + key0.replace(/~/g, "~0").replace(/\//g, "~1"), parentData: data0, parentDataProperty: key0, rootData, dynamicAnchors }))) {
+                            vErrors = vErrors === null ? validate0.errors : vErrors.concat(validate0.errors);
+                            errors = vErrors.length;
+                        }
+                        else {
+                            var props1 = validate0.evaluated.props;
+                            if (props0 !== true && props1 !== undefined) {
+                                if (props1 === true) {
+                                    props0 = true;
+                                }
+                                else {
+                                    props0 = props0 || {};
+                                    Object.assign(props0, props1);
+                                }
+                            }
+                            var items1 = validate0.evaluated.items;
+                            if (items0 !== true && items1 !== undefined) {
+                                items0 = items1 === true ? true : items0 > items1 ? items0 : items1;
+                            }
+                        }
+                    }
+                }
+            }
+            else {
+                const err1 = { instancePath: instancePath + "/definitions", schemaPath: "#/properties/definitions/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                if (vErrors === null) {
+                    vErrors = [err1];
+                }
+                else {
+                    vErrors.push(err1);
+                }
+                errors++;
+            }
+        }
+        if (data.dependencies !== undefined) {
+            let data2 = data.dependencies;
+            if (data2 && typeof data2 == "object" && !Array.isArray(data2)) {
+                for (const key1 in data2) {
+                    let data3 = data2[key1];
+                    const _errs19 = errors;
+                    let valid4 = false;
+                    const _errs20 = errors;
+                    let _v1 = dynamicAnchors.meta;
+                    if (_v1) {
+                        if (!(_v1(data3, { instancePath: instancePath + "/dependencies/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"), parentData: data2, parentDataProperty: key1, rootData, dynamicAnchors }))) {
+                            vErrors = vErrors === null ? _v1.errors : vErrors.concat(_v1.errors);
+                            errors = vErrors.length;
+                        }
+                        else {
+                            var props2 = _v1.evaluated.props;
+                            var items2 = _v1.evaluated.items;
+                        }
+                    }
+                    else {
+                        if (!(validate0(data3, { instancePath: instancePath + "/dependencies/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"), parentData: data2, parentDataProperty: key1, rootData, dynamicAnchors }))) {
+                            vErrors = vErrors === null ? validate0.errors : vErrors.concat(validate0.errors);
+                            errors = vErrors.length;
+                        }
+                        else {
+                            var props3 = validate0.evaluated.props;
+                            if (props2 !== true && props3 !== undefined) {
+                                if (props3 === true) {
+                                    props2 = true;
+                                }
+                                else {
+                                    props2 = props2 || {};
+                                    Object.assign(props2, props3);
+                                }
+                            }
+                            var items3 = validate0.evaluated.items;
+                            if (items2 !== true && items3 !== undefined) {
+                                items2 = items3 === true ? true : items2 > items3 ? items2 : items3;
+                            }
+                        }
+                    }
+                    var _valid0 = _errs20 === errors;
+                    valid4 = valid4 || _valid0;
+                    const _errs21 = errors;
+                    if (Array.isArray(data3)) {
+                        const len0 = data3.length;
+                        for (let i0 = 0; i0 < len0; i0++) {
+                            if (typeof data3[i0] !== "string") {
+                                const err2 = { instancePath: instancePath + "/dependencies/" + key1.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + i0, schemaPath: "meta/validation#/$defs/stringArray/items/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                                if (vErrors === null) {
+                                    vErrors = [err2];
+                                }
+                                else {
+                                    vErrors.push(err2);
+                                }
+                                errors++;
+                            }
+                        }
+                        let i1 = data3.length;
+                        let j0;
+                        if (i1 > 1) {
+                            const indices0 = {};
+                            for (; i1--;) {
+                                let item0 = data3[i1];
+                                if (typeof item0 !== "string") {
+                                    continue;
+                                }
+                                if (typeof indices0[item0] == "number") {
+                                    j0 = indices0[item0];
+                                    const err3 = { instancePath: instancePath + "/dependencies/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "meta/validation#/$defs/stringArray/uniqueItems", keyword: "uniqueItems", params: { i: i1, j: j0 }, message: "must NOT have duplicate items (items ## " + j0 + " and " + i1 + " are identical)" };
+                                    if (vErrors === null) {
+                                        vErrors = [err3];
+                                    }
+                                    else {
+                                        vErrors.push(err3);
+                                    }
+                                    errors++;
+                                    break;
+                                }
+                                indices0[item0] = i1;
+                            }
+                        }
+                    }
+                    else {
+                        const err4 = { instancePath: instancePath + "/dependencies/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "meta/validation#/$defs/stringArray/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+                        if (vErrors === null) {
+                            vErrors = [err4];
+                        }
+                        else {
+                            vErrors.push(err4);
+                        }
+                        errors++;
+                    }
+                    var _valid0 = _errs21 === errors;
+                    valid4 = valid4 || _valid0;
+                    if (_valid0) {
+                        if (items2 !== true) {
+                            items2 = true;
+                        }
+                    }
+                    if (!valid4) {
+                        const err5 = { instancePath: instancePath + "/dependencies/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/properties/dependencies/additionalProperties/anyOf", keyword: "anyOf", params: {}, message: "must match a schema in anyOf" };
+                        if (vErrors === null) {
+                            vErrors = [err5];
+                        }
+                        else {
+                            vErrors.push(err5);
+                        }
+                        errors++;
+                    }
+                    else {
+                        errors = _errs19;
+                        if (vErrors !== null) {
+                            if (_errs19) {
+                                vErrors.length = _errs19;
+                            }
+                            else {
+                                vErrors = null;
+                            }
+                        }
+                    }
+                }
+            }
+            else {
+                const err6 = { instancePath: instancePath + "/dependencies", schemaPath: "#/properties/dependencies/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                if (vErrors === null) {
+                    vErrors = [err6];
+                }
+                else {
+                    vErrors.push(err6);
+                }
+                errors++;
+            }
+        }
+        if (data.$recursiveAnchor !== undefined) {
+            let data5 = data.$recursiveAnchor;
+            if (typeof data5 === "string") {
+                if (!pattern1.test(data5)) {
+                    const err7 = { instancePath: instancePath + "/$recursiveAnchor", schemaPath: "meta/core#/$defs/anchorString/pattern", keyword: "pattern", params: { pattern: "^[A-Za-z_][-A-Za-z0-9._]*$" }, message: "must match pattern \"" + "^[A-Za-z_][-A-Za-z0-9._]*$" + "\"" };
+                    if (vErrors === null) {
+                        vErrors = [err7];
+                    }
+                    else {
+                        vErrors.push(err7);
+                    }
+                    errors++;
+                }
+            }
+            else {
+                const err8 = { instancePath: instancePath + "/$recursiveAnchor", schemaPath: "meta/core#/$defs/anchorString/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                if (vErrors === null) {
+                    vErrors = [err8];
+                }
+                else {
+                    vErrors.push(err8);
+                }
+                errors++;
+            }
+        }
+        if (data.$recursiveRef !== undefined) {
+            if (!(typeof data.$recursiveRef === "string")) {
+                const err9 = { instancePath: instancePath + "/$recursiveRef", schemaPath: "meta/core#/$defs/uriReferenceString/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                if (vErrors === null) {
+                    vErrors = [err9];
+                }
+                else {
+                    vErrors.push(err9);
+                }
+                errors++;
+            }
+        }
+    }
+    validate0.errors = vErrors;
+    return errors === 0;
+}
+validate0.evaluated = { "props": { "definitions": true, "dependencies": true, "$recursiveAnchor": true, "$recursiveRef": true, "contentEncoding": true, "contentMediaType": true, "contentSchema": true, "format": true, "title": true, "description": true, "default": true, "deprecated": true, "readOnly": true, "writeOnly": true, "examples": true, "type": true, "const": true, "enum": true, "multipleOf": true, "maximum": true, "exclusiveMaximum": true, "minimum": true, "exclusiveMinimum": true, "maxLength": true, "minLength": true, "pattern": true, "maxItems": true, "minItems": true, "uniqueItems": true, "maxContains": true, "minContains": true, "maxProperties": true, "minProperties": true, "required": true, "dependentRequired": true, "unevaluatedItems": true, "unevaluatedProperties": true, "prefixItems": true, "items": true, "contains": true, "additionalProperties": true, "properties": true, "patternProperties": true, "dependentSchemas": true, "propertyNames": true, "if": true, "then": true, "else": true, "allOf": true, "anyOf": true, "oneOf": true, "not": true, "$id": true, "$schema": true, "$ref": true, "$anchor": true, "$dynamicRef": true, "$dynamicAnchor": true, "$vocabulary": true, "$comment": true, "$defs": true }, "dynamicProps": false, "dynamicItems": false };
+function validate20(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+    /*# sourceURL="https://schemas.astrale.ai/dsl/v1/value-schema" */ ;
+    let vErrors = null;
+    let errors = 0;
+    const evaluated0 = validate20.evaluated;
+    if (evaluated0.dynamicProps) {
+        evaluated0.props = undefined;
+    }
+    if (evaluated0.dynamicItems) {
+        evaluated0.items = undefined;
+    }
+    if (!(validate0(data, { instancePath, parentData, parentDataProperty, rootData, dynamicAnchors }))) {
+        vErrors = vErrors === null ? validate0.errors : vErrors.concat(validate0.errors);
+        errors = vErrors.length;
+    }
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+        if (data.fullMatch !== undefined) {
+            if (typeof data.fullMatch !== "string") {
+                const err0 = { instancePath: instancePath + "/fullMatch", schemaPath: "#/properties/fullMatch/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                if (vErrors === null) {
+                    vErrors = [err0];
+                }
+                else {
+                    vErrors.push(err0);
+                }
+                errors++;
+            }
+        }
+        if (data["x-astrale-path"] !== undefined) {
+            let data1 = data["x-astrale-path"];
+            if (!(data1 && typeof data1 == "object" && !Array.isArray(data1))) {
+                const err1 = { instancePath: instancePath + "/x-astrale-path", schemaPath: "#/properties/x-astrale-path/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                if (vErrors === null) {
+                    vErrors = [err1];
+                }
+                else {
+                    vErrors.push(err1);
+                }
+                errors++;
+            }
+        }
+    }
+    validate20.errors = vErrors;
+    return errors === 0;
+}
+validate20.evaluated = { "props": { "fullMatch": true, "x-astrale-path": true, "definitions": true, "dependencies": true, "$recursiveAnchor": true, "$recursiveRef": true, "contentEncoding": true, "contentMediaType": true, "contentSchema": true, "format": true, "title": true, "description": true, "default": true, "deprecated": true, "readOnly": true, "writeOnly": true, "examples": true, "type": true, "const": true, "enum": true, "multipleOf": true, "maximum": true, "exclusiveMaximum": true, "minimum": true, "exclusiveMinimum": true, "maxLength": true, "minLength": true, "pattern": true, "maxItems": true, "minItems": true, "uniqueItems": true, "maxContains": true, "minContains": true, "maxProperties": true, "minProperties": true, "required": true, "dependentRequired": true, "unevaluatedItems": true, "unevaluatedProperties": true, "prefixItems": true, "items": true, "contains": true, "additionalProperties": true, "properties": true, "patternProperties": true, "dependentSchemas": true, "propertyNames": true, "if": true, "then": true, "else": true, "allOf": true, "anyOf": true, "oneOf": true, "not": true, "$id": true, "$schema": true, "$ref": true, "$anchor": true, "$dynamicRef": true, "$dynamicAnchor": true, "$vocabulary": true, "$comment": true, "$defs": true }, "dynamicProps": false, "dynamicItems": false };