fastapi-rtk 0.1.14 → 0.1.16

package/dist/.external/esm/ajv@8.17.1/ajv/dist/runtime/equal.mjs

@@ -0,0 +1,15 @@
+import { __exports as equal } from "../../../../../../.bundled/jsonforms/esm/_virtual/equal.mjs";
+import { __require as requireFastDeepEqual } from "../../../../fast-deep-equal@3.1.3/fast-deep-equal/index.mjs";
+var hasRequiredEqual;
+function requireEqual() {
+  if (hasRequiredEqual) return equal;
+  hasRequiredEqual = 1;
+  Object.defineProperty(equal, "__esModule", { value: true });
+  const equal$1 = requireFastDeepEqual();
+  equal$1.code = 'require("ajv/dist/runtime/equal").default';
+  equal.default = equal$1;
+  return equal;
+}
+export {
+  requireEqual as __require
+};

package/dist/.external/esm/ajv@8.17.1/ajv/dist/runtime/ucs2length.mjs

@@ -0,0 +1,29 @@
+import { __exports as ucs2length } from "../../../../../../.bundled/jsonforms/esm/_virtual/ucs2length.mjs";
+var hasRequiredUcs2length;
+function requireUcs2length() {
+  if (hasRequiredUcs2length) return ucs2length;
+  hasRequiredUcs2length = 1;
+  Object.defineProperty(ucs2length, "__esModule", { value: true });
+  function ucs2length$1(str) {
+    const len = str.length;
+    let length = 0;
+    let pos = 0;
+    let value;
+    while (pos < len) {
+      length++;
+      value = str.charCodeAt(pos++);
+      if (value >= 55296 && value <= 56319 && pos < len) {
+        value = str.charCodeAt(pos);
+        if ((value & 64512) === 56320)
+          pos++;
+      }
+    }
+    return length;
+  }
+  ucs2length.default = ucs2length$1;
+  ucs2length$1.code = 'require("ajv/dist/runtime/ucs2length").default';
+  return ucs2length;
+}
+export {
+  requireUcs2length as __require
+};

package/dist/.external/esm/ajv@8.17.1/ajv/dist/runtime/uri.mjs

@@ -0,0 +1,15 @@
+import { __exports as uri } from "../../../../../../.bundled/jsonforms/esm/_virtual/uri.mjs";
+import { __require as requireFastUri } from "../../../../fast-uri@3.0.6/fast-uri/index.mjs";
+var hasRequiredUri;
+function requireUri() {
+  if (hasRequiredUri) return uri;
+  hasRequiredUri = 1;
+  Object.defineProperty(uri, "__esModule", { value: true });
+  const uri$1 = requireFastUri();
+  uri$1.code = 'require("ajv/dist/runtime/uri").default';
+  uri.default = uri$1;
+  return uri;
+}
+export {
+  requireUri as __require
+};

package/dist/.external/esm/ajv@8.17.1/ajv/dist/runtime/validation_error.mjs

@@ -0,0 +1,19 @@
+import { __exports as validation_error } from "../../../../../../.bundled/jsonforms/esm/_virtual/validation_error.mjs";
+var hasRequiredValidation_error;
+function requireValidation_error() {
+  if (hasRequiredValidation_error) return validation_error;
+  hasRequiredValidation_error = 1;
+  Object.defineProperty(validation_error, "__esModule", { value: true });
+  class ValidationError extends Error {
+    constructor(errors) {
+      super("validation failed");
+      this.errors = errors;
+      this.ajv = this.validation = true;
+    }
+  }
+  validation_error.default = ValidationError;
+  return validation_error;
+}
+export {
+  requireValidation_error as __require
+};

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

