toolcraft 0.0.115 → 0.0.117

package/node_modules/ajv/lib/vocabularies/validation/dependentRequired.ts

@@ -1,23 +0,0 @@
-import type {CodeKeywordDefinition, ErrorObject} from "../../types"
-import {
-  validatePropertyDeps,
-  error,
-  DependenciesErrorParams,
-  PropertyDependencies,
-} from "../applicator/dependencies"
-
-export type DependentRequiredError = ErrorObject<
-  "dependentRequired",
-  DependenciesErrorParams,
-  PropertyDependencies
->
-
-const def: CodeKeywordDefinition = {
-  keyword: "dependentRequired",
-  type: "object",
-  schemaType: "object",
-  error,
-  code: (cxt) => validatePropertyDeps(cxt),
-}
-
-export default def

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

@@ -1,54 +0,0 @@
-import type {CodeKeywordDefinition, ErrorObject, KeywordErrorDefinition} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {_, or, Name, Code} from "../../compile/codegen"
-import {useFunc} from "../../compile/util"
-import equal from "../../runtime/equal"
-
-export type EnumError = ErrorObject<"enum", {allowedValues: any[]}, any[] | {$data: 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",
-  $data: true,
-  error,
-  code(cxt: KeywordCxt) {
-    const {gen, data, $data, schema, schemaCode, it} = cxt
-    if (!$data && schema.length === 0) throw new Error("enum must have non-empty array")
-    const useLoop = schema.length >= it.opts.loopEnum
-    let eql: Name | undefined
-    const getEql = (): Name => (eql ??= useFunc(gen, equal))
-
-    let valid: Code
-    if (useLoop || $data) {
-      valid = gen.let("valid")
-      cxt.block$data(valid, loopEnum)
-    } else {
-      /* istanbul ignore if */
-      if (!Array.isArray(schema)) throw new Error("ajv implementation error")
-      const vSchema = gen.const("vSchema", schemaCode)
-      valid = or(...schema.map((_x: unknown, i: number) => equalCode(vSchema, i)))
-    }
-    cxt.pass(valid)
-
-    function loopEnum(): void {
-      gen.assign(valid, false)
-      gen.forOf("v", schemaCode as Code, (v) =>
-        gen.if(_`${getEql()}(${data}, ${v})`, () => gen.assign(valid, true).break())
-      )
-    }
-
-    function equalCode(vSchema: Name, i: number): Code {
-      const sch = schema[i]
-      return typeof sch === "object" && sch !== null
-        ? _`${getEql()}(${data}, ${vSchema}[${i}])`
-        : _`${data} === ${sch}`
-    }
-  },
-}
-
-export default def

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

@@ -1,49 +0,0 @@
-import type {ErrorObject, Vocabulary} from "../../types"
-import limitNumber, {LimitNumberError} from "./limitNumber"
-import multipleOf, {MultipleOfError} from "./multipleOf"
-import limitLength from "./limitLength"
-import pattern, {PatternError} from "./pattern"
-import limitProperties from "./limitProperties"
-import required, {RequiredError} from "./required"
-import limitItems from "./limitItems"
-import uniqueItems, {UniqueItemsError} from "./uniqueItems"
-import constKeyword, {ConstError} from "./const"
-import enumKeyword, {EnumError} from "./enum"
-
-const validation: Vocabulary = [
-  // number
-  limitNumber,
-  multipleOf,
-  // string
-  limitLength,
-  pattern,
-  // object
-  limitProperties,
-  required,
-  // array
-  limitItems,
-  uniqueItems,
-  // any
-  {keyword: "type", schemaType: ["string", "array"]},
-  {keyword: "nullable", schemaType: "boolean"},
-  constKeyword,
-  enumKeyword,
-]
-
-export default validation
-
-type LimitError = ErrorObject<
-  "maxItems" | "minItems" | "minProperties" | "maxProperties" | "minLength" | "maxLength",
-  {limit: number},
-  number | {$data: string}
->
-
-export type ValidationKeywordError =
-  | LimitError
-  | LimitNumberError
-  | MultipleOfError
-  | PatternError
-  | RequiredError
-  | UniqueItemsError
-  | ConstError
-  | EnumError

package/node_modules/ajv/lib/vocabularies/validation/limitContains.ts

