@nocobase/plugin-flow-engine 2.1.0-alpha.13 → 2.1.0-alpha.14

package/dist/node_modules/ajv/dist/vocabularies/jtd/optionalProperties.d.ts

@@ -1,3 +0,0 @@
-import type { CodeKeywordDefinition } from "../../types";
-declare const def: CodeKeywordDefinition;
-export default def;

package/dist/node_modules/ajv/dist/vocabularies/jtd/optionalProperties.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const properties_1 = require("./properties");
-const def = {
-    keyword: "optionalProperties",
-    schemaType: "object",
-    error: properties_1.error,
-    code(cxt) {
-        if (cxt.parentSchema.properties)
-            return;
-        (0, properties_1.validateProperties)(cxt);
-    },
-};
-exports.default = def;
-//# sourceMappingURL=optionalProperties.js.map

package/dist/node_modules/ajv/dist/vocabularies/jtd/properties.d.ts

@@ -1,22 +0,0 @@
-import type { CodeKeywordDefinition, ErrorObject, KeywordErrorDefinition, SchemaObject } from "../../types";
-import type { KeywordCxt } from "../../compile/validate";
-import { _JTDTypeError } from "./error";
-declare enum PropError {
-    Additional = "additional",
-    Missing = "missing"
-}
-type PropKeyword = "properties" | "optionalProperties";
-type PropSchema = {
-    [P in string]?: SchemaObject;
-};
-export type JTDPropertiesError = _JTDTypeError<PropKeyword, "object", PropSchema> | ErrorObject<PropKeyword, {
-    error: PropError.Additional;
-    additionalProperty: string;
-}, PropSchema> | ErrorObject<PropKeyword, {
-    error: PropError.Missing;
-    missingProperty: string;
-}, PropSchema>;
-export declare const error: KeywordErrorDefinition;
-declare const def: CodeKeywordDefinition;
-export declare function validateProperties(cxt: KeywordCxt): void;
-export default def;

package/dist/node_modules/ajv/dist/vocabularies/jtd/properties.js

