@mininglamp-oss/octo-runtime 1.0.0 → 1.1.0

package/node_modules/ajv/lib/vocabularies/discriminator/index.ts

@@ -1,113 +0,0 @@
-import type {CodeKeywordDefinition, AnySchemaObject, KeywordErrorDefinition} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {_, getProperty, Name} from "../../compile/codegen"
-import {DiscrError, DiscrErrorObj} from "../discriminator/types"
-import {resolveRef, SchemaEnv} from "../../compile"
-import MissingRefError from "../../compile/ref_error"
-import {schemaHasRulesButRef} from "../../compile/util"
-
-export type DiscriminatorError = DiscrErrorObj<DiscrError.Tag> | DiscrErrorObj<DiscrError.Mapping>
-
-const error: KeywordErrorDefinition = {
-  message: ({params: {discrError, tagName}}) =>
-    discrError === DiscrError.Tag
-      ? `tag "${tagName}" must be string`
-      : `value of tag "${tagName}" must be in oneOf`,
-  params: ({params: {discrError, tag, tagName}}) =>
-    _`{error: ${discrError}, tag: ${tagName}, tagValue: ${tag}}`,
-}
-
-const def: CodeKeywordDefinition = {
-  keyword: "discriminator",
-  type: "object",
-  schemaType: "object",
-  error,
-  code(cxt: KeywordCxt) {
-    const {gen, data, schema, parentSchema, it} = cxt
-    const {oneOf} = parentSchema
-    if (!it.opts.discriminator) {
-      throw new Error("discriminator: requires discriminator option")
-    }
-    const tagName = schema.propertyName
-    if (typeof tagName != "string") throw new Error("discriminator: requires propertyName")
-    if (schema.mapping) throw new Error("discriminator: mapping is not supported")
-    if (!oneOf) throw new Error("discriminator: requires oneOf keyword")
-    const valid = gen.let("valid", false)
-    const tag = gen.const("tag", _`${data}${getProperty(tagName)}`)
-    gen.if(
-      _`typeof ${tag} == "string"`,
-      () => validateMapping(),
-      () => cxt.error(false, {discrError: DiscrError.Tag, tag, tagName})
-    )
-    cxt.ok(valid)
-
-    function validateMapping(): void {
-      const mapping = getMapping()
-      gen.if(false)
-      for (const tagValue in mapping) {
-        gen.elseIf(_`${tag} === ${tagValue}`)
-        gen.assign(valid, applyTagSchema(mapping[tagValue]))
-      }
-      gen.else()
-      cxt.error(false, {discrError: DiscrError.Mapping, tag, tagName})
-      gen.endIf()
-    }
-
-    function applyTagSchema(schemaProp?: number): Name {
-      const _valid = gen.name("valid")
-      const schCxt = cxt.subschema({keyword: "oneOf", schemaProp}, _valid)
-      cxt.mergeEvaluated(schCxt, Name)
-      return _valid
-    }
-
-    function getMapping(): {[T in string]?: number} {
-      const oneOfMapping: {[T in string]?: number} = {}
-      const topRequired = hasRequired(parentSchema)
-      let tagRequired = true
-      for (let i = 0; i < oneOf.length; i++) {
-        let sch = oneOf[i]
-        if (sch?.$ref && !schemaHasRulesButRef(sch, it.self.RULES)) {
-          const ref = sch.$ref
-          sch = resolveRef.call(it.self, it.schemaEnv.root, it.baseId, ref)
-          if (sch instanceof SchemaEnv) sch = sch.schema
-          if (sch === undefined) throw new MissingRefError(it.opts.uriResolver, it.baseId, ref)
-        }
-        const propSch = sch?.properties?.[tagName]
-        if (typeof propSch != "object") {
-          throw new Error(
-            `discriminator: oneOf subschemas (or referenced schemas) must have "properties/${tagName}"`
-          )
-        }
-        tagRequired = tagRequired && (topRequired || hasRequired(sch))
-        addMappings(propSch, i)
-      }
-      if (!tagRequired) throw new Error(`discriminator: "${tagName}" must be required`)
-      return oneOfMapping
-
-      function hasRequired({required}: AnySchemaObject): boolean {
-        return Array.isArray(required) && required.includes(tagName)
-      }
-
-      function addMappings(sch: AnySchemaObject, i: number): void {
-        if (sch.const) {
-          addMapping(sch.const, i)
-        } else if (sch.enum) {
-          for (const tagValue of sch.enum) {
-            addMapping(tagValue, i)
-          }
-        } else {
-          throw new Error(`discriminator: "properties/${tagName}" must have "const" or "enum"`)
-        }
-      }
-
-      function addMapping(tagValue: unknown, i: number): void {
-        if (typeof tagValue != "string" || tagValue in oneOfMapping) {
-          throw new Error(`discriminator: "${tagName}" values must be unique strings`)
-        }
-        oneOfMapping[tagValue] = i
-      }
-    }
-  },
-}
-
-export default def