@@ -1,16 +0,0 @@
-import type {CodeKeywordDefinition} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {checkStrictMode} from "../../compile/util"
-
-const def: CodeKeywordDefinition = {
-  keyword: ["maxContains", "minContains"],
-  type: "array",
-  schemaType: "number",
-  code({keyword, parentSchema, it}: KeywordCxt) {
-    if (parentSchema.contains === undefined) {
-      checkStrictMode(it, `"${keyword}" without "contains" is ignored`)
-    }
-  },
-}
-
-export default def

package/node_modules/ajv/lib/vocabularies/validation/limitItems.ts

@@ -1,26 +0,0 @@
-import type {CodeKeywordDefinition, KeywordErrorDefinition} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {_, str, operators} from "../../compile/codegen"
-
-const error: KeywordErrorDefinition = {
-  message({keyword, schemaCode}) {
-    const comp = keyword === "maxItems" ? "more" : "fewer"
-    return str`must NOT have ${comp} than ${schemaCode} items`
-  },
-  params: ({schemaCode}) => _`{limit: ${schemaCode}}`,
-}
-
-const def: CodeKeywordDefinition = {
-  keyword: ["maxItems", "minItems"],
-  type: "array",
-  schemaType: "number",
-  $data: true,
-  error,
-  code(cxt: KeywordCxt) {
-    const {keyword, data, schemaCode} = cxt
-    const op = keyword === "maxItems" ? operators.GT : operators.LT
-    cxt.fail$data(_`${data}.length ${op} ${schemaCode}`)
-  },
-}
-
-export default def

package/node_modules/ajv/lib/vocabularies/validation/limitLength.ts

@@ -1,30 +0,0 @@
-import type {CodeKeywordDefinition, KeywordErrorDefinition} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {_, str, operators} from "../../compile/codegen"
-import {useFunc} from "../../compile/util"
-import ucs2length from "../../runtime/ucs2length"
-
-const error: KeywordErrorDefinition = {
-  message({keyword, schemaCode}) {
-    const comp = keyword === "maxLength" ? "more" : "fewer"
-    return str`must NOT have ${comp} than ${schemaCode} characters`
-  },
-  params: ({schemaCode}) => _`{limit: ${schemaCode}}`,
-}
-
-const def: CodeKeywordDefinition = {
-  keyword: ["maxLength", "minLength"],
-  type: "string",
-  schemaType: "number",
-  $data: true,
-  error,
-  code(cxt: KeywordCxt) {
-    const {keyword, data, schemaCode, it} = cxt
-    const op = keyword === "maxLength" ? operators.GT : operators.LT
-    const len =
-      it.opts.unicode === false ? _`${data}.length` : _`${useFunc(cxt.gen, ucs2length)}(${data})`
-    cxt.fail$data(_`${len} ${op} ${schemaCode}`)
-  },
-}
-
-export default def

package/node_modules/ajv/lib/vocabularies/validation/limitNumber.ts

@@ -1,42 +0,0 @@
-import type {CodeKeywordDefinition, ErrorObject, KeywordErrorDefinition} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {_, str, operators, Code} from "../../compile/codegen"
-
-const ops = operators
-
-type Kwd = "maximum" | "minimum" | "exclusiveMaximum" | "exclusiveMinimum"
-
-type Comparison = "<=" | ">=" | "<" | ">"
-
-const KWDs: {[K in Kwd]: {okStr: Comparison; ok: Code; fail: Code}} = {
-  maximum: {okStr: "<=", ok: ops.LTE, fail: ops.GT},
-  minimum: {okStr: ">=", ok: ops.GTE, fail: ops.LT},
-  exclusiveMaximum: {okStr: "<", ok: ops.LT, fail: ops.GTE},
-  exclusiveMinimum: {okStr: ">", ok: ops.GT, fail: ops.LTE},
-}
-
-export type LimitNumberError = ErrorObject<
-  Kwd,
-  {limit: number; comparison: Comparison},
-  number | {$data: string}
->
-
-const error: KeywordErrorDefinition = {
-  message: ({keyword, schemaCode}) => str`must be ${KWDs[keyword as Kwd].okStr} ${schemaCode}`,
-  params: ({keyword, schemaCode}) =>
-    _`{comparison: ${KWDs[keyword as Kwd].okStr}, limit: ${schemaCode}}`,
-}
-
-const def: CodeKeywordDefinition = {
-  keyword: Object.keys(KWDs),
-  type: "number",
-  schemaType: "number",
-  $data: true,
-  error,
-  code(cxt: KeywordCxt) {
-    const {keyword, data, schemaCode} = cxt
-    cxt.fail$data(_`${data} ${KWDs[keyword as Kwd].fail} ${schemaCode} || isNaN(${data})`)
-  },
-}
-
-export default def

