fastapi-rtk 0.1.14 → 0.1.16

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

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

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

@@ -0,0 +1,42 @@
+import { __exports as items2020 } from "../../../../../../../.bundled/jsonforms/esm/_virtual/items2020.mjs";
+import { __require as requireCodegen } from "../../compile/codegen/index.mjs";
+import { __require as requireUtil } from "../../compile/util.mjs";
+import { __require as requireCode } from "../code.mjs";
+import { __require as requireAdditionalItems } from "./additionalItems.mjs";
+var hasRequiredItems2020;
+function requireItems2020() {
+  if (hasRequiredItems2020) return items2020;
+  hasRequiredItems2020 = 1;
+  Object.defineProperty(items2020, "__esModule", { value: true });
+  const codegen_1 = requireCodegen();
+  const util_1 = requireUtil();
+  const code_1 = requireCode();
+  const additionalItems_1 = requireAdditionalItems();
+  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));
+    }
+  };
+  items2020.default = def;
+  return items2020;
+}
+export {
+  requireItems2020 as __require
+};

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/id.mjs

@@ -0,0 +1,18 @@
+import { __exports as id } from "../../../../../../../.bundled/jsonforms/esm/_virtual/id.mjs";
+var hasRequiredId;
+function requireId() {
+  if (hasRequiredId) return id;
+  hasRequiredId = 1;
+  Object.defineProperty(id, "__esModule", { value: true });
+  const def = {
+    keyword: "id",
+    code() {
+      throw new Error('NOT SUPPORTED: keyword "id", use "$id" for schema ID');
+    }
+  };
+  id.default = def;
+  return id;
+}
+export {
+  requireId 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/index7.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
+};