@@ -1,149 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateProperties = exports.error = void 0;
-const code_1 = require("../code");
-const util_1 = require("../../compile/util");
-const codegen_1 = require("../../compile/codegen");
-const metadata_1 = require("./metadata");
-const nullable_1 = require("./nullable");
-const error_1 = require("./error");
-var PropError;
-(function (PropError) {
-    PropError["Additional"] = "additional";
-    PropError["Missing"] = "missing";
-})(PropError || (PropError = {}));
-exports.error = {
-    message: (cxt) => {
-        const { params } = cxt;
-        return params.propError
-            ? params.propError === PropError.Additional
-                ? "must NOT have additional properties"
-                : `must have property '${params.missingProperty}'`
-            : (0, error_1.typeErrorMessage)(cxt, "object");
-    },
-    params: (cxt) => {
-        const { params } = cxt;
-        return params.propError
-            ? params.propError === PropError.Additional
-                ? (0, codegen_1._) `{error: ${params.propError}, additionalProperty: ${params.additionalProperty}}`
-                : (0, codegen_1._) `{error: ${params.propError}, missingProperty: ${params.missingProperty}}`
-            : (0, error_1.typeErrorParams)(cxt, "object");
-    },
-};
-const def = {
-    keyword: "properties",
-    schemaType: "object",
-    error: exports.error,
-    code: validateProperties,
-};
-// const error: KeywordErrorDefinition = {
-//   message: "should NOT have additional properties",
-//   params: ({params}) => _`{additionalProperty: ${params.additionalProperty}}`,
-// }
-function validateProperties(cxt) {
-    (0, metadata_1.checkMetadata)(cxt);
-    const { gen, data, parentSchema, it } = cxt;
-    const { additionalProperties, nullable } = parentSchema;
-    if (it.jtdDiscriminator && nullable)
-        throw new Error("JTD: nullable inside discriminator mapping");
-    if (commonProperties()) {
-        throw new Error("JTD: properties and optionalProperties have common members");
-    }
-    const [allProps, properties] = schemaProperties("properties");
-    const [allOptProps, optProperties] = schemaProperties("optionalProperties");
-    if (properties.length === 0 && optProperties.length === 0 && additionalProperties) {
-        return;
-    }
-    const [valid, cond] = it.jtdDiscriminator === undefined
-        ? (0, nullable_1.checkNullableObject)(cxt, data)
-        : [gen.let("valid", false), true];
-    gen.if(cond, () => gen.assign(valid, true).block(() => {
-        validateProps(properties, "properties", true);
-        validateProps(optProperties, "optionalProperties");
-        if (!additionalProperties)
-            validateAdditional();
-    }));
-    cxt.pass(valid);
-    function commonProperties() {
-        const props = parentSchema.properties;
-        const optProps = parentSchema.optionalProperties;
-        if (!(props && optProps))
-            return false;
-        for (const p in props) {
-            if (Object.prototype.hasOwnProperty.call(optProps, p))
-                return true;
-        }
-        return false;
-    }
-    function schemaProperties(keyword) {
-        const schema = parentSchema[keyword];
-        const allPs = schema ? (0, code_1.allSchemaProperties)(schema) : [];
-        if (it.jtdDiscriminator && allPs.some((p) => p === it.jtdDiscriminator)) {
-            throw new Error(`JTD: discriminator tag used in ${keyword}`);
-        }
-        const ps = allPs.filter((p) => !(0, util_1.alwaysValidSchema)(it, schema[p]));
-        return [allPs, ps];
-    }
-    function validateProps(props, keyword, required) {
-        const _valid = gen.var("valid");
-        for (const prop of props) {
-            gen.if((0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties), () => applyPropertySchema(prop, keyword, _valid), () => missingProperty(prop));
-            cxt.ok(_valid);
-        }
-        function missingProperty(prop) {
-            if (required) {
-                gen.assign(_valid, false);
-                cxt.error(false, { propError: PropError.Missing, missingProperty: prop }, { schemaPath: prop });
-            }
-            else {
-                gen.assign(_valid, true);
-            }
-        }
-    }
-    function applyPropertySchema(prop, keyword, _valid) {
-        cxt.subschema({
-            keyword,
-            schemaProp: prop,
-            dataProp: prop,
-        }, _valid);
-    }
-    function validateAdditional() {
-        gen.forIn("key", data, (key) => {
-            const addProp = isAdditional(key, allProps, "properties", it.jtdDiscriminator);
-            const addOptProp = isAdditional(key, allOptProps, "optionalProperties");
-            const extra = addProp === true ? addOptProp : addOptProp === true ? addProp : (0, codegen_1.and)(addProp, addOptProp);
-            gen.if(extra, () => {
-                if (it.opts.removeAdditional) {
-                    gen.code((0, codegen_1._) `delete ${data}[${key}]`);
-                }
-                else {
-                    cxt.error(false, { propError: PropError.Additional, additionalProperty: key }, { instancePath: key, parentSchema: true });
-                    if (!it.opts.allErrors)
-                        gen.break();
-                }
-            });
-        });
-    }
-    function isAdditional(key, props, keyword, jtdDiscriminator) {
-        let additional;
-        if (props.length > 8) {
-            // TODO maybe an option instead of hard-coded 8?
-            const propsSchema = (0, util_1.schemaRefOrVal)(it, parentSchema[keyword], keyword);
-            additional = (0, codegen_1.not)((0, code_1.isOwnProperty)(gen, propsSchema, key));
-            if (jtdDiscriminator !== undefined) {
-                additional = (0, codegen_1.and)(additional, (0, codegen_1._) `${key} !== ${jtdDiscriminator}`);
-            }
-        }
-        else if (props.length || jtdDiscriminator !== undefined) {
-            const ps = jtdDiscriminator === undefined ? props : [jtdDiscriminator].concat(props);
-            additional = (0, codegen_1.and)(...ps.map((p) => (0, codegen_1._) `${key} !== ${p}`));
-        }
-        else {
-            additional = true;
-        }
-        return additional;
-    }
-}
-exports.validateProperties = validateProperties;
-exports.default = def;
-//# sourceMappingURL=properties.js.map

