@vibedeckx/win32-x64 0.1.16 → 0.1.17

package/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/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/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/lib/refs/jtd-schema.ts

@@ -1,130 +0,0 @@
-import {SchemaObject} from "../types"
-
-type MetaSchema = (root: boolean) => SchemaObject
-
-const shared: MetaSchema = (root) => {
-  const sch: SchemaObject = {
-    nullable: {type: "boolean"},
-    metadata: {
-      optionalProperties: {
-        union: {elements: {ref: "schema"}},
-      },
-      additionalProperties: true,
-    },
-  }
-  if (root) sch.definitions = {values: {ref: "schema"}}
-  return sch
-}
-
-const emptyForm: MetaSchema = (root) => ({
-  optionalProperties: shared(root),
-})
-
-const refForm: MetaSchema = (root) => ({
-  properties: {
-    ref: {type: "string"},
-  },
-  optionalProperties: shared(root),
-})
-
-const typeForm: MetaSchema = (root) => ({
-  properties: {
-    type: {
-      enum: [
-        "boolean",
-        "timestamp",
-        "string",
-        "float32",
-        "float64",
-        "int8",
-        "uint8",
-        "int16",
-        "uint16",
-        "int32",
-        "uint32",
-      ],
-    },
-  },
-  optionalProperties: shared(root),
-})
-
-const enumForm: MetaSchema = (root) => ({
-  properties: {
-    enum: {elements: {type: "string"}},
-  },
-  optionalProperties: shared(root),
-})
-
-const elementsForm: MetaSchema = (root) => ({
-  properties: {
-    elements: {ref: "schema"},
-  },
-  optionalProperties: shared(root),
-})
-
-const propertiesForm: MetaSchema = (root) => ({
-  properties: {
-    properties: {values: {ref: "schema"}},
-  },
-  optionalProperties: {
-    optionalProperties: {values: {ref: "schema"}},
-    additionalProperties: {type: "boolean"},
-    ...shared(root),
-  },
-})
-
-const optionalPropertiesForm: MetaSchema = (root) => ({
-  properties: {
-    optionalProperties: {values: {ref: "schema"}},
-  },
-  optionalProperties: {
-    additionalProperties: {type: "boolean"},
-    ...shared(root),
-  },
-})
-
-const discriminatorForm: MetaSchema = (root) => ({
-  properties: {
-    discriminator: {type: "string"},
-    mapping: {
-      values: {
-        metadata: {
-          union: [propertiesForm(false), optionalPropertiesForm(false)],
-        },
-      },
-    },
-  },
-  optionalProperties: shared(root),
-})
-
-const valuesForm: MetaSchema = (root) => ({
-  properties: {
-    values: {ref: "schema"},
-  },
-  optionalProperties: shared(root),
-})
-
-const schema: MetaSchema = (root) => ({
-  metadata: {
-    union: [
-      emptyForm,
-      refForm,
-      typeForm,
-      enumForm,
-      elementsForm,
-      propertiesForm,
-      optionalPropertiesForm,
-      discriminatorForm,
-      valuesForm,
-    ].map((s) => s(root)),
-  },
-})
-
-const jtdMetaSchema: SchemaObject = {
-  definitions: {
-    schema: schema(false),
-  },
-  ...schema(true),
-}
-
-export default jtdMetaSchema

package/node_modules/ajv/lib/runtime/equal.ts

@@ -1,7 +0,0 @@
-// https://github.com/ajv-validator/ajv/issues/889
-import * as equal from "fast-deep-equal"
-
-type Equal = typeof equal & {code: string}
-;(equal as Equal).code = 'require("ajv/dist/runtime/equal").default'
-
-export default equal as Equal

package/node_modules/ajv/lib/runtime/parseJson.ts

