fastapi-rtk 0.1.14 → 0.1.16

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
+};

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/discriminator/types.mjs

@@ -0,0 +1,17 @@
+import { __exports as types } from "../../../../../../../.bundled/jsonforms/esm/_virtual/types.mjs";
+var hasRequiredTypes;
+function requireTypes() {
+  if (hasRequiredTypes) return types;
+  hasRequiredTypes = 1;
+  Object.defineProperty(types, "__esModule", { value: true });
+  types.DiscrError = void 0;
+  var DiscrError;
+  (function(DiscrError2) {
+    DiscrError2["Tag"] = "tag";
+    DiscrError2["Mapping"] = "mapping";
+  })(DiscrError || (types.DiscrError = DiscrError = {}));
+  return types;
+}
+export {
+  requireTypes 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/index10.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/metadata.mjs

@@ -0,0 +1,26 @@
+import { __exports as metadata } from "../../../../../../.bundled/jsonforms/esm/_virtual/metadata.mjs";
+var hasRequiredMetadata;
+function requireMetadata() {
+  if (hasRequiredMetadata) return metadata;
+  hasRequiredMetadata = 1;
+  Object.defineProperty(metadata, "__esModule", { value: true });
+  metadata.contentVocabulary = metadata.metadataVocabulary = void 0;
+  metadata.metadataVocabulary = [
+    "title",
+    "description",
+    "default",
+    "deprecated",
+    "readOnly",
+    "writeOnly",
+    "examples"
+  ];
+  metadata.contentVocabulary = [
+    "contentMediaType",
+    "contentEncoding",
+    "contentSchema"
+  ];
+  return metadata;
+}
+export {
+  requireMetadata 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/index8.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
+};