package/node_modules/ajv/lib/vocabularies/discriminator/types.ts

@@ -1,12 +0,0 @@
-import type {ErrorObject} from "../../types"
-
-export enum DiscrError {
-  Tag = "tag",
-  Mapping = "mapping",
-}
-
-export type DiscrErrorObj<E extends DiscrError> = ErrorObject<
-  "discriminator",
-  {error: E; tag: string; tagValue: unknown},
-  string
->

package/node_modules/ajv/lib/vocabularies/draft2020.ts

@@ -1,23 +0,0 @@
-import type {Vocabulary} from "../types"
-import coreVocabulary from "./core"
-import validationVocabulary from "./validation"
-import getApplicatorVocabulary from "./applicator"
-import dynamicVocabulary from "./dynamic"
-import nextVocabulary from "./next"
-import unevaluatedVocabulary from "./unevaluated"
-import formatVocabulary from "./format"
-import {metadataVocabulary, contentVocabulary} from "./metadata"
-
-const draft2020Vocabularies: Vocabulary[] = [
-  dynamicVocabulary,
-  coreVocabulary,
-  validationVocabulary,
-  getApplicatorVocabulary(true),
-  formatVocabulary,
-  metadataVocabulary,
-  contentVocabulary,
-  nextVocabulary,
-  unevaluatedVocabulary,
-]
-
-export default draft2020Vocabularies

package/node_modules/ajv/lib/vocabularies/draft7.ts

@@ -1,17 +0,0 @@
-import type {Vocabulary} from "../types"
-import coreVocabulary from "./core"
-import validationVocabulary from "./validation"
-import getApplicatorVocabulary from "./applicator"
-import formatVocabulary from "./format"
-import {metadataVocabulary, contentVocabulary} from "./metadata"
-
-const draft7Vocabularies: Vocabulary[] = [
-  coreVocabulary,
-  validationVocabulary,
-  getApplicatorVocabulary(),
-  formatVocabulary,
-  metadataVocabulary,
-  contentVocabulary,
-]
-
-export default draft7Vocabularies

package/node_modules/ajv/lib/vocabularies/dynamic/dynamicAnchor.ts

@@ -1,31 +0,0 @@
-import type {CodeKeywordDefinition} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {_, getProperty, Code} from "../../compile/codegen"
-import N from "../../compile/names"
-import {SchemaEnv, compileSchema} from "../../compile"
-import {getValidate} from "../core/ref"
-
-const def: CodeKeywordDefinition = {
-  keyword: "$dynamicAnchor",
-  schemaType: "string",
-  code: (cxt) => dynamicAnchor(cxt, cxt.schema),
-}
-
-export function dynamicAnchor(cxt: KeywordCxt, anchor: string): void {
-  const {gen, it} = cxt
-  it.schemaEnv.root.dynamicAnchors[anchor] = true
-  const v = _`${N.dynamicAnchors}${getProperty(anchor)}`
-  const validate = it.errSchemaPath === "#" ? it.validateName : _getValidate(cxt)
-  gen.if(_`!${v}`, () => gen.assign(v, validate))
-}
-
-function _getValidate(cxt: KeywordCxt): Code {
-  const {schemaEnv, schema, self} = cxt.it
-  const {root, baseId, localRefs, meta} = schemaEnv.root
-  const {schemaId} = self.opts
-  const sch = new SchemaEnv({schema, schemaId, root, baseId, localRefs, meta})
-  compileSchema.call(self, sch)
-  return getValidate(cxt, sch)
-}
-
-export default def

package/node_modules/ajv/lib/vocabularies/dynamic/dynamicRef.ts