package/dist/node_modules/ajv/dist/vocabularies/jtd/ref.d.ts

@@ -1,4 +0,0 @@
-import type { CodeKeywordDefinition, AnySchemaObject } from "../../types";
-declare const def: CodeKeywordDefinition;
-export declare function hasRef(schema: AnySchemaObject): boolean;
-export default def;

package/dist/node_modules/ajv/dist/vocabularies/jtd/ref.js

@@ -1,67 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasRef = void 0;
-const compile_1 = require("../../compile");
-const codegen_1 = require("../../compile/codegen");
-const ref_error_1 = require("../../compile/ref_error");
-const names_1 = require("../../compile/names");
-const ref_1 = require("../core/ref");
-const metadata_1 = require("./metadata");
-const def = {
-    keyword: "ref",
-    schemaType: "string",
-    code(cxt) {
-        (0, metadata_1.checkMetadata)(cxt);
-        const { gen, data, schema: ref, parentSchema, it } = cxt;
-        const { schemaEnv: { root }, } = it;
-        const valid = gen.name("valid");
-        if (parentSchema.nullable) {
-            gen.var(valid, (0, codegen_1._) `${data} === null`);
-            gen.if((0, codegen_1.not)(valid), validateJtdRef);
-        }
-        else {
-            gen.var(valid, false);
-            validateJtdRef();
-        }
-        cxt.ok(valid);
-        function validateJtdRef() {
-            var _a;
-            const refSchema = (_a = root.schema.definitions) === null || _a === void 0 ? void 0 : _a[ref];
-            if (!refSchema) {
-                throw new ref_error_1.default(it.opts.uriResolver, "", ref, `No definition ${ref}`);
-            }
-            if (hasRef(refSchema) || !it.opts.inlineRefs)
-                callValidate(refSchema);
-            else
-                inlineRefSchema(refSchema);
-        }
-        function callValidate(schema) {
-            const sch = compile_1.compileSchema.call(it.self, new compile_1.SchemaEnv({ schema, root, schemaPath: `/definitions/${ref}` }));
-            const v = (0, ref_1.getValidate)(cxt, sch);
-            const errsCount = gen.const("_errs", names_1.default.errors);
-            (0, ref_1.callRef)(cxt, v, sch, sch.$async);
-            gen.assign(valid, (0, codegen_1._) `${errsCount} === ${names_1.default.errors}`);
-        }
-        function inlineRefSchema(schema) {
-            const schName = gen.scopeValue("schema", it.opts.code.source === true ? { ref: schema, code: (0, codegen_1.stringify)(schema) } : { ref: schema });
-            cxt.subschema({
-                schema,
-                dataTypes: [],
-                schemaPath: codegen_1.nil,
-                topSchemaRef: schName,
-                errSchemaPath: `/definitions/${ref}`,
-            }, valid);
-        }
-    },
-};
-function hasRef(schema) {
-    for (const key in schema) {
-        let sch;
-        if (key === "ref" || (typeof (sch = schema[key]) == "object" && hasRef(sch)))
-            return true;
-    }
-    return false;
-}
-exports.hasRef = hasRef;
-exports.default = def;
-//# sourceMappingURL=ref.js.map

package/dist/node_modules/ajv/dist/vocabularies/jtd/type.d.ts

@@ -1,10 +0,0 @@
-import type { CodeKeywordDefinition } from "../../types";
-import { _JTDTypeError } from "./error";
-export type JTDTypeError = _JTDTypeError<"type", JTDType, JTDType>;
-export type IntType = "int8" | "uint8" | "int16" | "uint16" | "int32" | "uint32";
-export declare const intRange: {
-    [T in IntType]: [number, number, number];
-};
-export type JTDType = "boolean" | "string" | "timestamp" | "float32" | "float64" | IntType;
-declare const def: CodeKeywordDefinition;
-export default def;