@@ -1,177 +0,0 @@
-const rxParseJson = /position\s(\d+)(?: \(line \d+ column \d+\))?$/
-
-export function parseJson(s: string, pos: number): unknown {
-  let endPos: number | undefined
-  parseJson.message = undefined
-  let matches: RegExpExecArray | null
-  if (pos) s = s.slice(pos)
-  try {
-    parseJson.position = pos + s.length
-    return JSON.parse(s)
-  } catch (e) {
-    matches = rxParseJson.exec((e as Error).message)
-    if (!matches) {
-      parseJson.message = "unexpected end"
-      return undefined
-    }
-    endPos = +matches[1]
-    const c = s[endPos]
-    s = s.slice(0, endPos)
-    parseJson.position = pos + endPos
-    try {
-      return JSON.parse(s)
-    } catch (e1) {
-      parseJson.message = `unexpected token ${c}`
-      return undefined
-    }
-  }
-}
-
-parseJson.message = undefined as string | undefined
-parseJson.position = 0 as number
-parseJson.code = 'require("ajv/dist/runtime/parseJson").parseJson'
-
-export function parseJsonNumber(s: string, pos: number, maxDigits?: number): number | undefined {
-  let numStr = ""
-  let c: string
-  parseJsonNumber.message = undefined
-  if (s[pos] === "-") {
-    numStr += "-"
-    pos++
-  }
-  if (s[pos] === "0") {
-    numStr += "0"
-    pos++
-  } else {
-    if (!parseDigits(maxDigits)) {
-      errorMessage()
-      return undefined
-    }
-  }
-  if (maxDigits) {
-    parseJsonNumber.position = pos
-    return +numStr
-  }
-  if (s[pos] === ".") {
-    numStr += "."
-    pos++
-    if (!parseDigits()) {
-      errorMessage()
-      return undefined
-    }
-  }
-  if (((c = s[pos]), c === "e" || c === "E")) {
-    numStr += "e"
-    pos++
-    if (((c = s[pos]), c === "+" || c === "-")) {
-      numStr += c
-      pos++
-    }
-    if (!parseDigits()) {
-      errorMessage()
-      return undefined
-    }
-  }
-  parseJsonNumber.position = pos
-  return +numStr
-
-  function parseDigits(maxLen?: number): boolean {
-    let digit = false
-    while (((c = s[pos]), c >= "0" && c <= "9" && (maxLen === undefined || maxLen-- > 0))) {
-      digit = true
-      numStr += c
-      pos++
-    }
-    return digit
-  }
-
-  function errorMessage(): void {
-    parseJsonNumber.position = pos
-    parseJsonNumber.message = pos < s.length ? `unexpected token ${s[pos]}` : "unexpected end"
-  }
-}
-
-parseJsonNumber.message = undefined as string | undefined
-parseJsonNumber.position = 0 as number
-parseJsonNumber.code = 'require("ajv/dist/runtime/parseJson").parseJsonNumber'
-
-const escapedChars: {[X in string]?: string} = {
-  b: "\b",
-  f: "\f",
-  n: "\n",
-  r: "\r",
-  t: "\t",
-  '"': '"',
-  "/": "/",
-  "\\": "\\",
-}
-
-const CODE_A: number = "a".charCodeAt(0)
-const CODE_0: number = "0".charCodeAt(0)
-
-export function parseJsonString(s: string, pos: number): string | undefined {
-  let str = ""
-  let c: string | undefined
-  parseJsonString.message = undefined
-  // eslint-disable-next-line no-constant-condition, @typescript-eslint/no-unnecessary-condition
-  while (true) {
-    c = s[pos++]
-    if (c === '"') break
-    if (c === "\\") {
-      c = s[pos]
-      if (c in escapedChars) {
-        str += escapedChars[c]
-        pos++
-      } else if (c === "u") {
-        pos++
-        let count = 4
-        let code = 0
-        while (count--) {
-          code <<= 4
-          c = s[pos]
-          // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-          if (c === undefined) {
-            errorMessage("unexpected end")
-            return undefined
-          }
-          c = c.toLowerCase()
-          if (c >= "a" && c <= "f") {
-            code += c.charCodeAt(0) - CODE_A + 10
-          } else if (c >= "0" && c <= "9") {
-            code += c.charCodeAt(0) - CODE_0
-          } else {
-            errorMessage(`unexpected token ${c}`)
-            return undefined
-          }
-          pos++
-        }
-        str += String.fromCharCode(code)
-      } else {
-        errorMessage(`unexpected token ${c}`)
-        return undefined
-      }
-      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    } else if (c === undefined) {
-      errorMessage("unexpected end")
-      return undefined
-    } else {
-      if (c.charCodeAt(0) >= 0x20) {
-        str += c
-      } else {
-        errorMessage(`unexpected token ${c}`)
-        return undefined
-      }
-    }
-  }
-  parseJsonString.position = pos
-  return str
-
-  function errorMessage(msg: string): void {
-    parseJsonString.position = pos
-    parseJsonString.message = msg
-  }
-}
-
-parseJsonString.message = undefined as string | undefined
-parseJsonString.position = 0 as number
-parseJsonString.code = 'require("ajv/dist/runtime/parseJson").parseJsonString'

package/node_modules/ajv/lib/runtime/quote.ts

