@kubb/agent 4.27.2 → 4.28.0

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

@@ -1,60 +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: "must match exactly one schema in oneOf",
-    params: ({ params }) => (0, codegen_1._) `{passingSchemas: ${params.passing}}`,
-};
-const def = {
-    keyword: "oneOf",
-    schemaType: "array",
-    trackErrors: true,
-    error,
-    code(cxt) {
-        const { gen, schema, parentSchema, it } = cxt;
-        /* istanbul ignore if */
-        if (!Array.isArray(schema))
-            throw new Error("ajv implementation error");
-        if (it.opts.discriminator && parentSchema.discriminator)
-            return;
-        const schArr = schema;
-        const valid = gen.let("valid", false);
-        const passing = gen.let("passing", null);
-        const schValid = gen.name("_valid");
-        cxt.setParams({ passing });
-        // TODO possibly fail straight away (with warning or exception) if there are two empty always valid schemas
-        gen.block(validateOneOf);
-        cxt.result(valid, () => cxt.reset(), () => cxt.error(true));
-        function validateOneOf() {
-            schArr.forEach((sch, i) => {
-                let schCxt;
-                if ((0, util_1.alwaysValidSchema)(it, sch)) {
-                    gen.var(schValid, true);
-                }
-                else {
-                    schCxt = cxt.subschema({
-                        keyword: "oneOf",
-                        schemaProp: i,
-                        compositeRule: true,
-                    }, schValid);
-                }
-                if (i > 0) {
-                    gen
-                        .if((0, codegen_1._) `${schValid} && ${valid}`)
-                        .assign(valid, false)
-                        .assign(passing, (0, codegen_1._) `[${passing}, ${i}]`)
-                        .else();
-                }
-                gen.if(schValid, () => {
-                    gen.assign(valid, true);
-                    gen.assign(passing, i);
-                    if (schCxt)
-                        cxt.mergeEvaluated(schCxt, codegen_1.Name);
-                });
-            });
-        }
-    },
-};
-exports.default = def;
-//# sourceMappingURL=oneOf.js.map

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

