@kubb/agent 4.27.2 → 4.28.0

package/.output/server/node_modules/@redocly/ajv/dist/runtime/ucs2length.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-// https://mathiasbynens.be/notes/javascript-encoding
-// https://github.com/bestiejs/punycode.js - punycode.ucs2.decode
-function ucs2length(str) {
-    const len = str.length;
-    let length = 0;
-    let pos = 0;
-    let value;
-    while (pos < len) {
-        length++;
-        value = str.charCodeAt(pos++);
-        if (value >= 0xd800 && value <= 0xdbff && pos < len) {
-            // high surrogate, and there is a next character
-            value = str.charCodeAt(pos);
-            if ((value & 0xfc00) === 0xdc00)
-                pos++; // low surrogate
-        }
-    }
-    return length;
-}
-exports.default = ucs2length;
-ucs2length.code = 'require("ajv/dist/runtime/ucs2length").default';
-//# sourceMappingURL=ucs2length.js.map

package/.output/server/node_modules/@redocly/ajv/dist/runtime/uri.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const uri = require("fast-uri");
-uri.code = 'require("ajv/dist/runtime/uri").default';
-exports.default = uri;
-//# sourceMappingURL=uri.js.map

package/.output/server/node_modules/@redocly/ajv/dist/runtime/validation_error.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class ValidationError extends Error {
-    constructor(errors) {
-        super("validation failed");
-        this.errors = errors;
-        this.ajv = this.validation = true;
-    }
-}
-exports.default = ValidationError;
-//# sourceMappingURL=validation_error.js.map

package/.output/server/node_modules/@redocly/ajv/dist/vocabularies/applicator/additionalItems.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateAdditionalItems = void 0;
-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: "additionalItems",
-    type: "array",
-    schemaType: ["boolean", "object"],
-    before: "uniqueItems",
-    error,
-    code(cxt) {
-        const { parentSchema, it } = cxt;
-        const { items } = parentSchema;
-        if (!Array.isArray(items)) {
-            (0, util_1.checkStrictMode)(it, '"additionalItems" is ignored when "items" is not an array of schemas');
-            return;
-        }
-        validateAdditionalItems(cxt, items);
-    },
-};
-function validateAdditionalItems(cxt, items) {
-    const { gen, schema, data, keyword, it } = cxt;
-    it.items = true;
-    const len = gen.const("len", (0, codegen_1._) `${data}.length`);
-    if (schema === false) {
-        cxt.setParams({ len: items.length });
-        cxt.pass((0, codegen_1._) `${len} <= ${items.length}`);
-    }
-    else if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) {
-        const valid = gen.var("valid", (0, codegen_1._) `${len} <= ${items.length}`); // TODO var
-        gen.if((0, codegen_1.not)(valid), () => validateItems(valid));
-        cxt.ok(valid);
-    }
-    function validateItems(valid) {
-        gen.forRange("i", items.length, len, (i) => {
-            cxt.subschema({ keyword, dataProp: i, dataPropType: util_1.Type.Num }, valid);
-            if (!it.allErrors)
-                gen.if((0, codegen_1.not)(valid), () => gen.break());
-        });
-    }
-}
-exports.validateAdditionalItems = validateAdditionalItems;
-exports.default = def;
-//# sourceMappingURL=additionalItems.js.map

package/.output/server/node_modules/@redocly/ajv/dist/vocabularies/applicator/additionalProperties.js

