@sean.holung/minicode 0.3.10 → 0.3.11

package/node_modules/ajv-formats/node_modules/ajv/lib/jtd.ts

@@ -1,132 +0,0 @@
-import type {AnySchemaObject, SchemaObject, JTDParser} from "./types"
-import type {JTDSchemaType, SomeJTDSchemaType, JTDDataType} from "./types/jtd-schema"
-import AjvCore, {CurrentOptions} from "./core"
-import jtdVocabulary from "./vocabularies/jtd"
-import jtdMetaSchema from "./refs/jtd-schema"
-import compileSerializer from "./compile/jtd/serialize"
-import compileParser from "./compile/jtd/parse"
-import {SchemaEnv} from "./compile"
-
-const META_SCHEMA_ID = "JTD-meta-schema"
-
-type JTDOptions = CurrentOptions & {
-  // strict mode options not supported with JTD:
-  strict?: never
-  allowMatchingProperties?: never
-  allowUnionTypes?: never
-  validateFormats?: never
-  // validation and reporting options not supported with JTD:
-  $data?: never
-  verbose?: boolean
-  $comment?: never
-  formats?: never
-  loadSchema?: never
-  // options to modify validated data:
-  useDefaults?: never
-  coerceTypes?: never
-  // advanced options:
-  next?: never
-  unevaluated?: never
-  dynamicRef?: never
-  meta?: boolean
-  defaultMeta?: never
-  inlineRefs?: boolean
-  loopRequired?: never
-  multipleOfPrecision?: never
-}
-
-export class Ajv extends AjvCore {
-  constructor(opts: JTDOptions = {}) {
-    super({
-      ...opts,
-      jtd: true,
-    })
-  }
-
-  _addVocabularies(): void {
-    super._addVocabularies()
-    this.addVocabulary(jtdVocabulary)
-  }
-
-  _addDefaultMetaSchema(): void {
-    super._addDefaultMetaSchema()
-    if (!this.opts.meta) return
-    this.addMetaSchema(jtdMetaSchema, META_SCHEMA_ID, false)
-  }
-
-  defaultMeta(): string | AnySchemaObject | undefined {
-    return (this.opts.defaultMeta =
-      super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : undefined))
-  }
-
-  compileSerializer<T = unknown>(schema: SchemaObject): (data: T) => string
-  // Separated for type inference to work
-  // eslint-disable-next-line @typescript-eslint/unified-signatures
-  compileSerializer<T = unknown>(schema: JTDSchemaType<T>): (data: T) => string
-  compileSerializer<T = unknown>(schema: SchemaObject): (data: T) => string {
-    const sch = this._addSchema(schema)
-    return sch.serialize || this._compileSerializer(sch)
-  }
-
-  compileParser<T = unknown>(schema: SchemaObject): JTDParser<T>
-  // Separated for type inference to work
-  // eslint-disable-next-line @typescript-eslint/unified-signatures
-  compileParser<T = unknown>(schema: JTDSchemaType<T>): JTDParser<T>
-  compileParser<T = unknown>(schema: SchemaObject): JTDParser<T> {
-    const sch = this._addSchema(schema)
-    return (sch.parse || this._compileParser(sch)) as JTDParser<T>
-  }
-
-  private _compileSerializer<T>(sch: SchemaEnv): (data: T) => string {
-    compileSerializer.call(this, sch, (sch.schema as AnySchemaObject).definitions || {})
-    /* istanbul ignore if */
-    if (!sch.serialize) throw new Error("ajv implementation error")
-    return sch.serialize
-  }
-
-  private _compileParser(sch: SchemaEnv): JTDParser {
-    compileParser.call(this, sch, (sch.schema as AnySchemaObject).definitions || {})
-    /* istanbul ignore if */
-    if (!sch.parse) throw new Error("ajv implementation error")
-    return sch.parse
-  }
-}
-
-module.exports = exports = Ajv
-module.exports.Ajv = Ajv
-Object.defineProperty(exports, "__esModule", {value: true})
-
-export default Ajv
-
-export {
-  Format,
-  FormatDefinition,
-  AsyncFormatDefinition,
-  KeywordDefinition,
-  KeywordErrorDefinition,
-  CodeKeywordDefinition,
-  MacroKeywordDefinition,
-  FuncKeywordDefinition,
-  Vocabulary,
-  Schema,
-  SchemaObject,
-  AnySchemaObject,
-  AsyncSchema,
-  AnySchema,
-  ValidateFunction,
-  AsyncValidateFunction,
-  ErrorObject,
-  ErrorNoParams,
-  JTDParser,
-} from "./types"
-
-export {Plugin, Options, CodeOptions, InstanceOptions, Logger, ErrorsTextOptions} from "./core"
-export {SchemaCxt, SchemaObjCxt} from "./compile"
-export {KeywordCxt} from "./compile/validate"
-export {JTDErrorObject} from "./vocabularies/jtd"
-export {_, str, stringify, nil, Name, Code, CodeGen, CodeGenOptions} from "./compile/codegen"
-
-export {JTDSchemaType, SomeJTDSchemaType, JTDDataType}
-export {JTDOptions}
-export {default as ValidationError} from "./runtime/validation_error"
-export {default as MissingRefError} from "./compile/ref_error"