@@ -1,51 +0,0 @@
-import type {CodeKeywordDefinition} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {_, getProperty, Code, Name} from "../../compile/codegen"
-import N from "../../compile/names"
-import {callRef} from "../core/ref"
-
-const def: CodeKeywordDefinition = {
-  keyword: "$dynamicRef",
-  schemaType: "string",
-  code: (cxt) => dynamicRef(cxt, cxt.schema),
-}
-
-export function dynamicRef(cxt: KeywordCxt, ref: string): void {
-  const {gen, keyword, it} = cxt
-  if (ref[0] !== "#") throw new Error(`"${keyword}" only supports hash fragment reference`)
-  const anchor = ref.slice(1)
-  if (it.allErrors) {
-    _dynamicRef()
-  } else {
-    const valid = gen.let("valid", false)
-    _dynamicRef(valid)
-    cxt.ok(valid)
-  }
-
-  function _dynamicRef(valid?: Name): void {
-    // TODO the assumption here is that `recursiveRef: #` always points to the root
-    // of the schema object, which is not correct, because there may be $id that
-    // makes # point to it, and the target schema may not contain dynamic/recursiveAnchor.
-    // Because of that 2 tests in recursiveRef.json fail.
-    // This is a similar problem to #815 (`$id` doesn't alter resolution scope for `{ "$ref": "#" }`).
-    // (This problem is not tested in JSON-Schema-Test-Suite)
-    if (it.schemaEnv.root.dynamicAnchors[anchor]) {
-      const v = gen.let("_v", _`${N.dynamicAnchors}${getProperty(anchor)}`)
-      gen.if(v, _callRef(v, valid), _callRef(it.validateName, valid))
-    } else {
-      _callRef(it.validateName, valid)()
-    }
-  }
-
-  function _callRef(validate: Code, valid?: Name): () => void {
-    return valid
-      ? () =>
-          gen.block(() => {
-            callRef(cxt, validate)
-            gen.let(valid, true)
-          })
-      : () => callRef(cxt, validate)
-  }
-}
-
-export default def

package/node_modules/ajv/lib/vocabularies/dynamic/index.ts

@@ -1,9 +0,0 @@
-import type {Vocabulary} from "../../types"
-import dynamicAnchor from "./dynamicAnchor"
-import dynamicRef from "./dynamicRef"
-import recursiveAnchor from "./recursiveAnchor"
-import recursiveRef from "./recursiveRef"
-
-const dynamic: Vocabulary = [dynamicAnchor, dynamicRef, recursiveAnchor, recursiveRef]
-
-export default dynamic

package/node_modules/ajv/lib/vocabularies/dynamic/recursiveAnchor.ts

@@ -1,14 +0,0 @@
-import type {CodeKeywordDefinition} from "../../types"
-import {dynamicAnchor} from "./dynamicAnchor"
-import {checkStrictMode} from "../../compile/util"
-
-const def: CodeKeywordDefinition = {
-  keyword: "$recursiveAnchor",
-  schemaType: "boolean",
-  code(cxt) {
-    if (cxt.schema) dynamicAnchor(cxt, "")
-    else checkStrictMode(cxt.it, "$recursiveAnchor: false is ignored")
-  },
-}
-
-export default def

package/node_modules/ajv/lib/vocabularies/dynamic/recursiveRef.ts

@@ -1,10 +0,0 @@
-import type {CodeKeywordDefinition} from "../../types"
-import {dynamicRef} from "./dynamicRef"
-
-const def: CodeKeywordDefinition = {
-  keyword: "$recursiveRef",
-  schemaType: "string",
-  code: (cxt) => dynamicRef(cxt, cxt.schema),
-}
-
-export default def

package/node_modules/ajv/lib/vocabularies/errors.ts

@@ -1,18 +0,0 @@
-import type {TypeError} from "../compile/validate/dataType"
-import type {ApplicatorKeywordError} from "./applicator"
-import type {ValidationKeywordError} from "./validation"
-import type {FormatError} from "./format/format"
-import type {UnevaluatedPropertiesError} from "./unevaluated/unevaluatedProperties"
-import type {UnevaluatedItemsError} from "./unevaluated/unevaluatedItems"
-import type {DependentRequiredError} from "./validation/dependentRequired"
-import type {DiscriminatorError} from "./discriminator"
-
-export type DefinedError =
-  | TypeError
-  | ApplicatorKeywordError
-  | ValidationKeywordError
-  | FormatError
-  | UnevaluatedPropertiesError
-  | UnevaluatedItemsError
-  | DependentRequiredError
-  | DiscriminatorError

package/node_modules/ajv/lib/vocabularies/format/format.ts