@@ -1,107 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const code_1 = require("../code");
-const codegen_1 = require("../../compile/codegen");
-const names_1 = require("../../compile/names");
-const util_1 = require("../../compile/util");
-const error = {
-    message: "must NOT have additional properties",
-    params: ({ params }) => (0, codegen_1._) `{additionalProperty: ${params.additionalProperty}}`,
-};
-const def = {
-    keyword: "additionalProperties",
-    type: ["object"],
-    schemaType: ["boolean", "object"],
-    allowUndefined: true,
-    trackErrors: true,
-    error,
-    code(cxt) {
-        const { gen, parentSchema, data, errsCount, it } = cxt;
-        const { schema = it.opts.defaultAdditionalProperties } = cxt;
-        /* istanbul ignore if */
-        if (!errsCount)
-            throw new Error("ajv implementation error");
-        const { allErrors, opts } = it;
-        it.props = true;
-        if (opts.removeAdditional !== "all" && (0, util_1.alwaysValidSchema)(it, schema))
-            return;
-        const props = (0, code_1.allSchemaProperties)(parentSchema.properties);
-        const patProps = (0, code_1.allSchemaProperties)(parentSchema.patternProperties);
-        checkAdditionalProperties();
-        cxt.ok((0, codegen_1._) `${errsCount} === ${names_1.default.errors}`);
-        function checkAdditionalProperties() {
-            gen.forIn("key", data, (key) => {
-                if (!props.length && !patProps.length)
-                    additionalPropertyCode(key);
-                else
-                    gen.if(isAdditional(key), () => additionalPropertyCode(key));
-            });
-        }
-        function isAdditional(key) {
-            let definedProp;
-            if (props.length > 8) {
-                // TODO maybe an option instead of hard-coded 8?
-                const propsSchema = (0, util_1.schemaRefOrVal)(it, parentSchema.properties, "properties");
-                definedProp = (0, code_1.isOwnProperty)(gen, propsSchema, key);
-            }
-            else if (props.length) {
-                definedProp = (0, codegen_1.or)(...props.map((p) => (0, codegen_1._) `${key} === ${p}`));
-            }
-            else {
-                definedProp = codegen_1.nil;
-            }
-            if (patProps.length) {
-                definedProp = (0, codegen_1.or)(definedProp, ...patProps.map((p) => (0, codegen_1._) `${(0, code_1.usePattern)(cxt, p)}.test(${key})`));
-            }
-            return (0, codegen_1.not)(definedProp);
-        }
-        function deleteAdditional(key) {
-            gen.code((0, codegen_1._) `delete ${data}[${key}]`);
-        }
-        function additionalPropertyCode(key) {
-            if (opts.removeAdditional === "all" || (opts.removeAdditional && schema === false)) {
-                deleteAdditional(key);
-                return;
-            }
-            if (schema === false) {
-                cxt.setParams({ additionalProperty: key });
-                cxt.error();
-                if (!allErrors)
-                    gen.break();
-                return;
-            }
-            if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) {
-                const valid = gen.name("valid");
-                if (opts.removeAdditional === "failing") {
-                    applyAdditionalSchema(key, valid, false);
-                    gen.if((0, codegen_1.not)(valid), () => {
-                        cxt.reset();
-                        deleteAdditional(key);
-                    });
-                }
-                else {
-                    applyAdditionalSchema(key, valid);
-                    if (!allErrors)
-                        gen.if((0, codegen_1.not)(valid), () => gen.break());
-                }
-            }
-        }
-        function applyAdditionalSchema(key, valid, errors) {
-            const subschema = {
-                keyword: "additionalProperties",
-                dataProp: key,
-                dataPropType: util_1.Type.Str,
-            };
-            if (errors === false) {
-                Object.assign(subschema, {
-                    compositeRule: true,
-                    createErrors: false,
-                    allErrors: false,
-                });
-            }
-            cxt.subschema(subschema, valid);
-        }
-    },
-};
-exports.default = def;
-//# sourceMappingURL=additionalProperties.js.map

package/.output/server/node_modules/@redocly/ajv/dist/vocabularies/applicator/allOf.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const util_1 = require("../../compile/util");
-const def = {
-    keyword: "allOf",
-    schemaType: "array",
-    code(cxt) {
-        const { gen, schema, it } = cxt;
-        /* istanbul ignore if */
-        if (!Array.isArray(schema))
-            throw new Error("ajv implementation error");
-        const valid = gen.name("valid");
-        schema.forEach((sch, i) => {
-            if ((0, util_1.alwaysValidSchema)(it, sch))
-                return;
-            const schCxt = cxt.subschema({ keyword: "allOf", schemaProp: i }, valid, true);
-            cxt.ok(valid);
-            cxt.mergeEvaluated(schCxt);
-        });
-    },
-};
-exports.default = def;
-//# sourceMappingURL=allOf.js.map

