astro-md-editor 0.0.6 → 0.0.7

package/.output/server/_libs/ajv.mjs

@@ -2,7 +2,7 @@ import { g as getDefaultExportFromCjs } from "./react.mjs";
 import { r as requireFastDeepEqual } from "./fast-deep-equal.mjs";
 import { r as requireJsonSchemaTraverse } from "./json-schema-traverse.mjs";
 import { r as requireFastUri } from "./fast-uri.mjs";
-var ajv = { exports: {} };
+var _2020 = { exports: {} };
 var core$1 = {};
 var validate = {};
 var boolSchema = {};
@@ -2939,18 +2939,18 @@ function requireCompile() {
   }
   return compile;
 }
-const $id$1 = "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#";
+const $id$9 = "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#";
 const description = "Meta-schema for $data reference (JSON AnySchema extension proposal)";
-const type$1 = "object";
+const type$9 = "object";
 const required$1 = ["$data"];
-const properties$2 = { "$data": { "type": "string", "anyOf": [{ "format": "relative-json-pointer" }, { "format": "json-pointer" }] } };
+const properties$a = { "$data": { "type": "string", "anyOf": [{ "format": "relative-json-pointer" }, { "format": "json-pointer" }] } };
 const additionalProperties$1 = false;
 const require$$9 = {
-  $id: $id$1,
+  $id: $id$9,
   description,
-  type: type$1,
+  type: type$9,
   required: required$1,
-  properties: properties$2,
+  properties: properties$a,
   additionalProperties: additionalProperties$1
 };
 var uri = {};
@@ -3073,7 +3073,7 @@ function requireCore$1() {
         uriResolver
       };
     }
-    class Ajv2 {
+    class Ajv {
       constructor(opts = {}) {
         this.schemas = {};
         this.refs = {};
@@ -3443,9 +3443,9 @@ function requireCore$1() {
         }
       }
     }
-    Ajv2.ValidationError = validation_error_1.default;
-    Ajv2.MissingRefError = ref_error_1.default;
-    exports$1.default = Ajv2;
+    Ajv.ValidationError = validation_error_1.default;
+    Ajv.MissingRefError = ref_error_1.default;
+    exports$1.default = Ajv;
     function checkOptions(checkOpts, options, msg, log = "error") {
       for (const key in checkOpts) {
         const opt = key;
@@ -3576,7 +3576,7 @@ function requireCore$1() {
   })(core$1);
   return core$1;
 }
-var draft7 = {};
+var draft2020 = {};
 var core = {};
 var id = {};
 var hasRequiredId;
@@ -4726,12 +4726,12 @@ function requireAdditionalProperties() {
   additionalProperties.default = def;
   return additionalProperties;
 }
-var properties$1 = {};
+var properties$9 = {};
 var hasRequiredProperties;
 function requireProperties() {
-  if (hasRequiredProperties) return properties$1;
+  if (hasRequiredProperties) return properties$9;
   hasRequiredProperties = 1;
-  Object.defineProperty(properties$1, "__esModule", { value: true });
+  Object.defineProperty(properties$9, "__esModule", { value: true });
   const validate_1 = /* @__PURE__ */ requireValidate();
   const code_1 = /* @__PURE__ */ requireCode();
   const util_1 = /* @__PURE__ */ requireUtil();
@@ -4781,8 +4781,8 @@ function requireProperties() {
       }
     }
   };
-  properties$1.default = def;
-  return properties$1;
+  properties$9.default = def;
+  return properties$9;
 }
 var patternProperties = {};
 var hasRequiredPatternProperties;
@@ -4964,12 +4964,12 @@ function requireOneOf() {
   oneOf.default = def;
   return oneOf;
 }
-var allOf = {};
+var allOf$1 = {};
 var hasRequiredAllOf;
 function requireAllOf() {
-  if (hasRequiredAllOf) return allOf;
+  if (hasRequiredAllOf) return allOf$1;
   hasRequiredAllOf = 1;
-  Object.defineProperty(allOf, "__esModule", { value: true });
+  Object.defineProperty(allOf$1, "__esModule", { value: true });
   const util_1 = /* @__PURE__ */ requireUtil();
   const def = {
     keyword: "allOf",
@@ -4988,8 +4988,8 @@ function requireAllOf() {
       });
     }
   };
-  allOf.default = def;
-  return allOf;
+  allOf$1.default = def;
+  return allOf$1;
 }
 var _if = {};
 var hasRequired_if;