@@ -0,0 +1,58 @@
+import { __exports as additionalItems } from "../../../../../../../.bundled/jsonforms/esm/_virtual/additionalItems.mjs";
+import { __require as requireCodegen } from "../../compile/codegen/index.mjs";
+import { __require as requireUtil } from "../../compile/util.mjs";
+var hasRequiredAdditionalItems;
+function requireAdditionalItems() {
+  if (hasRequiredAdditionalItems) return additionalItems;
+  hasRequiredAdditionalItems = 1;
+  Object.defineProperty(additionalItems, "__esModule", { value: true });
+  additionalItems.validateAdditionalItems = void 0;
+  const codegen_1 = requireCodegen();
+  const util_1 = requireUtil();
+  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: "additionalItems",
+    type: "array",
+    schemaType: ["boolean", "object"],
+    before: "uniqueItems",
+    error,
+    code(cxt) {
+      const { parentSchema, it } = cxt;
+      const { items } = parentSchema;
+      if (!Array.isArray(items)) {
+        (0, util_1.checkStrictMode)(it, '"additionalItems" is ignored when "items" is not an array of schemas');
+        return;
+      }
+      validateAdditionalItems(cxt, items);
+    }
+  };
+  function validateAdditionalItems(cxt, items) {
+    const { gen, schema, data, keyword, it } = cxt;
+    it.items = true;
+    const len = gen.const("len", (0, codegen_1._)`${data}.length`);
+    if (schema === false) {
+      cxt.setParams({ len: items.length });
+      cxt.pass((0, codegen_1._)`${len} <= ${items.length}`);
+    } else if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) {
+      const valid = gen.var("valid", (0, codegen_1._)`${len} <= ${items.length}`);
+      gen.if((0, codegen_1.not)(valid), () => validateItems(valid));
+      cxt.ok(valid);
+    }
+    function validateItems(valid) {
+      gen.forRange("i", items.length, len, (i) => {
+        cxt.subschema({ keyword, dataProp: i, dataPropType: util_1.Type.Num }, valid);
+        if (!it.allErrors)
+          gen.if((0, codegen_1.not)(valid), () => gen.break());
+      });
+    }
+  }
+  additionalItems.validateAdditionalItems = validateAdditionalItems;
+  additionalItems.default = def;
+  return additionalItems;
+}
+export {
+  requireAdditionalItems as __require
+};

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

@@ -0,0 +1,113 @@
+import { __exports as additionalProperties } from "../../../../../../../.bundled/jsonforms/esm/_virtual/additionalProperties.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 requireUtil } from "../../compile/util.mjs";
+var hasRequiredAdditionalProperties;
+function requireAdditionalProperties() {
+  if (hasRequiredAdditionalProperties) return additionalProperties;
+  hasRequiredAdditionalProperties = 1;
+  Object.defineProperty(additionalProperties, "__esModule", { value: true });
+  const code_1 = requireCode();
+  const codegen_1 = requireCodegen();
+  const names_1 = requireNames();
+  const util_1 = requireUtil();
+  const error = {
+    message: "must NOT have additional properties",
+    params: ({ params }) => (0, codegen_1._)`{additionalProperty: ${params.additionalProperty}}`
+  };
+  const def = {
+    keyword: "additionalProperties",
+    type: ["object"],
+    schemaType: ["boolean", "object"],
+    allowUndefined: true,
+    trackErrors: true,
+    error,
+    code(cxt) {
+      const { gen, schema, parentSchema, data, errsCount, it } = cxt;
+      if (!errsCount)
+        throw new Error("ajv implementation error");
+      const { allErrors, opts } = it;
+      it.props = true;
+      if (opts.removeAdditional !== "all" && (0, util_1.alwaysValidSchema)(it, schema))
+        return;
+      const props = (0, code_1.allSchemaProperties)(parentSchema.properties);
+      const patProps = (0, code_1.allSchemaProperties)(parentSchema.patternProperties);
+      checkAdditionalProperties();
+      cxt.ok((0, codegen_1._)`${errsCount} === ${names_1.default.errors}`);
+      function checkAdditionalProperties() {
+        gen.forIn("key", data, (key) => {
+          if (!props.length && !patProps.length)
+            additionalPropertyCode(key);
+          else
+            gen.if(isAdditional(key), () => additionalPropertyCode(key));
+        });
+      }
+      function isAdditional(key) {
+        let definedProp;
+        if (props.length > 8) {
+          const propsSchema = (0, util_1.schemaRefOrVal)(it, parentSchema.properties, "properties");
+          definedProp = (0, code_1.isOwnProperty)(gen, propsSchema, key);
+        } else if (props.length) {
+          definedProp = (0, codegen_1.or)(...props.map((p) => (0, codegen_1._)`${key} === ${p}`));
+        } else {
+          definedProp = codegen_1.nil;
+        }
+        if (patProps.length) {
+          definedProp = (0, codegen_1.or)(definedProp, ...patProps.map((p) => (0, codegen_1._)`${(0, code_1.usePattern)(cxt, p)}.test(${key})`));
+        }
+        return (0, codegen_1.not)(definedProp);
+      }
+      function deleteAdditional(key) {
+        gen.code((0, codegen_1._)`delete ${data}[${key}]`);
+      }
+      function additionalPropertyCode(key) {
+        if (opts.removeAdditional === "all" || opts.removeAdditional && schema === false) {
+          deleteAdditional(key);
+          return;
+        }
+        if (schema === false) {
+          cxt.setParams({ additionalProperty: key });
+          cxt.error();
+          if (!allErrors)
+            gen.break();
+          return;
+        }
+        if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) {
+          const valid = gen.name("valid");
+          if (opts.removeAdditional === "failing") {
+            applyAdditionalSchema(key, valid, false);
+            gen.if((0, codegen_1.not)(valid), () => {
+              cxt.reset();
+              deleteAdditional(key);
+            });
+          } else {
+            applyAdditionalSchema(key, valid);
+            if (!allErrors)
+              gen.if((0, codegen_1.not)(valid), () => gen.break());
+          }
+        }
+      }
+      function applyAdditionalSchema(key, valid, errors) {
+        const subschema = {
+          keyword: "additionalProperties",
+          dataProp: key,
+          dataPropType: util_1.Type.Str
+        };
+        if (errors === false) {
+          Object.assign(subschema, {
+            compositeRule: true,
+            createErrors: false,
+            allErrors: false
+          });
+        }
+        cxt.subschema(subschema, valid);
+      }
+    }
+  };
+  additionalProperties.default = def;
+  return additionalProperties;
+}
+export {
+  requireAdditionalProperties as __require
+};

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