package/.output/server/node_modules/@redocly/ajv/dist/vocabularies/applicator/anyOf.js

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

package/.output/server/node_modules/@redocly/ajv/dist/vocabularies/applicator/contains.js

@@ -1,95 +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: { min, max } }) => max === undefined
-        ? (0, codegen_1.str) `must contain at least ${min} valid item(s)`
-        : (0, codegen_1.str) `must contain at least ${min} and no more than ${max} valid item(s)`,
-    params: ({ params: { min, max } }) => max === undefined ? (0, codegen_1._) `{minContains: ${min}}` : (0, codegen_1._) `{minContains: ${min}, maxContains: ${max}}`,
-};
-const def = {
-    keyword: "contains",
-    type: "array",
-    schemaType: ["object", "boolean"],
-    before: "uniqueItems",
-    trackErrors: true,
-    error,
-    code(cxt) {
-        const { gen, schema, parentSchema, data, it } = cxt;
-        let min;
-        let max;
-        const { minContains, maxContains } = parentSchema;
-        if (it.opts.next) {
-            min = minContains === undefined ? 1 : minContains;
-            max = maxContains;
-        }
-        else {
-            min = 1;
-        }
-        const len = gen.const("len", (0, codegen_1._) `${data}.length`);
-        cxt.setParams({ min, max });
-        if (max === undefined && min === 0) {
-            (0, util_1.checkStrictMode)(it, `"minContains" == 0 without "maxContains": "contains" keyword ignored`);
-            return;
-        }
-        if (max !== undefined && min > max) {
-            (0, util_1.checkStrictMode)(it, `"minContains" > "maxContains" is always invalid`);
-            cxt.fail();
-            return;
-        }
-        if ((0, util_1.alwaysValidSchema)(it, schema)) {
-            let cond = (0, codegen_1._) `${len} >= ${min}`;
-            if (max !== undefined)
-                cond = (0, codegen_1._) `${cond} && ${len} <= ${max}`;
-            cxt.pass(cond);
-            return;
-        }
-        it.items = true;
-        const valid = gen.name("valid");
-        if (max === undefined && min === 1) {
-            validateItems(valid, () => gen.if(valid, () => gen.break()));
-        }
-        else if (min === 0) {
-            gen.let(valid, true);
-            if (max !== undefined)
-                gen.if((0, codegen_1._) `${data}.length > 0`, validateItemsWithCount);
-        }
-        else {
-            gen.let(valid, false);
-            validateItemsWithCount();
-        }
-        cxt.result(valid, () => cxt.reset());
-        function validateItemsWithCount() {
-            const schValid = gen.name("_valid");
-            const count = gen.let("count", 0);
-            validateItems(schValid, () => gen.if(schValid, () => checkLimits(count)));
-        }
-        function validateItems(_valid, block) {
-            gen.forRange("i", 0, len, (i) => {
-                cxt.subschema({
-                    keyword: "contains",
-                    dataProp: i,
-                    dataPropType: util_1.Type.Num,
-                    compositeRule: true,
-                }, _valid);
-                block();
-            });
-        }
-        function checkLimits(count) {
-            gen.code((0, codegen_1._) `${count}++`);
-            if (max === undefined) {
-                gen.if((0, codegen_1._) `${count} >= ${min}`, () => gen.assign(valid, true).break());
-            }
-            else {
-                gen.if((0, codegen_1._) `${count} > ${max}`, () => gen.assign(valid, false).break());
-                if (min === 1)
-                    gen.assign(valid, true);
-                else
-                    gen.if((0, codegen_1._) `${count} >= ${min}`, () => gen.assign(valid, true));
-            }
-        }
-    },
-};
-exports.default = def;
-//# sourceMappingURL=contains.js.map