package/dist/node_modules/ajv/dist/vocabularies/jtd/type.js

@@ -1,69 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.intRange = void 0;
-const codegen_1 = require("../../compile/codegen");
-const timestamp_1 = require("../../runtime/timestamp");
-const util_1 = require("../../compile/util");
-const metadata_1 = require("./metadata");
-const error_1 = require("./error");
-exports.intRange = {
-    int8: [-128, 127, 3],
-    uint8: [0, 255, 3],
-    int16: [-32768, 32767, 5],
-    uint16: [0, 65535, 5],
-    int32: [-2147483648, 2147483647, 10],
-    uint32: [0, 4294967295, 10],
-};
-const error = {
-    message: (cxt) => (0, error_1.typeErrorMessage)(cxt, cxt.schema),
-    params: (cxt) => (0, error_1.typeErrorParams)(cxt, cxt.schema),
-};
-function timestampCode(cxt) {
-    const { gen, data, it } = cxt;
-    const { timestamp, allowDate } = it.opts;
-    if (timestamp === "date")
-        return (0, codegen_1._) `${data} instanceof Date `;
-    const vts = (0, util_1.useFunc)(gen, timestamp_1.default);
-    const allowDateArg = allowDate ? (0, codegen_1._) `, true` : codegen_1.nil;
-    const validString = (0, codegen_1._) `typeof ${data} == "string" && ${vts}(${data}${allowDateArg})`;
-    return timestamp === "string" ? validString : (0, codegen_1.or)((0, codegen_1._) `${data} instanceof Date`, validString);
-}
-const def = {
-    keyword: "type",
-    schemaType: "string",
-    error,
-    code(cxt) {
-        (0, metadata_1.checkMetadata)(cxt);
-        const { data, schema, parentSchema, it } = cxt;
-        let cond;
-        switch (schema) {
-            case "boolean":
-            case "string":
-                cond = (0, codegen_1._) `typeof ${data} == ${schema}`;
-                break;
-            case "timestamp": {
-                cond = timestampCode(cxt);
-                break;
-            }
-            case "float32":
-            case "float64":
-                cond = (0, codegen_1._) `typeof ${data} == "number"`;
-                break;
-            default: {
-                const sch = schema;
-                cond = (0, codegen_1._) `typeof ${data} == "number" && isFinite(${data}) && !(${data} % 1)`;
-                if (!it.opts.int32range && (sch === "int32" || sch === "uint32")) {
-                    if (sch === "uint32")
-                        cond = (0, codegen_1._) `${cond} && ${data} >= 0`;
-                }
-                else {
-                    const [min, max] = exports.intRange[sch];
-                    cond = (0, codegen_1._) `${cond} && ${data} >= ${min} && ${data} <= ${max}`;
-                }
-            }
-        }
-        cxt.pass(parentSchema.nullable ? (0, codegen_1.or)((0, codegen_1._) `${data} === null`, cond) : cond);
-    },
-};
-exports.default = def;
-//# sourceMappingURL=type.js.map

package/dist/node_modules/ajv/dist/vocabularies/jtd/union.d.ts

@@ -1,3 +0,0 @@
-import type { CodeKeywordDefinition } from "../../types";
-declare const def: CodeKeywordDefinition;
-export default def;

package/dist/node_modules/ajv/dist/vocabularies/jtd/union.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const code_1 = require("../code");
-const def = {
-    keyword: "union",
-    schemaType: "array",
-    trackErrors: true,
-    code: code_1.validateUnion,
-    error: { message: "must match a schema in union" },
-};
-exports.default = def;
-//# sourceMappingURL=union.js.map