package/node_modules/ajv/lib/vocabularies/validation/limitProperties.ts

@@ -1,26 +0,0 @@
-import type {CodeKeywordDefinition, KeywordErrorDefinition} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {_, str, operators} from "../../compile/codegen"
-
-const error: KeywordErrorDefinition = {
-  message({keyword, schemaCode}) {
-    const comp = keyword === "maxProperties" ? "more" : "fewer"
-    return str`must NOT have ${comp} than ${schemaCode} properties`
-  },
-  params: ({schemaCode}) => _`{limit: ${schemaCode}}`,
-}
-
-const def: CodeKeywordDefinition = {
-  keyword: ["maxProperties", "minProperties"],
-  type: "object",
-  schemaType: "number",
-  $data: true,
-  error,
-  code(cxt: KeywordCxt) {
-    const {keyword, data, schemaCode} = cxt
-    const op = keyword === "maxProperties" ? operators.GT : operators.LT
-    cxt.fail$data(_`Object.keys(${data}).length ${op} ${schemaCode}`)
-  },
-}
-
-export default def

package/node_modules/ajv/lib/vocabularies/validation/multipleOf.ts

@@ -1,34 +0,0 @@
-import type {CodeKeywordDefinition, ErrorObject, KeywordErrorDefinition} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {_, str} from "../../compile/codegen"
-
-export type MultipleOfError = ErrorObject<
-  "multipleOf",
-  {multipleOf: number},
-  number | {$data: string}
->
-
-const error: KeywordErrorDefinition = {
-  message: ({schemaCode}) => str`must be multiple of ${schemaCode}`,
-  params: ({schemaCode}) => _`{multipleOf: ${schemaCode}}`,
-}
-
-const def: CodeKeywordDefinition = {
-  keyword: "multipleOf",
-  type: "number",
-  schemaType: "number",
-  $data: true,
-  error,
-  code(cxt: KeywordCxt) {
-    const {gen, data, schemaCode, it} = cxt
-    // const bdt = bad$DataType(schemaCode, <string>def.schemaType, $data)
-    const prec = it.opts.multipleOfPrecision
-    const res = gen.let("res")
-    const invalid = prec
-      ? _`Math.abs(Math.round(${res}) - ${res}) > 1e-${prec}`
-      : _`${res} !== parseInt(${res})`
-    cxt.fail$data(_`(${schemaCode} === 0 || (${res} = ${data}/${schemaCode}, ${invalid}))`)
-  },
-}
-
-export default def

package/node_modules/ajv/lib/vocabularies/validation/pattern.ts

@@ -1,39 +0,0 @@
-import type {CodeKeywordDefinition, ErrorObject, KeywordErrorDefinition} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {usePattern} from "../code"
-import {useFunc} from "../../compile/util"
-import {_, str} from "../../compile/codegen"
-
-export type PatternError = ErrorObject<"pattern", {pattern: string}, string | {$data: string}>
-
-const error: KeywordErrorDefinition = {
-  message: ({schemaCode}) => str`must match pattern "${schemaCode}"`,
-  params: ({schemaCode}) => _`{pattern: ${schemaCode}}`,
-}
-
-const def: CodeKeywordDefinition = {
-  keyword: "pattern",
-  type: "string",
-  schemaType: "string",
-  $data: true,
-  error,
-  code(cxt: KeywordCxt) {
-    const {gen, data, $data, schema, schemaCode, it} = cxt
-    const u = it.opts.unicodeRegExp ? "u" : ""
-    if ($data) {
-      const {regExp} = it.opts.code
-      const regExpCode = regExp.code === "new RegExp" ? _`new RegExp` : useFunc(gen, regExp)
-      const valid = gen.let("valid")
-      gen.try(
-        () => gen.assign(valid, _`${regExpCode}(${schemaCode}, ${u}).test(${data})`),
-        () => gen.assign(valid, false)
-      )
-      cxt.fail$data(_`!${valid}`)
-    } else {
-      const regExp = usePattern(cxt, schema)
-      cxt.fail$data(_`!${regExp}.test(${data})`)
-    }
-  },
-}
-
-export default def

