@highstate/designer 0.4.5 → 0.4.6

package/.output/server/node_modules/ajv/dist/compile/resolve.js

@@ -1,155 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSchemaRefs = exports.resolveUrl = exports.normalizeId = exports._getFullPath = exports.getFullPath = exports.inlineRef = void 0;
-const util_1 = require("./util");
-const equal = require("fast-deep-equal");
-const traverse = require("json-schema-traverse");
-// TODO refactor to use keyword definitions
-const SIMPLE_INLINED = new Set([
-    "type",
-    "format",
-    "pattern",
-    "maxLength",
-    "minLength",
-    "maxProperties",
-    "minProperties",
-    "maxItems",
-    "minItems",
-    "maximum",
-    "minimum",
-    "uniqueItems",
-    "multipleOf",
-    "required",
-    "enum",
-    "const",
-]);
-function inlineRef(schema, limit = true) {
-    if (typeof schema == "boolean")
-        return true;
-    if (limit === true)
-        return !hasRef(schema);
-    if (!limit)
-        return false;
-    return countKeys(schema) <= limit;
-}
-exports.inlineRef = inlineRef;
-const REF_KEYWORDS = new Set([
-    "$ref",
-    "$recursiveRef",
-    "$recursiveAnchor",
-    "$dynamicRef",
-    "$dynamicAnchor",
-]);
-function hasRef(schema) {
-    for (const key in schema) {
-        if (REF_KEYWORDS.has(key))
-            return true;
-        const sch = schema[key];
-        if (Array.isArray(sch) && sch.some(hasRef))
-            return true;
-        if (typeof sch == "object" && hasRef(sch))
-            return true;
-    }
-    return false;
-}
-function countKeys(schema) {
-    let count = 0;
-    for (const key in schema) {
-        if (key === "$ref")
-            return Infinity;
-        count++;
-        if (SIMPLE_INLINED.has(key))
-            continue;
-        if (typeof schema[key] == "object") {
-            (0, util_1.eachItem)(schema[key], (sch) => (count += countKeys(sch)));
-        }
-        if (count === Infinity)
-            return Infinity;
-    }
-    return count;
-}
-function getFullPath(resolver, id = "", normalize) {
-    if (normalize !== false)
-        id = normalizeId(id);
-    const p = resolver.parse(id);
-    return _getFullPath(resolver, p);
-}
-exports.getFullPath = getFullPath;
-function _getFullPath(resolver, p) {
-    const serialized = resolver.serialize(p);
-    return serialized.split("#")[0] + "#";
-}
-exports._getFullPath = _getFullPath;
-const TRAILING_SLASH_HASH = /#\/?$/;
-function normalizeId(id) {
-    return id ? id.replace(TRAILING_SLASH_HASH, "") : "";
-}
-exports.normalizeId = normalizeId;
-function resolveUrl(resolver, baseId, id) {
-    id = normalizeId(id);
-    return resolver.resolve(baseId, id);
-}
-exports.resolveUrl = resolveUrl;
-const ANCHOR = /^[a-z_][-a-z0-9._]*$/i;
-function getSchemaRefs(schema, baseId) {
-    if (typeof schema == "boolean")
-        return {};
-    const { schemaId, uriResolver } = this.opts;
-    const schId = normalizeId(schema[schemaId] || baseId);
-    const baseIds = { "": schId };
-    const pathPrefix = getFullPath(uriResolver, schId, false);
-    const localRefs = {};
-    const schemaRefs = new Set();
-    traverse(schema, { allKeys: true }, (sch, jsonPtr, _, parentJsonPtr) => {
-        if (parentJsonPtr === undefined)
-            return;
-        const fullPath = pathPrefix + jsonPtr;
-        let innerBaseId = baseIds[parentJsonPtr];
-        if (typeof sch[schemaId] == "string")
-            innerBaseId = addRef.call(this, sch[schemaId]);
-        addAnchor.call(this, sch.$anchor);
-        addAnchor.call(this, sch.$dynamicAnchor);
-        baseIds[jsonPtr] = innerBaseId;
-        function addRef(ref) {
-            // eslint-disable-next-line @typescript-eslint/unbound-method
-            const _resolve = this.opts.uriResolver.resolve;
-            ref = normalizeId(innerBaseId ? _resolve(innerBaseId, ref) : ref);
-            if (schemaRefs.has(ref))
-                throw ambiguos(ref);
-            schemaRefs.add(ref);
-            let schOrRef = this.refs[ref];
-            if (typeof schOrRef == "string")
-                schOrRef = this.refs[schOrRef];
-            if (typeof schOrRef == "object") {
-                checkAmbiguosRef(sch, schOrRef.schema, ref);
-            }
-            else if (ref !== normalizeId(fullPath)) {
-                if (ref[0] === "#") {
-                    checkAmbiguosRef(sch, localRefs[ref], ref);
-                    localRefs[ref] = sch;
-                }
-                else {
-                    this.refs[ref] = fullPath;
-                }
-            }
-            return ref;
-        }
-        function addAnchor(anchor) {
-            if (typeof anchor == "string") {
-                if (!ANCHOR.test(anchor))
-                    throw new Error(`invalid anchor "${anchor}"`);
-                addRef.call(this, `#${anchor}`);
-            }
-        }
-    });
-    return localRefs;
-    function checkAmbiguosRef(sch1, sch2, ref) {
-        if (sch2 !== undefined && !equal(sch1, sch2))
-            throw ambiguos(ref);
-    }
-    function ambiguos(ref) {
-        return new Error(`reference "${ref}" resolves to more than one schema`);
-    }
-}
-exports.getSchemaRefs = getSchemaRefs;
-//# sourceMappingURL=resolve.js.map