package/dist/node_modules/ajv/dist/vocabularies/jtd/values.d.ts

@@ -1,5 +0,0 @@
-import type { CodeKeywordDefinition, SchemaObject } from "../../types";
-import { _JTDTypeError } from "./error";
-export type JTDValuesError = _JTDTypeError<"values", "object", SchemaObject>;
-declare const def: CodeKeywordDefinition;
-export default def;

package/dist/node_modules/ajv/dist/vocabularies/jtd/values.js

@@ -1,51 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const util_1 = require("../../compile/util");
-const codegen_1 = require("../../compile/codegen");
-const metadata_1 = require("./metadata");
-const nullable_1 = require("./nullable");
-const error_1 = require("./error");
-const def = {
-    keyword: "values",
-    schemaType: "object",
-    error: (0, error_1.typeError)("object"),
-    code(cxt) {
-        (0, metadata_1.checkMetadata)(cxt);
-        const { gen, data, schema, it } = cxt;
-        const [valid, cond] = (0, nullable_1.checkNullableObject)(cxt, data);
-        if ((0, util_1.alwaysValidSchema)(it, schema)) {
-            gen.if((0, codegen_1.not)((0, codegen_1.or)(cond, valid)), () => cxt.error());
-        }
-        else {
-            gen.if(cond);
-            gen.assign(valid, validateMap());
-            gen.elseIf((0, codegen_1.not)(valid));
-            cxt.error();
-            gen.endIf();
-        }
-        cxt.ok(valid);
-        function validateMap() {
-            const _valid = gen.name("valid");
-            if (it.allErrors) {
-                const validMap = gen.let("valid", true);
-                validateValues(() => gen.assign(validMap, false));
-                return validMap;
-            }
-            gen.var(_valid, true);
-            validateValues(() => gen.break());
-            return _valid;
-            function validateValues(notValid) {
-                gen.forIn("key", data, (key) => {
-                    cxt.subschema({
-                        keyword: "values",
-                        dataProp: key,
-                        dataPropType: util_1.Type.Str,
-                    }, _valid);
-                    gen.if((0, codegen_1.not)(_valid), notValid);
-                });
-            }
-        }
-    },
-};
-exports.default = def;
-//# sourceMappingURL=values.js.map

package/dist/node_modules/ajv/dist/vocabularies/metadata.d.ts

@@ -1,3 +0,0 @@
-import type { Vocabulary } from "../types";
-export declare const metadataVocabulary: Vocabulary;
-export declare const contentVocabulary: Vocabulary;

package/dist/node_modules/ajv/dist/vocabularies/metadata.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.contentVocabulary = exports.metadataVocabulary = void 0;
-exports.metadataVocabulary = [
-    "title",
-    "description",
-    "default",
-    "deprecated",
-    "readOnly",
-    "writeOnly",
-    "examples",
-];
-exports.contentVocabulary = [
-    "contentMediaType",
-    "contentEncoding",
-    "contentSchema",
-];
-//# sourceMappingURL=metadata.js.map

package/dist/node_modules/ajv/dist/vocabularies/next.d.ts

@@ -1,3 +0,0 @@
-import type { Vocabulary } from "../types";
-declare const next: Vocabulary;
-export default next;

package/dist/node_modules/ajv/dist/vocabularies/next.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const dependentRequired_1 = require("./validation/dependentRequired");
-const dependentSchemas_1 = require("./applicator/dependentSchemas");
-const limitContains_1 = require("./validation/limitContains");
-const next = [dependentRequired_1.default, dependentSchemas_1.default, limitContains_1.default];
-exports.default = next;
-//# sourceMappingURL=next.js.map

package/dist/node_modules/ajv/dist/vocabularies/unevaluated/index.d.ts

@@ -1,3 +0,0 @@
-import type { Vocabulary } from "../../types";
-declare const unevaluated: Vocabulary;
-export default unevaluated;