@@ -1,31 +0,0 @@
-const rxEscapable =
-  // eslint-disable-next-line no-control-regex, no-misleading-character-class
-  /[\\"\u0000-\u001f\u007f-\u009f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g
-
-const escaped: {[K in string]?: string} = {
-  "\b": "\\b",
-  "\t": "\\t",
-  "\n": "\\n",
-  "\f": "\\f",
-  "\r": "\\r",
-  '"': '\\"',
-  "\\": "\\\\",
-}
-
-export default function quote(s: string): string {
-  rxEscapable.lastIndex = 0
-  return (
-    '"' +
-    (rxEscapable.test(s)
-      ? s.replace(rxEscapable, (a) => {
-          const c = escaped[a]
-          return typeof c === "string"
-            ? c
-            : "\\u" + ("0000" + a.charCodeAt(0).toString(16)).slice(-4)
-        })
-      : s) +
-    '"'
-  )
-}
-
-quote.code = 'require("ajv/dist/runtime/quote").default'

package/node_modules/ajv/lib/runtime/re2.ts

@@ -1,6 +0,0 @@
-import * as re2 from "re2"
-
-type Re2 = typeof re2 & {code: string}
-;(re2 as Re2).code = 'require("ajv/dist/runtime/re2").default'
-
-export default re2 as Re2

package/node_modules/ajv/lib/runtime/timestamp.ts

@@ -1,46 +0,0 @@
-const DT_SEPARATOR = /t|\s/i
-const DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/
-const TIME = /^(\d\d):(\d\d):(\d\d)(?:\.\d+)?(?:z|([+-]\d\d)(?::?(\d\d))?)$/i
-const DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
-
-export default function validTimestamp(str: string, allowDate: boolean): boolean {
-  // http://tools.ietf.org/html/rfc3339#section-5.6
-  const dt: string[] = str.split(DT_SEPARATOR)
-  return (
-    (dt.length === 2 && validDate(dt[0]) && validTime(dt[1])) ||
-    (allowDate && dt.length === 1 && validDate(dt[0]))
-  )
-}
-
-function validDate(str: string): boolean {
-  const matches: string[] | null = DATE.exec(str)
-  if (!matches) return false
-  const y: number = +matches[1]
-  const m: number = +matches[2]
-  const d: number = +matches[3]
-  return (
-    m >= 1 &&
-    m <= 12 &&
-    d >= 1 &&
-    (d <= DAYS[m] ||
-      // leap year: https://tools.ietf.org/html/rfc3339#appendix-C
-      (m === 2 && d === 29 && (y % 100 === 0 ? y % 400 === 0 : y % 4 === 0)))
-  )
-}
-
-function validTime(str: string): boolean {
-  const matches: string[] | null = TIME.exec(str)
-  if (!matches) return false
-  const hr: number = +matches[1]
-  const min: number = +matches[2]
-  const sec: number = +matches[3]
-  const tzH: number = +(matches[4] || 0)
-  const tzM: number = +(matches[5] || 0)
-  return (
-    (hr <= 23 && min <= 59 && sec <= 59) ||
-    // leap second
-    (hr - tzH === 23 && min - tzM === 59 && sec === 60)
-  )
-}
-
-validTimestamp.code = 'require("ajv/dist/runtime/timestamp").default'

package/node_modules/ajv/lib/runtime/ucs2length.ts

@@ -1,20 +0,0 @@
-// https://mathiasbynens.be/notes/javascript-encoding
-// https://github.com/bestiejs/punycode.js - punycode.ucs2.decode
-export default function ucs2length(str: string): number {
-  const len = str.length
-  let length = 0
-  let pos = 0
-  let value: number
-  while (pos < len) {
-    length++
-    value = str.charCodeAt(pos++)
-    if (value >= 0xd800 && value <= 0xdbff && pos < len) {
-      // high surrogate, and there is a next character
-      value = str.charCodeAt(pos)
-      if ((value & 0xfc00) === 0xdc00) pos++ // low surrogate
-    }
-  }
-  return length
-}
-
-ucs2length.code = 'require("ajv/dist/runtime/ucs2length").default'

package/node_modules/ajv/lib/runtime/uri.ts

@@ -1,6 +0,0 @@
-import * as uri from "fast-uri"
-
-type URI = typeof uri & {code: string}
-;(uri as URI).code = 'require("ajv/dist/runtime/uri").default'
-
-export default uri as URI

package/node_modules/ajv/lib/runtime/validation_error.ts

@@ -1,13 +0,0 @@
-import type {ErrorObject} from "../types"
-
-export default class ValidationError extends Error {
-  readonly errors: Partial<ErrorObject>[]
-  readonly ajv: true
-  readonly validation: true
-
-  constructor(errors: Partial<ErrorObject>[]) {
-    super("validation failed")
-    this.errors = errors
-    this.ajv = this.validation = true
-  }
-}