package/.output/server/node_modules/ajv/dist/compile/rules.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRules = exports.isJSONType = void 0;
-const _jsonTypes = ["string", "number", "integer", "boolean", "null", "object", "array"];
-const jsonTypes = new Set(_jsonTypes);
-function isJSONType(x) {
-    return typeof x == "string" && jsonTypes.has(x);
-}
-exports.isJSONType = isJSONType;
-function getRules() {
-    const groups = {
-        number: { type: "number", rules: [] },
-        string: { type: "string", rules: [] },
-        array: { type: "array", rules: [] },
-        object: { type: "object", rules: [] },
-    };
-    return {
-        types: { ...groups, integer: true, boolean: true, null: true },
-        rules: [{ rules: [] }, groups.number, groups.string, groups.array, groups.object],
-        post: { rules: [] },
-        all: {},
-        keywords: {},
-    };
-}
-exports.getRules = getRules;
-//# sourceMappingURL=rules.js.map

package/.output/server/node_modules/ajv/dist/compile/util.js

@@ -1,178 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkStrictMode = exports.getErrorPath = exports.Type = exports.useFunc = exports.setEvaluated = exports.evaluatedPropsToName = exports.mergeEvaluated = exports.eachItem = exports.unescapeJsonPointer = exports.escapeJsonPointer = exports.escapeFragment = exports.unescapeFragment = exports.schemaRefOrVal = exports.schemaHasRulesButRef = exports.schemaHasRules = exports.checkUnknownRules = exports.alwaysValidSchema = exports.toHash = void 0;
-const codegen_1 = require("./codegen");
-const code_1 = require("./codegen/code");
-// TODO refactor to use Set
-function toHash(arr) {
-    const hash = {};
-    for (const item of arr)
-        hash[item] = true;
-    return hash;
-}
-exports.toHash = toHash;
-function alwaysValidSchema(it, schema) {
-    if (typeof schema == "boolean")
-        return schema;
-    if (Object.keys(schema).length === 0)
-        return true;
-    checkUnknownRules(it, schema);
-    return !schemaHasRules(schema, it.self.RULES.all);
-}
-exports.alwaysValidSchema = alwaysValidSchema;
-function checkUnknownRules(it, schema = it.schema) {
-    const { opts, self } = it;
-    if (!opts.strictSchema)
-        return;
-    if (typeof schema === "boolean")
-        return;
-    const rules = self.RULES.keywords;
-    for (const key in schema) {
-        if (!rules[key])
-            checkStrictMode(it, `unknown keyword: "${key}"`);
-    }
-}
-exports.checkUnknownRules = checkUnknownRules;
-function schemaHasRules(schema, rules) {
-    if (typeof schema == "boolean")
-        return !schema;
-    for (const key in schema)
-        if (rules[key])
-            return true;
-    return false;
-}
-exports.schemaHasRules = schemaHasRules;
-function schemaHasRulesButRef(schema, RULES) {
-    if (typeof schema == "boolean")
-        return !schema;
-    for (const key in schema)
-        if (key !== "$ref" && RULES.all[key])
-            return true;
-    return false;
-}
-exports.schemaHasRulesButRef = schemaHasRulesButRef;
-function schemaRefOrVal({ topSchemaRef, schemaPath }, schema, keyword, $data) {
-    if (!$data) {
-        if (typeof schema == "number" || typeof schema == "boolean")
-            return schema;
-        if (typeof schema == "string")
-            return (0, codegen_1._) `${schema}`;
-    }
-    return (0, codegen_1._) `${topSchemaRef}${schemaPath}${(0, codegen_1.getProperty)(keyword)}`;
-}
-exports.schemaRefOrVal = schemaRefOrVal;
-function unescapeFragment(str) {
-    return unescapeJsonPointer(decodeURIComponent(str));
-}
-exports.unescapeFragment = unescapeFragment;
-function escapeFragment(str) {
-    return encodeURIComponent(escapeJsonPointer(str));
-}
-exports.escapeFragment = escapeFragment;
-function escapeJsonPointer(str) {
-    if (typeof str == "number")
-        return `${str}`;
-    return str.replace(/~/g, "~0").replace(/\//g, "~1");
-}
-exports.escapeJsonPointer = escapeJsonPointer;
-function unescapeJsonPointer(str) {
-    return str.replace(/~1/g, "/").replace(/~0/g, "~");
-}
-exports.unescapeJsonPointer = unescapeJsonPointer;
-function eachItem(xs, f) {
-    if (Array.isArray(xs)) {
-        for (const x of xs)
-            f(x);
-    }
-    else {
-        f(xs);
-    }
-}
-exports.eachItem = eachItem;
-function makeMergeEvaluated({ mergeNames, mergeToName, mergeValues, resultToName, }) {
-    return (gen, from, to, toName) => {
-        const res = to === undefined
-            ? from
-            : to instanceof codegen_1.Name
-                ? (from instanceof codegen_1.Name ? mergeNames(gen, from, to) : mergeToName(gen, from, to), to)
-                : from instanceof codegen_1.Name
-                    ? (mergeToName(gen, to, from), from)
-                    : mergeValues(from, to);
-        return toName === codegen_1.Name && !(res instanceof codegen_1.Name) ? resultToName(gen, res) : res;
-    };
-}
-exports.mergeEvaluated = {
-    props: makeMergeEvaluated({
-        mergeNames: (gen, from, to) => gen.if((0, codegen_1._) `${to} !== true && ${from} !== undefined`, () => {
-            gen.if((0, codegen_1._) `${from} === true`, () => gen.assign(to, true), () => gen.assign(to, (0, codegen_1._) `${to} || {}`).code((0, codegen_1._) `Object.assign(${to}, ${from})`));
-        }),
-        mergeToName: (gen, from, to) => gen.if((0, codegen_1._) `${to} !== true`, () => {
-            if (from === true) {
-                gen.assign(to, true);
-            }
-            else {
-                gen.assign(to, (0, codegen_1._) `${to} || {}`);
-                setEvaluated(gen, to, from);
-            }
-        }),
-        mergeValues: (from, to) => (from === true ? true : { ...from, ...to }),
-        resultToName: evaluatedPropsToName,
-    }),
-    items: makeMergeEvaluated({
-        mergeNames: (gen, from, to) => gen.if((0, codegen_1._) `${to} !== true && ${from} !== undefined`, () => gen.assign(to, (0, codegen_1._) `${from} === true ? true : ${to} > ${from} ? ${to} : ${from}`)),
-        mergeToName: (gen, from, to) => gen.if((0, codegen_1._) `${to} !== true`, () => gen.assign(to, from === true ? true : (0, codegen_1._) `${to} > ${from} ? ${to} : ${from}`)),
-        mergeValues: (from, to) => (from === true ? true : Math.max(from, to)),
-        resultToName: (gen, items) => gen.var("items", items),
-    }),
-};
-function evaluatedPropsToName(gen, ps) {
-    if (ps === true)
-        return gen.var("props", true);
-    const props = gen.var("props", (0, codegen_1._) `{}`);
-    if (ps !== undefined)
-        setEvaluated(gen, props, ps);
-    return props;
-}
-exports.evaluatedPropsToName = evaluatedPropsToName;
-function setEvaluated(gen, props, ps) {
-    Object.keys(ps).forEach((p) => gen.assign((0, codegen_1._) `${props}${(0, codegen_1.getProperty)(p)}`, true));
-}
-exports.setEvaluated = setEvaluated;
-const snippets = {};
-function useFunc(gen, f) {
-    return gen.scopeValue("func", {
-        ref: f,
-        code: snippets[f.code] || (snippets[f.code] = new code_1._Code(f.code)),
-    });
-}
-exports.useFunc = useFunc;
-var Type;
-(function (Type) {
-    Type[Type["Num"] = 0] = "Num";
-    Type[Type["Str"] = 1] = "Str";
-})(Type || (exports.Type = Type = {}));
-function getErrorPath(dataProp, dataPropType, jsPropertySyntax) {
-    // let path
-    if (dataProp instanceof codegen_1.Name) {
-        const isNumber = dataPropType === Type.Num;
-        return jsPropertySyntax
-            ? isNumber
-                ? (0, codegen_1._) `"[" + ${dataProp} + "]"`
-                : (0, codegen_1._) `"['" + ${dataProp} + "']"`
-            : isNumber
-                ? (0, codegen_1._) `"/" + ${dataProp}`
-                : (0, codegen_1._) `"/" + ${dataProp}.replace(/~/g, "~0").replace(/\\//g, "~1")`; // TODO maybe use global escapePointer
-    }
-    return jsPropertySyntax ? (0, codegen_1.getProperty)(dataProp).toString() : "/" + escapeJsonPointer(dataProp);
-}
-exports.getErrorPath = getErrorPath;
-function checkStrictMode(it, msg, mode = it.opts.strictSchema) {
-    if (!mode)
-        return;
-    msg = `strict mode: ${msg}`;
-    if (mode === true)
-        throw new Error(msg);
-    it.self.logger.warn(msg);
-}
-exports.checkStrictMode = checkStrictMode;
-//# sourceMappingURL=util.js.map

package/.output/server/node_modules/ajv/dist/compile/validate/applicability.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.shouldUseRule = exports.shouldUseGroup = exports.schemaHasRulesForType = void 0;
-function schemaHasRulesForType({ schema, self }, type) {
-    const group = self.RULES.types[type];
-    return group && group !== true && shouldUseGroup(schema, group);
-}
-exports.schemaHasRulesForType = schemaHasRulesForType;
-function shouldUseGroup(schema, group) {
-    return group.rules.some((rule) => shouldUseRule(schema, rule));
-}
-exports.shouldUseGroup = shouldUseGroup;
-function shouldUseRule(schema, rule) {
-    var _a;
-    return (schema[rule.keyword] !== undefined ||
-        ((_a = rule.definition.implements) === null || _a === void 0 ? void 0 : _a.some((kwd) => schema[kwd] !== undefined)));
-}
-exports.shouldUseRule = shouldUseRule;
-//# sourceMappingURL=applicability.js.map

package/.output/server/node_modules/ajv/dist/compile/validate/boolSchema.js

@@ -1,50 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.boolOrEmptySchema = exports.topBoolOrEmptySchema = void 0;
-const errors_1 = require("../errors");
-const codegen_1 = require("../codegen");
-const names_1 = require("../names");
-const boolError = {
-    message: "boolean schema is false",
-};
-function topBoolOrEmptySchema(it) {
-    const { gen, schema, validateName } = it;
-    if (schema === false) {
-        falseSchemaError(it, false);
-    }
-    else if (typeof schema == "object" && schema.$async === true) {
-        gen.return(names_1.default.data);
-    }
-    else {
-        gen.assign((0, codegen_1._) `${validateName}.errors`, null);
-        gen.return(true);
-    }
-}
-exports.topBoolOrEmptySchema = topBoolOrEmptySchema;
-function boolOrEmptySchema(it, valid) {
-    const { gen, schema } = it;
-    if (schema === false) {
-        gen.var(valid, false); // TODO var
-        falseSchemaError(it);
-    }
-    else {
-        gen.var(valid, true); // TODO var
-    }
-}
-exports.boolOrEmptySchema = boolOrEmptySchema;
-function falseSchemaError(it, overrideAllErrors) {
-    const { gen, data } = it;
-    // TODO maybe some other interface should be used for non-keyword validation errors...
-    const cxt = {
-        gen,
-        keyword: "false schema",
-        data,
-        schema: false,
-        schemaCode: false,
-        schemaValue: false,
-        params: {},
-        it,
-    };
-    (0, errors_1.reportError)(cxt, boolError, undefined, overrideAllErrors);
-}
-//# sourceMappingURL=boolSchema.js.map

package/.output/server/node_modules/ajv/dist/compile/validate/dataType.js

@@ -1,203 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.reportTypeError = exports.checkDataTypes = exports.checkDataType = exports.coerceAndCheckDataType = exports.getJSONTypes = exports.getSchemaTypes = exports.DataType = void 0;
-const rules_1 = require("../rules");
-const applicability_1 = require("./applicability");
-const errors_1 = require("../errors");
-const codegen_1 = require("../codegen");
-const util_1 = require("../util");
-var DataType;
-(function (DataType) {
-    DataType[DataType["Correct"] = 0] = "Correct";
-    DataType[DataType["Wrong"] = 1] = "Wrong";
-})(DataType || (exports.DataType = DataType = {}));
-function getSchemaTypes(schema) {
-    const types = getJSONTypes(schema.type);
-    const hasNull = types.includes("null");
-    if (hasNull) {
-        if (schema.nullable === false)
-            throw new Error("type: null contradicts nullable: false");
-    }
-    else {
-        if (!types.length && schema.nullable !== undefined) {
-            throw new Error('"nullable" cannot be used without "type"');
-        }
-        if (schema.nullable === true)
-            types.push("null");
-    }
-    return types;
-}
-exports.getSchemaTypes = getSchemaTypes;
-// eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
-function getJSONTypes(ts) {
-    const types = Array.isArray(ts) ? ts : ts ? [ts] : [];
-    if (types.every(rules_1.isJSONType))
-        return types;
-    throw new Error("type must be JSONType or JSONType[]: " + types.join(","));
-}
-exports.getJSONTypes = getJSONTypes;
-function coerceAndCheckDataType(it, types) {
-    const { gen, data, opts } = it;
-    const coerceTo = coerceToTypes(types, opts.coerceTypes);
-    const checkTypes = types.length > 0 &&
-        !(coerceTo.length === 0 && types.length === 1 && (0, applicability_1.schemaHasRulesForType)(it, types[0]));
-    if (checkTypes) {
-        const wrongType = checkDataTypes(types, data, opts.strictNumbers, DataType.Wrong);
-        gen.if(wrongType, () => {
-            if (coerceTo.length)
-                coerceData(it, types, coerceTo);
-            else
-                reportTypeError(it);
-        });
-    }
-    return checkTypes;
-}
-exports.coerceAndCheckDataType = coerceAndCheckDataType;
-const COERCIBLE = new Set(["string", "number", "integer", "boolean", "null"]);
-function coerceToTypes(types, coerceTypes) {
-    return coerceTypes
-        ? types.filter((t) => COERCIBLE.has(t) || (coerceTypes === "array" && t === "array"))
-        : [];
-}
-function coerceData(it, types, coerceTo) {
-    const { gen, data, opts } = it;
-    const dataType = gen.let("dataType", (0, codegen_1._) `typeof ${data}`);
-    const coerced = gen.let("coerced", (0, codegen_1._) `undefined`);
-    if (opts.coerceTypes === "array") {
-        gen.if((0, codegen_1._) `${dataType} == 'object' && Array.isArray(${data}) && ${data}.length == 1`, () => gen
-            .assign(data, (0, codegen_1._) `${data}[0]`)
-            .assign(dataType, (0, codegen_1._) `typeof ${data}`)
-            .if(checkDataTypes(types, data, opts.strictNumbers), () => gen.assign(coerced, data)));
-    }
-    gen.if((0, codegen_1._) `${coerced} !== undefined`);
-    for (const t of coerceTo) {
-        if (COERCIBLE.has(t) || (t === "array" && opts.coerceTypes === "array")) {
-            coerceSpecificType(t);
-        }
-    }
-    gen.else();
-    reportTypeError(it);
-    gen.endIf();
-    gen.if((0, codegen_1._) `${coerced} !== undefined`, () => {
-        gen.assign(data, coerced);
-        assignParentData(it, coerced);
-    });
-    function coerceSpecificType(t) {
-        switch (t) {
-            case "string":
-                gen
-                    .elseIf((0, codegen_1._) `${dataType} == "number" || ${dataType} == "boolean"`)
-                    .assign(coerced, (0, codegen_1._) `"" + ${data}`)
-                    .elseIf((0, codegen_1._) `${data} === null`)
-                    .assign(coerced, (0, codegen_1._) `""`);
-                return;
-            case "number":
-                gen
-                    .elseIf((0, codegen_1._) `${dataType} == "boolean" || ${data} === null
-              || (${dataType} == "string" && ${data} && ${data} == +${data})`)
-                    .assign(coerced, (0, codegen_1._) `+${data}`);
-                return;
-            case "integer":
-                gen
-                    .elseIf((0, codegen_1._) `${dataType} === "boolean" || ${data} === null
-              || (${dataType} === "string" && ${data} && ${data} == +${data} && !(${data} % 1))`)
-                    .assign(coerced, (0, codegen_1._) `+${data}`);
-                return;
-            case "boolean":
-                gen
-                    .elseIf((0, codegen_1._) `${data} === "false" || ${data} === 0 || ${data} === null`)
-                    .assign(coerced, false)
-                    .elseIf((0, codegen_1._) `${data} === "true" || ${data} === 1`)
-                    .assign(coerced, true);
-                return;
-            case "null":
-                gen.elseIf((0, codegen_1._) `${data} === "" || ${data} === 0 || ${data} === false`);
-                gen.assign(coerced, null);
-                return;
-            case "array":
-                gen
-                    .elseIf((0, codegen_1._) `${dataType} === "string" || ${dataType} === "number"
-              || ${dataType} === "boolean" || ${data} === null`)
-                    .assign(coerced, (0, codegen_1._) `[${data}]`);
-        }
-    }
-}
-function assignParentData({ gen, parentData, parentDataProperty }, expr) {
-    // TODO use gen.property
-    gen.if((0, codegen_1._) `${parentData} !== undefined`, () => gen.assign((0, codegen_1._) `${parentData}[${parentDataProperty}]`, expr));
-}
-function checkDataType(dataType, data, strictNums, correct = DataType.Correct) {
-    const EQ = correct === DataType.Correct ? codegen_1.operators.EQ : codegen_1.operators.NEQ;
-    let cond;
-    switch (dataType) {
-        case "null":
-            return (0, codegen_1._) `${data} ${EQ} null`;
-        case "array":
-            cond = (0, codegen_1._) `Array.isArray(${data})`;
-            break;
-        case "object":
-            cond = (0, codegen_1._) `${data} && typeof ${data} == "object" && !Array.isArray(${data})`;
-            break;
-        case "integer":
-            cond = numCond((0, codegen_1._) `!(${data} % 1) && !isNaN(${data})`);
-            break;
-        case "number":
-            cond = numCond();
-            break;
-        default:
-            return (0, codegen_1._) `typeof ${data} ${EQ} ${dataType}`;
-    }
-    return correct === DataType.Correct ? cond : (0, codegen_1.not)(cond);
-    function numCond(_cond = codegen_1.nil) {
-        return (0, codegen_1.and)((0, codegen_1._) `typeof ${data} == "number"`, _cond, strictNums ? (0, codegen_1._) `isFinite(${data})` : codegen_1.nil);
-    }
-}
-exports.checkDataType = checkDataType;
-function checkDataTypes(dataTypes, data, strictNums, correct) {
-    if (dataTypes.length === 1) {
-        return checkDataType(dataTypes[0], data, strictNums, correct);
-    }
-    let cond;
-    const types = (0, util_1.toHash)(dataTypes);
-    if (types.array && types.object) {
-        const notObj = (0, codegen_1._) `typeof ${data} != "object"`;
-        cond = types.null ? notObj : (0, codegen_1._) `!${data} || ${notObj}`;
-        delete types.null;
-        delete types.array;
-        delete types.object;
-    }
-    else {
-        cond = codegen_1.nil;
-    }
-    if (types.number)
-        delete types.integer;
-    for (const t in types)
-        cond = (0, codegen_1.and)(cond, checkDataType(t, data, strictNums, correct));
-    return cond;
-}
-exports.checkDataTypes = checkDataTypes;
-const typeError = {
-    message: ({ schema }) => `must be ${schema}`,
-    params: ({ schema, schemaValue }) => typeof schema == "string" ? (0, codegen_1._) `{type: ${schema}}` : (0, codegen_1._) `{type: ${schemaValue}}`,
-};
-function reportTypeError(it) {
-    const cxt = getTypeErrorContext(it);
-    (0, errors_1.reportError)(cxt, typeError);
-}
-exports.reportTypeError = reportTypeError;
-function getTypeErrorContext(it) {
-    const { gen, data, schema } = it;
-    const schemaCode = (0, util_1.schemaRefOrVal)(it, schema, "type");
-    return {
-        gen,
-        keyword: "type",
-        data,
-        schema: schema.type,
-        schemaCode,
-        schemaValue: schemaCode,
-        parentSchema: schema,
-        params: {},
-        it,
-    };
-}
-//# sourceMappingURL=dataType.js.map

package/.output/server/node_modules/ajv/dist/compile/validate/defaults.js

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assignDefaults = void 0;
-const codegen_1 = require("../codegen");
-const util_1 = require("../util");
-function assignDefaults(it, ty) {
-    const { properties, items } = it.schema;
-    if (ty === "object" && properties) {
-        for (const key in properties) {
-            assignDefault(it, key, properties[key].default);
-        }
-    }
-    else if (ty === "array" && Array.isArray(items)) {
-        items.forEach((sch, i) => assignDefault(it, i, sch.default));
-    }
-}
-exports.assignDefaults = assignDefaults;
-function assignDefault(it, prop, defaultValue) {
-    const { gen, compositeRule, data, opts } = it;
-    if (defaultValue === undefined)
-        return;
-    const childData = (0, codegen_1._) `${data}${(0, codegen_1.getProperty)(prop)}`;
-    if (compositeRule) {
-        (0, util_1.checkStrictMode)(it, `default is ignored for: ${childData}`);
-        return;
-    }
-    let condition = (0, codegen_1._) `${childData} === undefined`;
-    if (opts.useDefaults === "empty") {
-        condition = (0, codegen_1._) `${condition} || ${childData} === null || ${childData} === ""`;
-    }
-    // `${childData} === undefined` +
-    // (opts.useDefaults === "empty" ? ` || ${childData} === null || ${childData} === ""` : "")
-    gen.if(condition, (0, codegen_1._) `${childData} = ${(0, codegen_1.stringify)(defaultValue)}`);
-}
-//# sourceMappingURL=defaults.js.map