package/node_modules/ajv-formats/node_modules/ajv/lib/refs/data.json

@@ -1,13 +0,0 @@
-{
-  "$id": "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#",
-  "description": "Meta-schema for $data reference (JSON AnySchema extension proposal)",
-  "type": "object",
-  "required": ["$data"],
-  "properties": {
-    "$data": {
-      "type": "string",
-      "anyOf": [{"format": "relative-json-pointer"}, {"format": "json-pointer"}]
-    }
-  },
-  "additionalProperties": false
-}

package/node_modules/ajv-formats/node_modules/ajv/lib/refs/json-schema-2019-09/index.ts

@@ -1,28 +0,0 @@
-import type Ajv from "../../core"
-import type {AnySchemaObject} from "../../types"
-import * as metaSchema from "./schema.json"
-import * as applicator from "./meta/applicator.json"
-import * as content from "./meta/content.json"
-import * as core from "./meta/core.json"
-import * as format from "./meta/format.json"
-import * as metadata from "./meta/meta-data.json"
-import * as validation from "./meta/validation.json"
-
-const META_SUPPORT_DATA = ["/properties"]
-
-export default function addMetaSchema2019(this: Ajv, $data?: boolean): Ajv {
-  ;[
-    metaSchema,
-    applicator,
-    content,
-    core,
-    with$data(this, format),
-    metadata,
-    with$data(this, validation),
-  ].forEach((sch) => this.addMetaSchema(sch, undefined, false))
-  return this
-
-  function with$data(ajv: Ajv, sch: AnySchemaObject): AnySchemaObject {
-    return $data ? ajv.$dataMetaSchema(sch, META_SUPPORT_DATA) : sch
-  }
-}

package/node_modules/ajv-formats/node_modules/ajv/lib/refs/json-schema-2019-09/meta/applicator.json

@@ -1,53 +0,0 @@
-{
-  "$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": "#"}
-    }
-  }
-}

package/node_modules/ajv-formats/node_modules/ajv/lib/refs/json-schema-2019-09/meta/content.json

@@ -1,17 +0,0 @@
-{
-  "$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": "#"}
-  }
-}

package/node_modules/ajv-formats/node_modules/ajv/lib/refs/json-schema-2019-09/meta/core.json

@@ -1,57 +0,0 @@
-{
-  "$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": {}
-    }
-  }
-}

package/node_modules/ajv-formats/node_modules/ajv/lib/refs/json-schema-2019-09/meta/format.json

@@ -1,14 +0,0 @@
-{
-  "$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"}
-  }
-}

package/node_modules/ajv-formats/node_modules/ajv/lib/refs/json-schema-2019-09/meta/meta-data.json

@@ -1,37 +0,0 @@
-{
-  "$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
-    }
-  }
-}

package/node_modules/ajv-formats/node_modules/ajv/lib/refs/json-schema-2019-09/meta/validation.json

@@ -1,90 +0,0 @@
-{
-  "$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": []
-    }
-  }
-}

package/node_modules/ajv-formats/node_modules/ajv/lib/refs/json-schema-2019-09/schema.json

@@ -1,39 +0,0 @@
-{
-  "$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"}]
-      }
-    }
-  }
-}

package/node_modules/ajv-formats/node_modules/ajv/lib/refs/json-schema-2020-12/index.ts

@@ -1,30 +0,0 @@
-import type Ajv from "../../core"
-import type {AnySchemaObject} from "../../types"
-import * as metaSchema from "./schema.json"
-import * as applicator from "./meta/applicator.json"
-import * as unevaluated from "./meta/unevaluated.json"
-import * as content from "./meta/content.json"
-import * as core from "./meta/core.json"
-import * as format from "./meta/format-annotation.json"
-import * as metadata from "./meta/meta-data.json"
-import * as validation from "./meta/validation.json"
-
-const META_SUPPORT_DATA = ["/properties"]
-
-export default function addMetaSchema2020(this: Ajv, $data?: boolean): Ajv {
-  ;[
-    metaSchema,
-    applicator,
-    unevaluated,
-    content,
-    core,
-    with$data(this, format),
-    metadata,
-    with$data(this, validation),
-  ].forEach((sch) => this.addMetaSchema(sch, undefined, false))
-  return this
-
-  function with$data(ajv: Ajv, sch: AnySchemaObject): AnySchemaObject {
-    return $data ? ajv.$dataMetaSchema(sch, META_SUPPORT_DATA) : sch
-  }
-}

package/node_modules/ajv-formats/node_modules/ajv/lib/refs/json-schema-2020-12/meta/applicator.json

@@ -1,48 +0,0 @@
-{
-  "$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"}
-    }
-  }
-}

package/node_modules/ajv-formats/node_modules/ajv/lib/refs/json-schema-2020-12/meta/content.json

@@ -1,17 +0,0 @@
-{
-  "$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"}
-  }
-}

package/node_modules/ajv-formats/node_modules/ajv/lib/refs/json-schema-2020-12/meta/core.json

@@ -1,51 +0,0 @@
-{
-  "$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"
-    }
-  }
-}

package/node_modules/ajv-formats/node_modules/ajv/lib/refs/json-schema-2020-12/meta/format-annotation.json

@@ -1,14 +0,0 @@
-{
-  "$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"}
-  }
-}