fastapi-rtk 2.0.1 → 2.0.3

package/dist/.external/esm/ajv@8.17.1/ajv/dist/vocabularies/applicator/not.mjs

@@ -0,0 +1,35 @@
+import { __exports as not } from "../../../../../../../.bundled/jsonforms/esm/_virtual/not.mjs";
+import { __require as requireUtil } from "../../compile/util.mjs";
+var hasRequiredNot;
+function requireNot() {
+  if (hasRequiredNot) return not;
+  hasRequiredNot = 1;
+  Object.defineProperty(not, "__esModule", { value: true });
+  const util_1 = requireUtil();
+  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" }
+  };
+  not.default = def;
+  return not;
+}
+export {
+  requireNot as __require
+};

package/dist/.external/esm/ajv@8.17.1/ajv/dist/vocabularies/applicator/oneOf.mjs

@@ -0,0 +1,63 @@
+import { __exports as oneOf } from "../../../../../../../.bundled/jsonforms/esm/_virtual/oneOf.mjs";
+import { __require as requireCodegen } from "../../compile/codegen/index.mjs";
+import { __require as requireUtil } from "../../compile/util.mjs";
+var hasRequiredOneOf;
+function requireOneOf() {
+  if (hasRequiredOneOf) return oneOf;
+  hasRequiredOneOf = 1;
+  Object.defineProperty(oneOf, "__esModule", { value: true });
+  const codegen_1 = requireCodegen();
+  const util_1 = requireUtil();
+  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;
+      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 });
+      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);
+          });
+        });
+      }
+    }
+  };
+  oneOf.default = def;
+  return oneOf;
+}
+export {
+  requireOneOf as __require
+};

package/dist/.external/esm/ajv@8.17.1/ajv/dist/vocabularies/applicator/patternProperties.mjs

@@ -0,0 +1,80 @@
+import { __exports as patternProperties } from "../../../../../../../.bundled/jsonforms/esm/_virtual/patternProperties.mjs";
+import { __require as requireCode } from "../code.mjs";
+import { __require as requireCodegen } from "../../compile/codegen/index.mjs";
+import { __require as requireUtil } from "../../compile/util.mjs";
+var hasRequiredPatternProperties;
+function requirePatternProperties() {
+  if (hasRequiredPatternProperties) return patternProperties;
+  hasRequiredPatternProperties = 1;
+  Object.defineProperty(patternProperties, "__esModule", { value: true });
+  const code_1 = requireCode();
+  const codegen_1 = requireCodegen();
+  const util_1 = requireUtil();
+  const util_2 = requireUtil();
+  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);
+            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) {
+              gen.if((0, codegen_1.not)(valid), () => gen.break());
+            }
+          });
+        });
+      }
+    }
+  };
+  patternProperties.default = def;
+  return patternProperties;
+}
+export {
+  requirePatternProperties as __require
+};

package/dist/.external/esm/ajv@8.17.1/ajv/dist/vocabularies/applicator/prefixItems.mjs

@@ -0,0 +1,21 @@
+import { __exports as prefixItems } from "../../../../../../../.bundled/jsonforms/esm/_virtual/prefixItems.mjs";
+import { __require as requireItems } from "./items.mjs";
+var hasRequiredPrefixItems;
+function requirePrefixItems() {
+  if (hasRequiredPrefixItems) return prefixItems;
+  hasRequiredPrefixItems = 1;
+  Object.defineProperty(prefixItems, "__esModule", { value: true });
+  const items_1 = requireItems();
+  const def = {
+    keyword: "prefixItems",
+    type: "array",
+    schemaType: ["array"],
+    before: "uniqueItems",
+    code: (cxt) => (0, items_1.validateTuple)(cxt, "items")
+  };
+  prefixItems.default = def;
+  return prefixItems;
+}
+export {
+  requirePrefixItems as __require
+};

package/dist/.external/esm/ajv@8.17.1/ajv/dist/vocabularies/applicator/properties.mjs