package/.output/server/node_modules/@redocly/ajv/dist/vocabularies/applicator/dependencies.js

@@ -1,85 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateSchemaDeps = exports.validatePropertyDeps = exports.error = void 0;
-const codegen_1 = require("../../compile/codegen");
-const util_1 = require("../../compile/util");
-const code_1 = require("../code");
-exports.error = {
-    message: ({ params: { property, depsCount, deps } }) => {
-        const property_ies = depsCount === 1 ? "property" : "properties";
-        return (0, codegen_1.str) `must have ${property_ies} ${deps} when property ${property} is present`;
-    },
-    params: ({ params: { property, depsCount, deps, missingProperty } }) => (0, codegen_1._) `{property: ${property},
-    missingProperty: ${missingProperty},
-    depsCount: ${depsCount},
-    deps: ${deps}}`, // TODO change to reference
-};
-const def = {
-    keyword: "dependencies",
-    type: "object",
-    schemaType: "object",
-    error: exports.error,
-    code(cxt) {
-        const [propDeps, schDeps] = splitDependencies(cxt);
-        validatePropertyDeps(cxt, propDeps);
-        validateSchemaDeps(cxt, schDeps);
-    },
-};
-function splitDependencies({ schema }) {
-    const propertyDeps = {};
-    const schemaDeps = {};
-    for (const key in schema) {
-        if (key === "__proto__")
-            continue;
-        const deps = Array.isArray(schema[key]) ? propertyDeps : schemaDeps;
-        deps[key] = schema[key];
-    }
-    return [propertyDeps, schemaDeps];
-}
-function validatePropertyDeps(cxt, propertyDeps = cxt.schema) {
-    const { gen, data, it } = cxt;
-    if (Object.keys(propertyDeps).length === 0)
-        return;
-    const missing = gen.let("missing");
-    for (const prop in propertyDeps) {
-        const deps = propertyDeps[prop];
-        if (deps.length === 0)
-            continue;
-        const hasProperty = (0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties);
-        cxt.setParams({
-            property: prop,
-            depsCount: deps.length,
-            deps: deps.join(", "),
-        });
-        if (it.allErrors) {
-            gen.if(hasProperty, () => {
-                for (const depProp of deps) {
-                    (0, code_1.checkReportMissingProp)(cxt, depProp);
-                }
-            });
-        }
-        else {
-            gen.if((0, codegen_1._) `${hasProperty} && (${(0, code_1.checkMissingProp)(cxt, deps, missing)})`);
-            (0, code_1.reportMissingProp)(cxt, missing);
-            gen.else();
-        }
-    }
-}
-exports.validatePropertyDeps = validatePropertyDeps;
-function validateSchemaDeps(cxt, schemaDeps = cxt.schema) {
-    const { gen, data, keyword, it } = cxt;
-    const valid = gen.name("valid");
-    for (const prop in schemaDeps) {
-        if ((0, util_1.alwaysValidSchema)(it, schemaDeps[prop]))
-            continue;
-        gen.if((0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties), () => {
-            const schCxt = cxt.subschema({ keyword, schemaProp: prop }, valid);
-            cxt.mergeValidEvaluated(schCxt, valid);
-        }, () => gen.var(valid, true) // TODO var
-        );
-        cxt.ok(valid);
-    }
-}
-exports.validateSchemaDeps = validateSchemaDeps;
-exports.default = def;
-//# sourceMappingURL=dependencies.js.map

package/.output/server/node_modules/@redocly/ajv/dist/vocabularies/applicator/dependentSchemas.js

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

package/.output/server/node_modules/@redocly/ajv/dist/vocabularies/applicator/if.js

