baobox 0.1.0

package/dist/shared/utils.js

@@ -0,0 +1,1321 @@
+// @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);
+  }
+};
+export {
+  validateFormat,
+  stringMatchesKeySchema,
+  resolveStringActionSchema,
+  resolveRuntimeContext,
+  luhnCheck,
+  isValidRegex,
+  isValidJson,
+  isValidISODate,
+  isPromiseLike,
+  isIteratorLike,
+  isAsyncIteratorLike,
+  getPatternPropertySchemas,
+  getDefaultRuntimeContext,
+  deriveObjectSchema,
+  deriveIndexSchemasForEmission,
+  deriveIndexSchemas,
+  checkStringConstraints,
+  checkNumberConstraints,
+  UUID_RE,
+  URI_RE,
+  TypeSystemPolicy,
+  TypeRegistry,
+  Settings,
+  RuntimeContext,
+  LocaleCodes,
+  LUHN_DIGITS_RE,
+  KNOWN_FORMATS,
+  ISO_TIME_RE,
+  ISO_DUR_RE,
+  ISO_DT_RE,
+  ISO_DATE_RE,
+  IPV6_RE,
+  IPV4_RE,
+  HOSTNAME_RE,
+  HEX_RE,
+  HEXCLR_RE,
+  FormatRegistry,
+  EMAIL_RE,
+  CreateRuntimeContext,
+  BASE64_RE
+};
+
+//# debugId=5FF09D7A1E20DD1E64756E2164756E21
+//# sourceMappingURL=utils.js.map