package/dist/node_modules/ajv/dist/vocabularies/unevaluated/index.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const unevaluatedProperties_1 = require("./unevaluatedProperties");
-const unevaluatedItems_1 = require("./unevaluatedItems");
-const unevaluated = [unevaluatedProperties_1.default, unevaluatedItems_1.default];
-exports.default = unevaluated;
-//# sourceMappingURL=index.js.map

package/dist/node_modules/ajv/dist/vocabularies/unevaluated/unevaluatedItems.d.ts

@@ -1,6 +0,0 @@
-import type { CodeKeywordDefinition, ErrorObject, AnySchema } from "../../types";
-export type UnevaluatedItemsError = ErrorObject<"unevaluatedItems", {
-    limit: number;
-}, AnySchema>;
-declare const def: CodeKeywordDefinition;
-export default def;

package/dist/node_modules/ajv/dist/vocabularies/unevaluated/unevaluatedItems.js

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const codegen_1 = require("../../compile/codegen");
-const util_1 = require("../../compile/util");
-const error = {
-    message: ({ params: { len } }) => (0, codegen_1.str) `must NOT have more than ${len} items`,
-    params: ({ params: { len } }) => (0, codegen_1._) `{limit: ${len}}`,
-};
-const def = {
-    keyword: "unevaluatedItems",
-    type: "array",
-    schemaType: ["boolean", "object"],
-    error,
-    code(cxt) {
-        const { gen, schema, data, it } = cxt;
-        const items = it.items || 0;
-        if (items === true)
-            return;
-        const len = gen.const("len", (0, codegen_1._) `${data}.length`);
-        if (schema === false) {
-            cxt.setParams({ len: items });
-            cxt.fail((0, codegen_1._) `${len} > ${items}`);
-        }
-        else if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) {
-            const valid = gen.var("valid", (0, codegen_1._) `${len} <= ${items}`);
-            gen.if((0, codegen_1.not)(valid), () => validateItems(valid, items));
-            cxt.ok(valid);
-        }
-        it.items = true;
-        function validateItems(valid, from) {
-            gen.forRange("i", from, len, (i) => {
-                cxt.subschema({ keyword: "unevaluatedItems", dataProp: i, dataPropType: util_1.Type.Num }, valid);
-                if (!it.allErrors)
-                    gen.if((0, codegen_1.not)(valid), () => gen.break());
-            });
-        }
-    },
-};
-exports.default = def;
-//# sourceMappingURL=unevaluatedItems.js.map

package/dist/node_modules/ajv/dist/vocabularies/unevaluated/unevaluatedProperties.d.ts

@@ -1,6 +0,0 @@
-import type { CodeKeywordDefinition, ErrorObject, AnySchema } from "../../types";
-export type UnevaluatedPropertiesError = ErrorObject<"unevaluatedProperties", {
-    unevaluatedProperty: string;
-}, AnySchema>;
-declare const def: CodeKeywordDefinition;
-export default def;

package/dist/node_modules/ajv/dist/vocabularies/unevaluated/unevaluatedProperties.js

