fastapi-rtk 2.0.1 → 2.0.3

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

@@ -0,0 +1,113 @@
+import { __exports as discriminator } from "../../../../../../../.bundled/jsonforms/esm/_virtual/index3.mjs";
+import { __require as requireCodegen } from "../../compile/codegen/index.mjs";
+import { __require as requireTypes } from "./types.mjs";
+import { __require as requireCompile } from "../../compile/index.mjs";
+import { __require as requireRef_error } from "../../compile/ref_error.mjs";
+import { __require as requireUtil } from "../../compile/util.mjs";
+var hasRequiredDiscriminator;
+function requireDiscriminator() {
+  if (hasRequiredDiscriminator) return discriminator;
+  hasRequiredDiscriminator = 1;
+  Object.defineProperty(discriminator, "__esModule", { value: true });
+  const codegen_1 = requireCodegen();
+  const types_1 = requireTypes();
+  const compile_1 = requireCompile();
+  const ref_error_1 = requireRef_error();
+  const util_1 = requireUtil();
+  const error = {
+    message: ({ params: { discrError, tagName } }) => discrError === types_1.DiscrError.Tag ? `tag "${tagName}" must be string` : `value of tag "${tagName}" must be in oneOf`,
+    params: ({ params: { discrError, tag, tagName } }) => (0, codegen_1._)`{error: ${discrError}, tag: ${tagName}, tagValue: ${tag}}`
+  };
+  const def = {
+    keyword: "discriminator",
+    type: "object",
+    schemaType: "object",
+    error,
+    code(cxt) {
+      const { gen, data, schema, parentSchema, it } = cxt;
+      const { oneOf } = parentSchema;
+      if (!it.opts.discriminator) {
+        throw new Error("discriminator: requires discriminator option");
+      }
+      const tagName = schema.propertyName;
+      if (typeof tagName != "string")
+        throw new Error("discriminator: requires propertyName");
+      if (schema.mapping)
+        throw new Error("discriminator: mapping is not supported");
+      if (!oneOf)
+        throw new Error("discriminator: requires oneOf keyword");
+      const valid = gen.let("valid", false);
+      const tag = gen.const("tag", (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(tagName)}`);
+      gen.if((0, codegen_1._)`typeof ${tag} == "string"`, () => validateMapping(), () => cxt.error(false, { discrError: types_1.DiscrError.Tag, tag, tagName }));
+      cxt.ok(valid);
+      function validateMapping() {
+        const mapping = getMapping();
+        gen.if(false);
+        for (const tagValue in mapping) {
+          gen.elseIf((0, codegen_1._)`${tag} === ${tagValue}`);
+          gen.assign(valid, applyTagSchema(mapping[tagValue]));
+        }
+        gen.else();
+        cxt.error(false, { discrError: types_1.DiscrError.Mapping, tag, tagName });
+        gen.endIf();
+      }
+      function applyTagSchema(schemaProp) {
+        const _valid = gen.name("valid");
+        const schCxt = cxt.subschema({ keyword: "oneOf", schemaProp }, _valid);
+        cxt.mergeEvaluated(schCxt, codegen_1.Name);
+        return _valid;
+      }
+      function getMapping() {
+        var _a;
+        const oneOfMapping = {};
+        const topRequired = hasRequired(parentSchema);
+        let tagRequired = true;
+        for (let i = 0; i < oneOf.length; i++) {
+          let sch = oneOf[i];
+          if ((sch === null || sch === void 0 ? void 0 : sch.$ref) && !(0, util_1.schemaHasRulesButRef)(sch, it.self.RULES)) {
+            const ref = sch.$ref;
+            sch = compile_1.resolveRef.call(it.self, it.schemaEnv.root, it.baseId, ref);
+            if (sch instanceof compile_1.SchemaEnv)
+              sch = sch.schema;
+            if (sch === void 0)
+              throw new ref_error_1.default(it.opts.uriResolver, it.baseId, ref);
+          }
+          const propSch = (_a = sch === null || sch === void 0 ? void 0 : sch.properties) === null || _a === void 0 ? void 0 : _a[tagName];
+          if (typeof propSch != "object") {
+            throw new Error(`discriminator: oneOf subschemas (or referenced schemas) must have "properties/${tagName}"`);
+          }
+          tagRequired = tagRequired && (topRequired || hasRequired(sch));
+          addMappings(propSch, i);
+        }
+        if (!tagRequired)
+          throw new Error(`discriminator: "${tagName}" must be required`);
+        return oneOfMapping;
+        function hasRequired({ required }) {
+          return Array.isArray(required) && required.includes(tagName);
+        }
+        function addMappings(sch, i) {
+          if (sch.const) {
+            addMapping(sch.const, i);
+          } else if (sch.enum) {
+            for (const tagValue of sch.enum) {
+              addMapping(tagValue, i);
+            }
+          } else {
+            throw new Error(`discriminator: "properties/${tagName}" must have "const" or "enum"`);
+          }
+        }
+        function addMapping(tagValue, i) {
+          if (typeof tagValue != "string" || tagValue in oneOfMapping) {
+            throw new Error(`discriminator: "${tagName}" values must be unique strings`);
+          }
+          oneOfMapping[tagValue] = i;
+        }
+      }
+    }
+  };
+  discriminator.default = def;
+  return discriminator;
+}
+export {
+  requireDiscriminator as __require
+};

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

@@ -0,0 +1,30 @@
+import { __exports as draft7 } from "../../../../../../.bundled/jsonforms/esm/_virtual/draft7.mjs";
+import { __require as requireCore } from "./core/index.mjs";
+import { __require as requireValidation } from "./validation/index.mjs";
+import { __require as requireApplicator } from "./applicator/index.mjs";
+import { __require as requireFormat } from "./format/index.mjs";
+import { __require as requireMetadata } from "./metadata.mjs";
+var hasRequiredDraft7;
+function requireDraft7() {
+  if (hasRequiredDraft7) return draft7;
+  hasRequiredDraft7 = 1;
+  Object.defineProperty(draft7, "__esModule", { value: true });
+  const core_1 = requireCore();
+  const validation_1 = requireValidation();
+  const applicator_1 = requireApplicator();
+  const format_1 = requireFormat();
+  const metadata_1 = requireMetadata();
+  const draft7Vocabularies = [
+    core_1.default,
+    validation_1.default,
+    (0, applicator_1.default)(),
+    format_1.default,
+    metadata_1.metadataVocabulary,
+    metadata_1.contentVocabulary
+  ];
+  draft7.default = draft7Vocabularies;
+  return draft7;
+}
+export {
+  requireDraft7 as __require
+};

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

@@ -0,0 +1,94 @@
+import { __exports as format } from "../../../../../../../.bundled/jsonforms/esm/_virtual/format.mjs";
+import { __require as requireCodegen } from "../../compile/codegen/index.mjs";
+var hasRequiredFormat;
+function requireFormat() {
+  if (hasRequiredFormat) return format;
+  hasRequiredFormat = 1;
+  Object.defineProperty(format, "__esModule", { value: true });
+  const codegen_1 = requireCodegen();
+  const error = {
+    message: ({ schemaCode }) => (0, codegen_1.str)`must match format "${schemaCode}"`,
+    params: ({ schemaCode }) => (0, codegen_1._)`{format: ${schemaCode}}`
+  };
+  const def = {
+    keyword: "format",
+    type: ["number", "string"],
+    schemaType: "string",
+    $data: true,
+    error,
+    code(cxt, ruleType) {
+      const { gen, data, $data, schema, schemaCode, it } = cxt;
+      const { opts, errSchemaPath, schemaEnv, self } = it;
+      if (!opts.validateFormats)
+        return;
+      if ($data)
+        validate$DataFormat();
+      else
+        validateFormat();
+      function validate$DataFormat() {
+        const fmts = gen.scopeValue("formats", {
+          ref: self.formats,
+          code: opts.code.formats
+        });
+        const fDef = gen.const("fDef", (0, codegen_1._)`${fmts}[${schemaCode}]`);
+        const fType = gen.let("fType");
+        const format2 = gen.let("format");
+        gen.if((0, codegen_1._)`typeof ${fDef} == "object" && !(${fDef} instanceof RegExp)`, () => gen.assign(fType, (0, codegen_1._)`${fDef}.type || "string"`).assign(format2, (0, codegen_1._)`${fDef}.validate`), () => gen.assign(fType, (0, codegen_1._)`"string"`).assign(format2, fDef));
+        cxt.fail$data((0, codegen_1.or)(unknownFmt(), invalidFmt()));
+        function unknownFmt() {
+          if (opts.strictSchema === false)
+            return codegen_1.nil;
+          return (0, codegen_1._)`${schemaCode} && !${format2}`;
+        }
+        function invalidFmt() {
+          const callFormat = schemaEnv.$async ? (0, codegen_1._)`(${fDef}.async ? await ${format2}(${data}) : ${format2}(${data}))` : (0, codegen_1._)`${format2}(${data})`;
+          const validData = (0, codegen_1._)`(typeof ${format2} == "function" ? ${callFormat} : ${format2}.test(${data}))`;
+          return (0, codegen_1._)`${format2} && ${format2} !== true && ${fType} === ${ruleType} && !${validData}`;
+        }
+      }
+      function validateFormat() {
+        const formatDef = self.formats[schema];
+        if (!formatDef) {
+          unknownFormat();
+          return;
+        }
+        if (formatDef === true)
+          return;
+        const [fmtType, format2, fmtRef] = getFormat(formatDef);
+        if (fmtType === ruleType)
+          cxt.pass(validCondition());
+        function unknownFormat() {
+          if (opts.strictSchema === false) {
+            self.logger.warn(unknownMsg());
+            return;
+          }
+          throw new Error(unknownMsg());
+          function unknownMsg() {
+            return `unknown format "${schema}" ignored in schema at path "${errSchemaPath}"`;
+          }
+        }
+        function getFormat(fmtDef) {
+          const code = fmtDef instanceof RegExp ? (0, codegen_1.regexpCode)(fmtDef) : opts.code.formats ? (0, codegen_1._)`${opts.code.formats}${(0, codegen_1.getProperty)(schema)}` : void 0;
+          const fmt = gen.scopeValue("formats", { key: schema, ref: fmtDef, code });
+          if (typeof fmtDef == "object" && !(fmtDef instanceof RegExp)) {
+            return [fmtDef.type || "string", fmtDef.validate, (0, codegen_1._)`${fmt}.validate`];
+          }
+          return ["string", fmtDef, fmt];
+        }
+        function validCondition() {
+          if (typeof formatDef == "object" && !(formatDef instanceof RegExp) && formatDef.async) {
+            if (!schemaEnv.$async)
+              throw new Error("async format in sync schema");
+            return (0, codegen_1._)`await ${fmtRef}(${data})`;
+          }
+          return typeof format2 == "function" ? (0, codegen_1._)`${fmtRef}(${data})` : (0, codegen_1._)`${fmtRef}.test(${data})`;
+        }
+      }
+    }
+  };
+  format.default = def;
+  return format;
+}
+export {
+  requireFormat as __require
+};

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

@@ -0,0 +1,15 @@
+import { __exports as format } from "../../../../../../../.bundled/jsonforms/esm/_virtual/index9.mjs";
+import { __require as requireFormat$1 } from "./format.mjs";
+var hasRequiredFormat;
+function requireFormat() {
+  if (hasRequiredFormat) return format;
+  hasRequiredFormat = 1;
+  Object.defineProperty(format, "__esModule", { value: true });
+  const format_1 = requireFormat$1();
+  const format$1 = [format_1.default];
+  format.default = format$1;
+  return format;
+}
+export {
+  requireFormat as __require
+};

package/dist/.external/esm/ajv@8.17.1/ajv/dist/vocabularies/validation/const.mjs

@@ -0,0 +1,35 @@
+import { __exports as _const } from "../../../../../../../.bundled/jsonforms/esm/_virtual/const.mjs";
+import { __require as requireCodegen } from "../../compile/codegen/index.mjs";
+import { __require as requireUtil } from "../../compile/util.mjs";
+import { __require as requireEqual } from "../../runtime/equal.mjs";
+var hasRequired_const;
+function require_const() {
+  if (hasRequired_const) return _const;
+  hasRequired_const = 1;
+  Object.defineProperty(_const, "__esModule", { value: true });
+  const codegen_1 = requireCodegen();
+  const util_1 = requireUtil();
+  const equal_1 = requireEqual();
+  const error = {
+    message: "must be equal to constant",
+    params: ({ schemaCode }) => (0, codegen_1._)`{allowedValue: ${schemaCode}}`
+  };
+  const def = {
+    keyword: "const",
+    $data: true,
+    error,
+    code(cxt) {
+      const { gen, data, $data, schemaCode, schema } = cxt;
+      if ($data || schema && typeof schema == "object") {
+        cxt.fail$data((0, codegen_1._)`!${(0, util_1.useFunc)(gen, equal_1.default)}(${data}, ${schemaCode})`);
+      } else {
+        cxt.fail((0, codegen_1._)`${schema} !== ${data}`);
+      }
+    }
+  };
+  _const.default = def;
+  return _const;
+}
+export {
+  require_const as __require
+};

package/dist/.external/esm/ajv@8.17.1/ajv/dist/vocabularies/validation/enum.mjs

@@ -0,0 +1,55 @@
+import { __exports as _enum } from "../../../../../../../.bundled/jsonforms/esm/_virtual/enum.mjs";
+import { __require as requireCodegen } from "../../compile/codegen/index.mjs";
+import { __require as requireUtil } from "../../compile/util.mjs";
+import { __require as requireEqual } from "../../runtime/equal.mjs";
+var hasRequired_enum;
+function require_enum() {
+  if (hasRequired_enum) return _enum;
+  hasRequired_enum = 1;
+  Object.defineProperty(_enum, "__esModule", { value: true });
+  const codegen_1 = requireCodegen();
+  const util_1 = requireUtil();
+  const equal_1 = requireEqual();
+  const error = {
+    message: "must be equal to one of the allowed values",
+    params: ({ schemaCode }) => (0, codegen_1._)`{allowedValues: ${schemaCode}}`
+  };
+  const def = {
+    keyword: "enum",
+    schemaType: "array",
+    $data: true,
+    error,
+    code(cxt) {
+      const { gen, data, $data, schema, schemaCode, it } = cxt;
+      if (!$data && schema.length === 0)
+        throw new Error("enum must have non-empty array");
+      const useLoop = schema.length >= it.opts.loopEnum;
+      let eql;
+      const getEql = () => eql !== null && eql !== void 0 ? eql : eql = (0, util_1.useFunc)(gen, equal_1.default);
+      let valid;
+      if (useLoop || $data) {
+        valid = gen.let("valid");
+        cxt.block$data(valid, loopEnum);
+      } else {
+        if (!Array.isArray(schema))
+          throw new Error("ajv implementation error");
+        const vSchema = gen.const("vSchema", schemaCode);
+        valid = (0, codegen_1.or)(...schema.map((_x, i) => equalCode(vSchema, i)));
+      }
+      cxt.pass(valid);
+      function loopEnum() {
+        gen.assign(valid, false);
+        gen.forOf("v", schemaCode, (v) => gen.if((0, codegen_1._)`${getEql()}(${data}, ${v})`, () => gen.assign(valid, true).break()));
+      }
+      function equalCode(vSchema, i) {
+        const sch = schema[i];
+        return typeof sch === "object" && sch !== null ? (0, codegen_1._)`${getEql()}(${data}, ${vSchema}[${i}])` : (0, codegen_1._)`${data} === ${sch}`;
+      }
+    }
+  };
+  _enum.default = def;
+  return _enum;
+}
+export {
+  require_enum as __require
+};

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

@@ -0,0 +1,51 @@
+import { __exports as validation } from "../../../../../../../.bundled/jsonforms/esm/_virtual/index7.mjs";
+import { __require as requireLimitNumber } from "./limitNumber.mjs";
+import { __require as requireMultipleOf } from "./multipleOf.mjs";
+import { __require as requireLimitLength } from "./limitLength.mjs";
+import { __require as requirePattern } from "./pattern.mjs";
+import { __require as requireLimitProperties } from "./limitProperties.mjs";
+import { __require as requireRequired } from "./required.mjs";
+import { __require as requireLimitItems } from "./limitItems.mjs";
+import { __require as requireUniqueItems } from "./uniqueItems.mjs";
+import { __require as require_const } from "./const.mjs";
+import { __require as require_enum } from "./enum.mjs";
+var hasRequiredValidation;
+function requireValidation() {
+  if (hasRequiredValidation) return validation;
+  hasRequiredValidation = 1;
+  Object.defineProperty(validation, "__esModule", { value: true });
+  const limitNumber_1 = requireLimitNumber();
+  const multipleOf_1 = requireMultipleOf();
+  const limitLength_1 = requireLimitLength();
+  const pattern_1 = requirePattern();
+  const limitProperties_1 = requireLimitProperties();
+  const required_1 = requireRequired();
+  const limitItems_1 = requireLimitItems();
+  const uniqueItems_1 = requireUniqueItems();
+  const const_1 = require_const();
+  const enum_1 = require_enum();
+  const validation$1 = [
+    // number
+    limitNumber_1.default,
+    multipleOf_1.default,
+    // string
+    limitLength_1.default,
+    pattern_1.default,
+    // object
+    limitProperties_1.default,
+    required_1.default,
+    // array
+    limitItems_1.default,
+    uniqueItems_1.default,
+    // any
+    { keyword: "type", schemaType: ["string", "array"] },
+    { keyword: "nullable", schemaType: "boolean" },
+    const_1.default,
+    enum_1.default
+  ];
+  validation.default = validation$1;
+  return validation;
+}
+export {
+  requireValidation as __require
+};

package/dist/.external/esm/ajv@8.17.1/ajv/dist/vocabularies/validation/limitItems.mjs

@@ -0,0 +1,33 @@
+import { __exports as limitItems } from "../../../../../../../.bundled/jsonforms/esm/_virtual/limitItems.mjs";
+import { __require as requireCodegen } from "../../compile/codegen/index.mjs";
+var hasRequiredLimitItems;
+function requireLimitItems() {
+  if (hasRequiredLimitItems) return limitItems;
+  hasRequiredLimitItems = 1;
+  Object.defineProperty(limitItems, "__esModule", { value: true });
+  const codegen_1 = requireCodegen();
+  const error = {
+    message({ keyword, schemaCode }) {
+      const comp = keyword === "maxItems" ? "more" : "fewer";
+      return (0, codegen_1.str)`must NOT have ${comp} than ${schemaCode} items`;
+    },
+    params: ({ schemaCode }) => (0, codegen_1._)`{limit: ${schemaCode}}`
+  };
+  const def = {
+    keyword: ["maxItems", "minItems"],
+    type: "array",
+    schemaType: "number",
+    $data: true,
+    error,
+    code(cxt) {
+      const { keyword, data, schemaCode } = cxt;
+      const op = keyword === "maxItems" ? codegen_1.operators.GT : codegen_1.operators.LT;
+      cxt.fail$data((0, codegen_1._)`${data}.length ${op} ${schemaCode}`);
+    }
+  };
+  limitItems.default = def;
+  return limitItems;
+}
+export {
+  requireLimitItems as __require
+};

package/dist/.external/esm/ajv@8.17.1/ajv/dist/vocabularies/validation/limitLength.mjs

@@ -0,0 +1,38 @@
+import { __exports as limitLength } from "../../../../../../../.bundled/jsonforms/esm/_virtual/limitLength.mjs";
+import { __require as requireCodegen } from "../../compile/codegen/index.mjs";
+import { __require as requireUtil } from "../../compile/util.mjs";
+import { __require as requireUcs2length } from "../../runtime/ucs2length.mjs";
+var hasRequiredLimitLength;
+function requireLimitLength() {
+  if (hasRequiredLimitLength) return limitLength;
+  hasRequiredLimitLength = 1;
+  Object.defineProperty(limitLength, "__esModule", { value: true });
+  const codegen_1 = requireCodegen();
+  const util_1 = requireUtil();
+  const ucs2length_1 = requireUcs2length();
+  const error = {
+    message({ keyword, schemaCode }) {
+      const comp = keyword === "maxLength" ? "more" : "fewer";
+      return (0, codegen_1.str)`must NOT have ${comp} than ${schemaCode} characters`;
+    },
+    params: ({ schemaCode }) => (0, codegen_1._)`{limit: ${schemaCode}}`
+  };
+  const def = {
+    keyword: ["maxLength", "minLength"],
+    type: "string",
+    schemaType: "number",
+    $data: true,
+    error,
+    code(cxt) {
+      const { keyword, data, schemaCode, it } = cxt;
+      const op = keyword === "maxLength" ? codegen_1.operators.GT : codegen_1.operators.LT;
+      const len = it.opts.unicode === false ? (0, codegen_1._)`${data}.length` : (0, codegen_1._)`${(0, util_1.useFunc)(cxt.gen, ucs2length_1.default)}(${data})`;
+      cxt.fail$data((0, codegen_1._)`${len} ${op} ${schemaCode}`);
+    }
+  };
+  limitLength.default = def;
+  return limitLength;
+}
+export {
+  requireLimitLength as __require
+};

package/dist/.external/esm/ajv@8.17.1/ajv/dist/vocabularies/validation/limitNumber.mjs

@@ -0,0 +1,36 @@
+import { __exports as limitNumber } from "../../../../../../../.bundled/jsonforms/esm/_virtual/limitNumber.mjs";
+import { __require as requireCodegen } from "../../compile/codegen/index.mjs";
+var hasRequiredLimitNumber;
+function requireLimitNumber() {
+  if (hasRequiredLimitNumber) return limitNumber;
+  hasRequiredLimitNumber = 1;
+  Object.defineProperty(limitNumber, "__esModule", { value: true });
+  const codegen_1 = requireCodegen();
+  const ops = codegen_1.operators;
+  const KWDs = {
+    maximum: { okStr: "<=", ok: ops.LTE, fail: ops.GT },
+    minimum: { okStr: ">=", ok: ops.GTE, fail: ops.LT },
+    exclusiveMaximum: { okStr: "<", ok: ops.LT, fail: ops.GTE },
+    exclusiveMinimum: { okStr: ">", ok: ops.GT, fail: ops.LTE }
+  };
+  const error = {
+    message: ({ keyword, schemaCode }) => (0, codegen_1.str)`must be ${KWDs[keyword].okStr} ${schemaCode}`,
+    params: ({ keyword, schemaCode }) => (0, codegen_1._)`{comparison: ${KWDs[keyword].okStr}, limit: ${schemaCode}}`
+  };
+  const def = {
+    keyword: Object.keys(KWDs),
+    type: "number",
+    schemaType: "number",
+    $data: true,
+    error,
+    code(cxt) {
+      const { keyword, data, schemaCode } = cxt;
+      cxt.fail$data((0, codegen_1._)`${data} ${KWDs[keyword].fail} ${schemaCode} || isNaN(${data})`);
+    }
+  };
+  limitNumber.default = def;
+  return limitNumber;
+}
+export {
+  requireLimitNumber as __require
+};

package/dist/.external/esm/ajv@8.17.1/ajv/dist/vocabularies/validation/limitProperties.mjs

@@ -0,0 +1,33 @@
+import { __exports as limitProperties } from "../../../../../../../.bundled/jsonforms/esm/_virtual/limitProperties.mjs";
+import { __require as requireCodegen } from "../../compile/codegen/index.mjs";
+var hasRequiredLimitProperties;
+function requireLimitProperties() {
+  if (hasRequiredLimitProperties) return limitProperties;
+  hasRequiredLimitProperties = 1;
+  Object.defineProperty(limitProperties, "__esModule", { value: true });
+  const codegen_1 = requireCodegen();
+  const error = {
+    message({ keyword, schemaCode }) {
+      const comp = keyword === "maxProperties" ? "more" : "fewer";
+      return (0, codegen_1.str)`must NOT have ${comp} than ${schemaCode} properties`;
+    },
+    params: ({ schemaCode }) => (0, codegen_1._)`{limit: ${schemaCode}}`
+  };
+  const def = {
+    keyword: ["maxProperties", "minProperties"],
+    type: "object",
+    schemaType: "number",
+    $data: true,
+    error,
+    code(cxt) {
+      const { keyword, data, schemaCode } = cxt;
+      const op = keyword === "maxProperties" ? codegen_1.operators.GT : codegen_1.operators.LT;
+      cxt.fail$data((0, codegen_1._)`Object.keys(${data}).length ${op} ${schemaCode}`);
+    }
+  };
+  limitProperties.default = def;
+  return limitProperties;
+}
+export {
+  requireLimitProperties as __require
+};

package/dist/.external/esm/ajv@8.17.1/ajv/dist/vocabularies/validation/multipleOf.mjs

@@ -0,0 +1,32 @@
+import { __exports as multipleOf } from "../../../../../../../.bundled/jsonforms/esm/_virtual/multipleOf.mjs";
+import { __require as requireCodegen } from "../../compile/codegen/index.mjs";
+var hasRequiredMultipleOf;
+function requireMultipleOf() {
+  if (hasRequiredMultipleOf) return multipleOf;
+  hasRequiredMultipleOf = 1;
+  Object.defineProperty(multipleOf, "__esModule", { value: true });
+  const codegen_1 = requireCodegen();
+  const error = {
+    message: ({ schemaCode }) => (0, codegen_1.str)`must be multiple of ${schemaCode}`,
+    params: ({ schemaCode }) => (0, codegen_1._)`{multipleOf: ${schemaCode}}`
+  };
+  const def = {
+    keyword: "multipleOf",
+    type: "number",
+    schemaType: "number",
+    $data: true,
+    error,
+    code(cxt) {
+      const { gen, data, schemaCode, it } = cxt;
+      const prec = it.opts.multipleOfPrecision;
+      const res = gen.let("res");
+      const invalid = prec ? (0, codegen_1._)`Math.abs(Math.round(${res}) - ${res}) > 1e-${prec}` : (0, codegen_1._)`${res} !== parseInt(${res})`;
+      cxt.fail$data((0, codegen_1._)`(${schemaCode} === 0 || (${res} = ${data}/${schemaCode}, ${invalid}))`);
+    }
+  };
+  multipleOf.default = def;
+  return multipleOf;
+}
+export {
+  requireMultipleOf as __require
+};

package/dist/.external/esm/ajv@8.17.1/ajv/dist/vocabularies/validation/pattern.mjs

@@ -0,0 +1,33 @@
+import { __exports as pattern } from "../../../../../../../.bundled/jsonforms/esm/_virtual/pattern.mjs";
+import { __require as requireCode } from "../code.mjs";
+import { __require as requireCodegen } from "../../compile/codegen/index.mjs";
+var hasRequiredPattern;
+function requirePattern() {
+  if (hasRequiredPattern) return pattern;
+  hasRequiredPattern = 1;
+  Object.defineProperty(pattern, "__esModule", { value: true });
+  const code_1 = requireCode();
+  const codegen_1 = requireCodegen();
+  const error = {
+    message: ({ schemaCode }) => (0, codegen_1.str)`must match pattern "${schemaCode}"`,
+    params: ({ schemaCode }) => (0, codegen_1._)`{pattern: ${schemaCode}}`
+  };
+  const def = {
+    keyword: "pattern",
+    type: "string",
+    schemaType: "string",
+    $data: true,
+    error,
+    code(cxt) {
+      const { data, $data, schema, schemaCode, it } = cxt;
+      const u = it.opts.unicodeRegExp ? "u" : "";
+      const regExp = $data ? (0, codegen_1._)`(new RegExp(${schemaCode}, ${u}))` : (0, code_1.usePattern)(cxt, schema);
+      cxt.fail$data((0, codegen_1._)`!${regExp}.test(${data})`);
+    }
+  };
+  pattern.default = def;
+  return pattern;
+}
+export {
+  requirePattern as __require
+};