@@ -1,66 +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 }) => (0, codegen_1.str) `must match "${params.ifClause}" schema`,
-    params: ({ params }) => (0, codegen_1._) `{failingKeyword: ${params.ifClause}}`,
-};
-const def = {
-    keyword: "if",
-    schemaType: ["object", "boolean"],
-    trackErrors: true,
-    error,
-    code(cxt) {
-        const { gen, parentSchema, it } = cxt;
-        if (parentSchema.then === undefined && parentSchema.else === undefined) {
-            (0, util_1.checkStrictMode)(it, '"if" without "then" and "else" is ignored');
-        }
-        const hasThen = hasSchema(it, "then");
-        const hasElse = hasSchema(it, "else");
-        if (!hasThen && !hasElse)
-            return;
-        const valid = gen.let("valid", true);
-        const schValid = gen.name("_valid");
-        validateIf();
-        cxt.reset();
-        if (hasThen && hasElse) {
-            const ifClause = gen.let("ifClause");
-            cxt.setParams({ ifClause });
-            gen.if(schValid, validateClause("then", ifClause), validateClause("else", ifClause));
-        }
-        else if (hasThen) {
-            gen.if(schValid, validateClause("then"));
-        }
-        else {
-            gen.if((0, codegen_1.not)(schValid), validateClause("else"));
-        }
-        cxt.pass(valid, () => cxt.error(true));
-        function validateIf() {
-            const schCxt = cxt.subschema({
-                keyword: "if",
-                compositeRule: true,
-                createErrors: false,
-                allErrors: false,
-            }, schValid);
-            cxt.mergeEvaluated(schCxt);
-        }
-        function validateClause(keyword, ifClause) {
-            return () => {
-                const schCxt = cxt.subschema({ keyword }, schValid);
-                gen.assign(valid, schValid);
-                cxt.mergeValidEvaluated(schCxt, valid);
-                if (ifClause)
-                    gen.assign(ifClause, (0, codegen_1._) `${keyword}`);
-                else
-                    cxt.setParams({ ifClause: keyword });
-            };
-        }
-    },
-};
-function hasSchema(it, keyword) {
-    const schema = it.schema[keyword];
-    return schema !== undefined && !(0, util_1.alwaysValidSchema)(it, schema);
-}
-exports.default = def;
-//# sourceMappingURL=if.js.map

package/.output/server/node_modules/@redocly/ajv/dist/vocabularies/applicator/index.js

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const additionalItems_1 = require("./additionalItems");
-const prefixItems_1 = require("./prefixItems");
-const items_1 = require("./items");
-const items2020_1 = require("./items2020");
-const contains_1 = require("./contains");
-const dependencies_1 = require("./dependencies");
-const propertyNames_1 = require("./propertyNames");
-const additionalProperties_1 = require("./additionalProperties");
-const properties_1 = require("./properties");
-const patternProperties_1 = require("./patternProperties");
-const not_1 = require("./not");
-const anyOf_1 = require("./anyOf");
-const oneOf_1 = require("./oneOf");
-const allOf_1 = require("./allOf");
-const if_1 = require("./if");
-const thenElse_1 = require("./thenElse");
-function getApplicator(draft2020 = false) {
-    const applicator = [
-        // any
-        not_1.default,
-        anyOf_1.default,
-        oneOf_1.default,
-        allOf_1.default,
-        if_1.default,
-        thenElse_1.default,
-        // object
-        propertyNames_1.default,
-        additionalProperties_1.default,
-        dependencies_1.default,
-        properties_1.default,
-        patternProperties_1.default,
-    ];
-    // array
-    if (draft2020)
-        applicator.push(prefixItems_1.default, items2020_1.default);
-    else
-        applicator.push(additionalItems_1.default, items_1.default);
-    applicator.push(contains_1.default);
-    return applicator;
-}
-exports.default = getApplicator;
-//# sourceMappingURL=index.js.map

package/.output/server/node_modules/@redocly/ajv/dist/vocabularies/applicator/items.js