@@ -0,0 +1,31 @@
+import { __exports as allOf } from "../../../../../../../.bundled/jsonforms/esm/_virtual/allOf.mjs";
+import { __require as requireUtil } from "../../compile/util.mjs";
+var hasRequiredAllOf;
+function requireAllOf() {
+  if (hasRequiredAllOf) return allOf;
+  hasRequiredAllOf = 1;
+  Object.defineProperty(allOf, "__esModule", { value: true });
+  const util_1 = requireUtil();
+  const def = {
+    keyword: "allOf",
+    schemaType: "array",
+    code(cxt) {
+      const { gen, schema, it } = cxt;
+      if (!Array.isArray(schema))
+        throw new Error("ajv implementation error");
+      const valid = gen.name("valid");
+      schema.forEach((sch, i) => {
+        if ((0, util_1.alwaysValidSchema)(it, sch))
+          return;
+        const schCxt = cxt.subschema({ keyword: "allOf", schemaProp: i }, valid);
+        cxt.ok(valid);
+        cxt.mergeEvaluated(schCxt);
+      });
+    }
+  };
+  allOf.default = def;
+  return allOf;
+}
+export {
+  requireAllOf as __require
+};

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

@@ -0,0 +1,21 @@
+import { __exports as anyOf } from "../../../../../../../.bundled/jsonforms/esm/_virtual/anyOf.mjs";
+import { __require as requireCode } from "../code.mjs";
+var hasRequiredAnyOf;
+function requireAnyOf() {
+  if (hasRequiredAnyOf) return anyOf;
+  hasRequiredAnyOf = 1;
+  Object.defineProperty(anyOf, "__esModule", { value: true });
+  const code_1 = requireCode();
+  const def = {
+    keyword: "anyOf",
+    schemaType: "array",
+    trackErrors: true,
+    code: code_1.validateUnion,
+    error: { message: "must match a schema in anyOf" }
+  };
+  anyOf.default = def;
+  return anyOf;
+}
+export {
+  requireAnyOf as __require
+};

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