@@ -1,75 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const code_1 = require("../code");
-const codegen_1 = require("../../compile/codegen");
-const util_1 = require("../../compile/util");
-const util_2 = require("../../compile/util");
-const def = {
-    keyword: "patternProperties",
-    type: "object",
-    schemaType: "object",
-    code(cxt) {
-        const { gen, schema, data, parentSchema, it } = cxt;
-        const { opts } = it;
-        const patterns = (0, code_1.allSchemaProperties)(schema);
-        const alwaysValidPatterns = patterns.filter((p) => (0, util_1.alwaysValidSchema)(it, schema[p]));
-        if (patterns.length === 0 ||
-            (alwaysValidPatterns.length === patterns.length &&
-                (!it.opts.unevaluated || it.props === true))) {
-            return;
-        }
-        const checkProperties = opts.strictSchema && !opts.allowMatchingProperties && parentSchema.properties;
-        const valid = gen.name("valid");
-        if (it.props !== true && !(it.props instanceof codegen_1.Name)) {
-            it.props = (0, util_2.evaluatedPropsToName)(gen, it.props);
-        }
-        const { props } = it;
-        validatePatternProperties();
-        function validatePatternProperties() {
-            for (const pat of patterns) {
-                if (checkProperties)
-                    checkMatchingProperties(pat);
-                if (it.allErrors) {
-                    validateProperties(pat);
-                }
-                else {
-                    gen.var(valid, true); // TODO var
-                    validateProperties(pat);
-                    gen.if(valid);
-                }
-            }
-        }
-        function checkMatchingProperties(pat) {
-            for (const prop in checkProperties) {
-                if (new RegExp(pat).test(prop)) {
-                    (0, util_1.checkStrictMode)(it, `property ${prop} matches pattern ${pat} (use allowMatchingProperties)`);
-                }
-            }
-        }
-        function validateProperties(pat) {
-            gen.forIn("key", data, (key) => {
-                gen.if((0, codegen_1._) `${(0, code_1.usePattern)(cxt, pat)}.test(${key})`, () => {
-                    const alwaysValid = alwaysValidPatterns.includes(pat);
-                    if (!alwaysValid) {
-                        cxt.subschema({
-                            keyword: "patternProperties",
-                            schemaProp: pat,
-                            dataProp: key,
-                            dataPropType: util_2.Type.Str,
-                        }, valid);
-                    }
-                    if (it.opts.unevaluated && props !== true) {
-                        gen.assign((0, codegen_1._) `${props}[${key}]`, true);
-                    }
-                    else if (!alwaysValid && !it.allErrors) {
-                        // can short-circuit if `unevaluatedProperties` is not supported (opts.next === false)
-                        // or if all properties were evaluated (props === true)
-                        gen.if((0, codegen_1.not)(valid), () => gen.break());
-                    }
-                });
-            });
-        }
-    },
-};
-exports.default = def;
-//# sourceMappingURL=patternProperties.js.map

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

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const items_1 = require("./items");
-const def = {
-    keyword: "prefixItems",
-    type: "array",
-    schemaType: ["array"],
-    before: "uniqueItems",
-    code: (cxt) => (0, items_1.validateTuple)(cxt, "items"),
-};
-exports.default = def;
-//# sourceMappingURL=prefixItems.js.map

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

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const validate_1 = require("../../compile/validate");
-const code_1 = require("../code");
-const util_1 = require("../../compile/util");
-const additionalProperties_1 = require("./additionalProperties");
-const def = {
-    keyword: "properties",
-    type: "object",
-    schemaType: "object",
-    code(cxt) {
-        const { gen, schema, parentSchema, data, it } = cxt;
-        if ((it.opts.removeAdditional === "all" && parentSchema.additionalProperties === undefined) ||
-            it.opts.defaultAdditionalProperties === false) {
-            additionalProperties_1.default.code(new validate_1.KeywordCxt(it, additionalProperties_1.default, "additionalProperties"));
-        }
-        const allProps = (0, code_1.allSchemaProperties)(schema);
-        for (const prop of allProps) {
-            it.definedProperties.add(prop);
-        }
-        if (it.opts.unevaluated && allProps.length && it.props !== true) {
-            it.props = util_1.mergeEvaluated.props(gen, (0, util_1.toHash)(allProps), it.props);
-        }
-        const properties = allProps.filter((p) => !(0, util_1.alwaysValidSchema)(it, schema[p]));
-        if (properties.length === 0)
-            return;
-        const valid = gen.name("valid");
-        for (const prop of properties) {
-            if (hasDefault(prop)) {
-                applyPropertySchema(prop);
-            }
-            else {
-                gen.if((0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties));
-                applyPropertySchema(prop);
-                if (!it.allErrors)
-                    gen.else().var(valid, true);
-                gen.endIf();
-            }
-            cxt.it.definedProperties.add(prop);
-            cxt.ok(valid);
-        }
-        function hasDefault(prop) {
-            return it.opts.useDefaults && !it.compositeRule && schema[prop].default !== undefined;
-        }
-        function applyPropertySchema(prop) {
-            cxt.subschema({
-                keyword: "properties",
-                schemaProp: prop,
-                dataProp: prop,
-            }, valid);
-        }
-    },
-};
-exports.default = def;
-//# sourceMappingURL=properties.js.map

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