@@ -1,52 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateTuple = void 0;
-const codegen_1 = require("../../compile/codegen");
-const util_1 = require("../../compile/util");
-const code_1 = require("../code");
-const def = {
-    keyword: "items",
-    type: "array",
-    schemaType: ["object", "array", "boolean"],
-    before: "uniqueItems",
-    code(cxt) {
-        const { schema, it } = cxt;
-        if (Array.isArray(schema))
-            return validateTuple(cxt, "additionalItems", schema);
-        it.items = true;
-        if ((0, util_1.alwaysValidSchema)(it, schema))
-            return;
-        cxt.ok((0, code_1.validateArray)(cxt));
-    },
-};
-function validateTuple(cxt, extraItems, schArr = cxt.schema) {
-    const { gen, parentSchema, data, keyword, it } = cxt;
-    checkStrictTuple(parentSchema);
-    if (it.opts.unevaluated && schArr.length && it.items !== true) {
-        it.items = util_1.mergeEvaluated.items(gen, schArr.length, it.items);
-    }
-    const valid = gen.name("valid");
-    const len = gen.const("len", (0, codegen_1._) `${data}.length`);
-    schArr.forEach((sch, i) => {
-        if ((0, util_1.alwaysValidSchema)(it, sch))
-            return;
-        gen.if((0, codegen_1._) `${len} > ${i}`, () => cxt.subschema({
-            keyword,
-            schemaProp: i,
-            dataProp: i,
-        }, valid));
-        cxt.ok(valid);
-    });
-    function checkStrictTuple(sch) {
-        const { opts, errSchemaPath } = it;
-        const l = schArr.length;
-        const fullTuple = l === sch.minItems && (l === sch.maxItems || sch[extraItems] === false);
-        if (opts.strictTuples && !fullTuple) {
-            const msg = `"${keyword}" is ${l}-tuple, but minItems or maxItems/${extraItems} are not specified or different at path "${errSchemaPath}"`;
-            (0, util_1.checkStrictMode)(it, msg, opts.strictTuples);
-        }
-    }
-}
-exports.validateTuple = validateTuple;
-exports.default = def;
-//# sourceMappingURL=items.js.map

package/.output/server/node_modules/@redocly/ajv/dist/vocabularies/applicator/items2020.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const codegen_1 = require("../../compile/codegen");
-const util_1 = require("../../compile/util");
-const code_1 = require("../code");
-const additionalItems_1 = require("./additionalItems");
-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: "items",
-    type: "array",
-    schemaType: ["object", "boolean"],
-    before: "uniqueItems",
-    error,
-    code(cxt) {
-        const { schema, parentSchema, it } = cxt;
-        const { prefixItems } = parentSchema;
-        it.items = true;
-        if ((0, util_1.alwaysValidSchema)(it, schema))
-            return;
-        if (prefixItems)
-            (0, additionalItems_1.validateAdditionalItems)(cxt, prefixItems);
-        else
-            cxt.ok((0, code_1.validateArray)(cxt));
-    },
-};
-exports.default = def;
-//# sourceMappingURL=items2020.js.map

package/.output/server/node_modules/@redocly/ajv/dist/vocabularies/applicator/not.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const util_1 = require("../../compile/util");
-const def = {
-    keyword: "not",
-    schemaType: ["object", "boolean"],
-    trackErrors: true,
-    code(cxt) {
-        const { gen, schema, it } = cxt;
-        if ((0, util_1.alwaysValidSchema)(it, schema)) {
-            cxt.fail();
-            return;
-        }
-        const valid = gen.name("valid");
-        cxt.subschema({
-            keyword: "not",
-            compositeRule: true,
-            createErrors: false,
-            allErrors: false,
-        }, valid);
-        cxt.failResult(valid, () => cxt.reset(), () => cxt.error());
-    },
-    error: { message: "must NOT be valid" },
-};
-exports.default = def;
-//# sourceMappingURL=not.js.map