@@ -0,0 +1,99 @@
+import { __exports as contains } from "../../../../../../../.bundled/jsonforms/esm/_virtual/contains.mjs";
+import { __require as requireCodegen } from "../../compile/codegen/index.mjs";
+import { __require as requireUtil } from "../../compile/util.mjs";
+var hasRequiredContains;
+function requireContains() {
+  if (hasRequiredContains) return contains;
+  hasRequiredContains = 1;
+  Object.defineProperty(contains, "__esModule", { value: true });
+  const codegen_1 = requireCodegen();
+  const util_1 = requireUtil();
+  const error = {
+    message: ({ params: { min, max } }) => max === void 0 ? (0, codegen_1.str)`must contain at least ${min} valid item(s)` : (0, codegen_1.str)`must contain at least ${min} and no more than ${max} valid item(s)`,
+    params: ({ params: { min, max } }) => max === void 0 ? (0, codegen_1._)`{minContains: ${min}}` : (0, codegen_1._)`{minContains: ${min}, maxContains: ${max}}`
+  };
+  const def = {
+    keyword: "contains",
+    type: "array",
+    schemaType: ["object", "boolean"],
+    before: "uniqueItems",
+    trackErrors: true,
+    error,
+    code(cxt) {
+      const { gen, schema, parentSchema, data, it } = cxt;
+      let min;
+      let max;
+      const { minContains, maxContains } = parentSchema;
+      if (it.opts.next) {
+        min = minContains === void 0 ? 1 : minContains;
+        max = maxContains;
+      } else {
+        min = 1;
+      }
+      const len = gen.const("len", (0, codegen_1._)`${data}.length`);
+      cxt.setParams({ min, max });
+      if (max === void 0 && min === 0) {
+        (0, util_1.checkStrictMode)(it, `"minContains" == 0 without "maxContains": "contains" keyword ignored`);
+        return;
+      }
+      if (max !== void 0 && min > max) {
+        (0, util_1.checkStrictMode)(it, `"minContains" > "maxContains" is always invalid`);
+        cxt.fail();
+        return;
+      }
+      if ((0, util_1.alwaysValidSchema)(it, schema)) {
+        let cond = (0, codegen_1._)`${len} >= ${min}`;
+        if (max !== void 0)
+          cond = (0, codegen_1._)`${cond} && ${len} <= ${max}`;
+        cxt.pass(cond);
+        return;
+      }
+      it.items = true;
+      const valid = gen.name("valid");
+      if (max === void 0 && min === 1) {
+        validateItems(valid, () => gen.if(valid, () => gen.break()));
+      } else if (min === 0) {
+        gen.let(valid, true);
+        if (max !== void 0)
+          gen.if((0, codegen_1._)`${data}.length > 0`, validateItemsWithCount);
+      } else {
+        gen.let(valid, false);
+        validateItemsWithCount();
+      }
+      cxt.result(valid, () => cxt.reset());
+      function validateItemsWithCount() {
+        const schValid = gen.name("_valid");
+        const count = gen.let("count", 0);
+        validateItems(schValid, () => gen.if(schValid, () => checkLimits(count)));
+      }
+      function validateItems(_valid, block) {
+        gen.forRange("i", 0, len, (i) => {
+          cxt.subschema({
+            keyword: "contains",
+            dataProp: i,
+            dataPropType: util_1.Type.Num,
+            compositeRule: true
+          }, _valid);
+          block();
+        });
+      }
+      function checkLimits(count) {
+        gen.code((0, codegen_1._)`${count}++`);
+        if (max === void 0) {
+          gen.if((0, codegen_1._)`${count} >= ${min}`, () => gen.assign(valid, true).break());
+        } else {
+          gen.if((0, codegen_1._)`${count} > ${max}`, () => gen.assign(valid, false).break());
+          if (min === 1)
+            gen.assign(valid, true);
+          else
+            gen.if((0, codegen_1._)`${count} >= ${min}`, () => gen.assign(valid, true));
+        }
+      }
+    }
+  };
+  contains.default = def;
+  return contains;
+}
+export {
+  requireContains as __require
+};

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