@@ -1,38 +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: "property name must be valid",
-    params: ({ params }) => (0, codegen_1._) `{propertyName: ${params.propertyName}}`,
-};
-const def = {
-    keyword: "propertyNames",
-    type: "object",
-    schemaType: ["object", "boolean"],
-    error,
-    code(cxt) {
-        const { gen, schema, data, it } = cxt;
-        if ((0, util_1.alwaysValidSchema)(it, schema))
-            return;
-        const valid = gen.name("valid");
-        gen.forIn("key", data, (key) => {
-            cxt.setParams({ propertyName: key });
-            cxt.subschema({
-                keyword: "propertyNames",
-                data: key,
-                dataTypes: ["string"],
-                propertyName: key,
-                compositeRule: true,
-            }, valid);
-            gen.if((0, codegen_1.not)(valid), () => {
-                cxt.error(true);
-                if (!it.allErrors)
-                    gen.break();
-            });
-        });
-        cxt.ok(valid);
-    },
-};
-exports.default = def;
-//# sourceMappingURL=propertyNames.js.map

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

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const util_1 = require("../../compile/util");
-const def = {
-    keyword: ["then", "else"],
-    schemaType: ["object", "boolean"],
-    code({ keyword, parentSchema, it }) {
-        if (parentSchema.if === undefined)
-            (0, util_1.checkStrictMode)(it, `"${keyword}" without "if" is ignored`);
-    },
-};
-exports.default = def;
-//# sourceMappingURL=thenElse.js.map

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