package/node_modules/ajv/lib/vocabularies/validation/required.ts

@@ -1,98 +0,0 @@
-import type {CodeKeywordDefinition, ErrorObject, KeywordErrorDefinition} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {
-  checkReportMissingProp,
-  checkMissingProp,
-  reportMissingProp,
-  propertyInData,
-  noPropertyInData,
-} from "../code"
-import {_, str, nil, not, Name, Code} from "../../compile/codegen"
-import {checkStrictMode} from "../../compile/util"
-
-export type RequiredError = ErrorObject<
-  "required",
-  {missingProperty: string},
-  string[] | {$data: string}
->
-
-const error: KeywordErrorDefinition = {
-  message: ({params: {missingProperty}}) => str`must have required property '${missingProperty}'`,
-  params: ({params: {missingProperty}}) => _`{missingProperty: ${missingProperty}}`,
-}
-
-const def: CodeKeywordDefinition = {
-  keyword: "required",
-  type: "object",
-  schemaType: "array",
-  $data: true,
-  error,
-  code(cxt: KeywordCxt) {
-    const {gen, schema, schemaCode, data, $data, it} = cxt
-    const {opts} = it
-    if (!$data && schema.length === 0) return
-    const useLoop = schema.length >= opts.loopRequired
-    if (it.allErrors) allErrorsMode()
-    else exitOnErrorMode()
-
-    if (opts.strictRequired) {
-      const props = cxt.parentSchema.properties
-      const {definedProperties} = cxt.it
-      for (const requiredKey of schema) {
-        if (props?.[requiredKey] === undefined && !definedProperties.has(requiredKey)) {
-          const schemaPath = it.schemaEnv.baseId + it.errSchemaPath
-          const msg = `required property "${requiredKey}" is not defined at "${schemaPath}" (strictRequired)`
-          checkStrictMode(it, msg, it.opts.strictRequired)
-        }
-      }
-    }
-
-    function allErrorsMode(): void {
-      if (useLoop || $data) {
-        cxt.block$data(nil, loopAllRequired)
-      } else {
-        for (const prop of schema) {
-          checkReportMissingProp(cxt, prop)
-        }
-      }
-    }
-
-    function exitOnErrorMode(): void {
-      const missing = gen.let("missing")
-      if (useLoop || $data) {
-        const valid = gen.let("valid", true)
-        cxt.block$data(valid, () => loopUntilMissing(missing, valid))
-        cxt.ok(valid)
-      } else {
-        gen.if(checkMissingProp(cxt, schema, missing))
-        reportMissingProp(cxt, missing)
-        gen.else()
-      }
-    }
-
-    function loopAllRequired(): void {
-      gen.forOf("prop", schemaCode as Code, (prop) => {
-        cxt.setParams({missingProperty: prop})
-        gen.if(noPropertyInData(gen, data, prop, opts.ownProperties), () => cxt.error())
-      })
-    }
-
-    function loopUntilMissing(missing: Name, valid: Name): void {
-      cxt.setParams({missingProperty: missing})
-      gen.forOf(
-        missing,
-        schemaCode as Code,
-        () => {
-          gen.assign(valid, propertyInData(gen, data, missing, opts.ownProperties))
-          gen.if(not(valid), () => {
-            cxt.error()
-            gen.break()
-          })
-        },
-        nil
-      )
-    }
-  },
-}
-
-export default def

package/node_modules/ajv/lib/vocabularies/validation/uniqueItems.ts