@@ -0,0 +1,102 @@
+import { __exports as dependencies } from "../../../../../../../.bundled/jsonforms/esm/_virtual/dependencies.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 hasRequiredDependencies;
+function requireDependencies() {
+  if (hasRequiredDependencies) return dependencies;
+  hasRequiredDependencies = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.validateSchemaDeps = exports.validatePropertyDeps = exports.error = void 0;
+    const codegen_1 = requireCodegen();
+    const util_1 = requireUtil();
+    const code_1 = requireCode();
+    exports.error = {
+      message: ({ params: { property, depsCount, deps } }) => {
+        const property_ies = depsCount === 1 ? "property" : "properties";
+        return (0, codegen_1.str)`must have ${property_ies} ${deps} when property ${property} is present`;
+      },
+      params: ({ params: { property, depsCount, deps, missingProperty } }) => (0, codegen_1._)`{property: ${property},
+    missingProperty: ${missingProperty},
+    depsCount: ${depsCount},
+    deps: ${deps}}`
+      // TODO change to reference
+    };
+    const def = {
+      keyword: "dependencies",
+      type: "object",
+      schemaType: "object",
+      error: exports.error,
+      code(cxt) {
+        const [propDeps, schDeps] = splitDependencies(cxt);
+        validatePropertyDeps(cxt, propDeps);
+        validateSchemaDeps(cxt, schDeps);
+      }
+    };
+    function splitDependencies({ schema }) {
+      const propertyDeps = {};
+      const schemaDeps = {};
+      for (const key in schema) {
+        if (key === "__proto__")
+          continue;
+        const deps = Array.isArray(schema[key]) ? propertyDeps : schemaDeps;
+        deps[key] = schema[key];
+      }
+      return [propertyDeps, schemaDeps];
+    }
+    function validatePropertyDeps(cxt, propertyDeps = cxt.schema) {
+      const { gen, data, it } = cxt;
+      if (Object.keys(propertyDeps).length === 0)
+        return;
+      const missing = gen.let("missing");
+      for (const prop in propertyDeps) {
+        const deps = propertyDeps[prop];
+        if (deps.length === 0)
+          continue;
+        const hasProperty = (0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties);
+        cxt.setParams({
+          property: prop,
+          depsCount: deps.length,
+          deps: deps.join(", ")
+        });
+        if (it.allErrors) {
+          gen.if(hasProperty, () => {
+            for (const depProp of deps) {
+              (0, code_1.checkReportMissingProp)(cxt, depProp);
+            }
+          });
+        } else {
+          gen.if((0, codegen_1._)`${hasProperty} && (${(0, code_1.checkMissingProp)(cxt, deps, missing)})`);
+          (0, code_1.reportMissingProp)(cxt, missing);
+          gen.else();
+        }
+      }
+    }
+    exports.validatePropertyDeps = validatePropertyDeps;
+    function validateSchemaDeps(cxt, schemaDeps = cxt.schema) {
+      const { gen, data, keyword, it } = cxt;
+      const valid = gen.name("valid");
+      for (const prop in schemaDeps) {
+        if ((0, util_1.alwaysValidSchema)(it, schemaDeps[prop]))
+          continue;
+        gen.if(
+          (0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties),
+          () => {
+            const schCxt = cxt.subschema({ keyword, schemaProp: prop }, valid);
+            cxt.mergeValidEvaluated(schCxt, valid);
+          },
+          () => gen.var(valid, true)
+          // TODO var
+        );
+        cxt.ok(valid);
+      }
+    }
+    exports.validateSchemaDeps = validateSchemaDeps;
+    exports.default = def;
+  })(dependencies);
+  return dependencies;
+}
+export {
+  requireDependencies as __require
+};

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

@@ -0,0 +1,74 @@
+import { __exports as _if } from "../../../../../../../.bundled/jsonforms/esm/_virtual/if.mjs";
+import { __require as requireCodegen } from "../../compile/codegen/index.mjs";
+import { __require as requireUtil } from "../../compile/util.mjs";
+var hasRequired_if;
+function require_if() {
+  if (hasRequired_if) return _if;
+  hasRequired_if = 1;
+  Object.defineProperty(_if, "__esModule", { value: true });
+  const codegen_1 = requireCodegen();
+  const util_1 = requireUtil();
+  const error = {
+    message: ({ params }) => (0, codegen_1.str)`must match "${params.ifClause}" schema`,
+    params: ({ params }) => (0, codegen_1._)`{failingKeyword: ${params.ifClause}}`
+  };
+  const def = {
+    keyword: "if",
+    schemaType: ["object", "boolean"],
+    trackErrors: true,
+    error,
+    code(cxt) {
+      const { gen, parentSchema, it } = cxt;
+      if (parentSchema.then === void 0 && parentSchema.else === void 0) {
+        (0, util_1.checkStrictMode)(it, '"if" without "then" and "else" is ignored');
+      }
+      const hasThen = hasSchema(it, "then");
+      const hasElse = hasSchema(it, "else");
+      if (!hasThen && !hasElse)
+        return;
+      const valid = gen.let("valid", true);
+      const schValid = gen.name("_valid");
+      validateIf();
+      cxt.reset();
+      if (hasThen && hasElse) {
+        const ifClause = gen.let("ifClause");
+        cxt.setParams({ ifClause });
+        gen.if(schValid, validateClause("then", ifClause), validateClause("else", ifClause));
+      } else if (hasThen) {
+        gen.if(schValid, validateClause("then"));
+      } else {
+        gen.if((0, codegen_1.not)(schValid), validateClause("else"));
+      }
+      cxt.pass(valid, () => cxt.error(true));
+      function validateIf() {
+        const schCxt = cxt.subschema({
+          keyword: "if",
+          compositeRule: true,
+          createErrors: false,
+          allErrors: false
+        }, schValid);
+        cxt.mergeEvaluated(schCxt);
+      }
+      function validateClause(keyword, ifClause) {
+        return () => {
+          const schCxt = cxt.subschema({ keyword }, schValid);
+          gen.assign(valid, schValid);
+          cxt.mergeValidEvaluated(schCxt, valid);
+          if (ifClause)
+            gen.assign(ifClause, (0, codegen_1._)`${keyword}`);
+          else
+            cxt.setParams({ ifClause: keyword });
+        };
+      }
+    }
+  };
+  function hasSchema(it, keyword) {
+    const schema = it.schema[keyword];
+    return schema !== void 0 && !(0, util_1.alwaysValidSchema)(it, schema);
+  }
+  _if.default = def;
+  return _if;
+}
+export {
+  require_if as __require
+};

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