@@ -1,138 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateUnion = exports.validateArray = exports.usePattern = exports.callValidateCode = exports.schemaProperties = exports.allSchemaProperties = exports.noPropertyInData = exports.propertyInData = exports.isOwnProperty = exports.hasPropFunc = exports.reportMissingProp = exports.checkMissingProp = exports.checkReportMissingProp = void 0;
-const codegen_1 = require("../compile/codegen");
-const util_1 = require("../compile/util");
-const names_1 = require("../compile/names");
-const util_2 = require("../compile/util");
-const oasContext_1 = require("./oasContext");
-function checkReportMissingProp(cxt, prop) {
-    const { gen, data, it } = cxt;
-    gen.if(noPropertyInData(gen, data, prop, it.opts.ownProperties), () => {
-        cxt.setParams({ missingProperty: (0, codegen_1._) `${prop}` }, true);
-        cxt.error();
-    });
-}
-exports.checkReportMissingProp = checkReportMissingProp;
-function checkMissingProp({ gen, data, it: { opts }, parentSchema }, properties, missing) {
-    return (0, codegen_1.or)(...properties.map((prop) => {
-        var _a;
-        return (0, codegen_1.and)((0, codegen_1.not)((_a = (0, oasContext_1.getSkipCondition)(parentSchema, prop)) !== null && _a !== void 0 ? _a : (0, codegen_1._) `false`), noPropertyInData(gen, data, prop, opts.ownProperties), (0, codegen_1._) `${missing} = ${prop}`);
-    }));
-}
-exports.checkMissingProp = checkMissingProp;
-function reportMissingProp(cxt, missing) {
-    cxt.setParams({ missingProperty: missing }, true);
-    cxt.error();
-}
-exports.reportMissingProp = reportMissingProp;
-function hasPropFunc(gen) {
-    return gen.scopeValue("func", {
-        // eslint-disable-next-line @typescript-eslint/unbound-method
-        ref: Object.prototype.hasOwnProperty,
-        code: (0, codegen_1._) `Object.prototype.hasOwnProperty`,
-    });
-}
-exports.hasPropFunc = hasPropFunc;
-function isOwnProperty(gen, data, property) {
-    return (0, codegen_1._) `${hasPropFunc(gen)}.call(${data}, ${property})`;
-}
-exports.isOwnProperty = isOwnProperty;
-function propertyInData(gen, data, property, ownProperties) {
-    const cond = (0, codegen_1._) `${data}${(0, codegen_1.getProperty)(property)} !== undefined`;
-    return ownProperties ? (0, codegen_1._) `${cond} && ${isOwnProperty(gen, data, property)}` : cond;
-}
-exports.propertyInData = propertyInData;
-function noPropertyInData(gen, data, property, ownProperties) {
-    const cond = (0, codegen_1._) `${data}${(0, codegen_1.getProperty)(property)} === undefined`;
-    return ownProperties ? (0, codegen_1.or)(cond, (0, codegen_1.not)(isOwnProperty(gen, data, property))) : cond;
-}
-exports.noPropertyInData = noPropertyInData;
-function allSchemaProperties(schemaMap) {
-    return schemaMap ? Object.keys(schemaMap).filter((p) => p !== "__proto__") : [];
-}
-exports.allSchemaProperties = allSchemaProperties;
-function schemaProperties(it, schemaMap) {
-    return allSchemaProperties(schemaMap).filter((p) => !(0, util_1.alwaysValidSchema)(it, schemaMap[p]));
-}
-exports.schemaProperties = schemaProperties;
-function callValidateCode({ schemaCode, data, it: { gen, topSchemaRef, schemaPath, errorPath }, it }, func, context, passSchema) {
-    const dataAndSchema = passSchema ? (0, codegen_1._) `${schemaCode}, ${data}, ${topSchemaRef}${schemaPath}` : data;
-    const valCxt = [
-        [names_1.default.instancePath, (0, codegen_1.strConcat)(names_1.default.instancePath, errorPath)],
-        [names_1.default.parentData, it.parentData],
-        [names_1.default.parentDataProperty, it.parentDataProperty],
-        [names_1.default.rootData, names_1.default.rootData],
-        [names_1.default.isAllOfVariant, it.isAllOfVariant ? 1 : 0],
-    ];
-    if (it.opts.dynamicRef)
-        valCxt.push([names_1.default.dynamicAnchors, names_1.default.dynamicAnchors]);
-    const args = (0, codegen_1._) `${dataAndSchema}, ${gen.object(...valCxt)}`;
-    return context !== codegen_1.nil ? (0, codegen_1._) `${func}.call(${context}, ${args})` : (0, codegen_1._) `${func}(${args})`;
-}
-exports.callValidateCode = callValidateCode;
-const newRegExp = (0, codegen_1._) `new RegExp`;
-function usePattern({ gen, it: { opts } }, pattern) {
-    const u = opts.unicodeRegExp ? "u" : "";
-    const { regExp } = opts.code;
-    const rx = regExp(pattern, u);
-    return gen.scopeValue("pattern", {
-        key: rx.toString(),
-        ref: rx,
-        code: (0, codegen_1._) `${regExp.code === "new RegExp" ? newRegExp : (0, util_2.useFunc)(gen, regExp)}(${pattern}, ${u})`,
-    });
-}
-exports.usePattern = usePattern;
-function validateArray(cxt) {
-    const { gen, data, keyword, it } = cxt;
-    const valid = gen.name("valid");
-    if (it.allErrors) {
-        const validArr = gen.let("valid", true);
-        validateItems(() => gen.assign(validArr, false));
-        return validArr;
-    }
-    gen.var(valid, true);
-    validateItems(() => gen.break());
-    return valid;
-    function validateItems(notValid) {
-        const len = gen.const("len", (0, codegen_1._) `${data}.length`);
-        gen.forRange("i", 0, len, (i) => {
-            cxt.subschema({
-                keyword,
-                dataProp: i,
-                dataPropType: util_1.Type.Num,
-            }, valid);
-            gen.if((0, codegen_1.not)(valid), notValid);
-        });
-    }
-}
-exports.validateArray = validateArray;
-function validateUnion(cxt) {
-    const { gen, schema, keyword, parentSchema, it } = cxt;
-    /* istanbul ignore if */
-    if (!Array.isArray(schema))
-        throw new Error("ajv implementation error");
-    if (it.opts.discriminator && parentSchema.discriminator)
-        return;
-    const alwaysValid = schema.some((sch) => (0, util_1.alwaysValidSchema)(it, sch));
-    if (alwaysValid && !it.opts.unevaluated)
-        return;
-    const valid = gen.let("valid", false);
-    const schValid = gen.name("_valid");
-    gen.block(() => schema.forEach((_sch, i) => {
-        const schCxt = cxt.subschema({
-            keyword,
-            schemaProp: i,
-            compositeRule: true,
-        }, schValid);
-        gen.assign(valid, (0, codegen_1._) `${valid} || ${schValid}`);
-        const merged = cxt.mergeValidEvaluated(schCxt, schValid);
-        // can short-circuit if `unevaluatedProperties/Items` not supported (opts.unevaluated !== true)
-        // or if all properties and items were evaluated (it.props === true && it.items === true)
-        if (!merged)
-            gen.if((0, codegen_1.not)(valid));
-    }));
-    cxt.result(valid, () => cxt.reset(), () => cxt.error(true));
-}
-exports.validateUnion = validateUnion;
-//# sourceMappingURL=code.js.map