@@ -1,79 +0,0 @@
-import type {CodeKeywordDefinition, ErrorObject, KeywordErrorDefinition} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {checkDataTypes, getSchemaTypes, DataType} from "../../compile/validate/dataType"
-import {_, str, Name} from "../../compile/codegen"
-import {useFunc} from "../../compile/util"
-import equal from "../../runtime/equal"
-
-export type UniqueItemsError = ErrorObject<
-  "uniqueItems",
-  {i: number; j: number},
-  boolean | {$data: string}
->
-
-const error: KeywordErrorDefinition = {
-  message: ({params: {i, j}}) =>
-    str`must NOT have duplicate items (items ## ${j} and ${i} are identical)`,
-  params: ({params: {i, j}}) => _`{i: ${i}, j: ${j}}`,
-}
-
-const def: CodeKeywordDefinition = {
-  keyword: "uniqueItems",
-  type: "array",
-  schemaType: "boolean",
-  $data: true,
-  error,
-  code(cxt: KeywordCxt) {
-    const {gen, data, $data, schema, parentSchema, schemaCode, it} = cxt
-    if (!$data && !schema) return
-    const valid = gen.let("valid")
-    const itemTypes = parentSchema.items ? getSchemaTypes(parentSchema.items) : []
-    cxt.block$data(valid, validateUniqueItems, _`${schemaCode} === false`)
-    cxt.ok(valid)
-
-    function validateUniqueItems(): void {
-      const i = gen.let("i", _`${data}.length`)
-      const j = gen.let("j")
-      cxt.setParams({i, j})
-      gen.assign(valid, true)
-      gen.if(_`${i} > 1`, () => (canOptimize() ? loopN : loopN2)(i, j))
-    }
-
-    function canOptimize(): boolean {
-      return itemTypes.length > 0 && !itemTypes.some((t) => t === "object" || t === "array")
-    }
-
-    function loopN(i: Name, j: Name): void {
-      const item = gen.name("item")
-      const wrongType = checkDataTypes(itemTypes, item, it.opts.strictNumbers, DataType.Wrong)
-      const indices = gen.const("indices", _`{}`)
-      gen.for(_`;${i}--;`, () => {
-        gen.let(item, _`${data}[${i}]`)
-        gen.if(wrongType, _`continue`)
-        if (itemTypes.length > 1) gen.if(_`typeof ${item} == "string"`, _`${item} += "_"`)
-        gen
-          .if(_`typeof ${indices}[${item}] == "number"`, () => {
-            gen.assign(j, _`${indices}[${item}]`)
-            cxt.error()
-            gen.assign(valid, false).break()
-          })
-          .code(_`${indices}[${item}] = ${i}`)
-      })
-    }
-
-    function loopN2(i: Name, j: Name): void {
-      const eql = useFunc(gen, equal)
-      const outer = gen.name("outer")
-      gen.label(outer).for(_`;${i}--;`, () =>
-        gen.for(_`${j} = ${i}; ${j}--;`, () =>
-          gen.if(_`${eql}(${data}[${i}], ${data}[${j}])`, () => {
-            cxt.error()
-            gen.assign(valid, false).break(outer)
-          })
-        )
-      )
-    }
-  },
-}
-
-export default def

package/node_modules/ajv/package.json