@@ -0,0 +1,67 @@
+import { __exports as applicator } from "../../../../../../../.bundled/jsonforms/esm/_virtual/index9.mjs";
+import { __require as requireAdditionalItems } from "./additionalItems.mjs";
+import { __require as requirePrefixItems } from "./prefixItems.mjs";
+import { __require as requireItems } from "./items.mjs";
+import { __require as requireItems2020 } from "./items2020.mjs";
+import { __require as requireContains } from "./contains.mjs";
+import { __require as requireDependencies } from "./dependencies.mjs";
+import { __require as requirePropertyNames } from "./propertyNames.mjs";
+import { __require as requireAdditionalProperties } from "./additionalProperties.mjs";
+import { __require as requireProperties } from "./properties.mjs";
+import { __require as requirePatternProperties } from "./patternProperties.mjs";
+import { __require as requireNot } from "./not.mjs";
+import { __require as requireAnyOf } from "./anyOf.mjs";
+import { __require as requireOneOf } from "./oneOf.mjs";
+import { __require as requireAllOf } from "./allOf.mjs";
+import { __require as require_if } from "./if.mjs";
+import { __require as requireThenElse } from "./thenElse.mjs";
+var hasRequiredApplicator;
+function requireApplicator() {
+  if (hasRequiredApplicator) return applicator;
+  hasRequiredApplicator = 1;
+  Object.defineProperty(applicator, "__esModule", { value: true });
+  const additionalItems_1 = requireAdditionalItems();
+  const prefixItems_1 = requirePrefixItems();
+  const items_1 = requireItems();
+  const items2020_1 = requireItems2020();
+  const contains_1 = requireContains();
+  const dependencies_1 = requireDependencies();
+  const propertyNames_1 = requirePropertyNames();
+  const additionalProperties_1 = requireAdditionalProperties();
+  const properties_1 = requireProperties();
+  const patternProperties_1 = requirePatternProperties();
+  const not_1 = requireNot();
+  const anyOf_1 = requireAnyOf();
+  const oneOf_1 = requireOneOf();
+  const allOf_1 = requireAllOf();
+  const if_1 = require_if();
+  const thenElse_1 = requireThenElse();
+  function getApplicator(draft2020 = false) {
+    const applicator2 = [
+      // any
+      not_1.default,
+      anyOf_1.default,
+      oneOf_1.default,
+      allOf_1.default,
+      if_1.default,
+      thenElse_1.default,
+      // object
+      propertyNames_1.default,
+      additionalProperties_1.default,
+      dependencies_1.default,
+      properties_1.default,
+      patternProperties_1.default
+    ];
+    if (draft2020)
+      applicator2.push(prefixItems_1.default, items2020_1.default);
+    else
+      applicator2.push(additionalItems_1.default, items_1.default);
+    applicator2.push(contains_1.default);
+    return applicator2;
+  }
+  applicator.default = getApplicator;
+  return applicator;
+}
+export {
+  requireApplicator as __require
+};