package/.output/server/node_modules/@redocly/ajv/dist/vocabularies/core/id.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const def = {
-    keyword: "id",
-    code() {
-        throw new Error('NOT SUPPORTED: keyword "id", use "$id" for schema ID');
-    },
-};
-exports.default = def;
-//# sourceMappingURL=id.js.map

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

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const id_1 = require("./id");
-const ref_1 = require("./ref");
-const core = [
-    "$schema",
-    "$id",
-    "$defs",
-    "$vocabulary",
-    { keyword: "$comment" },
-    "definitions",
-    id_1.default,
-    ref_1.default,
-];
-exports.default = core;
-//# sourceMappingURL=index.js.map

package/.output/server/node_modules/@redocly/ajv/dist/vocabularies/core/ref.js

@@ -1,132 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.callRef = exports.getValidate = void 0;
-const ref_error_1 = require("../../compile/ref_error");
-const code_1 = require("../code");
-const codegen_1 = require("../../compile/codegen");
-const names_1 = require("../../compile/names");
-const compile_1 = require("../../compile");
-const util_1 = require("../../compile/util");
-const def = {
-    keyword: "$ref",
-    schemaType: "string",
-    code(cxt) {
-        const { gen, schema: $ref, it } = cxt;
-        const { baseId, schemaEnv: env, validateName, opts, self } = it;
-        const { root } = env;
-        if (($ref === "#" || $ref === "#/") && baseId === root.baseId)
-            return callRootRef();
-        const schOrEnv = compile_1.resolveRef.call(self, root, baseId, $ref);
-        if (schOrEnv === undefined)
-            throw new ref_error_1.default(it.opts.uriResolver, baseId, $ref);
-        if (schOrEnv instanceof compile_1.SchemaEnv)
-            return callValidate(schOrEnv);
-        return inlineRefSchema(schOrEnv);
-        function callRootRef() {
-            if (env === root)
-                return callRef(cxt, validateName, env, env.$async);
-            const rootName = gen.scopeValue("root", { ref: root });
-            return callRef(cxt, (0, codegen_1._) `${rootName}.validate`, root, root.$async);
-        }
-        function callValidate(sch) {
-            const v = getValidate(cxt, sch);
-            callRef(cxt, v, sch, sch.$async);
-        }
-        function inlineRefSchema(sch) {
-            const schName = gen.scopeValue("schema", opts.code.source === true ? { ref: sch, code: (0, codegen_1.stringify)(sch) } : { ref: sch });
-            const valid = gen.name("valid");
-            const schCxt = cxt.subschema({
-                schema: sch,
-                dataTypes: [],
-                schemaPath: codegen_1.nil,
-                topSchemaRef: schName,
-                errSchemaPath: $ref,
-            }, valid, it.isAllOfVariant // pass isAllOfVariant into inlined $ref
-            );
-            cxt.mergeEvaluated(schCxt);
-            cxt.ok(valid);
-        }
-    },
-};
-function getValidate(cxt, sch) {
-    const { gen } = cxt;
-    return sch.validate
-        ? gen.scopeValue("validate", { ref: sch.validate })
-        : (0, codegen_1._) `${gen.scopeValue("wrapper", { ref: sch })}.validate`;
-}
-exports.getValidate = getValidate;
-function callRef(cxt, v, sch, $async) {
-    const { gen, it } = cxt;
-    const { allErrors, schemaEnv: env, opts } = it;
-    const passCxt = opts.passContext ? names_1.default.this : codegen_1.nil;
-    if ($async)
-        callAsyncRef();
-    else
-        callSyncRef();
-    function callAsyncRef() {
-        if (!env.$async)
-            throw new Error("async schema referenced by sync schema");
-        const valid = gen.let("valid");
-        gen.try(() => {
-            gen.code((0, codegen_1._) `await ${(0, code_1.callValidateCode)(cxt, v, passCxt)}`);
-            addEvaluatedFrom(v); // TODO will not work with async, it has to be returned with the result
-            if (!allErrors)
-                gen.assign(valid, true);
-        }, (e) => {
-            gen.if((0, codegen_1._) `!(${e} instanceof ${it.ValidationError})`, () => gen.throw(e));
-            addErrorsFrom(e);
-            if (!allErrors)
-                gen.assign(valid, false);
-        });
-        cxt.ok(valid);
-    }
-    function callSyncRef() {
-        const visitedNodes = gen.name("visitedNodes");
-        gen.code((0, codegen_1._) `const ${visitedNodes} = (typeof visitedNodesForRef !== 'undefined') && visitedNodesForRef.get(${v}) || new Set()`);
-        gen.if((0, codegen_1._) `!${visitedNodes}.has(${cxt.data})`, () => {
-            gen.code((0, codegen_1._) `if (typeof visitedNodesForRef !== 'undefined') visitedNodesForRef.set(${v}, ${visitedNodes})`);
-            gen.code((0, codegen_1._) `const dataNode = ${cxt.data}`);
-            gen.code((0, codegen_1._) `if (typeof dataNode === "object" && dataNode !== null) ${visitedNodes}.add(dataNode)`);
-            const res = cxt.result((0, code_1.callValidateCode)(cxt, v, passCxt), () => addEvaluatedFrom(v), () => addErrorsFrom(v));
-            gen.code((0, codegen_1._) `${visitedNodes}.delete(dataNode)`);
-            return res;
-        });
-    }
-    function addErrorsFrom(source) {
-        const errs = (0, codegen_1._) `${source}.errors`;
-        gen.assign(names_1.default.vErrors, (0, codegen_1._) `${names_1.default.vErrors} === null ? ${errs} : ${names_1.default.vErrors}.concat(${errs})`); // TODO tagged
-        gen.assign(names_1.default.errors, (0, codegen_1._) `${names_1.default.vErrors}.length`);
-    }
-    function addEvaluatedFrom(source) {
-        var _a;
-        if (!it.opts.unevaluated)
-            return;
-        const schEvaluated = (_a = sch === null || sch === void 0 ? void 0 : sch.validate) === null || _a === void 0 ? void 0 : _a.evaluated;
-        // TODO refactor
-        if (it.props !== true) {
-            if (schEvaluated && !schEvaluated.dynamicProps) {
-                if (schEvaluated.props !== undefined) {
-                    it.props = util_1.mergeEvaluated.props(gen, schEvaluated.props, it.props);
-                }
-            }
-            else {
-                const props = gen.var("props", (0, codegen_1._) `${source}.evaluated.props`);
-                it.props = util_1.mergeEvaluated.props(gen, props, it.props, codegen_1.Name);
-            }
-        }
-        if (it.items !== true) {
-            if (schEvaluated && !schEvaluated.dynamicItems) {
-                if (schEvaluated.items !== undefined) {
-                    it.items = util_1.mergeEvaluated.items(gen, schEvaluated.items, it.items);
-                }
-            }
-            else {
-                const items = gen.var("items", (0, codegen_1._) `${source}.evaluated.items`);
-                it.items = util_1.mergeEvaluated.items(gen, items, it.items, codegen_1.Name);
-            }
-        }
-    }
-}
-exports.callRef = callRef;
-exports.default = def;
-//# sourceMappingURL=ref.js.map