baobox 0.1.0

package/dist/schema/index.js

@@ -0,0 +1,3661 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/error/locales/shared.ts
+function formatList(values) {
+  return values === undefined ? "" : values.join(", ");
+}
+function labelFor(params, fallback) {
+  return params.label ?? fallback;
+}
+
+// src/error/locales/de.ts
+var deDECatalog = {
+  INVALID_TYPE: (params) => params.actual === undefined ? `Erwartet: ${params.expected ?? "Wert"}` : `Erwartet: ${params.expected ?? "Wert"}, erhalten: ${params.actual}`,
+  MIN_LENGTH: (params) => `${labelFor(params, "Der Wert")} muss mindestens ${params.minimum} sein`,
+  MAX_LENGTH: (params) => `${labelFor(params, "Der Wert")} darf h\xF6chstens ${params.maximum} sein`,
+  PATTERN: (params) => params.patterns !== undefined ? `${labelFor(params, "Der Wert")} muss einem von folgenden Mustern entsprechen: ${formatList(params.patterns)}` : `${labelFor(params, "Der Wert")} muss dem Muster ${params.pattern} entsprechen`,
+  FORMAT: (params) => `${labelFor(params, "Der Wert")} muss dem Format ${params.format} entsprechen`,
+  MINIMUM: (params) => `${labelFor(params, "Der Wert")} muss >= ${params.minimum} sein`,
+  MAXIMUM: (params) => `${labelFor(params, "Der Wert")} muss <= ${params.maximum} sein`,
+  EXCLUSIVE_MINIMUM: (params) => `${labelFor(params, "Der Wert")} muss > ${params.minimum} sein`,
+  EXCLUSIVE_MAXIMUM: (params) => `${labelFor(params, "Der Wert")} muss < ${params.maximum} sein`,
+  MULTIPLE_OF: (params) => `${labelFor(params, "Der Wert")} muss ein Vielfaches von ${params.divisor} sein`,
+  INVALID_CONST: (params) => `Erwartet: ${params.expectedValue}`,
+  MIN_ITEMS: (params) => `${labelFor(params, "Das Array")} muss mindestens ${params.minimum} Elemente enthalten`,
+  MAX_ITEMS: (params) => `${labelFor(params, "Das Array")} darf h\xF6chstens ${params.maximum} Elemente enthalten`,
+  UNIQUE_ITEMS: (params) => `Die Elemente von ${labelFor(params, "diesem Array")} m\xFCssen eindeutig sein`,
+  CONTAINS: (params) => `${labelFor(params, "Das Array")} muss mindestens ein passendes Element enthalten`,
+  MIN_CONTAINS: (params) => `${labelFor(params, "Das Array")} muss mindestens ${params.minimum} passende Elemente enthalten`,
+  MAX_CONTAINS: (params) => `${labelFor(params, "Das Array")} darf h\xF6chstens ${params.maximum} passende Elemente enthalten`,
+  MISSING_REQUIRED: (params) => `Erforderliche Eigenschaft "${params.property}" fehlt`,
+  ADDITIONAL_PROPERTY: (params) => `Unerwartete Eigenschaft "${params.property}"`,
+  ADDITIONAL_ITEMS: (params) => `Unerwartetes Element an Index ${params.count}`,
+  MIN_PROPERTIES: (params) => `${labelFor(params, "Das Objekt")} muss mindestens ${params.minimum} Eigenschaften haben`,
+  MAX_PROPERTIES: (params) => `${labelFor(params, "Das Objekt")} darf h\xF6chstens ${params.maximum} Eigenschaften haben`,
+  INVALID_KEY: (params) => `Ung\xFCltiger Schl\xFCssel "${params.key}"`,
+  UNION: () => "Der Wert passt zu keiner Union-Variante",
+  ENUM: (params) => `Der Wert muss einer von folgenden sein: ${formatList(params.values)}`,
+  UNRESOLVED_REF: () => "Nicht aufgel\xF6ste Schema-Referenz",
+  EXCLUDE: () => "Der Wert entspricht einem ausgeschlossenen Schema",
+  EXTRACT: () => "Der Wert entspricht nicht dem extrahierten Schema",
+  NEVER: () => "Der Wert ist nicht erlaubt",
+  NOT: () => "Der Wert entspricht einem negierten Schema",
+  KEYOF: (params) => `Der Wert muss einer von folgenden sein: ${formatList(params.values)}`,
+  CONDITIONAL: () => "Der Wert passt zu keinem bedingten Zweig",
+  INDEX: () => "Der Wert passt zu keinem indexierten Schema",
+  IDENTIFIER: () => "G\xFCltiger Bezeichner erwartet",
+  BASE: () => "Basisvalidierung fehlgeschlagen",
+  REFINE: (params) => params.customMessage ?? "Verfeinerung fehlgeschlagen",
+  CALL: () => "Aufrufschema konnte nicht instanziiert werden",
+  PARAMETERS_LENGTH: (params) => `${params.count} Parameter erwartet`,
+  CUSTOM_TYPE: (params) => `Validierung des benutzerdefinierten Typs "${params.kind}" fehlgeschlagen`
+};
+
+// src/error/locales/en.ts
+var enUSCatalog = {
+  INVALID_TYPE: (params) => params.actual === undefined ? `Expected ${params.expected ?? "value"}` : `Expected ${params.expected ?? "value"}, got ${params.actual}`,
+  MIN_LENGTH: (params) => `${labelFor(params, "Value")} must be at least ${params.minimum}`,
+  MAX_LENGTH: (params) => `${labelFor(params, "Value")} must be at most ${params.maximum}`,
+  PATTERN: (params) => params.patterns !== undefined ? `${labelFor(params, "Value")} must match one of: ${formatList(params.patterns)}` : `${labelFor(params, "Value")} must match pattern ${params.pattern}`,
+  FORMAT: (params) => `${labelFor(params, "Value")} must match format ${params.format}`,
+  MINIMUM: (params) => `${labelFor(params, "Value")} must be >= ${params.minimum}`,
+  MAXIMUM: (params) => `${labelFor(params, "Value")} must be <= ${params.maximum}`,
+  EXCLUSIVE_MINIMUM: (params) => `${labelFor(params, "Value")} must be > ${params.minimum}`,
+  EXCLUSIVE_MAXIMUM: (params) => `${labelFor(params, "Value")} must be < ${params.maximum}`,
+  MULTIPLE_OF: (params) => `${labelFor(params, "Value")} must be a multiple of ${params.divisor}`,
+  INVALID_CONST: (params) => `Expected ${params.expectedValue}`,
+  MIN_ITEMS: (params) => `${labelFor(params, "Array")} must have at least ${params.minimum} items`,
+  MAX_ITEMS: (params) => `${labelFor(params, "Array")} must have at most ${params.maximum} items`,
+  UNIQUE_ITEMS: (params) => `${labelFor(params, "Array")} items must be unique`,
+  CONTAINS: (params) => `${labelFor(params, "Array")} must contain at least one matching item`,
+  MIN_CONTAINS: (params) => `${labelFor(params, "Array")} must contain at least ${params.minimum} matching items`,
+  MAX_CONTAINS: (params) => `${labelFor(params, "Array")} must contain at most ${params.maximum} matching items`,
+  MISSING_REQUIRED: (params) => `Missing required property "${params.property}"`,
+  ADDITIONAL_PROPERTY: (params) => `Unexpected property "${params.property}"`,
+  ADDITIONAL_ITEMS: (params) => `Unexpected item at index ${params.count}`,
+  MIN_PROPERTIES: (params) => `${labelFor(params, "Object")} must have at least ${params.minimum} properties`,
+  MAX_PROPERTIES: (params) => `${labelFor(params, "Object")} must have at most ${params.maximum} properties`,
+  INVALID_KEY: (params) => `Invalid record key "${params.key}"`,
+  UNION: () => "Value does not match any union variant",
+  ENUM: (params) => `Value must be one of: ${formatList(params.values)}`,
+  UNRESOLVED_REF: () => "Unresolved schema reference",
+  EXCLUDE: () => "Value matched an excluded schema",
+  EXTRACT: () => "Value did not match the extracted schema",
+  NEVER: () => "Value is not allowed",
+  NOT: () => "Value matches a negated schema",
+  KEYOF: (params) => `Value must be one of: ${formatList(params.values)}`,
+  CONDITIONAL: () => "Value does not match any conditional branch",
+  INDEX: () => "Value does not match any indexed schema",
+  IDENTIFIER: () => "Expected valid identifier string",
+  BASE: () => "Base validation failed",
+  REFINE: (params) => params.customMessage ?? "Refinement failed",
+  CALL: () => "Unable to instantiate call schema",
+  PARAMETERS_LENGTH: (params) => `Expected ${params.count} parameters`,
+  CUSTOM_TYPE: (params) => `Custom type validation failed for kind "${params.kind}"`
+};
+
+// src/error/locales/es.ts
+var esESCatalog = {
+  INVALID_TYPE: (params) => params.actual === undefined ? `Se esperaba ${params.expected ?? "un valor"}` : `Se esperaba ${params.expected ?? "un valor"}, se recibi\xF3 ${params.actual}`,
+  MIN_LENGTH: (params) => `${labelFor(params, "El valor")} debe ser al menos ${params.minimum}`,
+  MAX_LENGTH: (params) => `${labelFor(params, "El valor")} debe ser como m\xE1ximo ${params.maximum}`,
+  PATTERN: (params) => params.patterns !== undefined ? `${labelFor(params, "El valor")} debe coincidir con uno de: ${formatList(params.patterns)}` : `${labelFor(params, "El valor")} debe coincidir con el patr\xF3n ${params.pattern}`,
+  FORMAT: (params) => `${labelFor(params, "El valor")} debe coincidir con el formato ${params.format}`,
+  MINIMUM: (params) => `${labelFor(params, "El valor")} debe ser >= ${params.minimum}`,
+  MAXIMUM: (params) => `${labelFor(params, "El valor")} debe ser <= ${params.maximum}`,
+  EXCLUSIVE_MINIMUM: (params) => `${labelFor(params, "El valor")} debe ser > ${params.minimum}`,
+  EXCLUSIVE_MAXIMUM: (params) => `${labelFor(params, "El valor")} debe ser < ${params.maximum}`,
+  MULTIPLE_OF: (params) => `${labelFor(params, "El valor")} debe ser m\xFAltiplo de ${params.divisor}`,
+  INVALID_CONST: (params) => `Se esperaba ${params.expectedValue}`,
+  MIN_ITEMS: (params) => `${labelFor(params, "El arreglo")} debe tener al menos ${params.minimum} elementos`,
+  MAX_ITEMS: (params) => `${labelFor(params, "El arreglo")} debe tener como m\xE1ximo ${params.maximum} elementos`,
+  UNIQUE_ITEMS: (params) => `Los elementos de ${labelFor(params, "este arreglo")} deben ser \xFAnicos`,
+  CONTAINS: (params) => `${labelFor(params, "El arreglo")} debe contener al menos un elemento coincidente`,
+  MIN_CONTAINS: (params) => `${labelFor(params, "El arreglo")} debe contener al menos ${params.minimum} elementos coincidentes`,
+  MAX_CONTAINS: (params) => `${labelFor(params, "El arreglo")} debe contener como m\xE1ximo ${params.maximum} elementos coincidentes`,
+  MISSING_REQUIRED: (params) => `Falta la propiedad requerida "${params.property}"`,
+  ADDITIONAL_PROPERTY: (params) => `Propiedad inesperada "${params.property}"`,
+  ADDITIONAL_ITEMS: (params) => `Elemento inesperado en el \xEDndice ${params.count}`,
+  MIN_PROPERTIES: (params) => `${labelFor(params, "El objeto")} debe tener al menos ${params.minimum} propiedades`,
+  MAX_PROPERTIES: (params) => `${labelFor(params, "El objeto")} debe tener como m\xE1ximo ${params.maximum} propiedades`,
+  INVALID_KEY: (params) => `Clave de registro no v\xE1lida "${params.key}"`,
+  UNION: () => "El valor no coincide con ninguna variante de la uni\xF3n",
+  ENUM: (params) => `El valor debe ser uno de: ${formatList(params.values)}`,
+  UNRESOLVED_REF: () => "Referencia de esquema no resuelta",
+  EXCLUDE: () => "El valor coincidi\xF3 con un esquema excluido",
+  EXTRACT: () => "El valor no coincidi\xF3 con el esquema extra\xEDdo",
+  NEVER: () => "El valor no est\xE1 permitido",
+  NOT: () => "El valor coincide con un esquema negado",
+  KEYOF: (params) => `El valor debe ser uno de: ${formatList(params.values)}`,
+  CONDITIONAL: () => "El valor no coincide con ninguna rama condicional",
+  INDEX: () => "El valor no coincide con ning\xFAn esquema indexado",
+  IDENTIFIER: () => "Se esperaba una cadena identificadora v\xE1lida",
+  BASE: () => "La validaci\xF3n base fall\xF3",
+  REFINE: (params) => params.customMessage ?? "La validaci\xF3n refinada fall\xF3",
+  CALL: () => "No se pudo instanciar el esquema de llamada",
+  PARAMETERS_LENGTH: (params) => `Se esperaban ${params.count} par\xE1metros`,
+  CUSTOM_TYPE: (params) => `La validaci\xF3n del tipo personalizado "${params.kind}" fall\xF3`
+};
+
+// src/error/locales/fr.ts
+var frFRCatalog = {
+  INVALID_TYPE: (params) => params.actual === undefined ? `Valeur attendue: ${params.expected ?? "valeur"}` : `Valeur attendue: ${params.expected ?? "valeur"}, re\xE7u: ${params.actual}`,
+  MIN_LENGTH: (params) => `${labelFor(params, "La valeur")} doit \xEAtre au moins ${params.minimum}`,
+  MAX_LENGTH: (params) => `${labelFor(params, "La valeur")} doit \xEAtre au plus ${params.maximum}`,
+  PATTERN: (params) => params.patterns !== undefined ? `${labelFor(params, "La valeur")} doit correspondre \xE0 l'un de: ${formatList(params.patterns)}` : `${labelFor(params, "La valeur")} doit correspondre au motif ${params.pattern}`,
+  FORMAT: (params) => `${labelFor(params, "La valeur")} doit respecter le format ${params.format}`,
+  MINIMUM: (params) => `${labelFor(params, "La valeur")} doit \xEAtre >= ${params.minimum}`,
+  MAXIMUM: (params) => `${labelFor(params, "La valeur")} doit \xEAtre <= ${params.maximum}`,
+  EXCLUSIVE_MINIMUM: (params) => `${labelFor(params, "La valeur")} doit \xEAtre > ${params.minimum}`,
+  EXCLUSIVE_MAXIMUM: (params) => `${labelFor(params, "La valeur")} doit \xEAtre < ${params.maximum}`,
+  MULTIPLE_OF: (params) => `${labelFor(params, "La valeur")} doit \xEAtre un multiple de ${params.divisor}`,
+  INVALID_CONST: (params) => `Valeur attendue: ${params.expectedValue}`,
+  MIN_ITEMS: (params) => `${labelFor(params, "Le tableau")} doit contenir au moins ${params.minimum} \xE9l\xE9ments`,
+  MAX_ITEMS: (params) => `${labelFor(params, "Le tableau")} doit contenir au plus ${params.maximum} \xE9l\xE9ments`,
+  UNIQUE_ITEMS: (params) => `Les \xE9l\xE9ments de ${labelFor(params, "ce tableau")} doivent \xEAtre uniques`,
+  CONTAINS: (params) => `${labelFor(params, "Le tableau")} doit contenir au moins un \xE9l\xE9ment correspondant`,
+  MIN_CONTAINS: (params) => `${labelFor(params, "Le tableau")} doit contenir au moins ${params.minimum} \xE9l\xE9ments correspondants`,
+  MAX_CONTAINS: (params) => `${labelFor(params, "Le tableau")} doit contenir au plus ${params.maximum} \xE9l\xE9ments correspondants`,
+  MISSING_REQUIRED: (params) => `Propri\xE9t\xE9 requise manquante "${params.property}"`,
+  ADDITIONAL_PROPERTY: (params) => `Propri\xE9t\xE9 inattendue "${params.property}"`,
+  ADDITIONAL_ITEMS: (params) => `\xC9l\xE9ment inattendu \xE0 l'index ${params.count}`,
+  MIN_PROPERTIES: (params) => `${labelFor(params, "L\u2019objet")} doit avoir au moins ${params.minimum} propri\xE9t\xE9s`,
+  MAX_PROPERTIES: (params) => `${labelFor(params, "L\u2019objet")} doit avoir au plus ${params.maximum} propri\xE9t\xE9s`,
+  INVALID_KEY: (params) => `Cl\xE9 d\u2019enregistrement invalide "${params.key}"`,
+  UNION: () => "La valeur ne correspond \xE0 aucune variante de l\u2019union",
+  ENUM: (params) => `La valeur doit \xEAtre l\u2019une de: ${formatList(params.values)}`,
+  UNRESOLVED_REF: () => "R\xE9f\xE9rence de sch\xE9ma non r\xE9solue",
+  EXCLUDE: () => "La valeur correspond \xE0 un sch\xE9ma exclu",
+  EXTRACT: () => "La valeur ne correspond pas au sch\xE9ma extrait",
+  NEVER: () => "La valeur n\u2019est pas autoris\xE9e",
+  NOT: () => "La valeur correspond \xE0 un sch\xE9ma n\xE9gatif",
+  KEYOF: (params) => `La valeur doit \xEAtre l\u2019une de: ${formatList(params.values)}`,
+  CONDITIONAL: () => "La valeur ne correspond \xE0 aucune branche conditionnelle",
+  INDEX: () => "La valeur ne correspond \xE0 aucun sch\xE9ma index\xE9",
+  IDENTIFIER: () => "Identifiant attendu valide",
+  BASE: () => "La validation de base a \xE9chou\xE9",
+  REFINE: (params) => params.customMessage ?? "Le raffinement a \xE9chou\xE9",
+  CALL: () => "Impossible d\u2019instancier le sch\xE9ma d\u2019appel",
+  PARAMETERS_LENGTH: (params) => `${params.count} param\xE8tres attendus`,
+  CUSTOM_TYPE: (params) => `La validation du type personnalis\xE9 "${params.kind}" a \xE9chou\xE9`
+};
+
+// src/error/locales/ja.ts
+var jaJPCatalog = {
+  INVALID_TYPE: (params) => params.actual === undefined ? `${params.expected ?? "\u5024"}\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059` : `${params.expected ?? "\u5024"}\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002\u5B9F\u969B\u306E\u578B: ${params.actual}`,
+  MIN_LENGTH: (params) => `${labelFor(params, "\u5024")}\u306F\u5C11\u306A\u304F\u3068\u3082${params.minimum}\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`,
+  MAX_LENGTH: (params) => `${labelFor(params, "\u5024")}\u306F\u6700\u5927\u3067${params.maximum}\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`,
+  PATTERN: (params) => params.patterns !== undefined ? `${labelFor(params, "\u5024")}\u306F\u6B21\u306E\u3044\u305A\u308C\u304B\u306B\u4E00\u81F4\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059: ${formatList(params.patterns)}` : `${labelFor(params, "\u5024")}\u306F\u30D1\u30BF\u30FC\u30F3${params.pattern}\u306B\u4E00\u81F4\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`,
+  FORMAT: (params) => `${labelFor(params, "\u5024")}\u306F\u5F62\u5F0F${params.format}\u306B\u4E00\u81F4\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`,
+  MINIMUM: (params) => `${labelFor(params, "\u5024")}\u306F${params.minimum}\u4EE5\u4E0A\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`,
+  MAXIMUM: (params) => `${labelFor(params, "\u5024")}\u306F${params.maximum}\u4EE5\u4E0B\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`,
+  EXCLUSIVE_MINIMUM: (params) => `${labelFor(params, "\u5024")}\u306F${params.minimum}\u3088\u308A\u5927\u304D\u3044\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`,
+  EXCLUSIVE_MAXIMUM: (params) => `${labelFor(params, "\u5024")}\u306F${params.maximum}\u3088\u308A\u5C0F\u3055\u3044\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`,
+  MULTIPLE_OF: (params) => `${labelFor(params, "\u5024")}\u306F${params.divisor}\u306E\u500D\u6570\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`,
+  INVALID_CONST: (params) => `${params.expectedValue}\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`,
+  MIN_ITEMS: (params) => `${labelFor(params, "\u914D\u5217")}\u306B\u306F\u5C11\u306A\u304F\u3068\u3082${params.minimum}\u500B\u306E\u9805\u76EE\u304C\u5FC5\u8981\u3067\u3059`,
+  MAX_ITEMS: (params) => `${labelFor(params, "\u914D\u5217")}\u306B\u306F\u6700\u5927${params.maximum}\u500B\u306E\u9805\u76EE\u307E\u3067\u8A31\u53EF\u3055\u308C\u307E\u3059`,
+  UNIQUE_ITEMS: (params) => `${labelFor(params, "\u914D\u5217")}\u306E\u9805\u76EE\u306F\u4E00\u610F\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`,
+  CONTAINS: (params) => `${labelFor(params, "\u914D\u5217")}\u306B\u306F\u4E00\u81F4\u3059\u308B\u9805\u76EE\u304C\u5C11\u306A\u304F\u3068\u30821\u3064\u5FC5\u8981\u3067\u3059`,
+  MIN_CONTAINS: (params) => `${labelFor(params, "\u914D\u5217")}\u306B\u306F\u4E00\u81F4\u3059\u308B\u9805\u76EE\u304C\u5C11\u306A\u304F\u3068\u3082${params.minimum}\u500B\u5FC5\u8981\u3067\u3059`,
+  MAX_CONTAINS: (params) => `${labelFor(params, "\u914D\u5217")}\u306B\u306F\u4E00\u81F4\u3059\u308B\u9805\u76EE\u3092\u6700\u5927${params.maximum}\u500B\u307E\u3067\u542B\u3081\u3089\u308C\u307E\u3059`,
+  MISSING_REQUIRED: (params) => `\u5FC5\u9808\u30D7\u30ED\u30D1\u30C6\u30A3"${params.property}"\u304C\u3042\u308A\u307E\u305B\u3093`,
+  ADDITIONAL_PROPERTY: (params) => `\u4E88\u671F\u3057\u306A\u3044\u30D7\u30ED\u30D1\u30C6\u30A3"${params.property}"\u3067\u3059`,
+  ADDITIONAL_ITEMS: (params) => `\u30A4\u30F3\u30C7\u30C3\u30AF\u30B9${params.count}\u306B\u4E88\u671F\u3057\u306A\u3044\u9805\u76EE\u304C\u3042\u308A\u307E\u3059`,
+  MIN_PROPERTIES: (params) => `${labelFor(params, "\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8")}\u306B\u306F\u5C11\u306A\u304F\u3068\u3082${params.minimum}\u500B\u306E\u30D7\u30ED\u30D1\u30C6\u30A3\u304C\u5FC5\u8981\u3067\u3059`,
+  MAX_PROPERTIES: (params) => `${labelFor(params, "\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8")}\u306B\u306F\u6700\u5927${params.maximum}\u500B\u306E\u30D7\u30ED\u30D1\u30C6\u30A3\u307E\u3067\u8A31\u53EF\u3055\u308C\u307E\u3059`,
+  INVALID_KEY: (params) => `\u7121\u52B9\u306A\u30EC\u30B3\u30FC\u30C9\u30AD\u30FC"${params.key}"\u3067\u3059`,
+  UNION: () => "\u5024\u304C\u3069\u306E\u30E6\u30CB\u30AA\u30F3\u5206\u5C90\u306B\u3082\u4E00\u81F4\u3057\u307E\u305B\u3093",
+  ENUM: (params) => `\u5024\u306F\u6B21\u306E\u3044\u305A\u308C\u304B\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059: ${formatList(params.values)}`,
+  UNRESOLVED_REF: () => "\u89E3\u6C7A\u3067\u304D\u306A\u3044\u30B9\u30AD\u30FC\u30DE\u53C2\u7167\u3067\u3059",
+  EXCLUDE: () => "\u5024\u304C\u9664\u5916\u3055\u308C\u305F\u30B9\u30AD\u30FC\u30DE\u306B\u4E00\u81F4\u3057\u307E\u3057\u305F",
+  EXTRACT: () => "\u5024\u304C\u62BD\u51FA\u3055\u308C\u305F\u30B9\u30AD\u30FC\u30DE\u306B\u4E00\u81F4\u3057\u307E\u305B\u3093",
+  NEVER: () => "\u5024\u306F\u8A31\u53EF\u3055\u308C\u3066\u3044\u307E\u305B\u3093",
+  NOT: () => "\u5024\u304C\u5426\u5B9A\u30B9\u30AD\u30FC\u30DE\u306B\u4E00\u81F4\u3057\u3066\u3044\u307E\u3059",
+  KEYOF: (params) => `\u5024\u306F\u6B21\u306E\u3044\u305A\u308C\u304B\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059: ${formatList(params.values)}`,
+  CONDITIONAL: () => "\u5024\u304C\u3069\u306E\u6761\u4EF6\u5206\u5C90\u306B\u3082\u4E00\u81F4\u3057\u307E\u305B\u3093",
+  INDEX: () => "\u5024\u304C\u3069\u306E\u30A4\u30F3\u30C7\u30C3\u30AF\u30B9\u5019\u88DC\u30B9\u30AD\u30FC\u30DE\u306B\u3082\u4E00\u81F4\u3057\u307E\u305B\u3093",
+  IDENTIFIER: () => "\u6709\u52B9\u306A\u8B58\u5225\u5B50\u6587\u5B57\u5217\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+  BASE: () => "\u57FA\u672C\u691C\u8A3C\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+  REFINE: (params) => params.customMessage ?? "\u8FFD\u52A0\u6761\u4EF6\u306E\u691C\u8A3C\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+  CALL: () => "\u547C\u3073\u51FA\u3057\u30B9\u30AD\u30FC\u30DE\u3092\u30A4\u30F3\u30B9\u30BF\u30F3\u30B9\u5316\u3067\u304D\u307E\u305B\u3093",
+  PARAMETERS_LENGTH: (params) => `\u30D1\u30E9\u30E1\u30FC\u30BF\u306F${params.count}\u500B\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`,
+  CUSTOM_TYPE: (params) => `\u30AB\u30B9\u30BF\u30E0\u578B"${params.kind}"\u306E\u691C\u8A3C\u306B\u5931\u6557\u3057\u307E\u3057\u305F`
+};
+
+// src/error/locales/ko.ts
+var koKRCatalog = {
+  INVALID_TYPE: (params) => params.actual === undefined ? `${params.expected ?? "\uAC12"}\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4` : `${params.expected ?? "\uAC12"}\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4. \uD604\uC7AC \uAC12 \uC720\uD615: ${params.actual}`,
+  MIN_LENGTH: (params) => `${labelFor(params, "\uAC12")}\uC740(\uB294) \uCD5C\uC18C ${params.minimum}\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4`,
+  MAX_LENGTH: (params) => `${labelFor(params, "\uAC12")}\uC740(\uB294) \uCD5C\uB300 ${params.maximum}\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4`,
+  PATTERN: (params) => params.patterns !== undefined ? `${labelFor(params, "\uAC12")}\uC740(\uB294) \uB2E4\uC74C \uC911 \uD558\uB098\uC640 \uC77C\uCE58\uD574\uC57C \uD569\uB2C8\uB2E4: ${formatList(params.patterns)}` : `${labelFor(params, "\uAC12")}\uC740(\uB294) \uD328\uD134 ${params.pattern}\uACFC \uC77C\uCE58\uD574\uC57C \uD569\uB2C8\uB2E4`,
+  FORMAT: (params) => `${labelFor(params, "\uAC12")}\uC740(\uB294) ${params.format} \uD615\uC2DD\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4`,
+  MINIMUM: (params) => `${labelFor(params, "\uAC12")}\uC740(\uB294) ${params.minimum} \uC774\uC0C1\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4`,
+  MAXIMUM: (params) => `${labelFor(params, "\uAC12")}\uC740(\uB294) ${params.maximum} \uC774\uD558\uC5EC\uC57C \uD569\uB2C8\uB2E4`,
+  EXCLUSIVE_MINIMUM: (params) => `${labelFor(params, "\uAC12")}\uC740(\uB294) ${params.minimum}\uBCF4\uB2E4 \uCEE4\uC57C \uD569\uB2C8\uB2E4`,
+  EXCLUSIVE_MAXIMUM: (params) => `${labelFor(params, "\uAC12")}\uC740(\uB294) ${params.maximum}\uBCF4\uB2E4 \uC791\uC544\uC57C \uD569\uB2C8\uB2E4`,
+  MULTIPLE_OF: (params) => `${labelFor(params, "\uAC12")}\uC740(\uB294) ${params.divisor}\uC758 \uBC30\uC218\uC5EC\uC57C \uD569\uB2C8\uB2E4`,
+  INVALID_CONST: (params) => `${params.expectedValue}\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4`,
+  MIN_ITEMS: (params) => `${labelFor(params, "\uBC30\uC5F4")}\uC740(\uB294) \uCD5C\uC18C ${params.minimum}\uAC1C \uD56D\uBAA9\uC774 \uD544\uC694\uD569\uB2C8\uB2E4`,
+  MAX_ITEMS: (params) => `${labelFor(params, "\uBC30\uC5F4")}\uC740(\uB294) \uCD5C\uB300 ${params.maximum}\uAC1C \uD56D\uBAA9\uB9CC \uD5C8\uC6A9\uB429\uB2C8\uB2E4`,
+  UNIQUE_ITEMS: (params) => `${labelFor(params, "\uBC30\uC5F4")} \uD56D\uBAA9\uC740 \uACE0\uC720\uD574\uC57C \uD569\uB2C8\uB2E4`,
+  CONTAINS: (params) => `${labelFor(params, "\uBC30\uC5F4")}\uC5D0 \uC77C\uCE58\uD558\uB294 \uD56D\uBAA9\uC774 \uD558\uB098 \uC774\uC0C1 \uC788\uC5B4\uC57C \uD569\uB2C8\uB2E4`,
+  MIN_CONTAINS: (params) => `${labelFor(params, "\uBC30\uC5F4")}\uC5D0 \uC77C\uCE58\uD558\uB294 \uD56D\uBAA9\uC774 \uCD5C\uC18C ${params.minimum}\uAC1C \uC788\uC5B4\uC57C \uD569\uB2C8\uB2E4`,
+  MAX_CONTAINS: (params) => `${labelFor(params, "\uBC30\uC5F4")}\uC5D0 \uC77C\uCE58\uD558\uB294 \uD56D\uBAA9\uC774 \uCD5C\uB300 ${params.maximum}\uAC1C\uAE4C\uC9C0\uB9CC \uD5C8\uC6A9\uB429\uB2C8\uB2E4`,
+  MISSING_REQUIRED: (params) => `\uD544\uC218 \uC18D\uC131 "${params.property}"\uC774(\uAC00) \uC5C6\uC2B5\uB2C8\uB2E4`,
+  ADDITIONAL_PROPERTY: (params) => `\uC608\uC0C1\uD558\uC9C0 \uBABB\uD55C \uC18D\uC131 "${params.property}"\uC785\uB2C8\uB2E4`,
+  ADDITIONAL_ITEMS: (params) => `\uC778\uB371\uC2A4 ${params.count}\uC758 \uD56D\uBAA9\uC740 \uD5C8\uC6A9\uB418\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4`,
+  MIN_PROPERTIES: (params) => `${labelFor(params, "\uAC1D\uCCB4")}\uC5D0\uB294 \uCD5C\uC18C ${params.minimum}\uAC1C\uC758 \uC18D\uC131\uC774 \uD544\uC694\uD569\uB2C8\uB2E4`,
+  MAX_PROPERTIES: (params) => `${labelFor(params, "\uAC1D\uCCB4")}\uC5D0\uB294 \uCD5C\uB300 ${params.maximum}\uAC1C\uC758 \uC18D\uC131\uB9CC \uD5C8\uC6A9\uB429\uB2C8\uB2E4`,
+  INVALID_KEY: (params) => `\uB808\uCF54\uB4DC \uD0A4 "${params.key}"\uAC00 \uC62C\uBC14\uB974\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4`,
+  UNION: () => "\uAC12\uC774 \uC5B4\uB5A4 \uC720\uB2C8\uC5B8 \uBD84\uAE30\uC640\uB3C4 \uC77C\uCE58\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4",
+  ENUM: (params) => `\uAC12\uC740 \uB2E4\uC74C \uC911 \uD558\uB098\uC5EC\uC57C \uD569\uB2C8\uB2E4: ${formatList(params.values)}`,
+  UNRESOLVED_REF: () => "\uC2A4\uD0A4\uB9C8 \uCC38\uC870\uB97C \uD655\uC778\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4",
+  EXCLUDE: () => "\uAC12\uC774 \uC81C\uC678\uB41C \uC2A4\uD0A4\uB9C8\uC640 \uC77C\uCE58\uD588\uC2B5\uB2C8\uB2E4",
+  EXTRACT: () => "\uAC12\uC774 \uCD94\uCD9C\uB41C \uC2A4\uD0A4\uB9C8\uC640 \uC77C\uCE58\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4",
+  NEVER: () => "\uAC12\uC774 \uD5C8\uC6A9\uB418\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4",
+  NOT: () => "\uAC12\uC774 \uBD80\uC815 \uC2A4\uD0A4\uB9C8\uC640 \uC77C\uCE58\uD569\uB2C8\uB2E4",
+  KEYOF: (params) => `\uAC12\uC740 \uB2E4\uC74C \uC911 \uD558\uB098\uC5EC\uC57C \uD569\uB2C8\uB2E4: ${formatList(params.values)}`,
+  CONDITIONAL: () => "\uAC12\uC774 \uC5B4\uB5A4 \uC870\uAC74 \uBD84\uAE30\uC640\uB3C4 \uC77C\uCE58\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4",
+  INDEX: () => "\uAC12\uC774 \uC5B4\uB5A4 \uC778\uB371\uC2A4 \uD6C4\uBCF4 \uC2A4\uD0A4\uB9C8\uC640\uB3C4 \uC77C\uCE58\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4",
+  IDENTIFIER: () => "\uC62C\uBC14\uB978 \uC2DD\uBCC4\uC790 \uBB38\uC790\uC5F4\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4",
+  BASE: () => "\uAE30\uBCF8 \uAC80\uC99D\uC5D0 \uC2E4\uD328\uD588\uC2B5\uB2C8\uB2E4",
+  REFINE: (params) => params.customMessage ?? "\uC138\uBD80 \uC870\uAC74 \uAC80\uC99D\uC5D0 \uC2E4\uD328\uD588\uC2B5\uB2C8\uB2E4",
+  CALL: () => "\uD638\uCD9C \uC2A4\uD0A4\uB9C8\uB97C \uC778\uC2A4\uD134\uC2A4\uD654\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4",
+  PARAMETERS_LENGTH: (params) => `\uB9E4\uAC1C\uBCC0\uC218\uB294 ${params.count}\uAC1C\uC5EC\uC57C \uD569\uB2C8\uB2E4`,
+  CUSTOM_TYPE: (params) => `\uC0AC\uC6A9\uC790 \uC815\uC758 \uD0C0\uC785 "${params.kind}" \uAC80\uC99D\uC5D0 \uC2E4\uD328\uD588\uC2B5\uB2C8\uB2E4`
+};
+
+// src/error/locales/pt.ts
+var ptBRCatalog = {
+  INVALID_TYPE: (params) => params.actual === undefined ? `Esperado ${params.expected ?? "valor"}` : `Esperado ${params.expected ?? "valor"}, recebido ${params.actual}`,
+  MIN_LENGTH: (params) => `${labelFor(params, "O valor")} deve ser no m\xEDnimo ${params.minimum}`,
+  MAX_LENGTH: (params) => `${labelFor(params, "O valor")} deve ser no m\xE1ximo ${params.maximum}`,
+  PATTERN: (params) => params.patterns !== undefined ? `${labelFor(params, "O valor")} deve corresponder a um destes padr\xF5es: ${formatList(params.patterns)}` : `${labelFor(params, "O valor")} deve corresponder ao padr\xE3o ${params.pattern}`,
+  FORMAT: (params) => `${labelFor(params, "O valor")} deve corresponder ao formato ${params.format}`,
+  MINIMUM: (params) => `${labelFor(params, "O valor")} deve ser >= ${params.minimum}`,
+  MAXIMUM: (params) => `${labelFor(params, "O valor")} deve ser <= ${params.maximum}`,
+  EXCLUSIVE_MINIMUM: (params) => `${labelFor(params, "O valor")} deve ser > ${params.minimum}`,
+  EXCLUSIVE_MAXIMUM: (params) => `${labelFor(params, "O valor")} deve ser < ${params.maximum}`,
+  MULTIPLE_OF: (params) => `${labelFor(params, "O valor")} deve ser m\xFAltiplo de ${params.divisor}`,
+  INVALID_CONST: (params) => `Esperado ${params.expectedValue}`,
+  MIN_ITEMS: (params) => `${labelFor(params, "O array")} deve ter pelo menos ${params.minimum} itens`,
+  MAX_ITEMS: (params) => `${labelFor(params, "O array")} deve ter no m\xE1ximo ${params.maximum} itens`,
+  UNIQUE_ITEMS: (params) => `Os itens de ${labelFor(params, "este array")} devem ser \xFAnicos`,
+  CONTAINS: (params) => `${labelFor(params, "O array")} deve conter ao menos um item correspondente`,
+  MIN_CONTAINS: (params) => `${labelFor(params, "O array")} deve conter pelo menos ${params.minimum} itens correspondentes`,
+  MAX_CONTAINS: (params) => `${labelFor(params, "O array")} deve conter no m\xE1ximo ${params.maximum} itens correspondentes`,
+  MISSING_REQUIRED: (params) => `Propriedade obrigat\xF3ria ausente "${params.property}"`,
+  ADDITIONAL_PROPERTY: (params) => `Propriedade inesperada "${params.property}"`,
+  ADDITIONAL_ITEMS: (params) => `Item inesperado no \xEDndice ${params.count}`,
+  MIN_PROPERTIES: (params) => `${labelFor(params, "O objeto")} deve ter pelo menos ${params.minimum} propriedades`,
+  MAX_PROPERTIES: (params) => `${labelFor(params, "O objeto")} deve ter no m\xE1ximo ${params.maximum} propriedades`,
+  INVALID_KEY: (params) => `Chave inv\xE1lida "${params.key}"`,
+  UNION: () => "O valor n\xE3o corresponde a nenhuma variante da uni\xE3o",
+  ENUM: (params) => `O valor deve ser um destes: ${formatList(params.values)}`,
+  UNRESOLVED_REF: () => "Refer\xEAncia de esquema n\xE3o resolvida",
+  EXCLUDE: () => "O valor correspondeu a um esquema exclu\xEDdo",
+  EXTRACT: () => "O valor n\xE3o correspondeu ao esquema extra\xEDdo",
+  NEVER: () => "O valor n\xE3o \xE9 permitido",
+  NOT: () => "O valor corresponde a um esquema negado",
+  KEYOF: (params) => `O valor deve ser um destes: ${formatList(params.values)}`,
+  CONDITIONAL: () => "O valor n\xE3o corresponde a nenhum ramo condicional",
+  INDEX: () => "O valor n\xE3o corresponde a nenhum esquema indexado",
+  IDENTIFIER: () => "Era esperado um identificador v\xE1lido",
+  BASE: () => "A valida\xE7\xE3o base falhou",
+  REFINE: (params) => params.customMessage ?? "A valida\xE7\xE3o refinada falhou",
+  CALL: () => "N\xE3o foi poss\xEDvel instanciar o esquema de chamada",
+  PARAMETERS_LENGTH: (params) => `Esperados ${params.count} par\xE2metros`,
+  CUSTOM_TYPE: (params) => `A valida\xE7\xE3o do tipo personalizado "${params.kind}" falhou`
+};
+
+// src/error/locales/zh.ts
+var zhHansCatalog = {
+  INVALID_TYPE: (params) => params.actual === undefined ? `\u5E94\u4E3A${params.expected ?? "\u503C"}` : `\u5E94\u4E3A${params.expected ?? "\u503C"}\uFF0C\u5B9E\u9645\u7C7B\u578B\u4E3A${params.actual}`,
+  MIN_LENGTH: (params) => `${labelFor(params, "\u503C")}\u5FC5\u987B\u81F3\u5C11\u4E3A${params.minimum}`,
+  MAX_LENGTH: (params) => `${labelFor(params, "\u503C")}\u6700\u591A\u53EA\u80FD\u4E3A${params.maximum}`,
+  PATTERN: (params) => params.patterns !== undefined ? `${labelFor(params, "\u503C")}\u5FC5\u987B\u5339\u914D\u4EE5\u4E0B\u4E4B\u4E00\uFF1A${formatList(params.patterns)}` : `${labelFor(params, "\u503C")}\u5FC5\u987B\u5339\u914D\u6A21\u5F0F${params.pattern}`,
+  FORMAT: (params) => `${labelFor(params, "\u503C")}\u5FC5\u987B\u5339\u914D\u683C\u5F0F${params.format}`,
+  MINIMUM: (params) => `${labelFor(params, "\u503C")}\u5FC5\u987B >= ${params.minimum}`,
+  MAXIMUM: (params) => `${labelFor(params, "\u503C")}\u5FC5\u987B <= ${params.maximum}`,
+  EXCLUSIVE_MINIMUM: (params) => `${labelFor(params, "\u503C")}\u5FC5\u987B > ${params.minimum}`,
+  EXCLUSIVE_MAXIMUM: (params) => `${labelFor(params, "\u503C")}\u5FC5\u987B < ${params.maximum}`,
+  MULTIPLE_OF: (params) => `${labelFor(params, "\u503C")}\u5FC5\u987B\u662F${params.divisor}\u7684\u500D\u6570`,
+  INVALID_CONST: (params) => `\u5E94\u4E3A${params.expectedValue}`,
+  MIN_ITEMS: (params) => `${labelFor(params, "\u6570\u7EC4")}\u81F3\u5C11\u9700\u8981${params.minimum}\u4E2A\u9879\u76EE`,
+  MAX_ITEMS: (params) => `${labelFor(params, "\u6570\u7EC4")}\u6700\u591A\u53EA\u80FD\u6709${params.maximum}\u4E2A\u9879\u76EE`,
+  UNIQUE_ITEMS: (params) => `${labelFor(params, "\u6570\u7EC4")}\u4E2D\u7684\u9879\u76EE\u5FC5\u987B\u552F\u4E00`,
+  CONTAINS: (params) => `${labelFor(params, "\u6570\u7EC4")}\u81F3\u5C11\u8981\u5305\u542B\u4E00\u4E2A\u5339\u914D\u9879\u76EE`,
+  MIN_CONTAINS: (params) => `${labelFor(params, "\u6570\u7EC4")}\u81F3\u5C11\u8981\u5305\u542B${params.minimum}\u4E2A\u5339\u914D\u9879\u76EE`,
+  MAX_CONTAINS: (params) => `${labelFor(params, "\u6570\u7EC4")}\u6700\u591A\u53EA\u80FD\u5305\u542B${params.maximum}\u4E2A\u5339\u914D\u9879\u76EE`,
+  MISSING_REQUIRED: (params) => `\u7F3A\u5C11\u5FC5\u586B\u5C5E\u6027"${params.property}"`,
+  ADDITIONAL_PROPERTY: (params) => `\u5B58\u5728\u672A\u9884\u671F\u7684\u5C5E\u6027"${params.property}"`,
+  ADDITIONAL_ITEMS: (params) => `\u7D22\u5F15${params.count}\u5904\u5B58\u5728\u672A\u9884\u671F\u7684\u9879\u76EE`,
+  MIN_PROPERTIES: (params) => `${labelFor(params, "\u5BF9\u8C61")}\u81F3\u5C11\u9700\u8981${params.minimum}\u4E2A\u5C5E\u6027`,
+  MAX_PROPERTIES: (params) => `${labelFor(params, "\u5BF9\u8C61")}\u6700\u591A\u53EA\u80FD\u6709${params.maximum}\u4E2A\u5C5E\u6027`,
+  INVALID_KEY: (params) => `\u65E0\u6548\u7684\u8BB0\u5F55\u952E"${params.key}"`,
+  UNION: () => "\u503C\u4E0D\u7B26\u5408\u4EFB\u4F55\u8054\u5408\u5206\u652F",
+  ENUM: (params) => `\u503C\u5FC5\u987B\u662F\u4EE5\u4E0B\u4E4B\u4E00\uFF1A${formatList(params.values)}`,
+  UNRESOLVED_REF: () => "\u65E0\u6CD5\u89E3\u6790\u7684\u6A21\u5F0F\u5F15\u7528",
+  EXCLUDE: () => "\u503C\u5339\u914D\u4E86\u88AB\u6392\u9664\u7684\u6A21\u5F0F",
+  EXTRACT: () => "\u503C\u4E0D\u5339\u914D\u63D0\u53D6\u540E\u7684\u6A21\u5F0F",
+  NEVER: () => "\u4E0D\u5141\u8BB8\u8BE5\u503C",
+  NOT: () => "\u503C\u5339\u914D\u4E86\u5426\u5B9A\u6A21\u5F0F",
+  KEYOF: (params) => `\u503C\u5FC5\u987B\u662F\u4EE5\u4E0B\u4E4B\u4E00\uFF1A${formatList(params.values)}`,
+  CONDITIONAL: () => "\u503C\u4E0D\u5339\u914D\u4EFB\u4F55\u6761\u4EF6\u5206\u652F",
+  INDEX: () => "\u503C\u4E0D\u5339\u914D\u4EFB\u4F55\u7D22\u5F15\u6A21\u5F0F",
+  IDENTIFIER: () => "\u5FC5\u987B\u662F\u6709\u6548\u7684\u6807\u8BC6\u7B26\u5B57\u7B26\u4E32",
+  BASE: () => "\u57FA\u7840\u9A8C\u8BC1\u5931\u8D25",
+  REFINE: (params) => params.customMessage ?? "\u7EC6\u5316\u9A8C\u8BC1\u5931\u8D25",
+  CALL: () => "\u65E0\u6CD5\u5B9E\u4F8B\u5316\u8C03\u7528\u6A21\u5F0F",
+  PARAMETERS_LENGTH: (params) => `\u53C2\u6570\u6570\u91CF\u5FC5\u987B\u4E3A${params.count}`,
+  CUSTOM_TYPE: (params) => `\u81EA\u5B9A\u4E49\u7C7B\u578B"${params.kind}"\u9A8C\u8BC1\u5931\u8D25`
+};
+var zhHantCatalog = {
+  ...zhHansCatalog,
+  INVALID_TYPE: (params) => params.actual === undefined ? `\u61C9\u70BA${params.expected ?? "\u503C"}` : `\u61C9\u70BA${params.expected ?? "\u503C"}\uFF0C\u5BE6\u969B\u985E\u578B\u70BA${params.actual}`,
+  PATTERN: (params) => params.patterns !== undefined ? `${labelFor(params, "\u503C")}\u5FC5\u9808\u7B26\u5408\u4EE5\u4E0B\u5176\u4E2D\u4E4B\u4E00\uFF1A${formatList(params.patterns)}` : `${labelFor(params, "\u503C")}\u5FC5\u9808\u7B26\u5408\u6A21\u5F0F${params.pattern}`,
+  MISSING_REQUIRED: (params) => `\u7F3A\u5C11\u5FC5\u8981\u5C6C\u6027"${params.property}"`,
+  ADDITIONAL_PROPERTY: (params) => `\u5B58\u5728\u672A\u9810\u671F\u7684\u5C6C\u6027"${params.property}"`,
+  ADDITIONAL_ITEMS: (params) => `\u7D22\u5F15${params.count}\u8655\u5B58\u5728\u672A\u9810\u671F\u7684\u9805\u76EE`,
+  MIN_PROPERTIES: (params) => `${labelFor(params, "\u7269\u4EF6")}\u81F3\u5C11\u9700\u8981${params.minimum}\u500B\u5C6C\u6027`,
+  MAX_PROPERTIES: (params) => `${labelFor(params, "\u7269\u4EF6")}\u6700\u591A\u53EA\u80FD\u6709${params.maximum}\u500B\u5C6C\u6027`,
+  INVALID_KEY: (params) => `\u7121\u6548\u7684\u8A18\u9304\u9375"${params.key}"`,
+  UNRESOLVED_REF: () => "\u7121\u6CD5\u89E3\u6790\u7684\u7D50\u69CB\u53C3\u7167",
+  EXCLUDE: () => "\u503C\u7B26\u5408\u88AB\u6392\u9664\u7684\u7D50\u69CB",
+  EXTRACT: () => "\u503C\u4E0D\u7B26\u5408\u63D0\u53D6\u5F8C\u7684\u7D50\u69CB",
+  NEVER: () => "\u4E0D\u5141\u8A31\u6B64\u503C",
+  CONDITIONAL: () => "\u503C\u4E0D\u7B26\u5408\u4EFB\u4F55\u689D\u4EF6\u5206\u652F",
+  INDEX: () => "\u503C\u4E0D\u7B26\u5408\u4EFB\u4F55\u7D22\u5F15\u7D50\u69CB",
+  IDENTIFIER: () => "\u5FC5\u9808\u662F\u6709\u6548\u7684\u8B58\u5225\u5B57\u4E32",
+  BASE: () => "\u57FA\u790E\u9A57\u8B49\u5931\u6557",
+  REFINE: (params) => params.customMessage ?? "\u7D30\u5316\u9A57\u8B49\u5931\u6557",
+  CALL: () => "\u7121\u6CD5\u5BE6\u4F8B\u5316\u547C\u53EB\u7D50\u69CB",
+  PARAMETERS_LENGTH: (params) => `\u53C3\u6578\u6578\u91CF\u5FC5\u9808\u70BA${params.count}`,
+  CUSTOM_TYPE: (params) => `\u81EA\u8A02\u985E\u578B"${params.kind}"\u9A57\u8B49\u5931\u6557`
+};
+
+// src/shared/locale.ts
+var LocaleCodes = {
+  ar_001: "ar_001",
+  bn_BD: "bn_BD",
+  cs_CZ: "cs_CZ",
+  de_DE: "de_DE",
+  el_GR: "el_GR",
+  en_US: "en_US",
+  es_419: "es_419",
+  es_AR: "es_AR",
+  es_ES: "es_ES",
+  es_MX: "es_MX",
+  fa_IR: "fa_IR",
+  fil_PH: "fil_PH",
+  fr_CA: "fr_CA",
+  fr_FR: "fr_FR",
+  ha_NG: "ha_NG",
+  hi_IN: "hi_IN",
+  hu_HU: "hu_HU",
+  id_ID: "id_ID",
+  it_IT: "it_IT",
+  ja_JP: "ja_JP",
+  ko_KR: "ko_KR",
+  ms_MY: "ms_MY",
+  nl_NL: "nl_NL",
+  pl_PL: "pl_PL",
+  pt_BR: "pt_BR",
+  pt_PT: "pt_PT",
+  ro_RO: "ro_RO",
+  ru_RU: "ru_RU",
+  sv_SE: "sv_SE",
+  sw_TZ: "sw_TZ",
+  th_TH: "th_TH",
+  tr_TR: "tr_TR",
+  uk_UA: "uk_UA",
+  ur_PK: "ur_PK",
+  vi_VN: "vi_VN",
+  yo_NG: "yo_NG",
+  zh_Hans: "zh_Hans",
+  zh_Hant: "zh_Hant"
+};
+
+// src/locale/index.ts
+var ar_001 = enUSCatalog;
+var bn_BD = enUSCatalog;
+var cs_CZ = enUSCatalog;
+var de_DE = deDECatalog;
+var el_GR = enUSCatalog;
+var en_US = enUSCatalog;
+var es_419 = esESCatalog;
+var es_AR = esESCatalog;
+var es_ES = esESCatalog;
+var es_MX = esESCatalog;
+var fa_IR = enUSCatalog;
+var fil_PH = enUSCatalog;
+var fr_CA = frFRCatalog;
+var fr_FR = frFRCatalog;
+var ha_NG = enUSCatalog;
+var hi_IN = enUSCatalog;
+var hu_HU = enUSCatalog;
+var id_ID = enUSCatalog;
+var it_IT = enUSCatalog;
+var ja_JP = jaJPCatalog;
+var ko_KR = koKRCatalog;
+var ms_MY = enUSCatalog;
+var nl_NL = enUSCatalog;
+var pl_PL = enUSCatalog;
+var pt_BR = ptBRCatalog;
+var pt_PT = ptBRCatalog;
+var ro_RO = enUSCatalog;
+var ru_RU = enUSCatalog;
+var sv_SE = enUSCatalog;
+var sw_TZ = enUSCatalog;
+var th_TH = enUSCatalog;
+var tr_TR = enUSCatalog;
+var uk_UA = enUSCatalog;
+var ur_PK = enUSCatalog;
+var vi_VN = enUSCatalog;
+var yo_NG = enUSCatalog;
+var zh_Hans = zhHansCatalog;
+var zh_Hant = zhHantCatalog;
+var OfficialLocaleCatalogs = {
+  [LocaleCodes.ar_001]: ar_001,
+  [LocaleCodes.bn_BD]: bn_BD,
+  [LocaleCodes.cs_CZ]: cs_CZ,
+  [LocaleCodes.de_DE]: de_DE,
+  [LocaleCodes.el_GR]: el_GR,
+  [LocaleCodes.en_US]: en_US,
+  [LocaleCodes.es_419]: es_419,
+  [LocaleCodes.es_AR]: es_AR,
+  [LocaleCodes.es_ES]: es_ES,
+  [LocaleCodes.es_MX]: es_MX,
+  [LocaleCodes.fa_IR]: fa_IR,
+  [LocaleCodes.fil_PH]: fil_PH,
+  [LocaleCodes.fr_CA]: fr_CA,
+  [LocaleCodes.fr_FR]: fr_FR,
+  [LocaleCodes.ha_NG]: ha_NG,
+  [LocaleCodes.hi_IN]: hi_IN,
+  [LocaleCodes.hu_HU]: hu_HU,
+  [LocaleCodes.id_ID]: id_ID,
+  [LocaleCodes.it_IT]: it_IT,
+  [LocaleCodes.ja_JP]: ja_JP,
+  [LocaleCodes.ko_KR]: ko_KR,
+  [LocaleCodes.ms_MY]: ms_MY,
+  [LocaleCodes.nl_NL]: nl_NL,
+  [LocaleCodes.pl_PL]: pl_PL,
+  [LocaleCodes.pt_BR]: pt_BR,
+  [LocaleCodes.pt_PT]: pt_PT,
+  [LocaleCodes.ro_RO]: ro_RO,
+  [LocaleCodes.ru_RU]: ru_RU,
+  [LocaleCodes.sv_SE]: sv_SE,
+  [LocaleCodes.sw_TZ]: sw_TZ,
+  [LocaleCodes.th_TH]: th_TH,
+  [LocaleCodes.tr_TR]: tr_TR,
+  [LocaleCodes.uk_UA]: uk_UA,
+  [LocaleCodes.ur_PK]: ur_PK,
+  [LocaleCodes.vi_VN]: vi_VN,
+  [LocaleCodes.yo_NG]: yo_NG,
+  [LocaleCodes.zh_Hans]: zh_Hans,
+  [LocaleCodes.zh_Hant]: zh_Hant
+};
+function LocaleCatalogEntries() {
+  return Object.values(LocaleCodes).map((locale) => [locale, OfficialLocaleCatalogs[locale]]);
+}
+var LocalePacks = OfficialLocaleCatalogs;
+var locale_default = LocalePacks;
+
+// src/shared/object-utils.ts
+function deriveObjectSchema(object, options = {}) {
+  const pickSet = options.pickKeys ? new Set(options.pickKeys) : undefined;
+  const omitSet = options.omitKeys ? new Set(options.omitKeys) : undefined;
+  const originalOptional = new Set((object.optional ?? []).map(String));
+  const originalRequired = new Set((object.required ?? []).map(String));
+  const originalProperties = object.properties;
+  const properties = {};
+  for (const [key, schema] of Object.entries(originalProperties)) {
+    if (pickSet && !pickSet.has(key))
+      continue;
+    if (omitSet && omitSet.has(key))
+      continue;
+    properties[key] = schema;
+  }
+  const keys = Object.keys(properties);
+  const required = options.requiredMode === "all" ? keys : options.requiredMode === "none" ? [] : keys.filter((key) => originalRequired.has(key));
+  const optional = keys.filter((key) => originalOptional.has(key) && !required.includes(key));
+  return {
+    "~kind": "Object",
+    properties,
+    ...required.length > 0 ? { required } : {},
+    ...optional.length > 0 ? { optional } : {},
+    ...object.patternProperties !== undefined ? { patternProperties: object.patternProperties } : {},
+    ...options.additionalProperties !== undefined ? { additionalProperties: options.additionalProperties } : object.additionalProperties !== undefined ? { additionalProperties: object.additionalProperties } : {}
+  };
+}
+function getPatternPropertySchemas(patternProperties, key) {
+  if (!patternProperties)
+    return [];
+  const matches = [];
+  for (const [pattern, schema] of Object.entries(patternProperties)) {
+    if (new RegExp(pattern).test(key)) {
+      matches.push(schema);
+    }
+  }
+  return matches;
+}
+function deriveIndexSchemas(object, keySchema, checkFn) {
+  const candidates = [];
+  const properties = object.properties;
+  for (const [key, schema] of Object.entries(properties)) {
+    if (checkFn(keySchema, key)) {
+      candidates.push(schema);
+    }
+  }
+  return candidates;
+}
+function deriveIndexSchemasForEmission(object, keySchema) {
+  const candidates = [];
+  const properties = object.properties;
+  const keySchemaRecord = keySchema;
+  for (const [key, schema] of Object.entries(properties)) {
+    const keyValidationSchema = {
+      "~kind": "String",
+      ...typeof keySchemaRecord.format === "string" ? { format: keySchemaRecord.format } : {},
+      ...typeof keySchemaRecord.pattern === "string" ? { pattern: keySchemaRecord.pattern } : {}
+    };
+    if (keySchemaRecord["~kind"] === "String" ? stringMatchesKeySchema(keyValidationSchema, key) : true) {
+      candidates.push(schema);
+    }
+  }
+  return candidates;
+}
+function stringMatchesKeySchema(schema, value) {
+  return schema.pattern === undefined || new RegExp(schema.pattern).test(value);
+}
+function transformStringLiteralValue(kind, value) {
+  switch (kind) {
+    case "Capitalize":
+      return value.length === 0 ? value : value.charAt(0).toUpperCase() + value.slice(1);
+    case "Lowercase":
+      return value.toLowerCase();
+    case "Uppercase":
+      return value.toUpperCase();
+    case "Uncapitalize":
+      return value.length === 0 ? value : value.charAt(0).toLowerCase() + value.slice(1);
+    default:
+      return value;
+  }
+}
+function resolveStringActionSchema(schema) {
+  const value = schema;
+  const kind = value["~kind"];
+  if (kind !== "Capitalize" && kind !== "Lowercase" && kind !== "Uppercase" && kind !== "Uncapitalize") {
+    return schema;
+  }
+  const item = value["item"];
+  if (typeof item !== "object" || item === null) {
+    return schema;
+  }
+  const target = item;
+  const targetKind = target["~kind"];
+  if (targetKind === "Literal" && typeof target["const"] === "string") {
+    return { "~kind": "Literal", const: transformStringLiteralValue(String(kind), target["const"]) };
+  }
+  if (targetKind === "Enum" && Array.isArray(target["values"]) && target["values"].every((entry) => typeof entry === "string")) {
+    return {
+      "~kind": "Enum",
+      values: target["values"].map((entry) => transformStringLiteralValue(String(kind), entry))
+    };
+  }
+  return item;
+}
+// src/shared/runtime-guards.ts
+function isPromiseLike(value) {
+  return (typeof value === "object" || typeof value === "function") && value !== null && "then" in value && typeof value.then === "function";
+}
+function isIteratorLike(value) {
+  return typeof value === "object" && value !== null && "next" in value && typeof value.next === "function" && Symbol.iterator in value && typeof value[Symbol.iterator] === "function";
+}
+function isAsyncIteratorLike(value) {
+  return typeof value === "object" && value !== null && "next" in value && typeof value.next === "function" && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
+}
+// src/shared/format-constants.ts
+var EMAIL_RE = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+var URI_RE = /^[a-zA-Z][a-zA-Z0-9+.-]*:/;
+var HOSTNAME_RE = /^(?!-)[a-zA-Z0-9-]{0,63}(?<!-)(.(?!-)[a-zA-Z0-9-]{0,63}(?<!-))*$/;
+var IPV4_RE = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
+var IPV6_RE = /^(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$|^::(?:[0-9a-fA-F]{1,4}:){0,6}[0-9a-fA-F]{1,4}$|^([0-9a-fA-F]{1,4}:){1,6}::$/;
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var ISO_DATE_RE = /^\d{4}-(0[1-9]|1[0-2])-([0-2]\d|3[01])$/;
+var ISO_DT_RE = /^\d{4}-(0[1-9]|1[0-2])-([0-2]\d|3[01])T([01]\d|2[0-3]):[0-5]\d:[0-5]\d(?:\.\d+)?(?:Z|[+-][01]\d:[0-5]\d)$/;
+var ISO_TIME_RE = /^([01]\d|2[0-3]):[0-5]\d:[0-5]\d(?:\.\d+)?$/;
+var ISO_DUR_RE = /^P(?:\d+Y)?(?:\d+M)?(?:\d+D)?(?:T(?:\d+H)?(?:\d+M)?(?:\d+S)?)?$/;
+var BASE64_RE = /^[a-zA-Z0-9+/]*={0,2}$/;
+var HEX_RE = /^[0-9a-fA-F]+$/;
+var HEXCLR_RE = /^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/;
+var LUHN_DIGITS_RE = /^\d{13,19}$/;
+var KNOWN_FORMATS = new Set([
+  "email",
+  "uri",
+  "hostname",
+  "ip",
+  "ipv4",
+  "ipv6",
+  "uuid",
+  "date",
+  "datetime",
+  "time",
+  "duration",
+  "base64",
+  "hex",
+  "hexcolor",
+  "creditcard",
+  "regex",
+  "uint8array",
+  "json"
+]);
+// src/shared/regex-json.ts
+function isAsciiDigit(value) {
+  return value >= "0" && value <= "9";
+}
+function consumeRegexQuantifier(pattern, start) {
+  let index = start;
+  const first = pattern[index];
+  if (first === undefined || !isAsciiDigit(first)) {
+    return -1;
+  }
+  while (index < pattern.length) {
+    const character = pattern[index];
+    if (character === undefined || !isAsciiDigit(character)) {
+      break;
+    }
+    index += 1;
+  }
+  if (pattern[index] === ",") {
+    index += 1;
+    while (index < pattern.length) {
+      const character = pattern[index];
+      if (character === undefined || !isAsciiDigit(character)) {
+        break;
+      }
+      index += 1;
+    }
+  }
+  return pattern[index] === "}" ? index : -1;
+}
+function isValidRegex(value) {
+  let escaped = false;
+  let inCharacterClass = false;
+  let groupDepth = 0;
+  let hasToken = false;
+  let groupPrefixAllowed = false;
+  for (let index = 0;index < value.length; index += 1) {
+    const character = value[index];
+    if (character === undefined)
+      return false;
+    if (escaped) {
+      escaped = false;
+      hasToken = true;
+      groupPrefixAllowed = false;
+      continue;
+    }
+    if (character === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (inCharacterClass) {
+      if (character === "]") {
+        inCharacterClass = false;
+        hasToken = true;
+      }
+      continue;
+    }
+    if (groupPrefixAllowed && character === "?") {
+      groupPrefixAllowed = false;
+      continue;
+    }
+    groupPrefixAllowed = false;
+    switch (character) {
+      case "[":
+        inCharacterClass = true;
+        hasToken = true;
+        break;
+      case "(":
+        groupDepth += 1;
+        hasToken = false;
+        groupPrefixAllowed = true;
+        break;
+      case ")":
+        if (groupDepth === 0)
+          return false;
+        groupDepth -= 1;
+        hasToken = true;
+        break;
+      case "{": {
+        if (!hasToken)
+          return false;
+        const quantifierEnd = consumeRegexQuantifier(value, index + 1);
+        if (quantifierEnd < 0)
+          return false;
+        index = quantifierEnd;
+        hasToken = true;
+        break;
+      }
+      case "*":
+      case "+":
+      case "?":
+        if (!hasToken)
+          return false;
+        hasToken = true;
+        break;
+      case "]":
+      case "}":
+        return false;
+      case "|":
+        hasToken = false;
+        break;
+      default:
+        hasToken = true;
+        break;
+    }
+  }
+  return !escaped && !inCharacterClass && groupDepth === 0;
+}
+function skipWhitespace(state) {
+  while (state.index < state.text.length) {
+    const character = state.text[state.index];
+    if (character !== " " && character !== `
+` && character !== "\r" && character !== "\t") {
+      break;
+    }
+    state.index += 1;
+  }
+}
+function consumeLiteral(state, literal) {
+  if (state.text.slice(state.index, state.index + literal.length) !== literal) {
+    return false;
+  }
+  state.index += literal.length;
+  return true;
+}
+function parseString(state) {
+  if (state.text[state.index] !== '"')
+    return false;
+  state.index += 1;
+  while (state.index < state.text.length) {
+    const character = state.text[state.index];
+    if (character === undefined)
+      return false;
+    if (character === '"') {
+      state.index += 1;
+      return true;
+    }
+    if (character === "\\") {
+      const escape = state.text[state.index + 1];
+      if (escape === undefined)
+        return false;
+      if (escape === "u") {
+        for (let offset = 2;offset < 6; offset += 1) {
+          const hex = state.text[state.index + offset];
+          if (hex === undefined || !/[0-9a-fA-F]/.test(hex))
+            return false;
+        }
+        state.index += 6;
+        continue;
+      }
+      if (!'"\\/bfnrt'.includes(escape))
+        return false;
+      state.index += 2;
+      continue;
+    }
+    if (character < " ")
+      return false;
+    state.index += 1;
+  }
+  return false;
+}
+function parseNumber(state) {
+  const start = state.index;
+  if (state.text[state.index] === "-") {
+    state.index += 1;
+  }
+  const firstDigit = state.text[state.index];
+  if (firstDigit === undefined || !isAsciiDigit(firstDigit))
+    return false;
+  if (firstDigit === "0") {
+    state.index += 1;
+  } else {
+    while (state.index < state.text.length) {
+      const digit = state.text[state.index];
+      if (digit === undefined || !isAsciiDigit(digit))
+        break;
+      state.index += 1;
+    }
+  }
+  if (state.text[state.index] === ".") {
+    state.index += 1;
+    const fractionDigit = state.text[state.index];
+    if (fractionDigit === undefined || !isAsciiDigit(fractionDigit))
+      return false;
+    while (state.index < state.text.length) {
+      const digit = state.text[state.index];
+      if (digit === undefined || !isAsciiDigit(digit))
+        break;
+      state.index += 1;
+    }
+  }
+  const exponent = state.text[state.index];
+  if (exponent === "e" || exponent === "E") {
+    state.index += 1;
+    const sign = state.text[state.index];
+    if (sign === "+" || sign === "-")
+      state.index += 1;
+    const exponentDigit = state.text[state.index];
+    if (exponentDigit === undefined || !isAsciiDigit(exponentDigit))
+      return false;
+    while (state.index < state.text.length) {
+      const digit = state.text[state.index];
+      if (digit === undefined || !isAsciiDigit(digit))
+        break;
+      state.index += 1;
+    }
+  }
+  return state.index > start;
+}
+function parseArray(state) {
+  if (state.text[state.index] !== "[")
+    return false;
+  state.index += 1;
+  skipWhitespace(state);
+  if (state.text[state.index] === "]") {
+    state.index += 1;
+    return true;
+  }
+  while (state.index < state.text.length) {
+    if (!parseValue(state))
+      return false;
+    skipWhitespace(state);
+    const separator = state.text[state.index];
+    if (separator === ",") {
+      state.index += 1;
+      skipWhitespace(state);
+      continue;
+    }
+    if (separator === "]") {
+      state.index += 1;
+      return true;
+    }
+    return false;
+  }
+  return false;
+}
+function parseObject(state) {
+  if (state.text[state.index] !== "{")
+    return false;
+  state.index += 1;
+  skipWhitespace(state);
+  if (state.text[state.index] === "}") {
+    state.index += 1;
+    return true;
+  }
+  while (state.index < state.text.length) {
+    if (!parseString(state))
+      return false;
+    skipWhitespace(state);
+    if (state.text[state.index] !== ":")
+      return false;
+    state.index += 1;
+    if (!parseValue(state))
+      return false;
+    skipWhitespace(state);
+    const separator = state.text[state.index];
+    if (separator === ",") {
+      state.index += 1;
+      skipWhitespace(state);
+      continue;
+    }
+    if (separator === "}") {
+      state.index += 1;
+      return true;
+    }
+    return false;
+  }
+  return false;
+}
+function parseValue(state) {
+  skipWhitespace(state);
+  const character = state.text[state.index];
+  switch (character) {
+    case '"':
+      return parseString(state);
+    case "{":
+      return parseObject(state);
+    case "[":
+      return parseArray(state);
+    case "t":
+      return consumeLiteral(state, "true");
+    case "f":
+      return consumeLiteral(state, "false");
+    case "n":
+      return consumeLiteral(state, "null");
+    default:
+      return character === "-" || character !== undefined && isAsciiDigit(character) ? parseNumber(state) : false;
+  }
+}
+function isValidJson(value) {
+  const state = { index: 0, text: value };
+  if (!parseValue(state))
+    return false;
+  skipWhitespace(state);
+  return state.index === state.text.length;
+}
+
+// src/shared/runtime-context.ts
+var builtinLocaleCatalogEntries = LocaleCatalogEntries();
+var defaultTypePolicy = {
+  AllowNaN: false,
+  AllowArrayObject: false,
+  AllowNullVoid: true
+};
+var defaultSettings = {
+  correctiveParse: false
+};
+var runtimeContextCounter = 0;
+function cloneEntries(entries) {
+  return Array.from(entries, ([key, value]) => [key, value]);
+}
+
+class RuntimeContext {
+  id = ++runtimeContextCounter;
+  revision = 0;
+  activeLocale;
+  formatValidators = new Map;
+  localeCatalogs = new Map;
+  settings;
+  typeValidators = new Map;
+  typePolicy;
+  FormatRegistry = {
+    Clear: () => {
+      this.formatValidators.clear();
+      this.touch();
+    },
+    Delete: (name) => {
+      const deleted = this.formatValidators.delete(name);
+      if (deleted) {
+        this.touch();
+      }
+      return deleted;
+    },
+    Entries: () => Array.from(this.formatValidators.entries()),
+    Get: (name) => this.formatValidators.get(name),
+    Has: (name) => this.formatValidators.has(name),
+    Set: (name, validator) => {
+      this.formatValidators.set(name, validator);
+      this.touch();
+    }
+  };
+  Locale = {
+    ...LocaleCodes,
+    Entries: () => Array.from(this.localeCatalogs.entries()),
+    Get: () => this.activeLocale,
+    GetCatalog: (locale = this.activeLocale) => this.localeCatalogs.get(locale) ?? this.localeCatalogs.get(LocaleCodes.en_US) ?? enUSCatalog,
+    Has: (locale) => this.localeCatalogs.has(locale),
+    Register: (locale, catalog) => {
+      this.localeCatalogs.set(locale, catalog);
+      this.touch();
+    },
+    Reset: () => {
+      this.activeLocale = LocaleCodes.en_US;
+      this.touch();
+    },
+    Set: (locale) => {
+      this.activeLocale = locale;
+      this.touch();
+    }
+  };
+  Settings = {
+    Get: () => this.settings,
+    Reset: () => {
+      this.settings = { ...defaultSettings };
+      this.touch();
+    },
+    Set: (options) => {
+      this.settings = { ...this.settings, ...options };
+      this.touch();
+    }
+  };
+  TypeRegistry = {
+    Clear: () => {
+      this.typeValidators.clear();
+      this.touch();
+    },
+    Delete: (kind) => {
+      const deleted = this.typeValidators.delete(kind);
+      if (deleted) {
+        this.touch();
+      }
+      return deleted;
+    },
+    Entries: () => Array.from(this.typeValidators.entries()),
+    Get: (kind) => this.typeValidators.get(kind),
+    Has: (kind) => this.typeValidators.has(kind),
+    Set: (kind, validator) => {
+      this.typeValidators.set(kind, validator);
+      this.touch();
+    }
+  };
+  TypeSystemPolicy = {
+    Get: () => this.typePolicy,
+    Reset: () => {
+      this.typePolicy = { ...defaultTypePolicy };
+      this.touch();
+    },
+    Set: (options) => {
+      this.typePolicy = { ...this.typePolicy, ...options };
+      this.touch();
+    }
+  };
+  constructor(options = {}) {
+    this.activeLocale = options.locale ?? LocaleCodes.en_US;
+    this.settings = { ...defaultSettings, ...options.settings };
+    this.typePolicy = { ...defaultTypePolicy, ...options.typePolicy };
+    for (const [locale, catalog] of builtinLocaleCatalogEntries) {
+      this.localeCatalogs.set(locale, catalog);
+    }
+    for (const [locale, catalog] of options.localeCatalogs ?? []) {
+      this.localeCatalogs.set(locale, catalog);
+    }
+    for (const [name, validator] of options.formats ?? []) {
+      this.formatValidators.set(name, validator);
+    }
+    for (const [kind, validator] of options.types ?? []) {
+      this.typeValidators.set(kind, validator);
+    }
+  }
+  Clone(options = {}) {
+    return new RuntimeContext({
+      formats: [...cloneEntries(this.formatValidators.entries()), ...options.formats ?? []],
+      locale: options.locale ?? this.activeLocale,
+      localeCatalogs: [...cloneEntries(this.localeCatalogs.entries()), ...options.localeCatalogs ?? []],
+      settings: { ...this.settings, ...options.settings },
+      typePolicy: { ...this.typePolicy, ...options.typePolicy },
+      types: [...cloneEntries(this.typeValidators.entries()), ...options.types ?? []]
+    });
+  }
+  CacheKey(namespace = "runtime") {
+    return `${namespace}:${this.id}:${this.revision}`;
+  }
+  touch() {
+    this.revision += 1;
+  }
+}
+var defaultRuntimeContext = new RuntimeContext;
+function CreateRuntimeContext(options = {}) {
+  return new RuntimeContext(options);
+}
+function getDefaultRuntimeContext() {
+  return defaultRuntimeContext;
+}
+function resolveRuntimeContext(context) {
+  if (context instanceof RuntimeContext) {
+    return context;
+  }
+  return context?.context ?? defaultRuntimeContext;
+}
+
+// src/shared/format-validators.ts
+function luhnCheck(digits) {
+  if (!LUHN_DIGITS_RE.test(digits))
+    return false;
+  let sum = 0;
+  let alternate = false;
+  for (let index = digits.length - 1;index >= 0; index -= 1) {
+    let digit = Number.parseInt(digits.charAt(index), 10);
+    if (alternate) {
+      digit *= 2;
+      if (digit > 9)
+        digit -= 9;
+    }
+    sum += digit;
+    alternate = !alternate;
+  }
+  return sum % 10 === 0;
+}
+function isValidISODate(value) {
+  const parts = value.split("-").map(Number);
+  const year = parts[0];
+  const month = parts[1];
+  const day = parts[2];
+  if (year === undefined || month === undefined || day === undefined)
+    return false;
+  const date = new globalThis.Date(year, month - 1, day);
+  return date.getFullYear() === year && date.getMonth() === month - 1 && date.getDate() === day;
+}
+function validateFormat(value, format, context) {
+  const runtimeContext = resolveRuntimeContext(context);
+  const custom = runtimeContext.FormatRegistry.Get(format);
+  if (custom !== undefined)
+    return custom(value);
+  switch (format) {
+    case "email":
+      return EMAIL_RE.test(value);
+    case "uri":
+      return URI_RE.test(value);
+    case "ip":
+      return IPV4_RE.test(value) || IPV6_RE.test(value);
+    case "hostname":
+      return HOSTNAME_RE.test(value);
+    case "ipv4":
+      return IPV4_RE.test(value);
+    case "ipv6":
+      return IPV6_RE.test(value);
+    case "uuid":
+      return UUID_RE.test(value);
+    case "date":
+      return ISO_DATE_RE.test(value) && isValidISODate(value);
+    case "datetime":
+      return ISO_DT_RE.test(value);
+    case "time":
+      return ISO_TIME_RE.test(value);
+    case "duration":
+      return ISO_DUR_RE.test(value);
+    case "base64":
+      return BASE64_RE.test(value);
+    case "hex":
+      return HEX_RE.test(value);
+    case "hexcolor":
+      return HEXCLR_RE.test(value);
+    case "creditcard":
+      return luhnCheck(value.replace(/\D/g, ""));
+    case "regex":
+      return isValidRegex(value);
+    case "json":
+      return isValidJson(value);
+    case "uint8array":
+      return BASE64_RE.test(value);
+    default:
+      return true;
+  }
+}
+function checkStringConstraints(schema, value, context) {
+  if (schema.minLength !== undefined && value.length < schema.minLength)
+    return false;
+  if (schema.maxLength !== undefined && value.length > schema.maxLength)
+    return false;
+  if (schema.pattern !== undefined) {
+    const regex = new RegExp(schema.pattern);
+    if (!regex.test(value))
+      return false;
+  }
+  return schema.format === undefined || validateFormat(value, schema.format, context);
+}
+function checkNumberConstraints(schema, value) {
+  if (schema.minimum !== undefined && value < schema.minimum)
+    return false;
+  if (schema.maximum !== undefined && value > schema.maximum)
+    return false;
+  if (schema.exclusiveMinimum !== undefined && value <= schema.exclusiveMinimum)
+    return false;
+  if (schema.exclusiveMaximum !== undefined && value >= schema.exclusiveMaximum)
+    return false;
+  return schema.multipleOf === undefined || value % schema.multipleOf === 0;
+}
+// src/shared/registries.ts
+var FormatRegistry = {
+  Clear() {
+    getDefaultRuntimeContext().FormatRegistry.Clear();
+  },
+  Delete(name) {
+    return getDefaultRuntimeContext().FormatRegistry.Delete(name);
+  },
+  Entries() {
+    return getDefaultRuntimeContext().FormatRegistry.Entries();
+  },
+  Get(name) {
+    return getDefaultRuntimeContext().FormatRegistry.Get(name);
+  },
+  Has(name) {
+    return getDefaultRuntimeContext().FormatRegistry.Has(name);
+  },
+  Set(name, validator) {
+    getDefaultRuntimeContext().FormatRegistry.Set(name, validator);
+  }
+};
+var TypeRegistry = {
+  Clear() {
+    getDefaultRuntimeContext().TypeRegistry.Clear();
+  },
+  Delete(kind) {
+    return getDefaultRuntimeContext().TypeRegistry.Delete(kind);
+  },
+  Entries() {
+    return getDefaultRuntimeContext().TypeRegistry.Entries();
+  },
+  Get(kind) {
+    return getDefaultRuntimeContext().TypeRegistry.Get(kind);
+  },
+  Has(kind) {
+    return getDefaultRuntimeContext().TypeRegistry.Has(kind);
+  },
+  Set(kind, validator) {
+    getDefaultRuntimeContext().TypeRegistry.Set(kind, validator);
+  }
+};
+var TypeSystemPolicy = {
+  Get() {
+    return getDefaultRuntimeContext().TypeSystemPolicy.Get();
+  },
+  Reset() {
+    getDefaultRuntimeContext().TypeSystemPolicy.Reset();
+  },
+  Set(options) {
+    getDefaultRuntimeContext().TypeSystemPolicy.Set(options);
+  }
+};
+var Settings = {
+  Get() {
+    return getDefaultRuntimeContext().Settings.Get();
+  },
+  Reset() {
+    getDefaultRuntimeContext().Settings.Reset();
+  },
+  Set(options) {
+    getDefaultRuntimeContext().Settings.Set(options);
+  }
+};
+// src/schema/schema.ts
+var exports_schema = {};
+__export(exports_schema, {
+  Validator: () => Validator,
+  TryParse: () => TryParse,
+  To: () => To,
+  Stack: () => Stack,
+  Set: () => Set2,
+  Schema: () => Schema,
+  Resolve: () => Resolve,
+  ResetFunctions: () => ResetFunctions,
+  ResetExternal: () => ResetExternal,
+  Ref: () => Ref,
+  Reducer: () => Reducer,
+  Pointer: () => Pointer,
+  ParseError: () => ParseError,
+  Parse: () => Parse,
+  IsUniqueItems: () => IsUniqueItems,
+  IsUnevaluatedProperties: () => IsUnevaluatedProperties,
+  IsUnevaluatedItems: () => IsUnevaluatedItems,
+  IsType: () => IsType,
+  IsThen: () => IsThen,
+  IsSchemaObject: () => IsSchemaObject2,
+  IsSchema: () => IsSchema2,
+  IsRequired: () => IsRequired,
+  IsRefine: () => IsRefine,
+  IsRef: () => IsRef,
+  IsRecursiveRef: () => IsRecursiveRef,
+  IsRecursiveAnchorTrue: () => IsRecursiveAnchorTrue,
+  IsRecursiveAnchor: () => IsRecursiveAnchor,
+  IsPropertyNames: () => IsPropertyNames,
+  IsProperties: () => IsProperties,
+  IsPrefixItems: () => IsPrefixItems,
+  IsPatternProperties: () => IsPatternProperties,
+  IsPattern: () => IsPattern,
+  IsOneOf: () => IsOneOf,
+  IsNot: () => IsNot,
+  IsMultipleOf: () => IsMultipleOf,
+  IsMinimum: () => IsMinimum,
+  IsMinProperties: () => IsMinProperties,
+  IsMinLength: () => IsMinLength,
+  IsMinItems: () => IsMinItems,
+  IsMinContains: () => IsMinContains,
+  IsMaximum: () => IsMaximum,
+  IsMaxProperties: () => IsMaxProperties,
+  IsMaxLength: () => IsMaxLength,
+  IsMaxItems: () => IsMaxItems,
+  IsMaxContains: () => IsMaxContains,
+  IsItemsUnsized: () => IsItemsUnsized,
+  IsItemsSized: () => IsItemsSized,
+  IsItems: () => IsItems,
+  IsIf: () => IsIf,
+  IsId: () => IsId,
+  IsGuardInterface: () => IsGuardInterface,
+  IsGuard: () => IsGuard,
+  IsFormat: () => IsFormat,
+  IsExclusiveMinimum: () => IsExclusiveMinimum,
+  IsExclusiveMaximum: () => IsExclusiveMaximum,
+  IsEnum: () => IsEnum,
+  IsElse: () => IsElse,
+  IsDynamicRef: () => IsDynamicRef,
+  IsDynamicAnchor: () => IsDynamicAnchor,
+  IsDependentSchemas: () => IsDependentSchemas,
+  IsDependentRequired: () => IsDependentRequired,
+  IsDependencies: () => IsDependencies,
+  IsDefs: () => IsDefs,
+  IsDefault: () => IsDefault,
+  IsContentMediaType: () => IsContentMediaType,
+  IsContentEncoding: () => IsContentEncoding,
+  IsContains: () => IsContains,
+  IsConst: () => IsConst,
+  IsBooleanSchema: () => IsBooleanSchema,
+  IsAnyOf: () => IsAnyOf,
+  IsAnchor: () => IsAnchor,
+  IsAllOf: () => IsAllOf,
+  IsAdditionalProperties: () => IsAdditionalProperties,
+  IsAdditionalItems: () => IsAdditionalItems,
+  Indices: () => Indices,
+  HasUnevaluated: () => HasUnevaluated,
+  Has: () => Has,
+  GetFunctions: () => GetFunctions,
+  GetExternal: () => GetExternal,
+  Get: () => Get,
+  Errors: () => Errors,
+  ErrorUniqueItems: () => ErrorUniqueItems,
+  ErrorUnevaluatedProperties: () => ErrorUnevaluatedProperties,
+  ErrorUnevaluatedItems: () => ErrorUnevaluatedItems,
+  ErrorType: () => ErrorType,
+  ErrorSchema: () => ErrorSchema,
+  ErrorRequired: () => ErrorRequired,
+  ErrorRefine: () => ErrorRefine,
+  ErrorRef: () => ErrorRef,
+  ErrorRecursiveRef: () => ErrorRecursiveRef,
+  ErrorPropertyNames: () => ErrorPropertyNames,
+  ErrorProperties: () => ErrorProperties,
+  ErrorPrefixItems: () => ErrorPrefixItems,
+  ErrorPatternProperties: () => ErrorPatternProperties,
+  ErrorPattern: () => ErrorPattern,
+  ErrorOneOf: () => ErrorOneOf,
+  ErrorNot: () => ErrorNot,
+  ErrorMultipleOf: () => ErrorMultipleOf,
+  ErrorMinimum: () => ErrorMinimum,
+  ErrorMinProperties: () => ErrorMinProperties,
+  ErrorMinLength: () => ErrorMinLength,
+  ErrorMinItems: () => ErrorMinItems,
+  ErrorMinContains: () => ErrorMinContains,
+  ErrorMaximum: () => ErrorMaximum,
+  ErrorMaxProperties: () => ErrorMaxProperties,
+  ErrorMaxLength: () => ErrorMaxLength,
+  ErrorMaxItems: () => ErrorMaxItems,
+  ErrorMaxContains: () => ErrorMaxContains,
+  ErrorItems: () => ErrorItems,
+  ErrorIf: () => ErrorIf,
+  ErrorGuard: () => ErrorGuard,
+  ErrorFormat: () => ErrorFormat,
+  ErrorExclusiveMinimum: () => ErrorExclusiveMinimum,
+  ErrorExclusiveMaximum: () => ErrorExclusiveMaximum,
+  ErrorEnum: () => ErrorEnum,
+  ErrorDependentSchemas: () => ErrorDependentSchemas,
+  ErrorDependentRequired: () => ErrorDependentRequired,
+  ErrorDependencies: () => ErrorDependencies,
+  ErrorContext: () => ErrorContext,
+  ErrorContains: () => ErrorContains,
+  ErrorConst: () => ErrorConst,
+  ErrorBooleanSchema: () => ErrorBooleanSchema,
+  ErrorAnyOf: () => ErrorAnyOf,
+  ErrorAllOf: () => ErrorAllOf,
+  ErrorAdditionalProperties: () => ErrorAdditionalProperties,
+  ErrorAdditionalItems: () => ErrorAdditionalItems,
+  Delete: () => Delete,
+  CreateVariable: () => CreateVariable,
+  CreateFunction: () => CreateFunction,
+  Compile: () => Compile,
+  CheckUniqueItems: () => CheckUniqueItems,
+  CheckUnevaluatedProperties: () => CheckUnevaluatedProperties,
+  CheckUnevaluatedItems: () => CheckUnevaluatedItems,
+  CheckType: () => CheckType,
+  CheckSchema: () => CheckSchema,
+  CheckRequired: () => CheckRequired,
+  CheckRefine: () => CheckRefine,
+  CheckRef: () => CheckRef,
+  CheckRecursiveRef: () => CheckRecursiveRef,
+  CheckPropertyNames: () => CheckPropertyNames,
+  CheckProperties: () => CheckProperties,
+  CheckPrefixItems: () => CheckPrefixItems,
+  CheckPatternProperties: () => CheckPatternProperties,
+  CheckPattern: () => CheckPattern,
+  CheckOneOf: () => CheckOneOf,
+  CheckNot: () => CheckNot,
+  CheckMultipleOf: () => CheckMultipleOf,
+  CheckMinimum: () => CheckMinimum,
+  CheckMinProperties: () => CheckMinProperties,
+  CheckMinLength: () => CheckMinLength,
+  CheckMinItems: () => CheckMinItems,
+  CheckMinContains: () => CheckMinContains,
+  CheckMaximum: () => CheckMaximum,
+  CheckMaxProperties: () => CheckMaxProperties,
+  CheckMaxLength: () => CheckMaxLength,
+  CheckMaxItems: () => CheckMaxItems,
+  CheckMaxContains: () => CheckMaxContains,
+  CheckItems: () => CheckItems,
+  CheckIf: () => CheckIf,
+  CheckGuard: () => CheckGuard,
+  CheckFormat: () => CheckFormat,
+  CheckExclusiveMinimum: () => CheckExclusiveMinimum,
+  CheckExclusiveMaximum: () => CheckExclusiveMaximum,
+  CheckEnum: () => CheckEnum,
+  CheckDependentSchemas: () => CheckDependentSchemas,
+  CheckDependentRequired: () => CheckDependentRequired,
+  CheckDependencies: () => CheckDependencies,
+  CheckContext: () => CheckContext,
+  CheckContains: () => CheckContains,
+  CheckConst: () => CheckConst,
+  CheckBooleanSchema: () => CheckBooleanSchema,
+  CheckAnyOf: () => CheckAnyOf,
+  CheckAllOf: () => CheckAllOf,
+  CheckAdditionalProperties: () => CheckAdditionalProperties,
+  CheckAdditionalItems: () => CheckAdditionalItems,
+  Check: () => Check,
+  CanAdditionalPropertiesFast: () => CanAdditionalPropertiesFast,
+  BuildUniqueItems: () => BuildUniqueItems,
+  BuildUnevaluatedProperties: () => BuildUnevaluatedProperties,
+  BuildUnevaluatedItems: () => BuildUnevaluatedItems,
+  BuildType: () => BuildType,
+  BuildSchema: () => BuildSchema,
+  BuildResult: () => BuildResult,
+  BuildRequired: () => BuildRequired,
+  BuildRefine: () => BuildRefine,
+  BuildRef: () => BuildRef,
+  BuildRecursiveRef: () => BuildRecursiveRef,
+  BuildPropertyNames: () => BuildPropertyNames,
+  BuildProperties: () => BuildProperties,
+  BuildPrefixItems: () => BuildPrefixItems,
+  BuildPatternProperties: () => BuildPatternProperties,
+  BuildPattern: () => BuildPattern,
+  BuildOneOf: () => BuildOneOf,
+  BuildNot: () => BuildNot,
+  BuildMultipleOf: () => BuildMultipleOf,
+  BuildMinimum: () => BuildMinimum,
+  BuildMinProperties: () => BuildMinProperties,
+  BuildMinLength: () => BuildMinLength,
+  BuildMinItems: () => BuildMinItems,
+  BuildMinContains: () => BuildMinContains,
+  BuildMaximum: () => BuildMaximum,
+  BuildMaxProperties: () => BuildMaxProperties,
+  BuildMaxLength: () => BuildMaxLength,
+  BuildMaxItems: () => BuildMaxItems,
+  BuildMaxContains: () => BuildMaxContains,
+  BuildItems: () => BuildItems,
+  BuildIf: () => BuildIf,
+  BuildGuard: () => BuildGuard,
+  BuildFormat: () => BuildFormat,
+  BuildExclusiveMinimum: () => BuildExclusiveMinimum,
+  BuildExclusiveMaximum: () => BuildExclusiveMaximum,
+  BuildEnum: () => BuildEnum,
+  BuildDependentSchemas: () => BuildDependentSchemas,
+  BuildDependentRequired: () => BuildDependentRequired,
+  BuildDependencies: () => BuildDependencies,
+  BuildContext: () => BuildContext,
+  BuildContains: () => BuildContains,
+  BuildConst: () => BuildConst,
+  BuildBooleanSchema: () => BuildBooleanSchema,
+  BuildAnyOf: () => BuildAnyOf,
+  BuildAllOf: () => BuildAllOf,
+  BuildAdditionalPropertiesStandard: () => BuildAdditionalPropertiesStandard,
+  BuildAdditionalPropertiesFast: () => BuildAdditionalPropertiesFast,
+  BuildAdditionalProperties: () => BuildAdditionalProperties,
+  BuildAdditionalItems: () => BuildAdditionalItems,
+  Build: () => Build,
+  AccumulatedErrorContext: () => AccumulatedErrorContext
+});
+
+// src/schema/shared.ts
+function IsArray(value) {
+  return Array.isArray(value);
+}
+function IsObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function IsPlainObject(value) {
+  return IsObject(value) && !Array.isArray(value);
+}
+function IsSchemaObject(value) {
+  return IsObject(value);
+}
+function IsSchema(value) {
+  return typeof value === "boolean" || IsSchemaObject(value);
+}
+function HasPropertyKey(value, key) {
+  return key in value;
+}
+function HasString(value, key) {
+  return typeof value[key] === "string";
+}
+function HasBoolean(value, key) {
+  return typeof value[key] === "boolean";
+}
+function HasArray(value, key) {
+  return Array.isArray(value[key]);
+}
+function HasObject(value, key) {
+  return IsObject(value[key]);
+}
+function Keys(value) {
+  return Object.keys(value);
+}
+function Entries(value) {
+  return Object.entries(value);
+}
+function NormalizeArgs(args) {
+  return args.length === 2 ? [{}, args[0], args[1]] : [args[0], args[1], args[2]];
+}
+function DecodePointerToken(token) {
+  return token.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function ProjectSchema(schema, keys, defaults = {}) {
+  if (typeof schema === "boolean") {
+    return schema;
+  }
+  const projected = { ...defaults };
+  for (const key of keys) {
+    if (key in schema) {
+      projected[key] = schema[key];
+    }
+  }
+  return projected;
+}
+
+// src/schema/pointer.ts
+function assertNotRoot(indices) {
+  if (indices.length === 0) {
+    throw new Error("Cannot set root");
+  }
+}
+function assertIndexable(value) {
+  if (!IsObject(value)) {
+    throw new Error("Cannot set value");
+  }
+}
+function hasIndex(index, value) {
+  return IsObject(value) && index in value;
+}
+function getIndex(index, value) {
+  return IsObject(value) ? value[index] : undefined;
+}
+function takeIndexRight(indices) {
+  return [indices.slice(0, indices.length - 1), indices[indices.length - 1] ?? ""];
+}
+function getIndices(indices, value) {
+  return indices.reduce((current, index) => getIndex(index, current), value);
+}
+function isNumericIndex(index) {
+  return /^(0|[1-9]\d*)$/.test(index);
+}
+function Indices(pointer) {
+  if (pointer.length === 0) {
+    return [];
+  }
+  const indices = pointer.split("/").map(DecodePointerToken);
+  return indices.length > 0 && indices[0] === "" ? indices.slice(1) : indices;
+}
+function Has(value, pointer) {
+  let current = value;
+  return Indices(pointer).every((index) => {
+    if (!hasIndex(index, current)) {
+      return false;
+    }
+    current = getIndex(index, current);
+    return true;
+  });
+}
+function Get(value, pointer) {
+  return getIndices(Indices(pointer), value);
+}
+function Set2(value, pointer, next) {
+  const indices = Indices(pointer);
+  assertNotRoot(indices);
+  const [head, index] = takeIndexRight(indices);
+  const parent = getIndices(head, value);
+  assertIndexable(parent);
+  if (Array.isArray(parent) && isNumericIndex(index)) {
+    parent[Number(index)] = next;
+  } else if (IsObject(parent)) {
+    parent[index] = next;
+  }
+  return value;
+}
+function Delete(value, pointer) {
+  const indices = Indices(pointer);
+  assertNotRoot(indices);
+  const [head, index] = takeIndexRight(indices);
+  const parent = getIndices(head, value);
+  assertIndexable(parent);
+  if (IsArray(parent) && isNumericIndex(index)) {
+    parent.splice(Number(index), 1);
+  } else {
+    delete parent[index];
+  }
+  return value;
+}
+var Pointer = {
+  Delete,
+  Get,
+  Has,
+  Indices,
+  Set: Set2
+};
+// src/schema/resolve.ts
+function matchHash(schema, ref) {
+  if (ref.href.endsWith("#")) {
+    return schema;
+  }
+  if (!ref.hash.startsWith("#")) {
+    return;
+  }
+  const value = Get(schema, decodeURIComponent(DecodePointerToken(ref.hash.slice(1))));
+  return IsSchema(value) ? value : undefined;
+}
+function matchId(schema, base, ref) {
+  const id = schema["$id"];
+  if (typeof id !== "string") {
+    return;
+  }
+  if (id === ref.hash) {
+    return schema;
+  }
+  const absoluteId = new URL(id, base.href);
+  const absoluteRef = new URL(ref.href, base.href);
+  if (absoluteId.pathname === absoluteRef.pathname) {
+    return ref.hash.startsWith("#") ? matchHash(schema, ref) : schema;
+  }
+  return;
+}
+function matchAnchor(schema, base, ref) {
+  const anchor = schema["$anchor"];
+  if (typeof anchor !== "string") {
+    return;
+  }
+  const absoluteAnchor = new URL(`#${anchor}`, base.href);
+  const absoluteRef = new URL(ref.href, base.href);
+  return absoluteAnchor.href === absoluteRef.href ? schema : undefined;
+}
+function match(schema, base, ref) {
+  return matchId(schema, base, ref) ?? matchAnchor(schema, base, ref) ?? matchHash(schema, ref);
+}
+function fromArray(values, base, ref) {
+  for (const value of values) {
+    const found = fromValue(value, base, ref);
+    if (found !== undefined) {
+      return found;
+    }
+  }
+  return;
+}
+function fromObject(schema, base, ref) {
+  for (const key of Keys(schema)) {
+    const found = fromValue(schema[key], base, ref);
+    if (found !== undefined) {
+      return found;
+    }
+  }
+  return;
+}
+function fromValue(value, base, ref) {
+  const nextId = IsSchemaObject(value) ? value["$id"] : undefined;
+  const nextBase = typeof nextId === "string" ? new URL(nextId, base.href) : base;
+  if (IsSchemaObject(value)) {
+    const found = match(value, nextBase, ref);
+    if (found !== undefined) {
+      return found;
+    }
+  }
+  if (IsArray(value)) {
+    return fromArray(value, nextBase, ref);
+  }
+  if (IsObject(value)) {
+    return fromObject(value, nextBase, ref);
+  }
+  return;
+}
+function Ref(schema, ref) {
+  const defaultBase = new URL("http://unknown");
+  const initialId = IsSchemaObject(schema) ? schema["$id"] : undefined;
+  const initialBase = typeof initialId === "string" ? new URL(initialId, defaultBase.href) : defaultBase;
+  const targetRef = new URL(ref, initialBase.href);
+  return fromValue(schema, initialBase, targetRef);
+}
+var Resolve = {
+  Ref
+};
+// src/schema/predicates.ts
+function hasKeyword(keyword) {
+  return (schema) => IsSchemaObject(schema) && HasPropertyKey(schema, keyword);
+}
+var IsSchemaObject2 = (schema) => IsSchemaObject(schema);
+var IsBooleanSchema = (schema) => typeof schema === "boolean";
+var IsSchema2 = (schema) => IsSchema(schema);
+var IsAdditionalItems = hasKeyword("additionalItems");
+var IsAdditionalProperties = hasKeyword("additionalProperties");
+var IsAllOf = hasKeyword("allOf");
+var IsAnchor = (schema) => IsSchemaObject(schema) && HasString(schema, "$anchor");
+var IsAnyOf = hasKeyword("anyOf");
+var IsConst = hasKeyword("const");
+var IsContains = hasKeyword("contains");
+var IsContentEncoding = hasKeyword("contentEncoding");
+var IsContentMediaType = hasKeyword("contentMediaType");
+var IsDefault = hasKeyword("default");
+var IsDefs = hasKeyword("$defs");
+var IsDependencies = hasKeyword("dependencies");
+var IsDependentRequired = hasKeyword("dependentRequired");
+var IsDependentSchemas = hasKeyword("dependentSchemas");
+var IsDynamicAnchor = (schema) => IsSchemaObject(schema) && HasString(schema, "$dynamicAnchor");
+var IsDynamicRef = (schema) => IsSchemaObject(schema) && HasString(schema, "$dynamicRef");
+var IsElse = hasKeyword("else");
+var IsEnum = hasKeyword("enum");
+var IsExclusiveMaximum = hasKeyword("exclusiveMaximum");
+var IsExclusiveMinimum = hasKeyword("exclusiveMinimum");
+var IsFormat = hasKeyword("format");
+var IsGuard = (schema) => IsSchemaObject(schema) && HasObject(schema, "~guard");
+var IsGuardInterface = IsGuard;
+var IsId = (schema) => IsSchemaObject(schema) && HasString(schema, "$id");
+var IsIf = hasKeyword("if");
+var IsItems = hasKeyword("items");
+var IsItemsSized = (schema) => IsSchemaObject(schema) && HasArray(schema, "prefixItems");
+var IsItemsUnsized = (schema) => IsSchemaObject(schema) && HasPropertyKey(schema, "items") && !HasArray(schema, "prefixItems");
+var IsMaxContains = hasKeyword("maxContains");
+var IsMaxItems = hasKeyword("maxItems");
+var IsMaxLength = hasKeyword("maxLength");
+var IsMaxProperties = hasKeyword("maxProperties");
+var IsMaximum = hasKeyword("maximum");
+var IsMinContains = hasKeyword("minContains");
+var IsMinItems = hasKeyword("minItems");
+var IsMinLength = hasKeyword("minLength");
+var IsMinProperties = hasKeyword("minProperties");
+var IsMinimum = hasKeyword("minimum");
+var IsMultipleOf = hasKeyword("multipleOf");
+var IsNot = hasKeyword("not");
+var IsOneOf = hasKeyword("oneOf");
+var IsPattern = hasKeyword("pattern");
+var IsPatternProperties = hasKeyword("patternProperties");
+var IsPrefixItems = hasKeyword("prefixItems");
+var IsProperties = hasKeyword("properties");
+var IsPropertyNames = hasKeyword("propertyNames");
+var IsRecursiveAnchor = hasKeyword("$recursiveAnchor");
+var IsRecursiveAnchorTrue = (schema) => IsSchemaObject(schema) && HasBoolean(schema, "$recursiveAnchor") && schema.$recursiveAnchor === true;
+var IsRecursiveRef = hasKeyword("$recursiveRef");
+var IsRef = hasKeyword("$ref");
+var IsRefine = (schema) => IsSchemaObject(schema) && HasArray(schema, "~refine");
+var IsRequired = hasKeyword("required");
+var IsThen = hasKeyword("then");
+var IsType = hasKeyword("type");
+var IsUnevaluatedItems = hasKeyword("unevaluatedItems");
+var IsUnevaluatedProperties = hasKeyword("unevaluatedProperties");
+var IsUniqueItems = hasKeyword("uniqueItems");
+// src/schema/core-keywords.ts
+function MatchesType(type, value) {
+  if (Array.isArray(type)) {
+    return type.some((entry) => MatchesType(entry, value));
+  }
+  if (typeof type !== "string") {
+    return true;
+  }
+  switch (type) {
+    case "array":
+      return Array.isArray(value);
+    case "boolean":
+      return typeof value === "boolean";
+    case "integer":
+      return typeof value === "number" && Number.isInteger(value);
+    case "null":
+      return value === null;
+    case "number":
+      return typeof value === "number" && Number.isFinite(value);
+    case "object":
+      return IsPlainObject(value);
+    case "string":
+      return typeof value === "string";
+    default:
+      return true;
+  }
+}
+function uniqueItems(items) {
+  const seen = new Set;
+  for (const item of items) {
+    const signature = JSON.stringify(item);
+    if (seen.has(signature)) {
+      return false;
+    }
+    seen.add(signature);
+  }
+  return true;
+}
+function CheckStringKeywords(record, value) {
+  if (typeof value !== "string") {
+    return true;
+  }
+  const minLength = record["minLength"];
+  if (typeof minLength === "number" && value.length < minLength) {
+    return false;
+  }
+  const maxLength = record["maxLength"];
+  if (typeof maxLength === "number" && value.length > maxLength) {
+    return false;
+  }
+  const pattern = record["pattern"];
+  if (typeof pattern === "string" && !new RegExp(pattern).test(value)) {
+    return false;
+  }
+  const format = record["format"];
+  if (typeof format === "string") {
+    const validator = FormatRegistry.Get(format);
+    if (validator !== undefined && !validator(value)) {
+      return false;
+    }
+  }
+  return true;
+}
+function CheckNumberKeywords(record, value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return true;
+  }
+  const minimum = record["minimum"];
+  if (typeof minimum === "number" && value < minimum) {
+    return false;
+  }
+  const maximum = record["maximum"];
+  if (typeof maximum === "number" && value > maximum) {
+    return false;
+  }
+  const exclusiveMinimum = record["exclusiveMinimum"];
+  if (typeof exclusiveMinimum === "number" && value <= exclusiveMinimum) {
+    return false;
+  }
+  const exclusiveMaximum = record["exclusiveMaximum"];
+  if (typeof exclusiveMaximum === "number" && value >= exclusiveMaximum) {
+    return false;
+  }
+  const multipleOf = record["multipleOf"];
+  if (typeof multipleOf === "number" && value % multipleOf !== 0) {
+    return false;
+  }
+  return true;
+}
+function CheckArrayKeywords(check, context, record, value, root) {
+  if (!Array.isArray(value)) {
+    return true;
+  }
+  const minItems = record["minItems"];
+  if (typeof minItems === "number" && value.length < minItems) {
+    return false;
+  }
+  const maxItems = record["maxItems"];
+  if (typeof maxItems === "number" && value.length > maxItems) {
+    return false;
+  }
+  if (record["uniqueItems"] === true && !uniqueItems(value)) {
+    return false;
+  }
+  const prefixItems = Array.isArray(record["prefixItems"]) ? record["prefixItems"] : undefined;
+  if (prefixItems !== undefined) {
+    for (let index = 0;index < prefixItems.length; index += 1) {
+      const itemSchema = prefixItems[index];
+      if (IsSchema(itemSchema) && !check(context, itemSchema, value[index], root)) {
+        return false;
+      }
+    }
+  }
+  const items = IsSchema(record["items"]) ? record["items"] : undefined;
+  if (items !== undefined) {
+    const start = prefixItems?.length ?? 0;
+    for (let index = start;index < value.length; index += 1) {
+      if (!check(context, items, value[index], root)) {
+        return false;
+      }
+    }
+  }
+  const additionalItems = IsSchema(record["additionalItems"]) ? record["additionalItems"] : undefined;
+  if (additionalItems !== undefined && prefixItems !== undefined && items === undefined) {
+    for (let index = prefixItems.length;index < value.length; index += 1) {
+      if (!check(context, additionalItems, value[index], root)) {
+        return false;
+      }
+    }
+  }
+  const unevaluatedItems = IsSchema(record["unevaluatedItems"]) ? record["unevaluatedItems"] : undefined;
+  if (unevaluatedItems !== undefined && prefixItems !== undefined && items === undefined) {
+    for (let index = prefixItems.length;index < value.length; index += 1) {
+      if (!check(context, unevaluatedItems, value[index], root)) {
+        return false;
+      }
+    }
+  }
+  const contains = IsSchema(record["contains"]) ? record["contains"] : undefined;
+  if (contains !== undefined) {
+    const count = value.filter((entry) => check(context, contains, entry, root)).length;
+    if (count === 0) {
+      return false;
+    }
+    const minContains = record["minContains"];
+    if (typeof minContains === "number" && count < minContains) {
+      return false;
+    }
+    const maxContains = record["maxContains"];
+    if (typeof maxContains === "number" && count > maxContains) {
+      return false;
+    }
+  }
+  return true;
+}
+function CheckObjectKeywords(check, context, record, value, root) {
+  if (!IsPlainObject(value)) {
+    return true;
+  }
+  const keys = Object.keys(value);
+  const minProperties = record["minProperties"];
+  if (typeof minProperties === "number" && keys.length < minProperties) {
+    return false;
+  }
+  const maxProperties = record["maxProperties"];
+  if (typeof maxProperties === "number" && keys.length > maxProperties) {
+    return false;
+  }
+  const required = Array.isArray(record["required"]) ? record["required"] : undefined;
+  if (required !== undefined && !required.every((entry) => typeof entry === "string" && (entry in value))) {
+    return false;
+  }
+  const propertyNames = IsSchema(record["propertyNames"]) ? record["propertyNames"] : undefined;
+  if (propertyNames !== undefined && !keys.every((key) => check(context, propertyNames, key, root))) {
+    return false;
+  }
+  const properties = IsObject(record["properties"]) ? record["properties"] : undefined;
+  const patternProperties = IsObject(record["patternProperties"]) ? record["patternProperties"] : undefined;
+  for (const key of keys) {
+    const propertySchema = properties?.[key];
+    const matchedPatterns = patternProperties === undefined ? [] : Entries(patternProperties).filter(([pattern, schema]) => new RegExp(pattern).test(key) && IsSchema(schema)).map(([, schema]) => schema);
+    if (IsSchema(propertySchema) && !check(context, propertySchema, value[key], root)) {
+      return false;
+    }
+    if (matchedPatterns.some((schema) => !check(context, schema, value[key], root))) {
+      return false;
+    }
+    if (propertySchema === undefined && matchedPatterns.length === 0) {
+      const additionalProperties = record["additionalProperties"];
+      if (additionalProperties === false) {
+        return false;
+      }
+      if (IsSchema(additionalProperties) && !check(context, additionalProperties, value[key], root)) {
+        return false;
+      }
+      const unevaluatedProperties = record["unevaluatedProperties"];
+      if (unevaluatedProperties === false) {
+        return false;
+      }
+      if (IsSchema(unevaluatedProperties) && !check(context, unevaluatedProperties, value[key], root)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function CheckDependentKeywords(check, context, record, value, root) {
+  if (!IsPlainObject(value)) {
+    return true;
+  }
+  const dependentRequired = IsObject(record["dependentRequired"]) ? record["dependentRequired"] : undefined;
+  if (dependentRequired !== undefined) {
+    for (const [key, dependency] of Entries(dependentRequired)) {
+      if (key in value && Array.isArray(dependency) && !dependency.every((entry) => typeof entry === "string" && (entry in value))) {
+        return false;
+      }
+    }
+  }
+  const dependentSchemas = IsObject(record["dependentSchemas"]) ? record["dependentSchemas"] : undefined;
+  if (dependentSchemas !== undefined) {
+    for (const [key, dependency] of Entries(dependentSchemas)) {
+      if (key in value && IsSchema(dependency) && !check(context, dependency, value, root)) {
+        return false;
+      }
+    }
+  }
+  const dependencies = IsObject(record["dependencies"]) ? record["dependencies"] : undefined;
+  if (dependencies !== undefined) {
+    for (const [key, dependency] of Entries(dependencies)) {
+      if (!(key in value)) {
+        continue;
+      }
+      if (Array.isArray(dependency) && !dependency.every((entry) => typeof entry === "string" && (entry in value))) {
+        return false;
+      }
+      if (IsSchema(dependency) && !check(context, dependency, value, root)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+// src/schema/core.ts
+function resolveReferencedSchema(context, schema, root) {
+  const schemaRecord = schema;
+  const refKeys = ["$ref", "$recursiveRef", "$dynamicRef"];
+  for (const key of refKeys) {
+    const value = schemaRecord[key];
+    const ref = typeof value === "string" ? value : undefined;
+    if (ref !== undefined) {
+      return context[ref] ?? Ref(root, ref);
+    }
+  }
+  return;
+}
+function checkCoreKeywords(context, schema, value, root) {
+  if ("const" in schema && !Object.is(schema["const"], value)) {
+    return false;
+  }
+  const enumValues = Array.isArray(schema["enum"]) ? schema["enum"] : undefined;
+  if (enumValues !== undefined && !enumValues.some((entry) => Object.is(entry, value))) {
+    return false;
+  }
+  if ("type" in schema && !MatchesType(schema["type"], value)) {
+    return false;
+  }
+  if (!CheckStringKeywords(schema, value) || !CheckNumberKeywords(schema, value)) {
+    return false;
+  }
+  if (!CheckArrayKeywords(CheckSchemaValue, context, schema, value, root) || !CheckObjectKeywords(CheckSchemaValue, context, schema, value, root)) {
+    return false;
+  }
+  return CheckDependentKeywords(CheckSchemaValue, context, schema, value, root);
+}
+function checkCompositionKeywords(context, schema, value, root) {
+  const allOf = Array.isArray(schema["allOf"]) ? schema["allOf"] : undefined;
+  if (allOf !== undefined && !allOf.every((entry) => IsSchema(entry) && CheckSchemaValue(context, entry, value, root))) {
+    return false;
+  }
+  const anyOf = Array.isArray(schema["anyOf"]) ? schema["anyOf"] : undefined;
+  if (anyOf !== undefined && !anyOf.some((entry) => IsSchema(entry) && CheckSchemaValue(context, entry, value, root))) {
+    return false;
+  }
+  const oneOf = Array.isArray(schema["oneOf"]) ? schema["oneOf"] : undefined;
+  if (oneOf !== undefined) {
+    const matches = oneOf.filter((entry) => IsSchema(entry) && CheckSchemaValue(context, entry, value, root));
+    if (matches.length !== 1) {
+      return false;
+    }
+  }
+  return true;
+}
+function checkConditionalKeywords(context, schema, value, root) {
+  const notSchema = IsSchema(schema["not"]) ? schema["not"] : undefined;
+  if (notSchema !== undefined && CheckSchemaValue(context, notSchema, value, root)) {
+    return false;
+  }
+  const ifSchema = IsSchema(schema["if"]) ? schema["if"] : undefined;
+  if (ifSchema !== undefined) {
+    const matched = CheckSchemaValue(context, ifSchema, value, root);
+    const thenSchema = IsSchema(schema["then"]) ? schema["then"] : undefined;
+    const elseSchema = IsSchema(schema["else"]) ? schema["else"] : undefined;
+    if (matched && thenSchema !== undefined) {
+      return CheckSchemaValue(context, thenSchema, value, root);
+    }
+    if (!matched && elseSchema !== undefined) {
+      return CheckSchemaValue(context, elseSchema, value, root);
+    }
+  }
+  return true;
+}
+function checkExtensionKeywords(context, schema, value, root) {
+  const guard = IsObject(schema["~guard"]) ? schema["~guard"] : undefined;
+  if (guard !== undefined && typeof guard["check"] === "function" && !guard["check"](value)) {
+    return false;
+  }
+  const refine = Array.isArray(schema["~refine"]) ? schema["~refine"] : undefined;
+  if (refine !== undefined && !refine.every((entry) => IsObject(entry) && typeof entry["refine"] === "function" && entry["refine"](value))) {
+    return false;
+  }
+  return true;
+}
+function CheckSchemaValue(context, schema, value, root = schema) {
+  if (typeof schema === "boolean") {
+    return schema;
+  }
+  const resolved = resolveReferencedSchema(context, schema, root);
+  if (resolved !== undefined) {
+    return CheckSchemaValue(context, resolved, value, root);
+  }
+  return checkCoreKeywords(context, schema, value, root) && checkCompositionKeywords(context, schema, value, root) && checkConditionalKeywords(context, schema, value, root) && checkExtensionKeywords(context, schema, value, root);
+}
+
+// src/schema/engine.ts
+var externalState = {
+  identifier: "external_0",
+  variables: []
+};
+var resetCount = 1;
+var functions = new Map;
+function scanUnevaluated(value) {
+  if (IsArray(value)) {
+    return value.some((entry) => scanUnevaluated(entry));
+  }
+  if (IsObject(value)) {
+    return Keys(value).some((key) => key === "unevaluatedItems" || key === "unevaluatedProperties" || scanUnevaluated(value[key]));
+  }
+  return false;
+}
+function HasUnevaluated(context, schema) {
+  return scanUnevaluated(schema) || Object.keys(context).some((key) => scanUnevaluated(context[key]));
+}
+
+class BuildContext {
+  hasUnevaluated;
+  constructor(hasUnevaluated) {
+    this.hasUnevaluated = hasUnevaluated;
+  }
+  UseUnevaluated() {
+    return this.hasUnevaluated;
+  }
+  AddIndex(index) {
+    return `context.AddIndex(${index})`;
+  }
+  AddKey(key) {
+    return `context.AddKey(${JSON.stringify(key)})`;
+  }
+  Merge(results) {
+    return `context.Merge(${results})`;
+  }
+}
+
+class CheckContext {
+  indices = new Set;
+  keys = new Set;
+  AddIndex(index) {
+    this.indices.add(index);
+    return true;
+  }
+  AddKey(key) {
+    this.keys.add(key);
+    return true;
+  }
+  GetIndices() {
+    return this.indices;
+  }
+  GetKeys() {
+    return this.keys;
+  }
+  Merge(results) {
+    results.forEach((result) => {
+      result.indices.forEach((entry) => this.indices.add(entry));
+      result.keys.forEach((entry) => this.keys.add(entry));
+    });
+    return true;
+  }
+}
+
+class ErrorContext extends CheckContext {
+  callback;
+  constructor(callback) {
+    super();
+    this.callback = callback;
+  }
+  AddError(error) {
+    this.callback(error);
+    return false;
+  }
+}
+
+class AccumulatedErrorContext extends ErrorContext {
+  errors = [];
+  constructor() {
+    super((error) => {
+      this.errors.push(error);
+    });
+  }
+  AddError(error) {
+    this.errors.push(error);
+    return false;
+  }
+  GetErrors() {
+    return this.errors;
+  }
+}
+function ResetExternal() {
+  externalState.identifier = `external_${resetCount}`;
+  externalState.variables = [];
+  resetCount += 1;
+}
+function CreateVariable(value) {
+  const call = `${externalState.identifier}[${externalState.variables.length}]`;
+  externalState.variables.push(value);
+  return call;
+}
+function GetExternal() {
+  return externalState;
+}
+function ResetFunctions() {
+  functions.clear();
+}
+function GetFunctions() {
+  return Array.from(functions.values());
+}
+
+class Stack {
+  context;
+  schema;
+  ids = [];
+  anchors = [];
+  constructor(context, schema) {
+    this.context = context;
+    this.schema = schema;
+  }
+  BaseURL() {
+    return this.ids.reduce((result, schema) => {
+      const id = schema["$id"];
+      return typeof id === "string" ? new URL(id, result.href) : result;
+    }, new URL("http://unknown"));
+  }
+  Base() {
+    return this.ids[this.ids.length - 1] ?? this.schema;
+  }
+  Push(schema) {
+    if (!IsSchemaObject(schema)) {
+      return;
+    }
+    if (HasString(schema, "$id")) {
+      this.ids.push(schema);
+    }
+    if (HasString(schema, "$anchor")) {
+      this.anchors.push(schema);
+    }
+  }
+  Pop(schema) {
+    if (!IsSchemaObject(schema)) {
+      return;
+    }
+    if (HasString(schema, "$id")) {
+      this.ids.pop();
+    }
+    if (HasString(schema, "$anchor")) {
+      this.anchors.pop();
+    }
+  }
+  Ref(ref) {
+    return this.context[ref] ?? Ref(this.Base(), ref);
+  }
+  RecursiveRef(ref) {
+    return this.Ref(ref);
+  }
+}
+function CreateFunction(_stack, _context, schema, value) {
+  const identifier = `check_${functions.size}`;
+  if (!functions.has(identifier)) {
+    functions.set(identifier, `const ${identifier} = (${value}) => ${JSON.stringify(schema)};`);
+  }
+  return `${identifier}(${value})`;
+}
+function Reducer(stack, context, schemas, value, check) {
+  const results = schemas.map((schema) => {
+    const next = new CheckContext;
+    return CheckSchemaValue({}, schema, value, stack.Base()) ? next : undefined;
+  }).filter((entry) => entry instanceof CheckContext);
+  return check && context.Merge(results);
+}
+function BuildGuard(_stack, _context, _schema, value) {
+  return `typeof ${value} !== 'undefined'`;
+}
+function CheckGuard(_stack, _context, schema, value) {
+  if (!IsSchemaObject(schema) || !HasObject(schema, "~guard")) {
+    return true;
+  }
+  const guard = schema["~guard"];
+  if (!IsObject(guard)) {
+    return true;
+  }
+  return typeof guard["check"] === "function" ? guard["check"](value) : true;
+}
+function ErrorGuard(stack, context, schemaPath, instancePath, schema, value) {
+  if (CheckGuard(stack, context, schema, value)) {
+    return true;
+  }
+  return context.AddError({ keyword: "~guard", schemaPath, instancePath, params: { value } });
+}
+function BuildRefine(_stack, _context, _schema, value) {
+  return `typeof ${value} !== 'undefined'`;
+}
+function CheckRefine(_stack, _context, schema, value) {
+  if (!IsSchemaObject(schema) || !Array.isArray(schema["~refine"])) {
+    return true;
+  }
+  return schema["~refine"].every((entry) => IsObject(entry) && typeof entry["refine"] === "function" && entry["refine"](value));
+}
+function ErrorRefine(stack, context, schemaPath, instancePath, schema, value) {
+  if (CheckRefine(stack, context, schema, value)) {
+    return true;
+  }
+  return context.AddError({ keyword: "~refine", schemaPath, instancePath, params: { value } });
+}
+// src/schema/error-collector.ts
+function error(path, message, code) {
+  return { path, message, code };
+}
+function collectReferenceErrors(context, schema, value, root, path) {
+  const ref = typeof schema["$ref"] === "string" ? schema["$ref"] : undefined;
+  if (ref !== undefined) {
+    const resolved = context[ref] ?? Ref(root, ref);
+    return resolved === undefined ? [error(path, `Unresolved reference ${ref}`, "UNRESOLVED_REF")] : CollectSchemaErrors(context, resolved, value, root, path);
+  }
+  return;
+}
+function collectPrimitiveErrors(schema, value, path) {
+  const errors = [];
+  if ("const" in schema && !Object.is(schema["const"], value)) {
+    errors.push(error(path, "Value does not match const", "CONST"));
+  }
+  const enumValues = Array.isArray(schema["enum"]) ? schema["enum"] : undefined;
+  if (enumValues !== undefined && !enumValues.some((entry) => Object.is(entry, value))) {
+    errors.push(error(path, "Value does not match enum", "ENUM"));
+  }
+  if ("type" in schema) {
+    errors.push(error(path, "Value does not match type", "TYPE"));
+  }
+  return errors;
+}
+function collectNestedErrors(context, schema, value, root, path) {
+  const errors = [];
+  if (Array.isArray(value)) {
+    const items = IsSchema(schema["items"]) ? schema["items"] : undefined;
+    if (items !== undefined) {
+      value.forEach((entry, index) => {
+        errors.push(...CollectSchemaErrors(context, items, entry, root, `${path}/${index}`));
+      });
+    }
+  }
+  if (IsPlainObject(value)) {
+    const properties = IsObject(schema["properties"]) ? schema["properties"] : undefined;
+    if (properties !== undefined) {
+      for (const [key, propertySchema] of Entries(properties)) {
+        if (IsSchema(propertySchema) && key in value) {
+          errors.push(...CollectSchemaErrors(context, propertySchema, value[key], root, `${path}/${key}`));
+        }
+      }
+    }
+  }
+  return errors;
+}
+function collectCompositionErrors(schema, path) {
+  const errors = [];
+  if (Array.isArray(schema["allOf"])) {
+    errors.push(error(path, "Value failed allOf", "ALL_OF"));
+  }
+  if (Array.isArray(schema["anyOf"])) {
+    errors.push(error(path, "Value failed anyOf", "ANY_OF"));
+  }
+  if (Array.isArray(schema["oneOf"])) {
+    errors.push(error(path, "Value failed oneOf", "ONE_OF"));
+  }
+  return errors;
+}
+function collectExtensionErrors(context, schema, value, root, path) {
+  const errors = [];
+  const notSchema = IsSchema(schema["not"]) ? schema["not"] : undefined;
+  if (notSchema !== undefined && CheckSchemaValue(context, notSchema, value, root)) {
+    errors.push(error(path, "Value matched a negated schema", "NOT"));
+  }
+  const guard = IsObject(schema["~guard"]) ? schema["~guard"] : undefined;
+  if (guard !== undefined && typeof guard["check"] === "function" && !guard["check"](value)) {
+    errors.push(error(path, "Guard validation failed", "GUARD"));
+  }
+  const refine = Array.isArray(schema["~refine"]) ? schema["~refine"] : undefined;
+  if (refine !== undefined) {
+    refine.forEach((entry, index) => {
+      if (IsObject(entry) && typeof entry["refine"] === "function" && !entry["refine"](value)) {
+        const message = typeof entry["message"] === "string" ? entry["message"] : `Refinement ${index} failed`;
+        errors.push(error(path, message, "REFINE"));
+      }
+    });
+  }
+  return errors;
+}
+function CollectSchemaErrors(context, schema, value, root = schema, path = "/") {
+  if (CheckSchemaValue(context, schema, value, root)) {
+    return [];
+  }
+  if (typeof schema === "boolean") {
+    return [error(path, "Boolean schema rejected the value", "BOOLEAN_SCHEMA")];
+  }
+  const referenceErrors = collectReferenceErrors(context, schema, value, root, path);
+  if (referenceErrors !== undefined) {
+    return referenceErrors;
+  }
+  const errors = [
+    ...collectPrimitiveErrors(schema, value, path),
+    ...collectNestedErrors(context, schema, value, root, path),
+    ...collectCompositionErrors(schema, path),
+    ...collectExtensionErrors(context, schema, value, root, path)
+  ];
+  return errors.length > 0 ? errors : [error(path, "Schema validation failed", "SCHEMA")];
+}
+
+// src/schema/runtime-keywords.ts
+function buildFromKeys(keys, defaults = {}) {
+  return (_stack, _context, schema, _value) => JSON.stringify(ProjectSchema(schema, keys, defaults));
+}
+function checkFromKeys(keys, defaults = {}) {
+  return (_stack, _context, schema, value) => CheckSchemaValue({}, ProjectSchema(schema, keys, defaults), value);
+}
+function errorFromKeys(keyword, check) {
+  return (stack, context, schemaPath, instancePath, schema, value) => {
+    if (check(stack, new CheckContext, schema, value)) {
+      return true;
+    }
+    const projectedErrors = CollectSchemaErrors({}, schema, value);
+    projectedErrors.forEach((error2) => {
+      context.AddError({ keyword, schemaPath, instancePath, params: error2 });
+    });
+    return false;
+  };
+}
+var CanAdditionalPropertiesFast = (schema) => typeof schema !== "boolean";
+var BuildBooleanSchema = buildFromKeys([]);
+var BuildConst = buildFromKeys(["const"]);
+var BuildEnum = buildFromKeys(["enum"]);
+var BuildType = buildFromKeys(["type"]);
+var BuildMinLength = buildFromKeys(["type", "minLength"], { type: "string" });
+var BuildMaxLength = buildFromKeys(["type", "maxLength"], { type: "string" });
+var BuildPattern = buildFromKeys(["type", "pattern"], { type: "string" });
+var BuildFormat = buildFromKeys(["type", "format"], { type: "string" });
+var BuildMinimum = buildFromKeys(["type", "minimum"], { type: "number" });
+var BuildMaximum = buildFromKeys(["type", "maximum"], { type: "number" });
+var BuildExclusiveMinimum = buildFromKeys(["type", "exclusiveMinimum"], { type: "number" });
+var BuildExclusiveMaximum = buildFromKeys(["type", "exclusiveMaximum"], { type: "number" });
+var BuildMultipleOf = buildFromKeys(["type", "multipleOf"], { type: "number" });
+var BuildMinItems = buildFromKeys(["type", "minItems"], { type: "array" });
+var BuildMaxItems = buildFromKeys(["type", "maxItems"], { type: "array" });
+var BuildUniqueItems = buildFromKeys(["type", "uniqueItems"], { type: "array" });
+var BuildItems = buildFromKeys(["type", "items", "prefixItems"], { type: "array" });
+var BuildPrefixItems = buildFromKeys(["type", "prefixItems"], { type: "array" });
+var BuildAdditionalItems = buildFromKeys(["type", "prefixItems", "items", "additionalItems"], { type: "array" });
+var BuildUnevaluatedItems = buildFromKeys(["type", "prefixItems", "items", "unevaluatedItems"], { type: "array" });
+var BuildContains = buildFromKeys(["type", "contains"], { type: "array" });
+var BuildMinContains = buildFromKeys(["type", "contains", "minContains"], { type: "array" });
+var BuildMaxContains = buildFromKeys(["type", "contains", "maxContains"], { type: "array" });
+var BuildMinProperties = buildFromKeys(["type", "minProperties"], { type: "object" });
+var BuildMaxProperties = buildFromKeys(["type", "maxProperties"], { type: "object" });
+var BuildRequired = buildFromKeys(["type", "properties", "required"], { type: "object" });
+var BuildProperties = buildFromKeys(["type", "properties", "required"], { type: "object" });
+var BuildPatternProperties = buildFromKeys(["type", "patternProperties"], { type: "object" });
+var BuildAdditionalProperties = buildFromKeys(["type", "properties", "patternProperties", "additionalProperties"], { type: "object" });
+var BuildAdditionalPropertiesFast = BuildAdditionalProperties;
+var BuildAdditionalPropertiesStandard = BuildAdditionalProperties;
+var BuildUnevaluatedProperties = buildFromKeys(["type", "properties", "patternProperties", "unevaluatedProperties"], { type: "object" });
+var BuildPropertyNames = buildFromKeys(["type", "propertyNames"], { type: "object" });
+var BuildDependencies = buildFromKeys(["type", "dependencies"], { type: "object" });
+var BuildDependentRequired = buildFromKeys(["type", "dependentRequired"], { type: "object" });
+var BuildDependentSchemas = buildFromKeys(["type", "dependentSchemas"], { type: "object" });
+var BuildAllOf = buildFromKeys(["allOf"]);
+var BuildAnyOf = buildFromKeys(["anyOf"]);
+var BuildOneOf = buildFromKeys(["oneOf"]);
+var BuildNot = buildFromKeys(["not"]);
+var BuildIf = buildFromKeys(["if", "then", "else"]);
+var BuildRef = buildFromKeys(["$ref"]);
+var BuildRecursiveRef = buildFromKeys(["$recursiveRef"]);
+var BuildSchema = (_stack, _context, schema, _value) => JSON.stringify(schema);
+var CheckBooleanSchema = (_stack, _context, schema, value) => CheckSchemaValue({}, schema, value);
+var CheckConst = checkFromKeys(["const"]);
+var CheckEnum = checkFromKeys(["enum"]);
+var CheckType = checkFromKeys(["type"]);
+var CheckMinLength = checkFromKeys(["type", "minLength"], { type: "string" });
+var CheckMaxLength = checkFromKeys(["type", "maxLength"], { type: "string" });
+var CheckPattern = checkFromKeys(["type", "pattern"], { type: "string" });
+var CheckFormat = checkFromKeys(["type", "format"], { type: "string" });
+var CheckMinimum = checkFromKeys(["type", "minimum"], { type: "number" });
+var CheckMaximum = checkFromKeys(["type", "maximum"], { type: "number" });
+var CheckExclusiveMinimum = checkFromKeys(["type", "exclusiveMinimum"], { type: "number" });
+var CheckExclusiveMaximum = checkFromKeys(["type", "exclusiveMaximum"], { type: "number" });
+var CheckMultipleOf = checkFromKeys(["type", "multipleOf"], { type: "number" });
+var CheckMinItems = checkFromKeys(["type", "minItems"], { type: "array" });
+var CheckMaxItems = checkFromKeys(["type", "maxItems"], { type: "array" });
+var CheckUniqueItems = checkFromKeys(["type", "uniqueItems"], { type: "array" });
+var CheckItems = checkFromKeys(["type", "items", "prefixItems"], { type: "array" });
+var CheckPrefixItems = checkFromKeys(["type", "prefixItems"], { type: "array" });
+var CheckAdditionalItems = checkFromKeys(["type", "prefixItems", "items", "additionalItems"], { type: "array" });
+var CheckUnevaluatedItems = checkFromKeys(["type", "prefixItems", "items", "unevaluatedItems"], { type: "array" });
+var CheckContains = checkFromKeys(["type", "contains"], { type: "array" });
+var CheckMinContains = checkFromKeys(["type", "contains", "minContains"], { type: "array" });
+var CheckMaxContains = checkFromKeys(["type", "contains", "maxContains"], { type: "array" });
+var CheckMinProperties = checkFromKeys(["type", "minProperties"], { type: "object" });
+var CheckMaxProperties = checkFromKeys(["type", "maxProperties"], { type: "object" });
+var CheckRequired = checkFromKeys(["type", "properties", "required"], { type: "object" });
+var CheckProperties = checkFromKeys(["type", "properties", "required"], { type: "object" });
+var CheckPatternProperties = checkFromKeys(["type", "patternProperties"], { type: "object" });
+var CheckAdditionalProperties = checkFromKeys(["type", "properties", "patternProperties", "additionalProperties"], { type: "object" });
+var CheckUnevaluatedProperties = checkFromKeys(["type", "properties", "patternProperties", "unevaluatedProperties"], { type: "object" });
+var CheckPropertyNames = checkFromKeys(["type", "propertyNames"], { type: "object" });
+var CheckDependencies = checkFromKeys(["type", "dependencies"], { type: "object" });
+var CheckDependentRequired = checkFromKeys(["type", "dependentRequired"], { type: "object" });
+var CheckDependentSchemas = checkFromKeys(["type", "dependentSchemas"], { type: "object" });
+var CheckAllOf = checkFromKeys(["allOf"]);
+var CheckAnyOf = checkFromKeys(["anyOf"]);
+var CheckOneOf = checkFromKeys(["oneOf"]);
+var CheckNot = checkFromKeys(["not"]);
+var CheckIf = checkFromKeys(["if", "then", "else"]);
+var CheckRef = (_stack, _context, schema, value) => CheckSchemaValue({}, schema, value);
+var CheckRecursiveRef = CheckRef;
+var CheckSchema = (_stack, _context, schema, value) => CheckSchemaValue({}, schema, value);
+var ErrorBooleanSchema = errorFromKeys("type", CheckBooleanSchema);
+var ErrorConst = errorFromKeys("const", CheckConst);
+var ErrorEnum = errorFromKeys("enum", CheckEnum);
+var ErrorType = errorFromKeys("type", CheckType);
+var ErrorMinLength = errorFromKeys("minLength", CheckMinLength);
+var ErrorMaxLength = errorFromKeys("maxLength", CheckMaxLength);
+var ErrorPattern = errorFromKeys("pattern", CheckPattern);
+var ErrorFormat = errorFromKeys("format", CheckFormat);
+var ErrorMinimum = errorFromKeys("minimum", CheckMinimum);
+var ErrorMaximum = errorFromKeys("maximum", CheckMaximum);
+var ErrorExclusiveMinimum = errorFromKeys("exclusiveMinimum", CheckExclusiveMinimum);
+var ErrorExclusiveMaximum = errorFromKeys("exclusiveMaximum", CheckExclusiveMaximum);
+var ErrorMultipleOf = errorFromKeys("multipleOf", CheckMultipleOf);
+var ErrorMinItems = errorFromKeys("minItems", CheckMinItems);
+var ErrorMaxItems = errorFromKeys("maxItems", CheckMaxItems);
+var ErrorUniqueItems = errorFromKeys("uniqueItems", CheckUniqueItems);
+var ErrorItems = errorFromKeys("items", CheckItems);
+var ErrorPrefixItems = errorFromKeys("prefixItems", CheckPrefixItems);
+var ErrorAdditionalItems = errorFromKeys("additionalItems", CheckAdditionalItems);
+var ErrorUnevaluatedItems = errorFromKeys("unevaluatedItems", CheckUnevaluatedItems);
+var ErrorContains = errorFromKeys("contains", CheckContains);
+var ErrorMinContains = errorFromKeys("minContains", CheckMinContains);
+var ErrorMaxContains = errorFromKeys("maxContains", CheckMaxContains);
+var ErrorMinProperties = errorFromKeys("minProperties", CheckMinProperties);
+var ErrorMaxProperties = errorFromKeys("maxProperties", CheckMaxProperties);
+var ErrorRequired = errorFromKeys("required", CheckRequired);
+var ErrorProperties = errorFromKeys("properties", CheckProperties);
+var ErrorPatternProperties = errorFromKeys("patternProperties", CheckPatternProperties);
+var ErrorAdditionalProperties = errorFromKeys("additionalProperties", CheckAdditionalProperties);
+var ErrorUnevaluatedProperties = errorFromKeys("unevaluatedProperties", CheckUnevaluatedProperties);
+var ErrorPropertyNames = errorFromKeys("propertyNames", CheckPropertyNames);
+var ErrorDependencies = errorFromKeys("dependencies", CheckDependencies);
+var ErrorDependentRequired = errorFromKeys("dependentRequired", CheckDependentRequired);
+var ErrorDependentSchemas = errorFromKeys("dependentSchemas", CheckDependentSchemas);
+var ErrorAllOf = errorFromKeys("allOf", CheckAllOf);
+var ErrorAnyOf = errorFromKeys("anyOf", CheckAnyOf);
+var ErrorOneOf = errorFromKeys("oneOf", CheckOneOf);
+var ErrorNot = errorFromKeys("not", CheckNot);
+var ErrorIf = errorFromKeys("if", CheckIf);
+var ErrorRef = errorFromKeys("$ref", CheckRef);
+var ErrorRecursiveRef = errorFromKeys("$recursiveRef", CheckRecursiveRef);
+var ErrorSchema = errorFromKeys("schema", CheckSchema);
+// src/schema/check.ts
+function Check(...args) {
+  const [context, schema, value] = NormalizeArgs(args);
+  return CheckSchemaValue(context, schema, value);
+}
+
+// src/schema/build.ts
+class BuildResult {
+  context;
+  schema;
+  external;
+  functions;
+  call;
+  useUnevaluated;
+  constructor(context, schema, external, functions2, call, useUnevaluated) {
+    this.context = context;
+    this.schema = schema;
+    this.external = external;
+    this.functions = functions2;
+    this.call = call;
+    this.useUnevaluated = useUnevaluated;
+  }
+  Context() {
+    return this.context;
+  }
+  Schema() {
+    return this.schema;
+  }
+  UseUnevaluated() {
+    return this.useUnevaluated;
+  }
+  External() {
+    return this.external;
+  }
+  Functions() {
+    return this.functions;
+  }
+  Call() {
+    return this.call;
+  }
+  Evaluate() {
+    return {
+      IsAccelerated: true,
+      Code: this.functions.join(`
+`),
+      Check: (value) => Check(this.context, this.schema, value)
+    };
+  }
+}
+function Build(...args) {
+  const context = args.length === 1 ? {} : args[0];
+  const schema = args.length === 1 ? args[0] : args[1];
+  ResetExternal();
+  ResetFunctions();
+  const useUnevaluated = HasUnevaluated(context, schema);
+  const stack = new Stack(context, schema);
+  const buildContext = new BuildContext(useUnevaluated);
+  const call = CreateFunction(stack, buildContext, schema, "value");
+  return new BuildResult(context, schema, GetExternal(), GetFunctions(), call, useUnevaluated);
+}
+// src/schema/errors.ts
+function Errors(...args) {
+  const [context, schema, value] = NormalizeArgs(args);
+  const errors = CollectSchemaErrors(context, schema, value);
+  return [errors.length === 0, errors];
+}
+
+// src/schema/parse.ts
+class ParseError extends Error {
+  schema;
+  value;
+  errors;
+  constructor(schema, value, errors) {
+    super(`Parse failed with ${errors.length} error(s)`);
+    this.schema = schema;
+    this.value = value;
+    this.errors = errors;
+    this.name = "ParseError";
+  }
+}
+function TryParse(...args) {
+  const [context, schema, value] = NormalizeArgs(args);
+  const [result, errors] = Errors(context, schema, value);
+  if (result) {
+    return {
+      success: true,
+      value
+    };
+  }
+  return {
+    success: false,
+    errors
+  };
+}
+function Parse(...args) {
+  const [context, schema, value] = NormalizeArgs(args);
+  const result = TryParse(context, schema, value);
+  if (!result.success) {
+    throw new ParseError(schema, value, result.errors);
+  }
+  return result.value;
+}
+
+// src/schema/compile.ts
+class Validator {
+  build;
+  result;
+  constructor(context, schema) {
+    this.build = Build(context, schema);
+    this.result = this.build.Evaluate();
+  }
+  IsAccelerated() {
+    return this.result.IsAccelerated;
+  }
+  Schema() {
+    return this.build.Schema();
+  }
+  Check(value) {
+    return this.result.Check(value);
+  }
+  Parse(value) {
+    return Parse(this.build.Context(), this.build.Schema(), value);
+  }
+  TryParse(value) {
+    return TryParse(this.build.Context(), this.build.Schema(), value);
+  }
+  Errors(value) {
+    return Errors(this.build.Context(), this.build.Schema(), value);
+  }
+}
+function Compile(...args) {
+  const context = args.length === 1 ? {} : args[0];
+  const schema = args.length === 1 ? args[0] : args[1];
+  return new Validator(context, schema);
+}
+// src/shared/schema-access.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isSchemaValue(value) {
+  return isRecord(value) && typeof value["~kind"] === "string";
+}
+function schemaNode(schema) {
+  return schema;
+}
+function schemaKind(schema) {
+  const kind = schemaNode(schema)["~kind"];
+  return typeof kind === "string" ? kind : undefined;
+}
+function schemaUnknownField(schema, field) {
+  return schemaNode(schema)[field];
+}
+function schemaStringField(schema, field) {
+  const value = schemaUnknownField(schema, field);
+  return typeof value === "string" ? value : undefined;
+}
+function schemaNumberField(schema, field) {
+  const value = schemaUnknownField(schema, field);
+  return typeof value === "number" ? value : undefined;
+}
+function schemaBigIntField(schema, field) {
+  const value = schemaUnknownField(schema, field);
+  return typeof value === "bigint" ? value : undefined;
+}
+function schemaBooleanField(schema, field) {
+  const value = schemaUnknownField(schema, field);
+  return typeof value === "boolean" ? value : undefined;
+}
+function schemaStringListField(schema, field) {
+  const value = schemaUnknownField(schema, field);
+  return Array.isArray(value) && value.every((entry) => typeof entry === "string") ? value : [];
+}
+function schemaSchemaField(schema, field) {
+  const value = schemaUnknownField(schema, field);
+  return isSchemaValue(value) ? value : undefined;
+}
+function schemaSchemaListField(schema, field) {
+  const value = schemaUnknownField(schema, field);
+  return Array.isArray(value) && value.every(isSchemaValue) ? value : [];
+}
+function schemaSchemaMapField(schema, field) {
+  const value = schemaUnknownField(schema, field);
+  if (!isRecord(value)) {
+    return {};
+  }
+  return Object.values(value).every(isSchemaValue) ? value : {};
+}
+function schemaBooleanOrSchemaField(schema, field) {
+  const value = schemaUnknownField(schema, field);
+  if (typeof value === "boolean" || value === undefined) {
+    return value;
+  }
+  return isSchemaValue(value) ? value : undefined;
+}
+function schemaCallbackField(schema, field) {
+  const value = schemaUnknownField(schema, field);
+  return typeof value === "function" ? value : undefined;
+}
+function schemaItem(schema) {
+  return schemaSchemaField(schema, "item");
+}
+function schemaInner(schema) {
+  return schemaSchemaField(schema, "inner");
+}
+function schemaItemOrInner(schema) {
+  return schemaItem(schema) ?? schemaInner(schema);
+}
+function schemaVariants(schema) {
+  return schemaSchemaListField(schema, "variants");
+}
+function schemaProperties(schema) {
+  return schemaSchemaMapField(schema, "properties");
+}
+function schemaDefinitions(schema) {
+  return schemaSchemaMapField(schema, "$defs");
+}
+function schemaPatternProperties(schema) {
+  return schemaSchemaMapField(schema, "patternProperties");
+}
+function schemaRequiredKeys(schema) {
+  return schemaStringListField(schema, "required");
+}
+function schemaOptionalKeys(schema) {
+  return schemaStringListField(schema, "optional");
+}
+function schemaConst(schema) {
+  return schemaUnknownField(schema, "const");
+}
+function schemaPatterns(schema) {
+  return schemaStringListField(schema, "patterns");
+}
+function schemaRefinements(schema) {
+  const value = schemaUnknownField(schema, "~refine");
+  return Array.isArray(value) ? value.filter((entry) => isRecord(entry) && typeof entry.refine === "function" && (entry.message === undefined || typeof entry.message === "string")) : [];
+}
+function schemaPath(path) {
+  return path.join(".") || "/";
+}
+
+// src/schema/emitter-base.ts
+function stringSchema(schema) {
+  const result = { type: "string" };
+  if (schema.minLength !== undefined)
+    result["minLength"] = schema.minLength;
+  if (schema.maxLength !== undefined)
+    result["maxLength"] = schema.maxLength;
+  if (schema.pattern !== undefined)
+    result["pattern"] = schema.pattern;
+  if (schema.format !== undefined && KNOWN_FORMATS.has(schema.format))
+    result["format"] = schema.format;
+  return result;
+}
+function objectLikeSchema(object, refs, options, emit) {
+  const properties = {};
+  const required = [];
+  const propertySchemas = schemaProperties(object);
+  for (const [key, propSchema] of Object.entries(propertySchemas)) {
+    properties[key] = emit(propSchema, refs, options);
+  }
+  const optional = new Set(schemaOptionalKeys(object).map(String));
+  for (const key of schemaRequiredKeys(object)) {
+    if (key in propertySchemas && !optional.has(String(key))) {
+      required.push(String(key));
+    }
+  }
+  const patternProperties = schemaPatternProperties(object);
+  const additionalProperties = schemaBooleanOrSchemaField(object, "additionalProperties");
+  return {
+    type: "object",
+    properties,
+    ...required.length > 0 ? { required } : {},
+    ...schemaUnknownField(object, "optional") !== undefined ? { $comment: "Optional keys are represented by omission from required in emitted JSON Schema." } : {},
+    ...Object.keys(patternProperties).length > 0 ? {
+      patternProperties: Object.fromEntries(Object.entries(patternProperties).map(([pattern, patternSchema]) => [pattern, emit(patternSchema, refs, options)]))
+    } : {},
+    ...additionalProperties === false ? { additionalProperties: false } : additionalProperties === true ? { additionalProperties: true } : additionalProperties !== undefined ? { additionalProperties: emit(additionalProperties, refs, options) } : {}
+  };
+}
+function numberSchema(schema) {
+  const result = { type: "number" };
+  if (schema.minimum !== undefined)
+    result["minimum"] = schema.minimum;
+  if (schema.maximum !== undefined)
+    result["maximum"] = schema.maximum;
+  if (schema.exclusiveMinimum !== undefined)
+    result["exclusiveMinimum"] = schema.exclusiveMinimum;
+  if (schema.exclusiveMaximum !== undefined)
+    result["exclusiveMaximum"] = schema.exclusiveMaximum;
+  if (schema.multipleOf !== undefined)
+    result["multipleOf"] = schema.multipleOf;
+  return result;
+}
+function integerSchema(schema) {
+  const result = { type: "integer" };
+  if (schema.minimum !== undefined)
+    result["minimum"] = schema.minimum;
+  if (schema.maximum !== undefined)
+    result["maximum"] = schema.maximum;
+  if (schema.exclusiveMinimum !== undefined)
+    result["exclusiveMinimum"] = schema.exclusiveMinimum;
+  if (schema.exclusiveMaximum !== undefined)
+    result["exclusiveMaximum"] = schema.exclusiveMaximum;
+  if (schema.multipleOf !== undefined)
+    result["multipleOf"] = schema.multipleOf;
+  return result;
+}
+
+// src/schema/emitter-derived.ts
+function emitDerivedSchema(kind, schema, refs, options, opt, emit) {
+  switch (kind) {
+    case "Exclude": {
+      const excluded = schema;
+      return opt({ allOf: [emit(excluded.left, refs, options), { not: emit(excluded.right, refs, options) }] });
+    }
+    case "Extract": {
+      const extracted = schema;
+      return opt({ allOf: [emit(extracted.left, refs, options), emit(extracted.right, refs, options)] });
+    }
+    case "Partial": {
+      const partial = schema;
+      const derived = deriveObjectSchema(partial.object, { requiredMode: "none" });
+      return opt(objectLikeSchema(derived, refs, options, emit));
+    }
+    case "Required": {
+      const required = schema;
+      const derived = deriveObjectSchema(required.object, { requiredMode: "all" });
+      return opt(objectLikeSchema(derived, refs, options, emit));
+    }
+    case "Pick": {
+      const picked = schema;
+      const derived = deriveObjectSchema(picked.object, { pickKeys: picked.keys.map(String), additionalProperties: false });
+      return opt(objectLikeSchema(derived, refs, options, emit));
+    }
+    case "Omit": {
+      const omitted = schema;
+      const derived = deriveObjectSchema(omitted.object, { omitKeys: omitted.keys.map(String), additionalProperties: false });
+      return opt(objectLikeSchema(derived, refs, options, emit));
+    }
+    case "KeyOf":
+      return opt({ type: "string", enum: Object.keys(schema.object.properties) });
+    case "Not":
+      return opt({ not: emit(schema.schema, refs, options) });
+    case "IfThenElse": {
+      const conditional = schema;
+      return opt({
+        if: emit(conditional.if, refs, options),
+        then: emit(conditional.then, refs, options),
+        ...conditional.else ? { else: emit(conditional.else, refs, options) } : {}
+      });
+    }
+    case "Conditional": {
+      const conditional = schema;
+      const elseBranch = conditional.default ? emit(conditional.default, refs, options) : undefined;
+      return opt({
+        if: emit(conditional.check, refs, options),
+        then: conditional.union.length > 0 ? { anyOf: conditional.union.map((entry) => emit(entry, refs, options)) } : {},
+        ...elseBranch !== undefined && Object.keys(elseBranch).length > 0 ? { else: elseBranch } : {}
+      });
+    }
+    case "Index": {
+      const index = schema;
+      const candidates = deriveIndexSchemasForEmission(index.object, index.key);
+      if (candidates.length === 0)
+        return opt({ not: {} });
+      if (candidates.length === 1 && candidates[0] !== undefined)
+        return emit(candidates[0], refs, options);
+      return opt({ anyOf: candidates.map((candidate) => emit(candidate, refs, options)) });
+    }
+    case "Mapped":
+      return opt(objectLikeSchema(schema.object, refs, options, emit));
+    default:
+      return;
+  }
+}
+
+// src/type/instantiation.ts
+function getString(value) {
+  return typeof value === "string" ? value : undefined;
+}
+function getSchema(value) {
+  if (typeof value !== "object" || value === null) {
+    return;
+  }
+  return typeof value["~kind"] === "string" ? value : undefined;
+}
+function getSchemaArray(value) {
+  return Array.isArray(value) ? value.flatMap((entry) => getSchema(entry) ? [entry] : []) : [];
+}
+function getParameterSchema(schema) {
+  const value = schema;
+  return {
+    name: getString(value["name"]) ?? "",
+    equals: getSchema(value["equals"]) ?? schema
+  };
+}
+function getInferSchema(schema) {
+  const value = schema;
+  return {
+    name: getString(value["name"]) ?? "",
+    extends: getSchema(value["extends"]) ?? schema
+  };
+}
+function getGenericSchema(schema) {
+  const value = schema;
+  const parameters = Array.isArray(value["parameters"]) ? value["parameters"].flatMap((entry) => {
+    if (typeof entry !== "object" || entry === null)
+      return [];
+    const candidate = entry;
+    return candidate["~kind"] === "Parameter" ? [entry] : [];
+  }) : [];
+  return {
+    parameters,
+    expression: getSchema(value["expression"]) ?? schema
+  };
+}
+function getCallSchema(schema) {
+  const value = schema;
+  return {
+    target: getSchema(value["target"]) ?? schema,
+    arguments: getSchemaArray(value["arguments"])
+  };
+}
+function getCyclicSchema(schema) {
+  const value = schema;
+  const defsSource = value["$defs"];
+  const defs = typeof defsSource === "object" && defsSource !== null ? Object.fromEntries(Object.entries(defsSource).flatMap(([key, entry]) => {
+    const nextSchema = getSchema(entry);
+    return nextSchema ? [[key, nextSchema]] : [];
+  })) : {};
+  return {
+    $defs: defs,
+    $ref: getString(value["$ref"]) ?? ""
+  };
+}
+function bindParameterContext(parameters, arguments_) {
+  const context = {};
+  for (let index = 0;index < parameters.length; index += 1) {
+    const parameter = parameters[index];
+    const name = parameter.name;
+    const argument = arguments_[index] ?? parameter.equals;
+    context[name] = argument;
+  }
+  return context;
+}
+function getObjectSchema(schema) {
+  const value = schema;
+  const propertiesSource = value["properties"];
+  const patternPropertiesSource = value["patternProperties"];
+  const requiredSource = value["required"];
+  const optionalSource = value["optional"];
+  return {
+    ...schema,
+    "~kind": "Object",
+    properties: typeof propertiesSource === "object" && propertiesSource !== null ? propertiesSource : {},
+    ...typeof patternPropertiesSource === "object" && patternPropertiesSource !== null ? { patternProperties: patternPropertiesSource } : {},
+    ...Array.isArray(requiredSource) ? { required: requiredSource.filter((entry) => typeof entry === "string") } : {},
+    ...Array.isArray(optionalSource) ? { optional: optionalSource.filter((entry) => typeof entry === "string") } : {}
+  };
+}
+function instantiateObject(context, schema) {
+  const objectSchema = getObjectSchema(schema);
+  const properties = {};
+  for (const [key, value] of Object.entries(objectSchema.properties)) {
+    properties[key] = Instantiate(context, value);
+  }
+  const patternProperties = objectSchema.patternProperties === undefined ? undefined : Object.fromEntries(Object.entries(objectSchema.patternProperties).map(([key, value]) => [key, Instantiate(context, value)]));
+  return {
+    ...objectSchema,
+    properties,
+    ...patternProperties !== undefined ? { patternProperties } : {},
+    ...typeof objectSchema.additionalProperties === "object" && objectSchema.additionalProperties !== null ? { additionalProperties: Instantiate(context, objectSchema.additionalProperties) } : {}
+  };
+}
+function Instantiate(context, schema) {
+  const value = schema;
+  const kind = value["~kind"];
+  switch (kind) {
+    case "Parameter": {
+      const parameter = getParameterSchema(schema);
+      return context[parameter.name] ?? parameter.equals;
+    }
+    case "Infer": {
+      const infer = getInferSchema(schema);
+      return context[infer.name] ?? infer.extends;
+    }
+    case "This":
+      return schema;
+    case "Ref": {
+      const name = value["name"];
+      return typeof name === "string" && context[name] !== undefined ? context[name] : schema;
+    }
+    case "Array":
+      return { ...schema, items: Instantiate(context, value["items"]) };
+    case "Object":
+      return instantiateObject(context, schema);
+    case "Tuple":
+      return { ...schema, items: value["items"].map((item) => Instantiate(context, item)) };
+    case "Record":
+      return {
+        ...schema,
+        key: Instantiate(context, value["key"]),
+        value: Instantiate(context, value["value"])
+      };
+    case "Union":
+    case "Intersect":
+      return { ...schema, variants: value["variants"].map((item) => Instantiate(context, item)) };
+    case "Optional":
+    case "Readonly":
+    case "Capitalize":
+    case "Lowercase":
+    case "Uppercase":
+    case "Uncapitalize":
+    case "Awaited":
+      return { ...schema, item: Instantiate(context, value["item"]) };
+    case "Immutable":
+    case "Refine":
+      return { ...schema, item: Instantiate(context, value["item"]) };
+    case "Codec":
+      return { ...schema, inner: Instantiate(context, value["inner"]) };
+    case "Exclude":
+    case "Extract":
+      return {
+        ...schema,
+        left: Instantiate(context, value["left"]),
+        right: Instantiate(context, value["right"])
+      };
+    case "Not":
+      return { ...schema, schema: Instantiate(context, value["schema"]) };
+    case "IfThenElse":
+      return {
+        ...schema,
+        if: Instantiate(context, value["if"]),
+        then: Instantiate(context, value["then"]),
+        else: Instantiate(context, value["else"])
+      };
+    case "Index":
+      return {
+        ...schema,
+        object: Instantiate(context, value["object"]),
+        key: Instantiate(context, value["key"])
+      };
+    case "Mapped":
+      return { ...schema, object: Instantiate(context, value["object"]) };
+    case "Conditional":
+      return {
+        ...schema,
+        check: Instantiate(context, value["check"]),
+        union: value["union"].map((item) => Instantiate(context, item)),
+        ...value["default"] !== undefined ? { default: Instantiate(context, value["default"]) } : {}
+      };
+    case "Function":
+    case "Constructor":
+      return {
+        ...schema,
+        parameters: value["parameters"].map((item) => Instantiate(context, item)),
+        returns: Instantiate(context, value["returns"])
+      };
+    case "Promise":
+    case "Iterator":
+    case "AsyncIterator":
+    case "Rest":
+      return { ...schema, item: Instantiate(context, value["item"]), items: Instantiate(context, value["items"] ?? value["item"]) };
+    case "Decode":
+      return { ...schema, inner: Instantiate(context, value["inner"]) };
+    case "Encode":
+      return { ...schema, inner: Instantiate(context, value["inner"]) };
+    case "ReturnType":
+    case "Parameters":
+      return { ...schema, function: Instantiate(context, value["function"]) };
+    case "InstanceType":
+    case "ConstructorParameters":
+      return { ...schema, constructor: Instantiate(context, value["constructor"]) };
+    case "Generic": {
+      const generic = getGenericSchema(schema);
+      return {
+        ...generic,
+        parameters: generic.parameters,
+        expression: Instantiate(context, generic.expression)
+      };
+    }
+    case "Call": {
+      const call = getCallSchema(schema);
+      const target = Instantiate(context, call.target);
+      const arguments_ = call.arguments.map((item) => Instantiate(context, item));
+      const targetValue = target;
+      if (targetValue["~kind"] === "Generic") {
+        const generic = getGenericSchema(target);
+        const nextContext = bindParameterContext(generic.parameters, arguments_);
+        return Instantiate({ ...context, ...nextContext }, generic.expression);
+      }
+      return {
+        "~kind": "Call",
+        target,
+        arguments: arguments_
+      };
+    }
+    case "Cyclic": {
+      const cyclic = getCyclicSchema(schema);
+      const defs = Object.fromEntries(Object.entries(cyclic.$defs).map(([key, value2]) => [key, Instantiate(context, value2)]));
+      return {
+        ...cyclic,
+        $defs: defs
+      };
+    }
+    default:
+      return schema;
+  }
+}
+
+// src/schema/emitter-reference.ts
+function emitReferenceSchema(kind, schema, refs, options, opt, emit) {
+  switch (kind) {
+    case "Recursive": {
+      const recursive = schema;
+      refs.set(recursive.name, recursive.schema);
+      return { $ref: `#/definitions/${recursive.name}` };
+    }
+    case "Cyclic": {
+      const definitions = schemaSchemaMapField(schema, "$defs");
+      const ref = schemaStringField(schema, "$ref");
+      return {
+        $defs: Object.fromEntries(Object.entries(definitions).map(([key, value]) => [key, emit(value, refs, options)])),
+        ...ref !== undefined ? { $ref: `#/$defs/${ref}` } : {}
+      };
+    }
+    case "Ref": {
+      const refSchema = schema;
+      return refs.has(refSchema.name) ? { $ref: `#/definitions/${refSchema.name}` } : opt({ not: {}, $comment: `Unresolved ref: ${refSchema.name}` });
+    }
+    case "This":
+      return { $ref: "#" };
+    case "Generic":
+      return emit(schemaSchemaField(schema, "expression") ?? schema, refs, options);
+    case "Call": {
+      const instantiated = Instantiate({}, schema);
+      return instantiated === schema ? opt({ not: {}, $comment: "Unable to instantiate call schema." }) : emit(instantiated, refs, options);
+    }
+    case "Infer":
+      return emit(schemaSchemaField(schema, "extends") ?? schema, refs, options);
+    case "Module": {
+      const definitions = schemaSchemaMapField(schema, "definitions");
+      return opt({
+        $defs: Object.fromEntries(Object.entries(definitions).map(([name, definition]) => [name, emit(definition, refs, options)]))
+      });
+    }
+    default:
+      return;
+  }
+}
+
+// src/schema/emitter-wrapper.ts
+function emitWrapperSchema(kind, schema, refs, options, opt, emit) {
+  switch (kind) {
+    case "Rest":
+      return opt({ type: "array", items: emit(schemaItem(schema) ?? schemaSchemaField(schema, "items") ?? schema, refs, options) });
+    case "Capitalize":
+    case "Lowercase":
+    case "Uppercase":
+    case "Uncapitalize":
+      return emit(resolveStringActionSchema(schema), refs, options);
+    case "Identifier":
+      return opt({ type: "string", pattern: "^[$A-Z_a-z][$\\w]*$" });
+    case "Parameter":
+      return emit(schemaSchemaField(schema, "equals") ?? schema, refs, options);
+    case "TemplateLiteral":
+      return opt({ type: "string", pattern: schemaPatterns(schema).join("|") });
+    case "Unsafe":
+      return { ...schema.schema };
+    case "Decode":
+    case "Encode":
+      return emit(schemaItemOrInner(schema) ?? schema, refs, options);
+    case "Awaited":
+      return emit(schemaItem(schemaSchemaField(schema, "promise") ?? schema) ?? schema, refs, options);
+    case "ReturnType":
+      return emit(schemaSchemaField(schemaSchemaField(schema, "function") ?? schema, "returns") ?? schema, refs, options);
+    case "Parameters": {
+      const parameters = schemaSchemaListField(schemaSchemaField(schema, "function") ?? schema, "parameters");
+      return opt({
+        type: "array",
+        prefixItems: parameters.map((entry) => emit(entry, refs, options)),
+        minItems: parameters.length,
+        maxItems: parameters.length
+      });
+    }
+    case "InstanceType":
+      return emit(schemaSchemaField(schemaSchemaField(schema, "constructor") ?? schema, "returns") ?? schema, refs, options);
+    case "ConstructorParameters": {
+      const parameters = schemaSchemaListField(schemaSchemaField(schema, "constructor") ?? schema, "parameters");
+      return opt({
+        type: "array",
+        prefixItems: parameters.map((entry) => emit(entry, refs, options)),
+        minItems: parameters.length,
+        maxItems: parameters.length
+      });
+    }
+    case "Function":
+    case "Constructor":
+    case "Promise":
+    case "Iterator":
+    case "AsyncIterator":
+    case "Symbol":
+    case "Base":
+      return opt({});
+    default:
+      return;
+  }
+}
+
+// src/schema/emitter-advanced.ts
+function emitAdvancedSchema(kind, schema, refs, options, opt, emit) {
+  return emitReferenceSchema(kind, schema, refs, options, opt, emit) ?? emitDerivedSchema(kind, schema, refs, options, opt, emit) ?? emitWrapperSchema(kind, schema, refs, options, opt, emit);
+}
+
+// src/schema/emitter.ts
+function Schema(schema, options = {}) {
+  const refs = new Map;
+  const emitted = toJsonSchema(schema, refs, options);
+  const definitions = {};
+  for (const [name, refSchema] of refs) {
+    definitions[name] = toJsonSchema(refSchema, refs, options);
+  }
+  return { schema: emitted, definitions };
+}
+function To(schema, options = {}) {
+  return toJsonSchema(schema, new Map, options ?? {});
+}
+function applySchemaOptions(schema, options) {
+  const { descriptions = true, titles = true, defaults = true } = options;
+  return (obj, extra = {}) => {
+    const result = { ...obj, ...extra };
+    const description = schemaUnknownField(schema, "description");
+    const title = schemaUnknownField(schema, "title");
+    const defaultValue = schemaUnknownField(schema, "default");
+    if (descriptions && typeof description === "string")
+      result.description = description;
+    if (titles && typeof title === "string")
+      result.title = title;
+    if (defaults && defaultValue !== undefined)
+      result["default"] = defaultValue;
+    return result;
+  };
+}
+function emitBuiltInSchema(kind, schema, refs, options, opt, emit) {
+  switch (kind) {
+    case "String":
+      return opt(stringSchema(schema));
+    case "Uint8Array": {
+      const bytes = schema;
+      return opt({
+        type: "string",
+        contentEncoding: "base64",
+        ...bytes.minByteLength !== undefined ? { minLength: Math.ceil(bytes.minByteLength * 4 / 3) } : {},
+        ...bytes.maxByteLength !== undefined ? { maxLength: Math.ceil(bytes.maxByteLength * 4 / 3) } : {},
+        $comment: "Uint8Array runtime values are represented as base64 strings in emitted JSON Schema."
+      });
+    }
+    case "RegExpInstance":
+      return opt({ type: "object", $comment: "RegExpInstance validates actual RegExp objects; no JSON Schema equivalent." });
+    case "Number":
+      return opt(numberSchema(schema));
+    case "Integer":
+      return opt(integerSchema(schema));
+    case "Boolean":
+      return opt({ type: "boolean" });
+    case "Null":
+      return opt({ type: "null" });
+    case "BigInt":
+      return opt({ type: "string", $comment: "BigInt runtime value; no native JSON Schema equivalent." });
+    case "Date":
+      return opt({ type: "string", format: "date-time", $comment: "Date runtime instance; validated as native Date at runtime." });
+    case "Literal":
+      return opt({ const: schemaConst(schema) });
+    case "Void":
+      return opt({ type: "null", description: "void (undefined or null)" });
+    case "Undefined":
+      return opt({ not: {}, description: "undefined" });
+    case "Unknown":
+    case "Any":
+      return opt({});
+    case "Never":
+      return opt({ not: {} });
+    case "Array": {
+      const array = schema;
+      return opt({
+        type: "array",
+        items: emit(array.items, refs, options),
+        ...array.minItems !== undefined ? { minItems: array.minItems } : {},
+        ...array.maxItems !== undefined ? { maxItems: array.maxItems } : {},
+        ...array.uniqueItems ? { uniqueItems: true } : {},
+        ...array.contains !== undefined ? { contains: emit(array.contains, refs, options) } : {},
+        ...array.minContains !== undefined ? { minContains: array.minContains } : {},
+        ...array.maxContains !== undefined ? { maxContains: array.maxContains } : {}
+      });
+    }
+    case "Object":
+      return opt(objectLikeSchema(schema, refs, options, emit));
+    case "Tuple": {
+      const tuple = schema;
+      return opt({
+        type: "array",
+        prefixItems: tuple.items.map((item) => emit(item, refs, options)),
+        minItems: tuple.minItems ?? tuple.items.length,
+        ...tuple.maxItems !== undefined ? { maxItems: tuple.maxItems } : tuple.additionalItems === true ? {} : { maxItems: tuple.items.length },
+        items: tuple.additionalItems === true ? {} : false
+      });
+    }
+    case "Record": {
+      const record = schema;
+      return opt({
+        type: "object",
+        propertyNames: emit(record.key, refs, options),
+        additionalProperties: emit(record.value, refs, options),
+        ...record.minProperties !== undefined ? { minProperties: record.minProperties } : {},
+        ...record.maxProperties !== undefined ? { maxProperties: record.maxProperties } : {}
+      });
+    }
+    case "Union":
+      return opt({ anyOf: schemaVariants(schema).map((entry) => emit(entry, refs, options)) });
+    case "Intersect":
+      return opt({ allOf: schemaVariants(schema).map((entry) => emit(entry, refs, options)) });
+    case "Optional":
+      return { ...emit(schemaItem(schema) ?? schema, refs, options), $comment: "Optional wrapper accepts undefined at runtime; JSON Schema represents the defined-value branch only." };
+    case "Readonly":
+    case "Immutable":
+      return emit(schemaItem(schema) ?? schema, refs, options);
+    case "Codec":
+      return emit(schemaItemOrInner(schema) ?? schema, refs, options);
+    case "Refine": {
+      const emitted = emit(schemaItem(schema) ?? schema, refs, options);
+      const messages = schemaRefinements(schema).flatMap((entry) => entry.message === undefined ? [] : [entry.message]);
+      return { ...emitted, ...messages.length > 0 ? { $comment: messages.join("; ") } : {} };
+    }
+    case "Enum":
+      return opt({ type: "string", enum: schemaStringListField(schema, "values") });
+    default:
+      return;
+  }
+}
+function toJsonSchema(schema, refs, options) {
+  const kind = schemaUnknownField(schema, "~kind");
+  const resolvedKind = typeof kind === "string" ? kind : undefined;
+  const opt = applySchemaOptions(schema, options);
+  const emit = (nextSchema, nextRefs, nextOptions) => toJsonSchema(nextSchema, nextRefs, nextOptions);
+  return emitBuiltInSchema(resolvedKind, schema, refs, options, opt, emit) ?? emitReferenceSchema(resolvedKind, schema, refs, options, opt, emit) ?? emitWrapperSchema(resolvedKind, schema, refs, options, opt, emit) ?? emitDerivedSchema(resolvedKind, schema, refs, options, opt, emit) ?? emitAdvancedSchema(resolvedKind, schema, refs, options, opt, emit) ?? {};
+}
+// src/schema/index.ts
+var schema_default = exports_schema;
+export {
+  schema_default as default,
+  Validator,
+  TryParse,
+  To,
+  Stack,
+  Set2 as Set,
+  Schema,
+  Resolve,
+  ResetFunctions,
+  ResetExternal,
+  Ref,
+  Reducer,
+  Pointer,
+  ParseError,
+  Parse,
+  IsUniqueItems,
+  IsUnevaluatedProperties,
+  IsUnevaluatedItems,
+  IsType,
+  IsThen,
+  IsSchemaObject2 as IsSchemaObject,
+  IsSchema2 as IsSchema,
+  IsRequired,
+  IsRefine,
+  IsRef,
+  IsRecursiveRef,
+  IsRecursiveAnchorTrue,
+  IsRecursiveAnchor,
+  IsPropertyNames,
+  IsProperties,
+  IsPrefixItems,
+  IsPatternProperties,
+  IsPattern,
+  IsOneOf,
+  IsNot,
+  IsMultipleOf,
+  IsMinimum,
+  IsMinProperties,
+  IsMinLength,
+  IsMinItems,
+  IsMinContains,
+  IsMaximum,
+  IsMaxProperties,
+  IsMaxLength,
+  IsMaxItems,
+  IsMaxContains,
+  IsItemsUnsized,
+  IsItemsSized,
+  IsItems,
+  IsIf,
+  IsId,
+  IsGuardInterface,
+  IsGuard,
+  IsFormat,
+  IsExclusiveMinimum,
+  IsExclusiveMaximum,
+  IsEnum,
+  IsElse,
+  IsDynamicRef,
+  IsDynamicAnchor,
+  IsDependentSchemas,
+  IsDependentRequired,
+  IsDependencies,
+  IsDefs,
+  IsDefault,
+  IsContentMediaType,
+  IsContentEncoding,
+  IsContains,
+  IsConst,
+  IsBooleanSchema,
+  IsAnyOf,
+  IsAnchor,
+  IsAllOf,
+  IsAdditionalProperties,
+  IsAdditionalItems,
+  Indices,
+  HasUnevaluated,
+  Has,
+  GetFunctions,
+  GetExternal,
+  Get,
+  Errors,
+  ErrorUniqueItems,
+  ErrorUnevaluatedProperties,
+  ErrorUnevaluatedItems,
+  ErrorType,
+  ErrorSchema,
+  ErrorRequired,
+  ErrorRefine,
+  ErrorRef,
+  ErrorRecursiveRef,
+  ErrorPropertyNames,
+  ErrorProperties,
+  ErrorPrefixItems,
+  ErrorPatternProperties,
+  ErrorPattern,
+  ErrorOneOf,
+  ErrorNot,
+  ErrorMultipleOf,
+  ErrorMinimum,
+  ErrorMinProperties,
+  ErrorMinLength,
+  ErrorMinItems,
+  ErrorMinContains,
+  ErrorMaximum,
+  ErrorMaxProperties,
+  ErrorMaxLength,
+  ErrorMaxItems,
+  ErrorMaxContains,
+  ErrorItems,
+  ErrorIf,
+  ErrorGuard,
+  ErrorFormat,
+  ErrorExclusiveMinimum,
+  ErrorExclusiveMaximum,
+  ErrorEnum,
+  ErrorDependentSchemas,
+  ErrorDependentRequired,
+  ErrorDependencies,
+  ErrorContext,
+  ErrorContains,
+  ErrorConst,
+  ErrorBooleanSchema,
+  ErrorAnyOf,
+  ErrorAllOf,
+  ErrorAdditionalProperties,
+  ErrorAdditionalItems,
+  Delete,
+  CreateVariable,
+  CreateFunction,
+  Compile,
+  CheckUniqueItems,
+  CheckUnevaluatedProperties,
+  CheckUnevaluatedItems,
+  CheckType,
+  CheckSchema,
+  CheckRequired,
+  CheckRefine,
+  CheckRef,
+  CheckRecursiveRef,
+  CheckPropertyNames,
+  CheckProperties,
+  CheckPrefixItems,
+  CheckPatternProperties,
+  CheckPattern,
+  CheckOneOf,
+  CheckNot,
+  CheckMultipleOf,
+  CheckMinimum,
+  CheckMinProperties,
+  CheckMinLength,
+  CheckMinItems,
+  CheckMinContains,
+  CheckMaximum,
+  CheckMaxProperties,
+  CheckMaxLength,
+  CheckMaxItems,
+  CheckMaxContains,
+  CheckItems,
+  CheckIf,
+  CheckGuard,
+  CheckFormat,
+  CheckExclusiveMinimum,
+  CheckExclusiveMaximum,
+  CheckEnum,
+  CheckDependentSchemas,
+  CheckDependentRequired,
+  CheckDependencies,
+  CheckContext,
+  CheckContains,
+  CheckConst,
+  CheckBooleanSchema,
+  CheckAnyOf,
+  CheckAllOf,
+  CheckAdditionalProperties,
+  CheckAdditionalItems,
+  Check,
+  CanAdditionalPropertiesFast,
+  BuildUniqueItems,
+  BuildUnevaluatedProperties,
+  BuildUnevaluatedItems,
+  BuildType,
+  BuildSchema,
+  BuildResult,
+  BuildRequired,
+  BuildRefine,
+  BuildRef,
+  BuildRecursiveRef,
+  BuildPropertyNames,
+  BuildProperties,
+  BuildPrefixItems,
+  BuildPatternProperties,
+  BuildPattern,
+  BuildOneOf,
+  BuildNot,
+  BuildMultipleOf,
+  BuildMinimum,
+  BuildMinProperties,
+  BuildMinLength,
+  BuildMinItems,
+  BuildMinContains,
+  BuildMaximum,
+  BuildMaxProperties,
+  BuildMaxLength,
+  BuildMaxItems,
+  BuildMaxContains,
+  BuildItems,
+  BuildIf,
+  BuildGuard,
+  BuildFormat,
+  BuildExclusiveMinimum,
+  BuildExclusiveMaximum,
+  BuildEnum,
+  BuildDependentSchemas,
+  BuildDependentRequired,
+  BuildDependencies,
+  BuildContext,
+  BuildContains,
+  BuildConst,
+  BuildBooleanSchema,
+  BuildAnyOf,
+  BuildAllOf,
+  BuildAdditionalPropertiesStandard,
+  BuildAdditionalPropertiesFast,
+  BuildAdditionalProperties,
+  BuildAdditionalItems,
+  Build,
+  AccumulatedErrorContext
+};
+
+//# debugId=E15CA57717B3AABF64756E2164756E21
+//# sourceMappingURL=index.js.map