@@ -1,120 +0,0 @@
-import type {
-  AddedFormat,
-  FormatValidator,
-  AsyncFormatValidator,
-  CodeKeywordDefinition,
-  KeywordErrorDefinition,
-  ErrorObject,
-} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {_, str, nil, or, Code, getProperty, regexpCode} from "../../compile/codegen"
-
-type FormatValidate =
-  | FormatValidator<string>
-  | FormatValidator<number>
-  | AsyncFormatValidator<string>
-  | AsyncFormatValidator<number>
-  | RegExp
-  | string
-  | true
-
-export type FormatError = ErrorObject<"format", {format: string}, string | {$data: string}>
-
-const error: KeywordErrorDefinition = {
-  message: ({schemaCode}) => str`must match format "${schemaCode}"`,
-  params: ({schemaCode}) => _`{format: ${schemaCode}}`,
-}
-
-const def: CodeKeywordDefinition = {
-  keyword: "format",
-  type: ["number", "string"],
-  schemaType: "string",
-  $data: true,
-  error,
-  code(cxt: KeywordCxt, ruleType?: string) {
-    const {gen, data, $data, schema, schemaCode, it} = cxt
-    const {opts, errSchemaPath, schemaEnv, self} = it
-    if (!opts.validateFormats) return
-
-    if ($data) validate$DataFormat()
-    else validateFormat()
-
-    function validate$DataFormat(): void {
-      const fmts = gen.scopeValue("formats", {
-        ref: self.formats,
-        code: opts.code.formats,
-      })
-      const fDef = gen.const("fDef", _`${fmts}[${schemaCode}]`)
-      const fType = gen.let("fType")
-      const format = gen.let("format")
-      // TODO simplify
-      gen.if(
-        _`typeof ${fDef} == "object" && !(${fDef} instanceof RegExp)`,
-        () => gen.assign(fType, _`${fDef}.type || "string"`).assign(format, _`${fDef}.validate`),
-        () => gen.assign(fType, _`"string"`).assign(format, fDef)
-      )
-      cxt.fail$data(or(unknownFmt(), invalidFmt()))
-
-      function unknownFmt(): Code {
-        if (opts.strictSchema === false) return nil
-        return _`${schemaCode} && !${format}`
-      }
-
-      function invalidFmt(): Code {
-        const callFormat = schemaEnv.$async
-          ? _`(${fDef}.async ? await ${format}(${data}) : ${format}(${data}))`
-          : _`${format}(${data})`
-        const validData = _`(typeof ${format} == "function" ? ${callFormat} : ${format}.test(${data}))`
-        return _`${format} && ${format} !== true && ${fType} === ${ruleType} && !${validData}`
-      }
-    }
-
-    function validateFormat(): void {
-      const formatDef: AddedFormat | undefined = self.formats[schema]
-      if (!formatDef) {
-        unknownFormat()
-        return
-      }
-      if (formatDef === true) return
-      const [fmtType, format, fmtRef] = getFormat(formatDef)
-      if (fmtType === ruleType) cxt.pass(validCondition())
-
-      function unknownFormat(): void {
-        if (opts.strictSchema === false) {
-          self.logger.warn(unknownMsg())
-          return
-        }
-        throw new Error(unknownMsg())
-
-        function unknownMsg(): string {
-          return `unknown format "${schema as string}" ignored in schema at path "${errSchemaPath}"`
-        }
-      }
-
-      function getFormat(fmtDef: AddedFormat): [string, FormatValidate, Code] {
-        const code =
-          fmtDef instanceof RegExp
-            ? regexpCode(fmtDef)
-            : opts.code.formats
-            ? _`${opts.code.formats}${getProperty(schema)}`
-            : undefined
-        const fmt = gen.scopeValue("formats", {key: schema, ref: fmtDef, code})
-        if (typeof fmtDef == "object" && !(fmtDef instanceof RegExp)) {
-          return [fmtDef.type || "string", fmtDef.validate, _`${fmt}.validate`]
-        }
-
-        return ["string", fmtDef, fmt]
-      }
-
-      function validCondition(): Code {
-        if (typeof formatDef == "object" && !(formatDef instanceof RegExp) && formatDef.async) {
-          if (!schemaEnv.$async) throw new Error("async format in sync schema")
-          return _`await ${fmtRef}(${data})`
-        }
-        return typeof format == "function" ? _`${fmtRef}(${data})` : _`${fmtRef}.test(${data})`
-      }
-    }
-  },
-}
-
-export default def

package/node_modules/ajv/lib/vocabularies/format/index.ts

