agenticreplay 0.1.0 → 0.1.2

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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,54 @@
+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

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,98 @@
+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

@@ -0,0 +1,79 @@
+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

@@ -0,0 +1,126 @@
+{
+  "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/ajv-formats/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 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.