@@ -0,0 +1,65 @@
+import { __exports as properties } from "../../../../../../../.bundled/jsonforms/esm/_virtual/properties.mjs";
+import { __require as requireValidate } from "../../compile/validate/index.mjs";
+import { __require as requireCode } from "../code.mjs";
+import { __require as requireUtil } from "../../compile/util.mjs";
+import { __require as requireAdditionalProperties } from "./additionalProperties.mjs";
+var hasRequiredProperties;
+function requireProperties() {
+  if (hasRequiredProperties) return properties;
+  hasRequiredProperties = 1;
+  Object.defineProperty(properties, "__esModule", { value: true });
+  const validate_1 = requireValidate();
+  const code_1 = requireCode();
+  const util_1 = requireUtil();
+  const additionalProperties_1 = requireAdditionalProperties();
+  const def = {
+    keyword: "properties",
+    type: "object",
+    schemaType: "object",
+    code(cxt) {
+      const { gen, schema, parentSchema, data, it } = cxt;
+      if (it.opts.removeAdditional === "all" && parentSchema.additionalProperties === void 0) {
+        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 properties2 = allProps.filter((p) => !(0, util_1.alwaysValidSchema)(it, schema[p]));
+      if (properties2.length === 0)
+        return;
+      const valid = gen.name("valid");
+      for (const prop of properties2) {
+        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 !== void 0;
+      }
+      function applyPropertySchema(prop) {
+        cxt.subschema({
+          keyword: "properties",
+          schemaProp: prop,
+          dataProp: prop
+        }, valid);
+      }
+    }
+  };
+  properties.default = def;
+  return properties;
+}
+export {
+  requireProperties as __require
+};

package/dist/.external/esm/ajv@8.17.1/ajv/dist/vocabularies/applicator/propertyNames.mjs

@@ -0,0 +1,48 @@
+import { __exports as propertyNames } from "../../../../../../../.bundled/jsonforms/esm/_virtual/propertyNames.mjs";
+import { __require as requireCodegen } from "../../compile/codegen/index.mjs";
+import { __require as requireUtil } from "../../compile/util.mjs";
+var hasRequiredPropertyNames;
+function requirePropertyNames() {
+  if (hasRequiredPropertyNames) return propertyNames;
+  hasRequiredPropertyNames = 1;
+  Object.defineProperty(propertyNames, "__esModule", { value: true });
+  const codegen_1 = requireCodegen();
+  const util_1 = requireUtil();
+  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);
+    }
+  };
+  propertyNames.default = def;
+  return propertyNames;
+}
+export {
+  requirePropertyNames as __require
+};

package/dist/.external/esm/ajv@8.17.1/ajv/dist/vocabularies/applicator/thenElse.mjs

@@ -0,0 +1,22 @@
+import { __exports as thenElse } from "../../../../../../../.bundled/jsonforms/esm/_virtual/thenElse.mjs";
+import { __require as requireUtil } from "../../compile/util.mjs";
+var hasRequiredThenElse;
+function requireThenElse() {
+  if (hasRequiredThenElse) return thenElse;
+  hasRequiredThenElse = 1;
+  Object.defineProperty(thenElse, "__esModule", { value: true });
+  const util_1 = requireUtil();
+  const def = {
+    keyword: ["then", "else"],
+    schemaType: ["object", "boolean"],
+    code({ keyword, parentSchema, it }) {
+      if (parentSchema.if === void 0)
+        (0, util_1.checkStrictMode)(it, `"${keyword}" without "if" is ignored`);
+    }
+  };
+  thenElse.default = def;
+  return thenElse;
+}
+export {
+  requireThenElse as __require
+};

package/dist/.external/esm/ajv@8.17.1/ajv/dist/vocabularies/code.mjs