@@ -1,6 +0,0 @@
-import type {Vocabulary} from "../../types"
-import formatKeyword from "./format"
-
-const format: Vocabulary = [formatKeyword]
-
-export default format

package/node_modules/ajv/lib/vocabularies/jtd/discriminator.ts

@@ -1,89 +0,0 @@
-import type {CodeKeywordDefinition, KeywordErrorDefinition} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {_, not, getProperty, Name} from "../../compile/codegen"
-import {checkMetadata} from "./metadata"
-import {checkNullableObject} from "./nullable"
-import {typeErrorMessage, typeErrorParams, _JTDTypeError} from "./error"
-import {DiscrError, DiscrErrorObj} from "../discriminator/types"
-
-export type JTDDiscriminatorError =
-  | _JTDTypeError<"discriminator", "object", string>
-  | DiscrErrorObj<DiscrError.Tag>
-  | DiscrErrorObj<DiscrError.Mapping>
-
-const error: KeywordErrorDefinition = {
-  message: (cxt) => {
-    const {schema, params} = cxt
-    return params.discrError
-      ? params.discrError === DiscrError.Tag
-        ? `tag "${schema}" must be string`
-        : `value of tag "${schema}" must be in mapping`
-      : typeErrorMessage(cxt, "object")
-  },
-  params: (cxt) => {
-    const {schema, params} = cxt
-    return params.discrError
-      ? _`{error: ${params.discrError}, tag: ${schema}, tagValue: ${params.tag}}`
-      : typeErrorParams(cxt, "object")
-  },
-}
-
-const def: CodeKeywordDefinition = {
-  keyword: "discriminator",
-  schemaType: "string",
-  implements: ["mapping"],
-  error,
-  code(cxt: KeywordCxt) {
-    checkMetadata(cxt)
-    const {gen, data, schema, parentSchema} = cxt
-    const [valid, cond] = checkNullableObject(cxt, data)
-
-    gen.if(cond)
-    validateDiscriminator()
-    gen.elseIf(not(valid))
-    cxt.error()
-    gen.endIf()
-    cxt.ok(valid)
-
-    function validateDiscriminator(): void {
-      const tag = gen.const("tag", _`${data}${getProperty(schema)}`)
-      gen.if(_`${tag} === undefined`)
-      cxt.error(false, {discrError: DiscrError.Tag, tag})
-      gen.elseIf(_`typeof ${tag} == "string"`)
-      validateMapping(tag)
-      gen.else()
-      cxt.error(false, {discrError: DiscrError.Tag, tag}, {instancePath: schema})
-      gen.endIf()
-    }
-
-    function validateMapping(tag: Name): void {
-      gen.if(false)
-      for (const tagValue in parentSchema.mapping) {
-        gen.elseIf(_`${tag} === ${tagValue}`)
-        gen.assign(valid, applyTagSchema(tagValue))
-      }
-      gen.else()
-      cxt.error(
-        false,
-        {discrError: DiscrError.Mapping, tag},
-        {instancePath: schema, schemaPath: "mapping", parentSchema: true}
-      )
-      gen.endIf()
-    }
-
-    function applyTagSchema(schemaProp: string): Name {
-      const _valid = gen.name("valid")
-      cxt.subschema(
-        {
-          keyword: "mapping",
-          schemaProp,
-          jtdDiscriminator: schema,
-        },
-        _valid
-      )
-      return _valid
-    }
-  },
-}
-
-export default def

package/node_modules/ajv/lib/vocabularies/jtd/elements.ts

@@ -1,32 +0,0 @@
-import type {CodeKeywordDefinition, SchemaObject} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {alwaysValidSchema} from "../../compile/util"
-import {validateArray} from "../code"
-import {_, not} from "../../compile/codegen"
-import {checkMetadata} from "./metadata"
-import {checkNullable} from "./nullable"
-import {typeError, _JTDTypeError} from "./error"
-
-export type JTDElementsError = _JTDTypeError<"elements", "array", SchemaObject>
-
-const def: CodeKeywordDefinition = {
-  keyword: "elements",
-  schemaType: "object",
-  error: typeError("array"),
-  code(cxt: KeywordCxt) {
-    checkMetadata(cxt)
-    const {gen, data, schema, it} = cxt
-    if (alwaysValidSchema(it, schema)) return
-    const [valid] = checkNullable(cxt)
-    gen.if(not(valid), () =>
-      gen.if(
-        _`Array.isArray(${data})`,
-        () => gen.assign(valid, validateArray(cxt)),
-        () => cxt.error()
-      )
-    )
-    cxt.ok(valid)
-  },
-}
-
-export default def