@@ -1,126 +0,0 @@
-{
-  "name": "ajv",
-  "version": "8.20.0",
-  "description": "Another JSON Schema Validator",
-  "main": "dist/ajv.js",
-  "types": "dist/ajv.d.ts",
-  "files": [
-    "lib/",
-    "dist/",
-    ".runkit_example.js"
-  ],
-  "sideEffects": false,
-  "scripts": {
-    "eslint": "eslint \"lib/**/*.ts\" \"spec/**/*.*s\" --ignore-pattern spec/JSON-Schema-Test-Suite",
-    "prettier:write": "prettier --write \"./**/*.{json,yaml,js,ts}\"",
-    "prettier:check": "prettier --list-different \"./**/*.{json,yaml,js,ts}\"",
-    "test-spec": "cross-env TS_NODE_PROJECT=spec/tsconfig.json mocha -r ts-node/register \"spec/**/*.spec.{ts,js}\" -R dot",
-    "test-codegen": "nyc cross-env TS_NODE_PROJECT=spec/tsconfig.json mocha -r ts-node/register 'spec/codegen.spec.ts' -R spec",
-    "test-debug": "npm run test-spec -- --inspect-brk",
-    "test-cov": "nyc npm run test-spec",
-    "rollup": "rm -rf bundle && rollup -c",
-    "bundle": "rm -rf bundle && node ./scripts/bundle.js ajv ajv7 ajv7 && node ./scripts/bundle.js 2019 ajv2019 ajv2019 && node ./scripts/bundle.js 2020 ajv2020 ajv2020 && node ./scripts/bundle.js jtd ajvJTD ajvJTD",
-    "build": "rm -rf dist && tsc && cp -r lib/refs dist && rm dist/refs/json-schema-2019-09/index.ts && rm dist/refs/json-schema-2020-12/index.ts && rm dist/refs/jtd-schema.ts",
-    "json-tests": "rm -rf spec/_json/*.js && node scripts/jsontests",
-    "test-karma": "karma start",
-    "test-browser": "rm -rf .browser && npm run bundle && scripts/prepare-tests && karma start",
-    "test-all": "npm run test-cov",
-    "test": "npm run json-tests && npm run prettier:check && npm run eslint && npm link && npm link --legacy-peer-deps ajv && npm run test-cov",
-    "test-ci": "AJV_FULL_TEST=true npm test",
-    "prepublish": "npm run build",
-    "benchmark": "npm i && npm run build && npm link && cd ./benchmark && npm link --legacy-peer-deps ajv && npm i && node ./jtd",
-    "docs:dev": "./scripts/prepare-site && vuepress dev docs",
-    "docs:build": "./scripts/prepare-site && vuepress build docs"
-  },
-  "nyc": {
-    "exclude": [
-      "**/spec/**",
-      "node_modules"
-    ],
-    "reporter": [
-      "lcov",
-      "text-summary"
-    ]
-  },
-  "repository": "ajv-validator/ajv",
-  "keywords": [
-    "JSON",
-    "schema",
-    "validator",
-    "validation",
-    "jsonschema",
-    "json-schema",
-    "json-schema-validator",
-    "json-schema-validation"
-  ],
-  "author": "Evgeny Poberezkin",
-  "license": "MIT",
-  "bugs": "https://github.com/ajv-validator/ajv/issues",
-  "homepage": "https://ajv.js.org",
-  "runkitExampleFilename": ".runkit_example.js",
-  "dependencies": {
-    "fast-deep-equal": "^3.1.3",
-    "fast-uri": "^3.0.1",
-    "json-schema-traverse": "^1.0.0",
-    "require-from-string": "^2.0.2"
-  },
-  "devDependencies": {
-    "@ajv-validator/config": "^0.5.0",
-    "@rollup/plugin-commonjs": "^25.0.7",
-    "@rollup/plugin-json": "^6.1.0",
-    "@rollup/plugin-node-resolve": "^15.2.3",
-    "@rollup/plugin-typescript": "^11.1.6",
-    "@types/chai": "^4.3.11",
-    "@types/mocha": "^10.0.6",
-    "@types/node": "^20.11.30",
-    "@types/require-from-string": "^1.2.3",
-    "@typescript-eslint/eslint-plugin": "^7.3.1",
-    "@typescript-eslint/parser": "^7.3.1",
-    "ajv-formats": "^3.0.1",
-    "browserify": "^17.0.0",
-    "chai": "^4.4.1",
-    "cross-env": "^7.0.3",
-    "dayjs": "^1.11.10",
-    "dayjs-plugin-utc": "^0.1.2",
-    "eslint": "^8.57.0",
-    "eslint-config-prettier": "^9.1.0",
-    "glob": "^10.3.10",
-    "husky": "^9.0.11",
-    "jimp": "^0.22.10",
-    "js-beautify": "^1.15.1",
-    "json-schema-test": "^2.0.0",
-    "karma": "^6.4.2",
-    "karma-chrome-launcher": "^3.2.0",
-    "karma-mocha": "^2.0.1",
-    "lint-staged": "^15.2.2",
-    "mocha": "^10.3.0",
-    "module-from-string": "^3.3.0",
-    "node-fetch": "^3.3.2",
-    "nyc": "^15.1.0",
-    "prettier": "3.0.3",
-    "re2": "^1.20.9",
-    "rollup": "^2.79.1",
-    "rollup-plugin-terser": "^7.0.2",
-    "ts-node": "^10.9.2",
-    "tsify": "^5.0.4",
-    "typescript": "5.3.3",
-    "uri-js": "^4.4.1"
-  },
-  "collective": {
-    "type": "opencollective",
-    "url": "https://opencollective.com/ajv"
-  },
-  "funding": {
-    "type": "github",
-    "url": "https://github.com/sponsors/epoberezkin"
-  },
-  "prettier": "@ajv-validator/config/prettierrc.json",
-  "husky": {
-    "hooks": {
-      "pre-commit": "lint-staged && npm test"
-    }
-  },
-  "lint-staged": {
-    "*.{json,yaml,js,ts}": "prettier --write"
-  }
-}

package/node_modules/fast-deep-equal/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2017 Evgeny Poberezkin
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.