@@ -5099,7 +5099,7 @@ function requireApplicator() {
   const allOf_1 = /* @__PURE__ */ requireAllOf();
   const if_1 = /* @__PURE__ */ require_if();
   const thenElse_1 = /* @__PURE__ */ requireThenElse();
-  function getApplicator(draft2020 = false) {
+  function getApplicator(draft20202 = false) {
     const applicator2 = [
       // any
       not_1.default,
@@ -5115,7 +5115,7 @@ function requireApplicator() {
       properties_1.default,
       patternProperties_1.default
     ];
-    if (draft2020)
+    if (draft20202)
       applicator2.push(prefixItems_1.default, items2020_1.default);
     else
       applicator2.push(additionalItems_1.default, items_1.default);
@@ -5125,6 +5125,325 @@ function requireApplicator() {
   applicator.default = getApplicator;
   return applicator;
 }
+var dynamic = {};
+var dynamicAnchor = {};
+var hasRequiredDynamicAnchor;
+function requireDynamicAnchor() {
+  if (hasRequiredDynamicAnchor) return dynamicAnchor;
+  hasRequiredDynamicAnchor = 1;
+  Object.defineProperty(dynamicAnchor, "__esModule", { value: true });
+  dynamicAnchor.dynamicAnchor = void 0;
+  const codegen_1 = /* @__PURE__ */ requireCodegen();
+  const names_1 = /* @__PURE__ */ requireNames();
+  const compile_1 = /* @__PURE__ */ requireCompile();
+  const ref_1 = /* @__PURE__ */ requireRef();
+  const def = {
+    keyword: "$dynamicAnchor",
+    schemaType: "string",
+    code: (cxt) => dynamicAnchor$1(cxt, cxt.schema)
+  };
+  function dynamicAnchor$1(cxt, anchor) {
+    const { gen, it } = cxt;
+    it.schemaEnv.root.dynamicAnchors[anchor] = true;
+    const v = (0, codegen_1._)`${names_1.default.dynamicAnchors}${(0, codegen_1.getProperty)(anchor)}`;
+    const validate2 = it.errSchemaPath === "#" ? it.validateName : _getValidate(cxt);
+    gen.if((0, codegen_1._)`!${v}`, () => gen.assign(v, validate2));
+  }
+  dynamicAnchor.dynamicAnchor = dynamicAnchor$1;
+  function _getValidate(cxt) {
+    const { schemaEnv, schema, self } = cxt.it;
+    const { root, baseId, localRefs, meta } = schemaEnv.root;
+    const { schemaId } = self.opts;
+    const sch = new compile_1.SchemaEnv({ schema, schemaId, root, baseId, localRefs, meta });
+    compile_1.compileSchema.call(self, sch);
+    return (0, ref_1.getValidate)(cxt, sch);
+  }
+  dynamicAnchor.default = def;
+  return dynamicAnchor;
+}
+var dynamicRef = {};
+var hasRequiredDynamicRef;
+function requireDynamicRef() {
+  if (hasRequiredDynamicRef) return dynamicRef;
+  hasRequiredDynamicRef = 1;
+  Object.defineProperty(dynamicRef, "__esModule", { value: true });
+  dynamicRef.dynamicRef = void 0;
+  const codegen_1 = /* @__PURE__ */ requireCodegen();
+  const names_1 = /* @__PURE__ */ requireNames();
+  const ref_1 = /* @__PURE__ */ requireRef();
+  const def = {
+    keyword: "$dynamicRef",
+    schemaType: "string",
+    code: (cxt) => dynamicRef$1(cxt, cxt.schema)
+  };
+  function dynamicRef$1(cxt, ref2) {
+    const { gen, keyword: keyword2, it } = cxt;
+    if (ref2[0] !== "#")
+      throw new Error(`"${keyword2}" only supports hash fragment reference`);
+    const anchor = ref2.slice(1);
+    if (it.allErrors) {
+      _dynamicRef();
+    } else {
+      const valid = gen.let("valid", false);
+      _dynamicRef(valid);
+      cxt.ok(valid);
+    }
+    function _dynamicRef(valid) {
+      if (it.schemaEnv.root.dynamicAnchors[anchor]) {
+        const v = gen.let("_v", (0, codegen_1._)`${names_1.default.dynamicAnchors}${(0, codegen_1.getProperty)(anchor)}`);
+        gen.if(v, _callRef(v, valid), _callRef(it.validateName, valid));
+      } else {
+        _callRef(it.validateName, valid)();
+      }
+    }
+    function _callRef(validate2, valid) {
+      return valid ? () => gen.block(() => {
+        (0, ref_1.callRef)(cxt, validate2);
+        gen.let(valid, true);
+      }) : () => (0, ref_1.callRef)(cxt, validate2);
+    }
+  }
+  dynamicRef.dynamicRef = dynamicRef$1;
+  dynamicRef.default = def;
+  return dynamicRef;
+}
+var recursiveAnchor = {};
+var hasRequiredRecursiveAnchor;
+function requireRecursiveAnchor() {
+  if (hasRequiredRecursiveAnchor) return recursiveAnchor;
+  hasRequiredRecursiveAnchor = 1;
+  Object.defineProperty(recursiveAnchor, "__esModule", { value: true });
+  const dynamicAnchor_1 = /* @__PURE__ */ requireDynamicAnchor();
+  const util_1 = /* @__PURE__ */ requireUtil();
+  const def = {
+    keyword: "$recursiveAnchor",
+    schemaType: "boolean",
+    code(cxt) {
+      if (cxt.schema)
+        (0, dynamicAnchor_1.dynamicAnchor)(cxt, "");
+      else
+        (0, util_1.checkStrictMode)(cxt.it, "$recursiveAnchor: false is ignored");
+    }
+  };
+  recursiveAnchor.default = def;
+  return recursiveAnchor;
+}
+var recursiveRef = {};
+var hasRequiredRecursiveRef;
+function requireRecursiveRef() {
+  if (hasRequiredRecursiveRef) return recursiveRef;
+  hasRequiredRecursiveRef = 1;
+  Object.defineProperty(recursiveRef, "__esModule", { value: true });
+  const dynamicRef_1 = /* @__PURE__ */ requireDynamicRef();
+  const def = {
+    keyword: "$recursiveRef",
+    schemaType: "string",
+    code: (cxt) => (0, dynamicRef_1.dynamicRef)(cxt, cxt.schema)
+  };
+  recursiveRef.default = def;
+  return recursiveRef;
+}
+var hasRequiredDynamic;
+function requireDynamic() {
+  if (hasRequiredDynamic) return dynamic;
+  hasRequiredDynamic = 1;
+  Object.defineProperty(dynamic, "__esModule", { value: true });
+  const dynamicAnchor_1 = /* @__PURE__ */ requireDynamicAnchor();
+  const dynamicRef_1 = /* @__PURE__ */ requireDynamicRef();
+  const recursiveAnchor_1 = /* @__PURE__ */ requireRecursiveAnchor();
+  const recursiveRef_1 = /* @__PURE__ */ requireRecursiveRef();
+  const dynamic$1 = [dynamicAnchor_1.default, dynamicRef_1.default, recursiveAnchor_1.default, recursiveRef_1.default];
+  dynamic.default = dynamic$1;
+  return dynamic;
+}
+var next = {};
+var dependentRequired = {};
+var hasRequiredDependentRequired;
+function requireDependentRequired() {
+  if (hasRequiredDependentRequired) return dependentRequired;
+  hasRequiredDependentRequired = 1;
+  Object.defineProperty(dependentRequired, "__esModule", { value: true });
+  const dependencies_1 = /* @__PURE__ */ requireDependencies();
+  const def = {
+    keyword: "dependentRequired",
+    type: "object",
+    schemaType: "object",
+    error: dependencies_1.error,
+    code: (cxt) => (0, dependencies_1.validatePropertyDeps)(cxt)
+  };
+  dependentRequired.default = def;
+  return dependentRequired;
+}
+var dependentSchemas = {};
+var hasRequiredDependentSchemas;
+function requireDependentSchemas() {
+  if (hasRequiredDependentSchemas) return dependentSchemas;
+  hasRequiredDependentSchemas = 1;
+  Object.defineProperty(dependentSchemas, "__esModule", { value: true });
+  const dependencies_1 = /* @__PURE__ */ requireDependencies();
+  const def = {
+    keyword: "dependentSchemas",
+    type: "object",
+    schemaType: "object",
+    code: (cxt) => (0, dependencies_1.validateSchemaDeps)(cxt)
+  };
+  dependentSchemas.default = def;
+  return dependentSchemas;
+}
+var limitContains = {};
+var hasRequiredLimitContains;
+function requireLimitContains() {
+  if (hasRequiredLimitContains) return limitContains;
+  hasRequiredLimitContains = 1;
+  Object.defineProperty(limitContains, "__esModule", { value: true });
+  const util_1 = /* @__PURE__ */ requireUtil();
+  const def = {
+    keyword: ["maxContains", "minContains"],
+    type: "array",
+    schemaType: "number",
+    code({ keyword: keyword2, parentSchema, it }) {
+      if (parentSchema.contains === void 0) {
+        (0, util_1.checkStrictMode)(it, `"${keyword2}" without "contains" is ignored`);
+      }
+    }
+  };
+  limitContains.default = def;
+  return limitContains;
+}
+var hasRequiredNext;
+function requireNext() {
+  if (hasRequiredNext) return next;
+  hasRequiredNext = 1;
+  Object.defineProperty(next, "__esModule", { value: true });
+  const dependentRequired_1 = /* @__PURE__ */ requireDependentRequired();
+  const dependentSchemas_1 = /* @__PURE__ */ requireDependentSchemas();
+  const limitContains_1 = /* @__PURE__ */ requireLimitContains();
+  const next$1 = [dependentRequired_1.default, dependentSchemas_1.default, limitContains_1.default];
+  next.default = next$1;
+  return next;
+}
+var unevaluated = {};
+var unevaluatedProperties = {};
+var hasRequiredUnevaluatedProperties;
+function requireUnevaluatedProperties() {
+  if (hasRequiredUnevaluatedProperties) return unevaluatedProperties;
+  hasRequiredUnevaluatedProperties = 1;
+  Object.defineProperty(unevaluatedProperties, "__esModule", { value: true });
+  const codegen_1 = /* @__PURE__ */ requireCodegen();
+  const util_1 = /* @__PURE__ */ requireUtil();
+  const names_1 = /* @__PURE__ */ requireNames();
+  const error = {
+    message: "must NOT have unevaluated properties",
+    params: ({ params }) => (0, codegen_1._)`{unevaluatedProperty: ${params.unevaluatedProperty}}`
+  };
+  const def = {
+    keyword: "unevaluatedProperties",
+    type: "object",
+    schemaType: ["boolean", "object"],
+    trackErrors: true,
+    error,
+    code(cxt) {
+      const { gen, schema, data, errsCount, it } = cxt;
+      if (!errsCount)
+        throw new Error("ajv implementation error");
+      const { allErrors, props } = it;
+      if (props instanceof codegen_1.Name) {
+        gen.if((0, codegen_1._)`${props} !== true`, () => gen.forIn("key", data, (key) => gen.if(unevaluatedDynamic(props, key), () => unevaluatedPropCode(key))));
+      } else if (props !== true) {
+        gen.forIn("key", data, (key) => props === void 0 ? unevaluatedPropCode(key) : gen.if(unevaluatedStatic(props, key), () => unevaluatedPropCode(key)));
+      }
+      it.props = true;
+      cxt.ok((0, codegen_1._)`${errsCount} === ${names_1.default.errors}`);
+      function unevaluatedPropCode(key) {
+        if (schema === false) {
+          cxt.setParams({ unevaluatedProperty: key });
+          cxt.error();
+          if (!allErrors)
+            gen.break();
+          return;
+        }
+        if (!(0, util_1.alwaysValidSchema)(it, schema)) {
+          const valid = gen.name("valid");
+          cxt.subschema({
+            keyword: "unevaluatedProperties",
+            dataProp: key,
+            dataPropType: util_1.Type.Str
+          }, valid);
+          if (!allErrors)
+            gen.if((0, codegen_1.not)(valid), () => gen.break());
+        }
+      }
+      function unevaluatedDynamic(evaluatedProps, key) {
+        return (0, codegen_1._)`!${evaluatedProps} || !${evaluatedProps}[${key}]`;
+      }
+      function unevaluatedStatic(evaluatedProps, key) {
+        const ps = [];
+        for (const p in evaluatedProps) {
+          if (evaluatedProps[p] === true)
+            ps.push((0, codegen_1._)`${key} !== ${p}`);
+        }
+        return (0, codegen_1.and)(...ps);
+      }
+    }
+  };
+  unevaluatedProperties.default = def;
+  return unevaluatedProperties;
+}
+var unevaluatedItems = {};
+var hasRequiredUnevaluatedItems;
+function requireUnevaluatedItems() {
+  if (hasRequiredUnevaluatedItems) return unevaluatedItems;
+  hasRequiredUnevaluatedItems = 1;
+  Object.defineProperty(unevaluatedItems, "__esModule", { value: true });
+  const codegen_1 = /* @__PURE__ */ requireCodegen();
+  const util_1 = /* @__PURE__ */ 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: "unevaluatedItems",
+    type: "array",
+    schemaType: ["boolean", "object"],
+    error,
+    code(cxt) {
+      const { gen, schema, data, it } = cxt;
+      const items2 = it.items || 0;
+      if (items2 === true)
+        return;
+      const len = gen.const("len", (0, codegen_1._)`${data}.length`);
+      if (schema === false) {
+        cxt.setParams({ len: items2 });
+        cxt.fail((0, codegen_1._)`${len} > ${items2}`);
+      } else if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) {
+        const valid = gen.var("valid", (0, codegen_1._)`${len} <= ${items2}`);
+        gen.if((0, codegen_1.not)(valid), () => validateItems(valid, items2));
+        cxt.ok(valid);
+      }
+      it.items = true;
+      function validateItems(valid, from) {
+        gen.forRange("i", from, len, (i) => {
+          cxt.subschema({ keyword: "unevaluatedItems", dataProp: i, dataPropType: util_1.Type.Num }, valid);
+          if (!it.allErrors)
+            gen.if((0, codegen_1.not)(valid), () => gen.break());
+        });
+      }
+    }
+  };
+  unevaluatedItems.default = def;
+  return unevaluatedItems;
+}
+var hasRequiredUnevaluated;
+function requireUnevaluated() {
+  if (hasRequiredUnevaluated) return unevaluated;
+  hasRequiredUnevaluated = 1;
+  Object.defineProperty(unevaluated, "__esModule", { value: true });
+  const unevaluatedProperties_1 = /* @__PURE__ */ requireUnevaluatedProperties();
+  const unevaluatedItems_1 = /* @__PURE__ */ requireUnevaluatedItems();
+  const unevaluated$1 = [unevaluatedProperties_1.default, unevaluatedItems_1.default];
+  unevaluated.default = unevaluated$1;
+  return unevaluated;
+}
 var format$1 = {};
 var format = {};
 var hasRequiredFormat$1;
@@ -5249,26 +5568,32 @@ function requireMetadata() {
   ];
   return metadata;
 }
-var hasRequiredDraft7;
-function requireDraft7() {
-  if (hasRequiredDraft7) return draft7;
-  hasRequiredDraft7 = 1;
-  Object.defineProperty(draft7, "__esModule", { value: true });
+var hasRequiredDraft2020;
+function requireDraft2020() {
+  if (hasRequiredDraft2020) return draft2020;
+  hasRequiredDraft2020 = 1;
+  Object.defineProperty(draft2020, "__esModule", { value: true });
   const core_1 = /* @__PURE__ */ requireCore();
   const validation_1 = /* @__PURE__ */ requireValidation();
   const applicator_1 = /* @__PURE__ */ requireApplicator();
+  const dynamic_1 = /* @__PURE__ */ requireDynamic();
+  const next_1 = /* @__PURE__ */ requireNext();
+  const unevaluated_1 = /* @__PURE__ */ requireUnevaluated();
   const format_1 = /* @__PURE__ */ requireFormat();
   const metadata_1 = /* @__PURE__ */ requireMetadata();
-  const draft7Vocabularies = [
+  const draft2020Vocabularies = [
+    dynamic_1.default,
     core_1.default,
     validation_1.default,
-    (0, applicator_1.default)(),
+    (0, applicator_1.default)(true),
     format_1.default,
     metadata_1.metadataVocabulary,
-    metadata_1.contentVocabulary
+    metadata_1.contentVocabulary,
+    next_1.default,
+    unevaluated_1.default
   ];
-  draft7.default = draft7Vocabularies;
-  return draft7;
+  draft2020.default = draft2020Vocabularies;
+  return draft2020;
 }
 var discriminator = {};
 var types = {};
@@ -5389,6 +5714,281 @@ function requireDiscriminator() {
   discriminator.default = def;
   return discriminator;
 }
+var jsonSchema202012 = {};
+const $schema$8 = "https://json-schema.org/draft/2020-12/schema";
+const $id$8 = "https://json-schema.org/draft/2020-12/schema";
+const $vocabulary$7 = { "https://json-schema.org/draft/2020-12/vocab/core": true, "https://json-schema.org/draft/2020-12/vocab/applicator": true, "https://json-schema.org/draft/2020-12/vocab/unevaluated": true, "https://json-schema.org/draft/2020-12/vocab/validation": true, "https://json-schema.org/draft/2020-12/vocab/meta-data": true, "https://json-schema.org/draft/2020-12/vocab/format-annotation": true, "https://json-schema.org/draft/2020-12/vocab/content": true };
+const $dynamicAnchor$7 = "meta";
+const title$8 = "Core and Validation specifications meta-schema";
+const allOf = [{ "$ref": "meta/core" }, { "$ref": "meta/applicator" }, { "$ref": "meta/unevaluated" }, { "$ref": "meta/validation" }, { "$ref": "meta/meta-data" }, { "$ref": "meta/format-annotation" }, { "$ref": "meta/content" }];
+const type$8 = ["object", "boolean"];
+const $comment = "This meta-schema also defines keywords that have appeared in previous drafts in order to prevent incompatible extensions as they remain in common use.";
+const properties$8 = { "definitions": { "$comment": '"definitions" has been replaced by "$defs".', "type": "object", "additionalProperties": { "$dynamicRef": "#meta" }, "deprecated": true, "default": {} }, "dependencies": { "$comment": '"dependencies" has been split and replaced by "dependentSchemas" and "dependentRequired" in order to serve their differing semantics.', "type": "object", "additionalProperties": { "anyOf": [{ "$dynamicRef": "#meta" }, { "$ref": "meta/validation#/$defs/stringArray" }] }, "deprecated": true, "default": {} }, "$recursiveAnchor": { "$comment": '"$recursiveAnchor" has been replaced by "$dynamicAnchor".', "$ref": "meta/core#/$defs/anchorString", "deprecated": true }, "$recursiveRef": { "$comment": '"$recursiveRef" has been replaced by "$dynamicRef".', "$ref": "meta/core#/$defs/uriReferenceString", "deprecated": true } };
+const require$$0 = {
+  $schema: $schema$8,
+  $id: $id$8,
+  $vocabulary: $vocabulary$7,
+  $dynamicAnchor: $dynamicAnchor$7,
+  title: title$8,
+  allOf,
+  type: type$8,
+  $comment,
+  properties: properties$8
+};
+const $schema$7 = "https://json-schema.org/draft/2020-12/schema";
+const $id$7 = "https://json-schema.org/draft/2020-12/meta/applicator";
+const $vocabulary$6 = { "https://json-schema.org/draft/2020-12/vocab/applicator": true };
+const $dynamicAnchor$6 = "meta";
+const title$7 = "Applicator vocabulary meta-schema";
+const type$7 = ["object", "boolean"];
+const properties$7 = { "prefixItems": { "$ref": "#/$defs/schemaArray" }, "items": { "$dynamicRef": "#meta" }, "contains": { "$dynamicRef": "#meta" }, "additionalProperties": { "$dynamicRef": "#meta" }, "properties": { "type": "object", "additionalProperties": { "$dynamicRef": "#meta" }, "default": {} }, "patternProperties": { "type": "object", "additionalProperties": { "$dynamicRef": "#meta" }, "propertyNames": { "format": "regex" }, "default": {} }, "dependentSchemas": { "type": "object", "additionalProperties": { "$dynamicRef": "#meta" }, "default": {} }, "propertyNames": { "$dynamicRef": "#meta" }, "if": { "$dynamicRef": "#meta" }, "then": { "$dynamicRef": "#meta" }, "else": { "$dynamicRef": "#meta" }, "allOf": { "$ref": "#/$defs/schemaArray" }, "anyOf": { "$ref": "#/$defs/schemaArray" }, "oneOf": { "$ref": "#/$defs/schemaArray" }, "not": { "$dynamicRef": "#meta" } };
+const $defs$2 = { "schemaArray": { "type": "array", "minItems": 1, "items": { "$dynamicRef": "#meta" } } };
+const require$$1 = {
+  $schema: $schema$7,
+  $id: $id$7,
+  $vocabulary: $vocabulary$6,
+  $dynamicAnchor: $dynamicAnchor$6,
+  title: title$7,
+  type: type$7,
+  properties: properties$7,
+  $defs: $defs$2
+};
+const $schema$6 = "https://json-schema.org/draft/2020-12/schema";
+const $id$6 = "https://json-schema.org/draft/2020-12/meta/unevaluated";
+const $vocabulary$5 = { "https://json-schema.org/draft/2020-12/vocab/unevaluated": true };
+const $dynamicAnchor$5 = "meta";
+const title$6 = "Unevaluated applicator vocabulary meta-schema";
+const type$6 = ["object", "boolean"];
+const properties$6 = { "unevaluatedItems": { "$dynamicRef": "#meta" }, "unevaluatedProperties": { "$dynamicRef": "#meta" } };
+const require$$2 = {
+  $schema: $schema$6,
+  $id: $id$6,
+  $vocabulary: $vocabulary$5,
+  $dynamicAnchor: $dynamicAnchor$5,
+  title: title$6,
+  type: type$6,
+  properties: properties$6
+};
+const $schema$5 = "https://json-schema.org/draft/2020-12/schema";
+const $id$5 = "https://json-schema.org/draft/2020-12/meta/content";
+const $vocabulary$4 = { "https://json-schema.org/draft/2020-12/vocab/content": true };
+const $dynamicAnchor$4 = "meta";
+const title$5 = "Content vocabulary meta-schema";
+const type$5 = ["object", "boolean"];
+const properties$5 = { "contentEncoding": { "type": "string" }, "contentMediaType": { "type": "string" }, "contentSchema": { "$dynamicRef": "#meta" } };
+const require$$3$1 = {
+  $schema: $schema$5,
+  $id: $id$5,
+  $vocabulary: $vocabulary$4,
+  $dynamicAnchor: $dynamicAnchor$4,
+  title: title$5,
+  type: type$5,
+  properties: properties$5
+};
+const $schema$4 = "https://json-schema.org/draft/2020-12/schema";
+const $id$4 = "https://json-schema.org/draft/2020-12/meta/core";
+const $vocabulary$3 = { "https://json-schema.org/draft/2020-12/vocab/core": true };
+const $dynamicAnchor$3 = "meta";
+const title$4 = "Core vocabulary meta-schema";
+const type$4 = ["object", "boolean"];
+const properties$4 = { "$id": { "$ref": "#/$defs/uriReferenceString", "$comment": "Non-empty fragments not allowed.", "pattern": "^[^#]*#?$" }, "$schema": { "$ref": "#/$defs/uriString" }, "$ref": { "$ref": "#/$defs/uriReferenceString" }, "$anchor": { "$ref": "#/$defs/anchorString" }, "$dynamicRef": { "$ref": "#/$defs/uriReferenceString" }, "$dynamicAnchor": { "$ref": "#/$defs/anchorString" }, "$vocabulary": { "type": "object", "propertyNames": { "$ref": "#/$defs/uriString" }, "additionalProperties": { "type": "boolean" } }, "$comment": { "type": "string" }, "$defs": { "type": "object", "additionalProperties": { "$dynamicRef": "#meta" } } };
+const $defs$1 = { "anchorString": { "type": "string", "pattern": "^[A-Za-z_][-A-Za-z0-9._]*$" }, "uriString": { "type": "string", "format": "uri" }, "uriReferenceString": { "type": "string", "format": "uri-reference" } };
+const require$$4 = {
+  $schema: $schema$4,
+  $id: $id$4,
+  $vocabulary: $vocabulary$3,
+  $dynamicAnchor: $dynamicAnchor$3,
+  title: title$4,
+  type: type$4,
+  properties: properties$4,
+  $defs: $defs$1
+};
+const $schema$3 = "https://json-schema.org/draft/2020-12/schema";
+const $id$3 = "https://json-schema.org/draft/2020-12/meta/format-annotation";
+const $vocabulary$2 = { "https://json-schema.org/draft/2020-12/vocab/format-annotation": true };
+const $dynamicAnchor$2 = "meta";
+const title$3 = "Format vocabulary meta-schema for annotation results";
+const type$3 = ["object", "boolean"];
+const properties$3 = { "format": { "type": "string" } };
+const require$$5 = {
+  $schema: $schema$3,
+  $id: $id$3,
+  $vocabulary: $vocabulary$2,
+  $dynamicAnchor: $dynamicAnchor$2,
+  title: title$3,
+  type: type$3,
+  properties: properties$3
+};
+const $schema$2 = "https://json-schema.org/draft/2020-12/schema";
+const $id$2 = "https://json-schema.org/draft/2020-12/meta/meta-data";
+const $vocabulary$1 = { "https://json-schema.org/draft/2020-12/vocab/meta-data": true };
+const $dynamicAnchor$1 = "meta";
+const title$2 = "Meta-data vocabulary meta-schema";
+const type$2 = ["object", "boolean"];
+const properties$2 = { "title": { "type": "string" }, "description": { "type": "string" }, "default": true, "deprecated": { "type": "boolean", "default": false }, "readOnly": { "type": "boolean", "default": false }, "writeOnly": { "type": "boolean", "default": false }, "examples": { "type": "array", "items": true } };
+const require$$6 = {
+  $schema: $schema$2,
+  $id: $id$2,
+  $vocabulary: $vocabulary$1,
+  $dynamicAnchor: $dynamicAnchor$1,
+  title: title$2,
+  type: type$2,
+  properties: properties$2
+};
+const $schema$1 = "https://json-schema.org/draft/2020-12/schema";
+const $id$1 = "https://json-schema.org/draft/2020-12/meta/validation";
+const $vocabulary = { "https://json-schema.org/draft/2020-12/vocab/validation": true };
+const $dynamicAnchor = "meta";
+const title$1 = "Validation vocabulary meta-schema";
+const type$1 = ["object", "boolean"];
+const properties$1 = { "type": { "anyOf": [{ "$ref": "#/$defs/simpleTypes" }, { "type": "array", "items": { "$ref": "#/$defs/simpleTypes" }, "minItems": 1, "uniqueItems": true }] }, "const": true, "enum": { "type": "array", "items": true }, "multipleOf": { "type": "number", "exclusiveMinimum": 0 }, "maximum": { "type": "number" }, "exclusiveMaximum": { "type": "number" }, "minimum": { "type": "number" }, "exclusiveMinimum": { "type": "number" }, "maxLength": { "$ref": "#/$defs/nonNegativeInteger" }, "minLength": { "$ref": "#/$defs/nonNegativeIntegerDefault0" }, "pattern": { "type": "string", "format": "regex" }, "maxItems": { "$ref": "#/$defs/nonNegativeInteger" }, "minItems": { "$ref": "#/$defs/nonNegativeIntegerDefault0" }, "uniqueItems": { "type": "boolean", "default": false }, "maxContains": { "$ref": "#/$defs/nonNegativeInteger" }, "minContains": { "$ref": "#/$defs/nonNegativeInteger", "default": 1 }, "maxProperties": { "$ref": "#/$defs/nonNegativeInteger" }, "minProperties": { "$ref": "#/$defs/nonNegativeIntegerDefault0" }, "required": { "$ref": "#/$defs/stringArray" }, "dependentRequired": { "type": "object", "additionalProperties": { "$ref": "#/$defs/stringArray" } } };
+const $defs = { "nonNegativeInteger": { "type": "integer", "minimum": 0 }, "nonNegativeIntegerDefault0": { "$ref": "#/$defs/nonNegativeInteger", "default": 0 }, "simpleTypes": { "enum": ["array", "boolean", "integer", "null", "number", "object", "string"] }, "stringArray": { "type": "array", "items": { "type": "string" }, "uniqueItems": true, "default": [] } };
+const require$$7 = {
+  $schema: $schema$1,
+  $id: $id$1,
+  $vocabulary,
+  $dynamicAnchor,
+  title: title$1,
+  type: type$1,
+  properties: properties$1,
+  $defs
+};
+var hasRequiredJsonSchema202012;
+function requireJsonSchema202012() {
+  if (hasRequiredJsonSchema202012) return jsonSchema202012;
+  hasRequiredJsonSchema202012 = 1;
+  Object.defineProperty(jsonSchema202012, "__esModule", { value: true });
+  const metaSchema = require$$0;
+  const applicator2 = require$$1;
+  const unevaluated2 = require$$2;
+  const content = require$$3$1;
+  const core2 = require$$4;
+  const format2 = require$$5;
+  const metadata2 = require$$6;
+  const validation2 = require$$7;
+  const META_SUPPORT_DATA = ["/properties"];
+  function addMetaSchema2020($data) {
+    [
+      metaSchema,
+      applicator2,
+      unevaluated2,
+      content,
+      core2,
+      with$data(this, format2),
+      metadata2,
+      with$data(this, validation2)
+    ].forEach((sch) => this.addMetaSchema(sch, void 0, false));
+    return this;
+    function with$data(ajv2, sch) {
+      return $data ? ajv2.$dataMetaSchema(sch, META_SUPPORT_DATA) : sch;
+    }
+  }
+  jsonSchema202012.default = addMetaSchema2020;
+  return jsonSchema202012;
+}
+var hasRequired_2020;
+function require_2020() {
+  if (hasRequired_2020) return _2020.exports;
+  hasRequired_2020 = 1;
+  (function(module, exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.MissingRefError = exports$1.ValidationError = exports$1.CodeGen = exports$1.Name = exports$1.nil = exports$1.stringify = exports$1.str = exports$1._ = exports$1.KeywordCxt = exports$1.Ajv2020 = void 0;
+    const core_1 = /* @__PURE__ */ requireCore$1();
+    const draft2020_1 = /* @__PURE__ */ requireDraft2020();
+    const discriminator_1 = /* @__PURE__ */ requireDiscriminator();
+    const json_schema_2020_12_1 = /* @__PURE__ */ requireJsonSchema202012();
+    const META_SCHEMA_ID = "https://json-schema.org/draft/2020-12/schema";
+    class Ajv20202 extends core_1.default {
+      constructor(opts = {}) {
+        super({
+          ...opts,
+          dynamicRef: true,
+          next: true,
+          unevaluated: true
+        });
+      }
+      _addVocabularies() {
+        super._addVocabularies();
+        draft2020_1.default.forEach((v) => this.addVocabulary(v));
+        if (this.opts.discriminator)
+          this.addKeyword(discriminator_1.default);
+      }
+      _addDefaultMetaSchema() {
+        super._addDefaultMetaSchema();
+        const { $data, meta } = this.opts;
+        if (!meta)
+          return;
+        json_schema_2020_12_1.default.call(this, $data);
+        this.refs["http://json-schema.org/schema"] = META_SCHEMA_ID;
+      }
+      defaultMeta() {
+        return this.opts.defaultMeta = super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : void 0);
+      }
+    }
+    exports$1.Ajv2020 = Ajv20202;
+    module.exports = exports$1 = Ajv20202;
+    module.exports.Ajv2020 = Ajv20202;
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.default = Ajv20202;
+    var validate_1 = /* @__PURE__ */ requireValidate();
+    Object.defineProperty(exports$1, "KeywordCxt", { enumerable: true, get: function() {
+      return validate_1.KeywordCxt;
+    } });
+    var codegen_1 = /* @__PURE__ */ requireCodegen();
+    Object.defineProperty(exports$1, "_", { enumerable: true, get: function() {
+      return codegen_1._;
+    } });
+    Object.defineProperty(exports$1, "str", { enumerable: true, get: function() {
+      return codegen_1.str;
+    } });
+    Object.defineProperty(exports$1, "stringify", { enumerable: true, get: function() {
+      return codegen_1.stringify;
+    } });
+    Object.defineProperty(exports$1, "nil", { enumerable: true, get: function() {
+      return codegen_1.nil;
+    } });
+    Object.defineProperty(exports$1, "Name", { enumerable: true, get: function() {
+      return codegen_1.Name;
+    } });
+    Object.defineProperty(exports$1, "CodeGen", { enumerable: true, get: function() {
+      return codegen_1.CodeGen;
+    } });
+    var validation_error_1 = /* @__PURE__ */ requireValidation_error();
+    Object.defineProperty(exports$1, "ValidationError", { enumerable: true, get: function() {
+      return validation_error_1.default;
+    } });
+    var ref_error_1 = /* @__PURE__ */ requireRef_error();
+    Object.defineProperty(exports$1, "MissingRefError", { enumerable: true, get: function() {
+      return ref_error_1.default;
+    } });
+  })(_2020, _2020.exports);
+  return _2020.exports;
+}
+var _2020Exports = /* @__PURE__ */ require_2020();
+const Ajv2020 = /* @__PURE__ */ getDefaultExportFromCjs(_2020Exports);
+var ajv = { exports: {} };
+var draft7 = {};
+var hasRequiredDraft7;
+function requireDraft7() {
+  if (hasRequiredDraft7) return draft7;
+  hasRequiredDraft7 = 1;
+  Object.defineProperty(draft7, "__esModule", { value: true });
+  const core_1 = /* @__PURE__ */ requireCore();
+  const validation_1 = /* @__PURE__ */ requireValidation();
+  const applicator_1 = /* @__PURE__ */ requireApplicator();
+  const format_1 = /* @__PURE__ */ requireFormat();
+  const metadata_1 = /* @__PURE__ */ 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;
+}
 const $schema = "http://json-schema.org/draft-07/schema#";
 const $id = "http://json-schema.org/draft-07/schema#";
 const title = "Core schema meta-schema";
@@ -5417,7 +6017,7 @@ function requireAjv() {
     const draft7MetaSchema = require$$3;
     const META_SUPPORT_DATA = ["/properties"];
     const META_SCHEMA_ID = "http://json-schema.org/draft-07/schema";
-    class Ajv2 extends core_1.default {
+    class Ajv extends core_1.default {
       _addVocabularies() {
         super._addVocabularies();
         draft7_1.default.forEach((v) => this.addVocabulary(v));
@@ -5436,11 +6036,11 @@ function requireAjv() {
         return this.opts.defaultMeta = super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : void 0);
       }
     }
-    exports$1.Ajv = Ajv2;
-    module.exports = exports$1 = Ajv2;
-    module.exports.Ajv = Ajv2;
+    exports$1.Ajv = Ajv;
+    module.exports = exports$1 = Ajv;
+    module.exports.Ajv = Ajv;
     Object.defineProperty(exports$1, "__esModule", { value: true });
-    exports$1.default = Ajv2;
+    exports$1.default = Ajv;
     var validate_1 = /* @__PURE__ */ requireValidate();
     Object.defineProperty(exports$1, "KeywordCxt", { enumerable: true, get: function() {
       return validate_1.KeywordCxt;
@@ -5475,10 +6075,8 @@ function requireAjv() {
   })(ajv, ajv.exports);
   return ajv.exports;
 }
-var ajvExports = /* @__PURE__ */ requireAjv();
-const Ajv = /* @__PURE__ */ getDefaultExportFromCjs(ajvExports);
 export {
-  Ajv as A,
+  Ajv2020 as A,
   requireAjv as a,
   requireCodegen as r
 };