package/node_modules/ajv/lib/vocabularies/jtd/enum.ts

@@ -1,45 +0,0 @@
-import type {CodeKeywordDefinition, KeywordErrorDefinition, ErrorObject} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {_, or, and, Code} from "../../compile/codegen"
-import {checkMetadata} from "./metadata"
-import {checkNullable} from "./nullable"
-
-export type JTDEnumError = ErrorObject<"enum", {allowedValues: string[]}, string[]>
-
-const error: KeywordErrorDefinition = {
-  message: "must be equal to one of the allowed values",
-  params: ({schemaCode}) => _`{allowedValues: ${schemaCode}}`,
-}
-
-const def: CodeKeywordDefinition = {
-  keyword: "enum",
-  schemaType: "array",
-  error,
-  code(cxt: KeywordCxt) {
-    checkMetadata(cxt)
-    const {gen, data, schema, schemaValue, parentSchema, it} = cxt
-    if (schema.length === 0) throw new Error("enum must have non-empty array")
-    if (schema.length !== new Set(schema).size) throw new Error("enum items must be unique")
-    let valid: Code
-    const isString = _`typeof ${data} == "string"`
-    if (schema.length >= it.opts.loopEnum) {
-      let cond: Code
-      ;[valid, cond] = checkNullable(cxt, isString)
-      gen.if(cond, loopEnum)
-    } else {
-      /* istanbul ignore if */
-      if (!Array.isArray(schema)) throw new Error("ajv implementation error")
-      valid = and(isString, or(...schema.map((value: string) => _`${data} === ${value}`)))
-      if (parentSchema.nullable) valid = or(_`${data} === null`, valid)
-    }
-    cxt.pass(valid)
-
-    function loopEnum(): void {
-      gen.forOf("v", schemaValue as Code, (v) =>
-        gen.if(_`${valid} = ${data} === ${v}`, () => gen.break())
-      )
-    }
-  },
-}
-
-export default def

package/node_modules/ajv/lib/vocabularies/jtd/error.ts

@@ -1,23 +0,0 @@
-import type {KeywordErrorDefinition, KeywordErrorCxt, ErrorObject} from "../../types"
-import {_, Code} from "../../compile/codegen"
-
-export type _JTDTypeError<K extends string, T extends string, S> = ErrorObject<
-  K,
-  {type: T; nullable: boolean},
-  S
->
-
-export function typeError(t: string): KeywordErrorDefinition {
-  return {
-    message: (cxt) => typeErrorMessage(cxt, t),
-    params: (cxt) => typeErrorParams(cxt, t),
-  }
-}
-
-export function typeErrorMessage({parentSchema}: KeywordErrorCxt, t: string): string {
-  return parentSchema?.nullable ? `must be ${t} or null` : `must be ${t}`
-}
-
-export function typeErrorParams({parentSchema}: KeywordErrorCxt, t: string): Code {
-  return _`{type: ${t}, nullable: ${!!parentSchema?.nullable}}`
-}

package/node_modules/ajv/lib/vocabularies/jtd/index.ts

@@ -1,37 +0,0 @@
-import type {Vocabulary} from "../../types"
-import refKeyword from "./ref"
-import typeKeyword, {JTDTypeError} from "./type"
-import enumKeyword, {JTDEnumError} from "./enum"
-import elements, {JTDElementsError} from "./elements"
-import properties, {JTDPropertiesError} from "./properties"
-import optionalProperties from "./optionalProperties"
-import discriminator, {JTDDiscriminatorError} from "./discriminator"
-import values, {JTDValuesError} from "./values"
-import union from "./union"
-import metadata from "./metadata"
-
-const jtdVocabulary: Vocabulary = [
-  "definitions",
-  refKeyword,
-  typeKeyword,
-  enumKeyword,
-  elements,
-  properties,
-  optionalProperties,
-  discriminator,
-  values,
-  union,
-  metadata,
-  {keyword: "additionalProperties", schemaType: "boolean"},
-  {keyword: "nullable", schemaType: "boolean"},
-]
-
-export default jtdVocabulary
-
-export type JTDErrorObject =
-  | JTDTypeError
-  | JTDEnumError
-  | JTDElementsError
-  | JTDPropertiesError
-  | JTDDiscriminatorError
-  | JTDValuesError