@@ -0,0 +1,139 @@
+import { __exports as code } from "../../../../../../.bundled/jsonforms/esm/_virtual/code2.mjs";
+import { __require as requireCodegen } from "../compile/codegen/index.mjs";
+import { __require as requireUtil } from "../compile/util.mjs";
+import { __require as requireNames } from "../compile/names.mjs";
+var hasRequiredCode;
+function requireCode() {
+  if (hasRequiredCode) return code;
+  hasRequiredCode = 1;
+  Object.defineProperty(code, "__esModule", { value: true });
+  code.validateUnion = code.validateArray = code.usePattern = code.callValidateCode = code.schemaProperties = code.allSchemaProperties = code.noPropertyInData = code.propertyInData = code.isOwnProperty = code.hasPropFunc = code.reportMissingProp = code.checkMissingProp = code.checkReportMissingProp = void 0;
+  const codegen_1 = requireCodegen();
+  const util_1 = requireUtil();
+  const names_1 = requireNames();
+  const util_2 = requireUtil();
+  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();
+    });
+  }
+  code.checkReportMissingProp = checkReportMissingProp;
+  function checkMissingProp({ gen, data, it: { opts } }, properties, missing) {
+    return (0, codegen_1.or)(...properties.map((prop) => (0, codegen_1.and)(noPropertyInData(gen, data, prop, opts.ownProperties), (0, codegen_1._)`${missing} = ${prop}`)));
+  }
+  code.checkMissingProp = checkMissingProp;
+  function reportMissingProp(cxt, missing) {
+    cxt.setParams({ missingProperty: missing }, true);
+    cxt.error();
+  }
+  code.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`
+    });
+  }
+  code.hasPropFunc = hasPropFunc;
+  function isOwnProperty(gen, data, property) {
+    return (0, codegen_1._)`${hasPropFunc(gen)}.call(${data}, ${property})`;
+  }
+  code.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;
+  }
+  code.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;
+  }
+  code.noPropertyInData = noPropertyInData;
+  function allSchemaProperties(schemaMap) {
+    return schemaMap ? Object.keys(schemaMap).filter((p) => p !== "__proto__") : [];
+  }
+  code.allSchemaProperties = allSchemaProperties;
+  function schemaProperties(it, schemaMap) {
+    return allSchemaProperties(schemaMap).filter((p) => !(0, util_1.alwaysValidSchema)(it, schemaMap[p]));
+  }
+  code.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]
+    ];
+    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})`;
+  }
+  code.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})`
+    });
+  }
+  code.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);
+      });
+    }
+  }
+  code.validateArray = validateArray;
+  function validateUnion(cxt) {
+    const { gen, schema, keyword, it } = cxt;
+    if (!Array.isArray(schema))
+      throw new Error("ajv implementation error");
+    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);
+      if (!merged)
+        gen.if((0, codegen_1.not)(valid));
+    }));
+    cxt.result(valid, () => cxt.reset(), () => cxt.error(true));
+  }
+  code.validateUnion = validateUnion;
+  return code;
+}
+export {
+  requireCode as __require
+};

package/dist/.external/esm/ajv@8.17.1/ajv/dist/vocabularies/core/index.mjs

@@ -0,0 +1,26 @@
+import { __exports as core } from "../../../../../../../.bundled/jsonforms/esm/_virtual/index6.mjs";
+import { __require as requireId } from "./id.mjs";
+import { __require as requireRef } from "./ref.mjs";
+var hasRequiredCore;
+function requireCore() {
+  if (hasRequiredCore) return core;
+  hasRequiredCore = 1;
+  Object.defineProperty(core, "__esModule", { value: true });
+  const id_1 = requireId();
+  const ref_1 = requireRef();
+  const core$1 = [
+    "$schema",
+    "$id",
+    "$defs",
+    "$vocabulary",
+    { keyword: "$comment" },
+    "definitions",
+    id_1.default,
+    ref_1.default
+  ];
+  core.default = core$1;
+  return core;
+}
+export {
+  requireCore as __require
+};

package/dist/.external/esm/ajv@8.17.1/ajv/dist/vocabularies/core/ref.mjs

@@ -0,0 +1,131 @@
+import { __exports as ref } from "../../../../../../../.bundled/jsonforms/esm/_virtual/ref.mjs";
+import { __require as requireRef_error } from "../../compile/ref_error.mjs";
+import { __require as requireCode } from "../code.mjs";
+import { __require as requireCodegen } from "../../compile/codegen/index.mjs";
+import { __require as requireNames } from "../../compile/names.mjs";
+import { __require as requireCompile } from "../../compile/index.mjs";
+import { __require as requireUtil } from "../../compile/util.mjs";
+var hasRequiredRef;
+function requireRef() {
+  if (hasRequiredRef) return ref;
+  hasRequiredRef = 1;
+  Object.defineProperty(ref, "__esModule", { value: true });
+  ref.callRef = ref.getValidate = void 0;
+  const ref_error_1 = requireRef_error();
+  const code_1 = requireCode();
+  const codegen_1 = requireCodegen();
+  const names_1 = requireNames();
+  const compile_1 = requireCompile();
+  const util_1 = requireUtil();
+  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 === void 0)
+        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);
+        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`;
+  }
+  ref.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);
+        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() {
+      cxt.result((0, code_1.callValidateCode)(cxt, v, passCxt), () => addEvaluatedFrom(v), () => addErrorsFrom(v));
+    }
+    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})`);
+      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;
+      if (it.props !== true) {
+        if (schEvaluated && !schEvaluated.dynamicProps) {
+          if (schEvaluated.props !== void 0) {
+            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 !== void 0) {
+            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);
+        }
+      }
+    }
+  }
+  ref.callRef = callRef;
+  ref.default = def;
+  return ref;
+}
+export {
+  requireRef as __require
+};