@@ -1,65 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const codegen_1 = require("../../compile/codegen");
-const util_1 = require("../../compile/util");
-const names_1 = require("../../compile/names");
-const error = {
-    message: "must NOT have unevaluated properties",
-    params: ({ params }) => (0, codegen_1._) `{unevaluatedProperty: ${params.unevaluatedProperty}}`,
-};
-const def = {
-    keyword: "unevaluatedProperties",
-    type: "object",
-    schemaType: ["boolean", "object"],
-    trackErrors: true,
-    error,
-    code(cxt) {
-        const { gen, schema, data, errsCount, it } = cxt;
-        /* istanbul ignore if */
-        if (!errsCount)
-            throw new Error("ajv implementation error");
-        const { allErrors, props } = it;
-        if (props instanceof codegen_1.Name) {
-            gen.if((0, codegen_1._) `${props} !== true`, () => gen.forIn("key", data, (key) => gen.if(unevaluatedDynamic(props, key), () => unevaluatedPropCode(key))));
-        }
-        else if (props !== true) {
-            gen.forIn("key", data, (key) => props === undefined
-                ? unevaluatedPropCode(key)
-                : gen.if(unevaluatedStatic(props, key), () => unevaluatedPropCode(key)));
-        }
-        it.props = true;
-        cxt.ok((0, codegen_1._) `${errsCount} === ${names_1.default.errors}`);
-        function unevaluatedPropCode(key) {
-            if (schema === false) {
-                cxt.setParams({ unevaluatedProperty: key });
-                cxt.error();
-                if (!allErrors)
-                    gen.break();
-                return;
-            }
-            if (!(0, util_1.alwaysValidSchema)(it, schema)) {
-                const valid = gen.name("valid");
-                cxt.subschema({
-                    keyword: "unevaluatedProperties",
-                    dataProp: key,
-                    dataPropType: util_1.Type.Str,
-                }, valid);
-                if (!allErrors)
-                    gen.if((0, codegen_1.not)(valid), () => gen.break());
-            }
-        }
-        function unevaluatedDynamic(evaluatedProps, key) {
-            return (0, codegen_1._) `!${evaluatedProps} || !${evaluatedProps}[${key}]`;
-        }
-        function unevaluatedStatic(evaluatedProps, key) {
-            const ps = [];
-            for (const p in evaluatedProps) {
-                if (evaluatedProps[p] === true)
-                    ps.push((0, codegen_1._) `${key} !== ${p}`);
-            }
-            return (0, codegen_1.and)(...ps);
-        }
-    },
-};
-exports.default = def;
-//# sourceMappingURL=unevaluatedProperties.js.map

package/dist/node_modules/ajv/dist/vocabularies/validation/const.d.ts

@@ -1,6 +0,0 @@
-import type { CodeKeywordDefinition, ErrorObject } from "../../types";
-export type ConstError = ErrorObject<"const", {
-    allowedValue: any;
-}>;
-declare const def: CodeKeywordDefinition;
-export default def;

package/dist/node_modules/ajv/dist/vocabularies/validation/const.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const codegen_1 = require("../../compile/codegen");
-const util_1 = require("../../compile/util");
-const equal_1 = require("../../runtime/equal");
-const error = {
-    message: "must be equal to constant",
-    params: ({ schemaCode }) => (0, codegen_1._) `{allowedValue: ${schemaCode}}`,
-};
-const def = {
-    keyword: "const",
-    $data: true,
-    error,
-    code(cxt) {
-        const { gen, data, $data, schemaCode, schema } = cxt;
-        if ($data || (schema && typeof schema == "object")) {
-            cxt.fail$data((0, codegen_1._) `!${(0, util_1.useFunc)(gen, equal_1.default)}(${data}, ${schemaCode})`);
-        }
-        else {
-            cxt.fail((0, codegen_1._) `${schema} !== ${data}`);
-        }
-    },
-};
-exports.default = def;
-//# sourceMappingURL=const.js.map

package/dist/node_modules/ajv/dist/vocabularies/validation/dependentRequired.d.ts

@@ -1,5 +0,0 @@
-import type { CodeKeywordDefinition, ErrorObject } from "../../types";
-import { DependenciesErrorParams, PropertyDependencies } from "../applicator/dependencies";
-export type DependentRequiredError = ErrorObject<"dependentRequired", DependenciesErrorParams, PropertyDependencies>;
-declare const def: CodeKeywordDefinition;
-export default def;

package/dist/node_modules/ajv/dist/vocabularies/validation/dependentRequired.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const dependencies_1 = require("../applicator/dependencies");
-const def = {
-    keyword: "dependentRequired",
-    type: "object",
-    schemaType: "object",
-    error: dependencies_1.error,
-    code: (cxt) => (0, dependencies_1.validatePropertyDeps)(cxt),
-};
-exports.default = def;
-//# sourceMappingURL=dependentRequired.js.map