@jarenjs/refs 0.8.2

package/dist/index.js

@@ -0,0 +1,1054 @@
+// ../core/src/index.js
+function isStringType(data) {
+  return typeof data === "string";
+}
+var TypedArray = Object.getPrototypeOf(Uint8Array);
+
+// src/json-schema-draft-06.json
+var json_schema_draft_06_default = {
+  $schema: "http://json-schema.org/draft-06/schema#",
+  $id: "http://json-schema.org/draft-06/schema#",
+  title: "Core schema meta-schema",
+  definitions: {
+    schemaArray: {
+      type: "array",
+      minItems: 1,
+      items: { $ref: "#" }
+    },
+    nonNegativeInteger: {
+      type: "integer",
+      minimum: 0
+    },
+    nonNegativeIntegerDefault0: {
+      allOf: [{ $ref: "#/definitions/nonNegativeInteger" }, { default: 0 }]
+    },
+    simpleTypes: {
+      enum: ["array", "boolean", "integer", "null", "number", "object", "string"]
+    },
+    stringArray: {
+      type: "array",
+      items: { type: "string" },
+      uniqueItems: true,
+      default: []
+    }
+  },
+  type: ["object", "boolean"],
+  properties: {
+    $id: {
+      type: "string",
+      format: "uri-reference"
+    },
+    $schema: {
+      type: "string",
+      format: "uri"
+    },
+    $ref: {
+      type: "string",
+      format: "uri-reference"
+    },
+    title: {
+      type: "string"
+    },
+    description: {
+      type: "string"
+    },
+    default: {},
+    examples: {
+      type: "array",
+      items: {}
+    },
+    multipleOf: {
+      type: "number",
+      exclusiveMinimum: 0
+    },
+    maximum: {
+      type: "number"
+    },
+    exclusiveMaximum: {
+      type: "number"
+    },
+    minimum: {
+      type: "number"
+    },
+    exclusiveMinimum: {
+      type: "number"
+    },
+    maxLength: { $ref: "#/definitions/nonNegativeInteger" },
+    minLength: { $ref: "#/definitions/nonNegativeIntegerDefault0" },
+    pattern: {
+      type: "string",
+      format: "regex"
+    },
+    additionalItems: { $ref: "#" },
+    items: {
+      anyOf: [{ $ref: "#" }, { $ref: "#/definitions/schemaArray" }],
+      default: {}
+    },
+    maxItems: { $ref: "#/definitions/nonNegativeInteger" },
+    minItems: { $ref: "#/definitions/nonNegativeIntegerDefault0" },
+    uniqueItems: {
+      type: "boolean",
+      default: false
+    },
+    contains: { $ref: "#" },
+    maxProperties: { $ref: "#/definitions/nonNegativeInteger" },
+    minProperties: { $ref: "#/definitions/nonNegativeIntegerDefault0" },
+    required: { $ref: "#/definitions/stringArray" },
+    additionalProperties: { $ref: "#" },
+    definitions: {
+      type: "object",
+      additionalProperties: { $ref: "#" },
+      default: {}
+    },
+    properties: {
+      type: "object",
+      additionalProperties: { $ref: "#" },
+      default: {}
+    },
+    patternProperties: {
+      type: "object",
+      additionalProperties: { $ref: "#" },
+      default: {}
+    },
+    dependencies: {
+      type: "object",
+      additionalProperties: {
+        anyOf: [{ $ref: "#" }, { $ref: "#/definitions/stringArray" }]
+      }
+    },
+    propertyNames: { $ref: "#" },
+    const: {},
+    enum: {
+      type: "array",
+      minItems: 1,
+      uniqueItems: true
+    },
+    type: {
+      anyOf: [
+        { $ref: "#/definitions/simpleTypes" },
+        {
+          type: "array",
+          items: { $ref: "#/definitions/simpleTypes" },
+          minItems: 1,
+          uniqueItems: true
+        }
+      ]
+    },
+    format: { type: "string" },
+    allOf: { $ref: "#/definitions/schemaArray" },
+    anyOf: { $ref: "#/definitions/schemaArray" },
+    oneOf: { $ref: "#/definitions/schemaArray" },
+    not: { $ref: "#" }
+  },
+  default: {}
+};
+
+// src/json-schema-draft-07.json
+var json_schema_draft_07_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "http://json-schema.org/draft-07/schema#",
+  title: "Core schema meta-schema",
+  definitions: {
+    schemaArray: {
+      type: "array",
+      minItems: 1,
+      items: { $ref: "#" }
+    },
+    nonNegativeInteger: {
+      type: "integer",
+      minimum: 0
+    },
+    nonNegativeIntegerDefault0: {
+      allOf: [{ $ref: "#/definitions/nonNegativeInteger" }, { default: 0 }]
+    },
+    simpleTypes: {
+      enum: ["array", "boolean", "integer", "null", "number", "object", "string"]
+    },
+    stringArray: {
+      type: "array",
+      items: { type: "string" },
+      uniqueItems: true,
+      default: []
+    }
+  },
+  type: ["object", "boolean"],
+  properties: {
+    $id: {
+      type: "string",
+      format: "uri-reference",
+      pattern: "^[^#]*#?$"
+    },
+    $schema: {
+      type: "string",
+      format: "uri"
+    },
+    $ref: {
+      type: "string",
+      format: "uri-reference"
+    },
+    $comment: {
+      type: "string"
+    },
+    title: {
+      type: "string"
+    },
+    description: {
+      type: "string"
+    },
+    default: true,
+    readOnly: {
+      type: "boolean",
+      default: false
+    },
+    examples: {
+      type: "array",
+      items: true
+    },
+    multipleOf: {
+      type: "number",
+      exclusiveMinimum: 0
+    },
+    maximum: {
+      type: "number"
+    },
+    exclusiveMaximum: {
+      type: "number"
+    },
+    minimum: {
+      type: "number"
+    },
+    exclusiveMinimum: {
+      type: "number"
+    },
+    maxLength: { $ref: "#/definitions/nonNegativeInteger" },
+    minLength: { $ref: "#/definitions/nonNegativeIntegerDefault0" },
+    pattern: {
+      type: "string",
+      format: "regex"
+    },
+    additionalItems: { $ref: "#" },
+    items: {
+      anyOf: [{ $ref: "#" }, { $ref: "#/definitions/schemaArray" }],
+      default: true
+    },
+    maxItems: { $ref: "#/definitions/nonNegativeInteger" },
+    minItems: { $ref: "#/definitions/nonNegativeIntegerDefault0" },
+    uniqueItems: {
+      type: "boolean",
+      default: false
+    },
+    contains: { $ref: "#" },
+    maxProperties: { $ref: "#/definitions/nonNegativeInteger" },
+    minProperties: { $ref: "#/definitions/nonNegativeIntegerDefault0" },
+    required: { $ref: "#/definitions/stringArray" },
+    additionalProperties: { $ref: "#" },
+    definitions: {
+      type: "object",
+      additionalProperties: { $ref: "#" },
+      default: {}
+    },
+    properties: {
+      type: "object",
+      additionalProperties: { $ref: "#" },
+      default: {}
+    },
+    patternProperties: {
+      type: "object",
+      additionalProperties: { $ref: "#" },
+      propertyNames: { format: "regex" },
+      default: {}
+    },
+    dependencies: {
+      type: "object",
+      additionalProperties: {
+        anyOf: [{ $ref: "#" }, { $ref: "#/definitions/stringArray" }]
+      }
+    },
+    propertyNames: { $ref: "#" },
+    const: true,
+    enum: {
+      type: "array",
+      items: true,
+      minItems: 1,
+      uniqueItems: true
+    },
+    type: {
+      anyOf: [
+        { $ref: "#/definitions/simpleTypes" },
+        {
+          type: "array",
+          items: { $ref: "#/definitions/simpleTypes" },
+          minItems: 1,
+          uniqueItems: true
+        }
+      ]
+    },
+    format: { type: "string" },
+    contentMediaType: { type: "string" },
+    contentEncoding: { type: "string" },
+    if: { $ref: "#" },
+    then: { $ref: "#" },
+    else: { $ref: "#" },
+    allOf: { $ref: "#/definitions/schemaArray" },
+    anyOf: { $ref: "#/definitions/schemaArray" },
+    oneOf: { $ref: "#/definitions/schemaArray" },
+    not: { $ref: "#" }
+  },
+  default: true
+};
+
+// src/index.import.no-lint.js
+var _draft6 = json_schema_draft_06_default;
+var _draft7 = json_schema_draft_07_default;
+
+// src/json-schema-2019-09/schema.json
+var schema_default = {
+  $schema: "https://json-schema.org/draft/2019-09/schema",
+  $id: "https://json-schema.org/draft/2019-09/schema",
+  $vocabulary: {
+    "https://json-schema.org/draft/2019-09/vocab/core": true,
+    "https://json-schema.org/draft/2019-09/vocab/applicator": true,
+    "https://json-schema.org/draft/2019-09/vocab/validation": true,
+    "https://json-schema.org/draft/2019-09/vocab/meta-data": true,
+    "https://json-schema.org/draft/2019-09/vocab/format": false,
+    "https://json-schema.org/draft/2019-09/vocab/content": true
+  },
+  $recursiveAnchor: true,
+  title: "Core and Validation specifications meta-schema",
+  allOf: [
+    { $ref: "meta/core" },
+    { $ref: "meta/applicator" },
+    { $ref: "meta/validation" },
+    { $ref: "meta/meta-data" },
+    { $ref: "meta/format" },
+    { $ref: "meta/content" }
+  ],
+  type: ["object", "boolean"],
+  properties: {
+    definitions: {
+      $comment: "While no longer an official keyword as it is replaced by $defs, this keyword is retained in the meta-schema to prevent incompatible extensions as it remains in common use.",
+      type: "object",
+      additionalProperties: { $recursiveRef: "#" },
+      default: {}
+    },
+    dependencies: {
+      $comment: '"dependencies" is no longer a keyword, but schema authors should avoid redefining it to facilitate a smooth transition to "dependentSchemas" and "dependentRequired"',
+      type: "object",
+      additionalProperties: {
+        anyOf: [{ $recursiveRef: "#" }, { $ref: "meta/validation#/$defs/stringArray" }]
+      }
+    }
+  }
+};
+
+// src/json-schema-2019-09/meta/applicator.json
+var applicator_default = {
+  $schema: "https://json-schema.org/draft/2019-09/schema",
+  $id: "https://json-schema.org/draft/2019-09/meta/applicator",
+  $vocabulary: {
+    "https://json-schema.org/draft/2019-09/vocab/applicator": true
+  },
+  $recursiveAnchor: true,
+  title: "Applicator vocabulary meta-schema",
+  type: ["object", "boolean"],
+  properties: {
+    additionalItems: { $recursiveRef: "#" },
+    unevaluatedItems: { $recursiveRef: "#" },
+    items: {
+      anyOf: [{ $recursiveRef: "#" }, { $ref: "#/$defs/schemaArray" }]
+    },
+    contains: { $recursiveRef: "#" },
+    additionalProperties: { $recursiveRef: "#" },
+    unevaluatedProperties: { $recursiveRef: "#" },
+    properties: {
+      type: "object",
+      additionalProperties: { $recursiveRef: "#" },
+      default: {}
+    },
+    patternProperties: {
+      type: "object",
+      additionalProperties: { $recursiveRef: "#" },
+      propertyNames: { format: "regex" },
+      default: {}
+    },
+    dependentSchemas: {
+      type: "object",
+      additionalProperties: {
+        $recursiveRef: "#"
+      }
+    },
+    propertyNames: { $recursiveRef: "#" },
+    if: { $recursiveRef: "#" },
+    then: { $recursiveRef: "#" },
+    else: { $recursiveRef: "#" },
+    allOf: { $ref: "#/$defs/schemaArray" },
+    anyOf: { $ref: "#/$defs/schemaArray" },
+    oneOf: { $ref: "#/$defs/schemaArray" },
+    not: { $recursiveRef: "#" }
+  },
+  $defs: {
+    schemaArray: {
+      type: "array",
+      minItems: 1,
+      items: { $recursiveRef: "#" }
+    }
+  }
+};
+
+// src/json-schema-2019-09/meta/content.json
+var content_default = {
+  $schema: "https://json-schema.org/draft/2019-09/schema",
+  $id: "https://json-schema.org/draft/2019-09/meta/content",
+  $vocabulary: {
+    "https://json-schema.org/draft/2019-09/vocab/content": true
+  },
+  $recursiveAnchor: true,
+  title: "Content vocabulary meta-schema",
+  type: ["object", "boolean"],
+  properties: {
+    contentMediaType: { type: "string" },
+    contentEncoding: { type: "string" },
+    contentSchema: { $recursiveRef: "#" }
+  }
+};
+
+// src/json-schema-2019-09/meta/core.json
+var core_default = {
+  $schema: "https://json-schema.org/draft/2019-09/schema",
+  $id: "https://json-schema.org/draft/2019-09/meta/core",
+  $vocabulary: {
+    "https://json-schema.org/draft/2019-09/vocab/core": true
+  },
+  $recursiveAnchor: true,
+  title: "Core vocabulary meta-schema",
+  type: ["object", "boolean"],
+  properties: {
+    $id: {
+      type: "string",
+      format: "uri-reference",
+      $comment: "Non-empty fragments not allowed.",
+      pattern: "^[^#]*#?$"
+    },
+    $schema: {
+      type: "string",
+      format: "uri"
+    },
+    $anchor: {
+      type: "string",
+      pattern: "^[A-Za-z][-A-Za-z0-9.:_]*$"
+    },
+    $ref: {
+      type: "string",
+      format: "uri-reference"
+    },
+    $recursiveRef: {
+      type: "string",
+      format: "uri-reference"
+    },
+    $recursiveAnchor: {
+      type: "boolean",
+      default: false
+    },
+    $vocabulary: {
+      type: "object",
+      propertyNames: {
+        type: "string",
+        format: "uri"
+      },
+      additionalProperties: {
+        type: "boolean"
+      }
+    },
+    $comment: {
+      type: "string"
+    },
+    $defs: {
+      type: "object",
+      additionalProperties: { $recursiveRef: "#" },
+      default: {}
+    }
+  }
+};
+
+// src/json-schema-2019-09/meta/format.json
+var format_default = {
+  $schema: "https://json-schema.org/draft/2019-09/schema",
+  $id: "https://json-schema.org/draft/2019-09/meta/format",
+  $vocabulary: {
+    "https://json-schema.org/draft/2019-09/vocab/format": true
+  },
+  $recursiveAnchor: true,
+  title: "Format vocabulary meta-schema",
+  type: ["object", "boolean"],
+  properties: {
+    format: { type: "string" }
+  }
+};
+
+// src/json-schema-2019-09/meta/meta-data.json
+var meta_data_default = {
+  $schema: "https://json-schema.org/draft/2019-09/schema",
+  $id: "https://json-schema.org/draft/2019-09/meta/meta-data",
+  $vocabulary: {
+    "https://json-schema.org/draft/2019-09/vocab/meta-data": true
+  },
+  $recursiveAnchor: true,
+  title: "Meta-data vocabulary meta-schema",
+  type: ["object", "boolean"],
+  properties: {
+    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
+    }
+  }
+};
+
+// src/json-schema-2019-09/meta/validation.json
+var validation_default = {
+  $schema: "https://json-schema.org/draft/2019-09/schema",
+  $id: "https://json-schema.org/draft/2019-09/meta/validation",
+  $vocabulary: {
+    "https://json-schema.org/draft/2019-09/vocab/validation": true
+  },
+  $recursiveAnchor: true,
+  title: "Validation vocabulary meta-schema",
+  type: ["object", "boolean"],
+  properties: {
+    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: true,
+    enum: {
+      type: "array",
+      items: true
+    },
+    type: {
+      anyOf: [
+        { $ref: "#/$defs/simpleTypes" },
+        {
+          type: "array",
+          items: { $ref: "#/$defs/simpleTypes" },
+          minItems: 1,
+          uniqueItems: true
+        }
+      ]
+    }
+  },
+  $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: []
+    }
+  }
+};
+
+// src/json-schema-2019-09/index.import.no-lint.js
+var index_import_no_lint_default = {
+  metaSchema: schema_default,
+  applicator: applicator_default,
+  content: content_default,
+  core: core_default,
+  format: format_default,
+  metadata: meta_data_default,
+  validation: validation_default
+};
+
+// src/json-schema-2019-09/index.js
+var draft2019 = [
+  index_import_no_lint_default.metaSchema,
+  index_import_no_lint_default.applicator,
+  index_import_no_lint_default.content,
+  index_import_no_lint_default.core,
+  index_import_no_lint_default.format,
+  index_import_no_lint_default.metadata,
+  index_import_no_lint_default.validation
+];
+var json_schema_2019_09_default = draft2019;
+
+// src/json-schema-2020-12/schema.json
+var schema_default2 = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://json-schema.org/draft/2020-12/schema",
+  $vocabulary: {
+    "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
+  },
+  $dynamicAnchor: "meta",
+  title: "Core and Validation specifications meta-schema",
+  allOf: [
+    { $ref: "meta/core" },
+    { $ref: "meta/applicator" },
+    { $ref: "meta/unevaluated" },
+    { $ref: "meta/validation" },
+    { $ref: "meta/meta-data" },
+    { $ref: "meta/format-annotation" },
+    { $ref: "meta/content" }
+  ],
+  type: ["object", "boolean"],
+  $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.",
+  properties: {
+    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
+    }
+  }
+};
+
+// src/json-schema-2020-12/meta/applicator.json
+var applicator_default2 = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://json-schema.org/draft/2020-12/meta/applicator",
+  $vocabulary: {
+    "https://json-schema.org/draft/2020-12/vocab/applicator": true
+  },
+  $dynamicAnchor: "meta",
+  title: "Applicator vocabulary meta-schema",
+  type: ["object", "boolean"],
+  properties: {
+    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" }
+  },
+  $defs: {
+    schemaArray: {
+      type: "array",
+      minItems: 1,
+      items: { $dynamicRef: "#meta" }
+    }
+  }
+};
+
+// src/json-schema-2020-12/meta/unevaluated.json
+var unevaluated_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://json-schema.org/draft/2020-12/meta/unevaluated",
+  $vocabulary: {
+    "https://json-schema.org/draft/2020-12/vocab/unevaluated": true
+  },
+  $dynamicAnchor: "meta",
+  title: "Unevaluated applicator vocabulary meta-schema",
+  type: ["object", "boolean"],
+  properties: {
+    unevaluatedItems: { $dynamicRef: "#meta" },
+    unevaluatedProperties: { $dynamicRef: "#meta" }
+  }
+};
+
+// src/json-schema-2020-12/meta/content.json
+var content_default2 = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://json-schema.org/draft/2020-12/meta/content",
+  $vocabulary: {
+    "https://json-schema.org/draft/2020-12/vocab/content": true
+  },
+  $dynamicAnchor: "meta",
+  title: "Content vocabulary meta-schema",
+  type: ["object", "boolean"],
+  properties: {
+    contentEncoding: { type: "string" },
+    contentMediaType: { type: "string" },
+    contentSchema: { $dynamicRef: "#meta" }
+  }
+};
+
+// src/json-schema-2020-12/meta/core.json
+var core_default2 = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://json-schema.org/draft/2020-12/meta/core",
+  $vocabulary: {
+    "https://json-schema.org/draft/2020-12/vocab/core": true
+  },
+  $dynamicAnchor: "meta",
+  title: "Core vocabulary meta-schema",
+  type: ["object", "boolean"],
+  properties: {
+    $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" }
+    }
+  },
+  $defs: {
+    anchorString: {
+      type: "string",
+      pattern: "^[A-Za-z_][-A-Za-z0-9._]*$"
+    },
+    uriString: {
+      type: "string",
+      format: "uri"
+    },
+    uriReferenceString: {
+      type: "string",
+      format: "uri-reference"
+    }
+  }
+};
+
+// src/json-schema-2020-12/meta/format-annotation.json
+var format_annotation_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://json-schema.org/draft/2020-12/meta/format-annotation",
+  $vocabulary: {
+    "https://json-schema.org/draft/2020-12/vocab/format-annotation": true
+  },
+  $dynamicAnchor: "meta",
+  title: "Format vocabulary meta-schema for annotation results",
+  type: ["object", "boolean"],
+  properties: {
+    format: { type: "string" }
+  }
+};
+
+// src/json-schema-2020-12/meta/meta-data.json
+var meta_data_default2 = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://json-schema.org/draft/2020-12/meta/meta-data",
+  $vocabulary: {
+    "https://json-schema.org/draft/2020-12/vocab/meta-data": true
+  },
+  $dynamicAnchor: "meta",
+  title: "Meta-data vocabulary meta-schema",
+  type: ["object", "boolean"],
+  properties: {
+    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
+    }
+  }
+};
+
+// src/json-schema-2020-12/meta/validation.json
+var validation_default2 = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://json-schema.org/draft/2020-12/meta/validation",
+  $vocabulary: {
+    "https://json-schema.org/draft/2020-12/vocab/validation": true
+  },
+  $dynamicAnchor: "meta",
+  title: "Validation vocabulary meta-schema",
+  type: ["object", "boolean"],
+  properties: {
+    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"
+      }
+    }
+  },
+  $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: []
+    }
+  }
+};
+
+// src/json-schema-2020-12/index.import.no-lint.js
+var index_import_no_lint_default2 = {
+  metaSchema: schema_default2,
+  applicator: applicator_default2,
+  unevaluated: unevaluated_default,
+  content: content_default2,
+  core: core_default2,
+  format: format_annotation_default,
+  metadata: meta_data_default2,
+  validation: validation_default2
+};
+
+// src/json-schema-2020-12/index.js
+var draft2020 = [
+  index_import_no_lint_default2.metaSchema,
+  index_import_no_lint_default2.applicator,
+  index_import_no_lint_default2.unevaluated,
+  index_import_no_lint_default2.content,
+  index_import_no_lint_default2.core,
+  index_import_no_lint_default2.format,
+  index_import_no_lint_default2.metadata,
+  index_import_no_lint_default2.validation
+];
+var json_schema_2020_12_default = draft2020;
+
+// src/index.js
+var schemaDrafts = {
+  6: { draft: "http://json-schema.org/draft-06/schema", schema: [_draft6] },
+  7: { draft: "http://json-schema.org/draft-07/schema", schema: [_draft7] },
+  2019: { draft: "https://json-schema.org/draft/2019-09/schema", schema: json_schema_2019_09_default },
+  2020: { draft: "https://json-schema.org/draft/2020-12/schema", schema: json_schema_2020_12_default }
+};
+function getSchemaDraftByVersion(version) {
+  if (version in schemaDrafts)
+    return schemaDrafts[version];
+  else
+    throw new Error("Unknown reference schema version");
+}
+function getSchemaDraftByName(name) {
+  switch (name) {
+    case "6":
+    case "draft6":
+    case "draft-6":
+    case "draft06":
+    case "draft-06":
+      return getSchemaDraftByVersion(6);
+    case "7":
+    case "draft7":
+    case "draft-7":
+    case "draft07":
+    case "draft-07":
+      return getSchemaDraftByVersion(7);
+    case "draft2019":
+    case "draft-2019":
+    case "2019":
+    case "2019-09":
+      return getSchemaDraftByVersion(2019);
+    case "draft2020":
+    case "draft-2020":
+    case "2020":
+    case "2020-12":
+      return getSchemaDraftByVersion(2020);
+    default:
+      throw new Error(`Unknown reference schema name: '${name}'`);
+  }
+}
+function getSchemaDraftById(id) {
+  if (!isStringType())
+    throw new Error("The schema id must be of type string");
+  const $id = id.toLowerCase();
+  for (const [_, item] of Object.entries(schemaDrafts)) {
+    const draft = item.draft;
+    if (draft.toLowerCase() === $id)
+      return item;
+  }
+  throw new Error(`Schema draft with id '${id}' does not exists`);
+}
+export {
+  getSchemaDraftById,
+  getSchemaDraftByName,
+  getSchemaDraftByVersion
+};
+//# sourceMappingURL=index.js.map