baobox 0.1.0

package/dist/typebox.js

@@ -0,0 +1,4767 @@
+// @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/type/combinator-core.ts
+function Union(variants, options) {
+  return { "~kind": "Union", variants, ...options };
+}
+function Intersect(variants, options) {
+  return { "~kind": "Intersect", variants, ...options };
+}
+function Evaluate(schema) {
+  if (schema["~kind"] === "Object") {
+    return schema;
+  }
+  const properties = {};
+  const required = new Set;
+  const optional = new Set;
+  const patternProperties = {};
+  let additionalProperties;
+  for (const variant of schema.variants) {
+    Object.assign(properties, variant.properties);
+    for (const key of variant.required ?? [])
+      required.add(String(key));
+    for (const key of variant.optional ?? [])
+      optional.add(String(key));
+    Object.assign(patternProperties, variant.patternProperties);
+    if (variant.additionalProperties === false) {
+      additionalProperties = false;
+    } else if (additionalProperties !== false && variant.additionalProperties !== undefined) {
+      additionalProperties = variant.additionalProperties;
+    }
+  }
+  for (const key of optional) {
+    required.delete(key);
+  }
+  return {
+    "~kind": "Object",
+    properties,
+    ...required.size > 0 ? { required: [...required] } : {},
+    ...optional.size > 0 ? { optional: [...optional] } : {},
+    ...Object.keys(patternProperties).length > 0 ? { patternProperties } : {},
+    ...additionalProperties !== undefined ? { additionalProperties } : {}
+  };
+}
+function Optional(item, options) {
+  return { "~kind": "Optional", item, ...options };
+}
+function Readonly(item, options) {
+  return { "~kind": "Readonly", item, ...options };
+}
+function Enum(values, options) {
+  return { "~kind": "Enum", values, ...options };
+}
+function Ref(name, options) {
+  return { "~kind": "Ref", name, ...options };
+}
+function Recursive(name, build, options) {
+  const self = Ref(name);
+  const schema = build(self);
+  return { "~kind": "Recursive", name, schema, ...options };
+}
+function Variant(discriminator, variants, options) {
+  return Union(variants, { discriminator, ...options });
+}
+// src/type/combinator-objects.ts
+function Exclude(left, right, options) {
+  return { "~kind": "Exclude", left, right, ...options };
+}
+function Extract(left, right, options) {
+  return { "~kind": "Extract", left, right, ...options };
+}
+function KeyOf(object, options) {
+  return { "~kind": "KeyOf", object, ...options };
+}
+function Partial(object, options) {
+  return { "~kind": "Partial", object, ...options };
+}
+function Required(object, options) {
+  return { "~kind": "Required", object, ...options };
+}
+function Pick(object, keys, options) {
+  return { "~kind": "Pick", object, keys, ...options };
+}
+function Omit(object, keys, options) {
+  return { "~kind": "Omit", object, keys, ...options };
+}
+function Not(schema, options) {
+  return { "~kind": "Not", schema, ...options };
+}
+function IfThenElse(condition, then, elseSchema, options) {
+  return {
+    "~kind": "IfThenElse",
+    if: condition,
+    then,
+    else: elseSchema,
+    ...options
+  };
+}
+function Unsafe(schema, options) {
+  return {
+    "~kind": "Unsafe",
+    schema,
+    type: undefined,
+    ...options
+  };
+}
+function Index(object, key, options) {
+  return {
+    "~kind": "Index",
+    object,
+    key: key ?? { "~kind": "String" },
+    ...options
+  };
+}
+function Mapped(object, transform, options) {
+  return { "~kind": "Mapped", object, ...transform ? { transform } : {}, ...options };
+}
+function Conditional(check, union, defaultSchema, options) {
+  return {
+    "~kind": "Conditional",
+    check,
+    union,
+    default: defaultSchema,
+    ...options
+  };
+}
+// src/type/combinator-functions.ts
+function Awaited(promise) {
+  return { "~kind": "Awaited", promise };
+}
+function ReturnType(fn) {
+  return { "~kind": "ReturnType", function: fn };
+}
+function Parameters(fn) {
+  return { "~kind": "Parameters", function: fn };
+}
+function InstanceType(ctor) {
+  return { "~kind": "InstanceType", constructor: ctor };
+}
+function ConstructorParameters(ctor) {
+  return { "~kind": "ConstructorParameters", constructor: ctor };
+}
+function Module(definitions) {
+  const mod = { "~kind": "Module", definitions };
+  return {
+    ...mod,
+    Import(name) {
+      return { "~kind": "Ref", name };
+    }
+  };
+}
+// src/type/containers.ts
+function Array2(item, options) {
+  return {
+    "~kind": "Array",
+    items: item,
+    ...options
+  };
+}
+function Object2(properties, options) {
+  return {
+    "~kind": "Object",
+    properties,
+    ...options
+  };
+}
+function Tuple(items, options) {
+  const expandedItems = ExpandTupleRest(items);
+  return {
+    "~kind": "Tuple",
+    items: expandedItems,
+    minItems: options?.minItems ?? expandedItems.length,
+    maxItems: options?.maxItems ?? (options?.additionalItems === true ? undefined : expandedItems.length),
+    additionalItems: options?.additionalItems ?? false,
+    ...options
+  };
+}
+function Record(key, value, options) {
+  return {
+    "~kind": "Record",
+    key,
+    value,
+    ...options
+  };
+}
+
+// src/value/clone.ts
+function cloneValue(value) {
+  return globalThis.structuredClone(value);
+}
+function Clone(value) {
+  return cloneValue(value);
+}
+
+// src/type/actions.ts
+function hasKind(value, kind) {
+  return value["~kind"] === kind;
+}
+function ExpandTupleRest(items) {
+  const expanded = [];
+  for (const item of items) {
+    if (hasKind(item, "Rest")) {
+      const rest = item;
+      if (hasKind(rest.items, "Tuple")) {
+        expanded.push(...rest.items.items);
+        continue;
+      }
+    }
+    expanded.push(item);
+  }
+  return expanded;
+}
+function Rest(item) {
+  return { "~kind": "Rest", type: "rest", items: item };
+}
+function Composite(objects) {
+  return Evaluate(Intersect(objects));
+}
+function Clone2(schema) {
+  return Clone(schema);
+}
+function Capitalize(item) {
+  return { "~kind": "Capitalize", item };
+}
+function Lowercase(item) {
+  return { "~kind": "Lowercase", item };
+}
+function Uppercase(item) {
+  return { "~kind": "Uppercase", item };
+}
+function Uncapitalize(item) {
+  return { "~kind": "Uncapitalize", item };
+}
+function Interface(heritage, properties, options) {
+  return {
+    ...Evaluate(Intersect([...heritage, Object2(properties)])),
+    ...options
+  };
+}
+function NonNullable(type, options) {
+  return Exclude(type, Union([Null(), Undefined()]), options);
+}
+function Options(type, options) {
+  return {
+    ...type,
+    ...options
+  };
+}
+function ReadonlyType(type, options) {
+  return Readonly(type, options);
+}
+function Identifier(name) {
+  return {
+    "~kind": "Identifier",
+    type: "identifier",
+    name
+  };
+}
+function Parameter(name, extends_, equals) {
+  const constraint = extends_ ?? Unknown();
+  const fallback = equals ?? constraint;
+  return {
+    "~kind": "Parameter",
+    name,
+    extends: constraint,
+    equals: fallback
+  };
+}
+function This(options) {
+  return {
+    "~kind": "This",
+    $ref: "#",
+    ...options
+  };
+}
+function Import(module, name) {
+  const definition = module.definitions[name];
+  if (definition === undefined) {
+    throw new Error(`Unknown module definition: ${name}`);
+  }
+  return definition;
+}
+
+// src/type/primitives.ts
+function String2(options) {
+  return { "~kind": "String", ...options };
+}
+function Number2(options) {
+  return { "~kind": "Number", ...options };
+}
+function Integer(options) {
+  return { "~kind": "Integer", ...options };
+}
+function Boolean(options) {
+  return { "~kind": "Boolean", ...options };
+}
+function Null(options) {
+  return { "~kind": "Null", ...options };
+}
+function Literal(value, options) {
+  return { "~kind": "Literal", const: value, ...options };
+}
+function Void(options) {
+  return { "~kind": "Void", ...options };
+}
+function Undefined(options) {
+  return { "~kind": "Undefined", ...options };
+}
+function Unknown(options) {
+  return { "~kind": "Unknown", ...options };
+}
+function Any(options) {
+  return { "~kind": "Any", ...options };
+}
+function Never(options) {
+  return { "~kind": "Never", ...options };
+}
+function BigInt(options) {
+  return { "~kind": "BigInt", ...options };
+}
+function Date(options) {
+  return { "~kind": "Date", ...options };
+}
+function DateFormat(options) {
+  return String2({ format: "date", ...options });
+}
+function Uuid(options) {
+  return String2({ format: "uuid", ...options });
+}
+function Email(options) {
+  return String2({ format: "email", ...options });
+}
+function Uri(options) {
+  return String2({ format: "uri", ...options });
+}
+function Hostname(options) {
+  return String2({ format: "hostname", ...options });
+}
+function Ip(options) {
+  return String2({ format: "ip", ...options });
+}
+function Base64(options) {
+  return String2({ format: "base64", ...options });
+}
+function Hex(options) {
+  return String2({ format: "hex", ...options });
+}
+function HexColor(options) {
+  return String2({ format: "hexcolor", ...options });
+}
+function DateTime(options) {
+  return String2({ format: "datetime", ...options });
+}
+function Time(options) {
+  return String2({ format: "time", ...options });
+}
+function Duration(options) {
+  return String2({ format: "duration", ...options });
+}
+function Json(options) {
+  return String2({ format: "json", ...options });
+}
+function CreditCard(options) {
+  return String2({ format: "creditcard", ...options });
+}
+function Uint8Array2(options) {
+  return { "~kind": "Uint8Array", ...options };
+}
+function RegExpInstance(options) {
+  return { "~kind": "RegExpInstance", ...options };
+}
+function RegExp2(options) {
+  return String2({ format: "regex", ...options });
+}
+function Symbol2(options) {
+  return { "~kind": "Symbol", ...options };
+}
+function TemplateLiteral(patterns, options) {
+  return { "~kind": "TemplateLiteral", patterns, ...options };
+}
+function Function(parameters, returns, options) {
+  const resolvedParameters = ExpandTupleRest(parameters ?? []);
+  const resolvedReturns = returns ?? Any();
+  return {
+    "~kind": "Function",
+    parameters: resolvedParameters,
+    returns: resolvedReturns,
+    ...options
+  };
+}
+function Constructor(parameters, returns, options) {
+  const resolvedParameters = ExpandTupleRest(parameters ?? []);
+  const resolvedReturns = returns ?? Any();
+  return {
+    "~kind": "Constructor",
+    parameters: resolvedParameters,
+    returns: resolvedReturns,
+    ...options
+  };
+}
+function Promise2(item, options) {
+  return { "~kind": "Promise", item, ...options };
+}
+function Iterator(item, options) {
+  return { "~kind": "Iterator", item, ...options };
+}
+function AsyncIterator(item, options) {
+  return { "~kind": "AsyncIterator", item, ...options };
+}
+function Decode(inner, decode) {
+  return { "~kind": "Decode", inner, decode };
+}
+function Encode(inner, encode) {
+  return { "~kind": "Encode", inner, encode };
+}
+// 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/type/extensions.ts
+class EncodeBuilder {
+  type;
+  decode;
+  constructor(type, decode) {
+    this.type = type;
+    this.decode = decode;
+  }
+  Encode(callback) {
+    return {
+      "~kind": "Codec",
+      inner: this.type,
+      codec: {
+        decode: this.decode,
+        encode: callback
+      }
+    };
+  }
+}
+
+class DecodeBuilder {
+  type;
+  constructor(type) {
+    this.type = type;
+  }
+  Decode(callback) {
+    return new EncodeBuilder(this.type, callback);
+  }
+}
+function Codec(type) {
+  return new DecodeBuilder(type);
+}
+function IsCodec(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const schema = value;
+  return schema["~kind"] === "Codec" && typeof schema.codec === "object" && schema.codec !== null && typeof schema.codec.decode === "function" && typeof schema.codec.encode === "function";
+}
+function Immutable(type) {
+  return {
+    "~kind": "Immutable",
+    item: type
+  };
+}
+function IsImmutable(value) {
+  return typeof value === "object" && value !== null && (value["~kind"] === "Immutable" || value["~immutable"] === true);
+}
+function Refine(type, refine, message = "error") {
+  return {
+    "~kind": "Refine",
+    item: type,
+    "~refine": [{ refine, message }]
+  };
+}
+function IsRefine(value) {
+  return typeof value === "object" && value !== null && (value["~kind"] === "Refine" || Array.isArray(value["~refine"]));
+}
+
+class Base {
+  "~kind" = "Base";
+  Check(value) {
+    return true;
+  }
+  Errors(_value) {
+    return [];
+  }
+  Convert(value) {
+    return value;
+  }
+  Clean(value) {
+    return value;
+  }
+  Default(value) {
+    return value;
+  }
+  Create() {
+    throw new Error("Create not implemented");
+  }
+  Clone() {
+    return this;
+  }
+}
+function IsBase(value) {
+  return value instanceof Base || typeof value === "object" && value !== null && value["~kind"] === "Base";
+}
+function Call(target, arguments_) {
+  const targetValue = target;
+  if (targetValue["~kind"] === "Generic") {
+    const parameters = targetValue.parameters ?? [];
+    const expression = targetValue.expression;
+    if (expression !== undefined) {
+      const context = bindParameterContext(parameters, arguments_);
+      return Instantiate(context, expression);
+    }
+  }
+  return {
+    "~kind": "Call",
+    target,
+    arguments: arguments_
+  };
+}
+function IsCall(value) {
+  return typeof value === "object" && value !== null && value["~kind"] === "Call";
+}
+function Cyclic($defs, $ref, options = {}) {
+  return {
+    "~kind": "Cyclic",
+    $defs,
+    $ref,
+    ...options
+  };
+}
+function IsCyclic(value) {
+  return typeof value === "object" && value !== null && value["~kind"] === "Cyclic";
+}
+function Generic(parameters, expression) {
+  return {
+    "~kind": "Generic",
+    type: "generic",
+    parameters,
+    expression
+  };
+}
+function IsGeneric(value) {
+  return typeof value === "object" && value !== null && value["~kind"] === "Generic";
+}
+function Infer(name, extends_) {
+  return {
+    "~kind": "Infer",
+    type: "infer",
+    name,
+    extends: extends_ ?? Unknown()
+  };
+}
+function IsInfer(value) {
+  return typeof value === "object" && value !== null && value["~kind"] === "Infer";
+}
+// 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/type/extends.ts
+function extendsUnion(inferred) {
+  return { "~kind": "ExtendsUnion", inferred };
+}
+function extendsTrue(inferred) {
+  return { "~kind": "ExtendsTrue", inferred };
+}
+function extendsFalse() {
+  return { "~kind": "ExtendsFalse" };
+}
+function isExtendsTrueLike(value) {
+  return value["~kind"] === "ExtendsTrue" || value["~kind"] === "ExtendsUnion";
+}
+function mergeInferred(left, right) {
+  return { ...left, ...right };
+}
+function extendsObject(inferred, left, right) {
+  const leftProps = left.properties;
+  const rightProps = right.properties;
+  let result = extendsTrue(inferred);
+  for (const [key, rightSchema] of Object.entries(rightProps)) {
+    const leftSchema = leftProps[key];
+    if (leftSchema === undefined) {
+      return extendsFalse();
+    }
+    result = extendsSchemas(result.inferred, leftSchema, rightSchema);
+    if (!isExtendsTrueLike(result)) {
+      return result;
+    }
+  }
+  return result;
+}
+function extendsLiteral(left, right) {
+  const leftValue = schemaConst(left);
+  const rightKind = schemaKind(right);
+  if (rightKind === "Literal") {
+    return leftValue === schemaConst(right);
+  }
+  if (rightKind === "String")
+    return typeof leftValue === "string";
+  if (rightKind === "Number" || rightKind === "Integer")
+    return typeof leftValue === "number";
+  if (rightKind === "Boolean")
+    return typeof leftValue === "boolean";
+  return false;
+}
+function extendsSameKind(inferred, left, right) {
+  const kind = schemaKind(left);
+  if (kind === "Object") {
+    return extendsObject(inferred, left, right);
+  }
+  return extendsTrue(inferred);
+}
+function inferFromSchema(inferred, left, right) {
+  if (schemaKind(right) === "Infer") {
+    const infer = right;
+    return extendsSchemas(mergeInferred(inferred, { [infer.name]: left }), left, infer.extends);
+  }
+  return extendsSchemas(inferred, left, right);
+}
+function extendsSchemas(inferred, left, right) {
+  const leftKind = schemaKind(left);
+  const rightKind = schemaKind(right);
+  if (rightKind === "Union") {
+    let sawUnion = false;
+    for (const variant of schemaVariants(right)) {
+      const result = inferFromSchema(inferred, left, variant);
+      if (result["~kind"] === "ExtendsTrue")
+        return result;
+      if (result["~kind"] === "ExtendsUnion")
+        sawUnion = true;
+    }
+    return sawUnion ? extendsUnion(inferred) : extendsFalse();
+  }
+  if (leftKind === "Union") {
+    let result = extendsTrue(inferred);
+    for (const variant of schemaVariants(left)) {
+      result = extendsSchemas(result.inferred, variant, right);
+      if (!isExtendsTrueLike(result))
+        return result;
+    }
+    return result;
+  }
+  if (leftKind === "Literal") {
+    return extendsLiteral(left, right) ? extendsTrue(inferred) : extendsFalse();
+  }
+  if (rightKind === "Unknown" || rightKind === "Any")
+    return extendsTrue(inferred);
+  if (leftKind === rightKind)
+    return extendsSameKind(inferred, left, right);
+  if (leftKind === "Integer" && rightKind === "Number")
+    return extendsTrue(inferred);
+  return extendsFalse();
+}
+function Extends(arg0, arg1, arg2) {
+  if (arg2 === undefined) {
+    return extendsSchemas({}, arg0, arg1);
+  }
+  return extendsSchemas(arg0, arg1, arg2);
+}
+var ExtendsResult = {
+  Union: extendsUnion,
+  True: extendsTrue,
+  False: extendsFalse,
+  IsExtendsUnion(value) {
+    return value["~kind"] === "ExtendsUnion";
+  },
+  IsExtendsTrue(value) {
+    return value["~kind"] === "ExtendsTrue";
+  },
+  IsExtendsFalse(value) {
+    return value["~kind"] === "ExtendsFalse";
+  },
+  IsExtendsTrueLike: isExtendsTrueLike
+};
+// src/type/guards.ts
+var exports_guards = {};
+__export(exports_guards, {
+  IsVoid: () => IsVoid,
+  IsUppercase: () => IsUppercase,
+  IsUnsafe: () => IsUnsafe,
+  IsUnknown: () => IsUnknown,
+  IsUnion: () => IsUnion,
+  IsUndefined: () => IsUndefined,
+  IsUncapitalize: () => IsUncapitalize,
+  IsUint8Array: () => IsUint8Array,
+  IsTuple: () => IsTuple,
+  IsThis: () => IsThis,
+  IsTemplateLiteral: () => IsTemplateLiteral,
+  IsSymbol: () => IsSymbol,
+  IsString: () => IsString,
+  IsSchema: () => IsSchema,
+  IsReturnType: () => IsReturnType,
+  IsRest: () => IsRest,
+  IsRequired: () => IsRequired,
+  IsRegExpInstance: () => IsRegExpInstance,
+  IsRefine: () => IsRefine2,
+  IsRef: () => IsRef,
+  IsRecursive: () => IsRecursive,
+  IsRecord: () => IsRecord,
+  IsReadonlyType: () => IsReadonlyType,
+  IsReadonly: () => IsReadonly,
+  IsPromise: () => IsPromise,
+  IsPick: () => IsPick,
+  IsPartial: () => IsPartial,
+  IsParameters: () => IsParameters,
+  IsParameter: () => IsParameter,
+  IsOptions: () => IsOptions,
+  IsOptional: () => IsOptional,
+  IsOmit: () => IsOmit,
+  IsObject: () => IsObject,
+  IsNumber: () => IsNumber,
+  IsNull: () => IsNull,
+  IsNot: () => IsNot,
+  IsNonNullable: () => IsNonNullable,
+  IsNever: () => IsNever,
+  IsModule: () => IsModule,
+  IsMapped: () => IsMapped,
+  IsLowercase: () => IsLowercase,
+  IsLiteral: () => IsLiteral,
+  IsKind: () => IsKind,
+  IsKeyOf: () => IsKeyOf,
+  IsIterator: () => IsIterator,
+  IsIntersect: () => IsIntersect,
+  IsInterface: () => IsInterface,
+  IsInteger: () => IsInteger,
+  IsInstanceType: () => IsInstanceType,
+  IsInfer: () => IsInfer2,
+  IsIndex: () => IsIndex,
+  IsImmutable: () => IsImmutable2,
+  IsIfThenElse: () => IsIfThenElse,
+  IsIdentifier: () => IsIdentifier,
+  IsGeneric: () => IsGeneric2,
+  IsFunction: () => IsFunction,
+  IsExtract: () => IsExtract,
+  IsExclude: () => IsExclude,
+  IsEnum: () => IsEnum,
+  IsEncode: () => IsEncode,
+  IsDecode: () => IsDecode,
+  IsDate: () => IsDate,
+  IsCyclic: () => IsCyclic2,
+  IsConstructorParameters: () => IsConstructorParameters,
+  IsConstructor: () => IsConstructor,
+  IsConditional: () => IsConditional,
+  IsCodec: () => IsCodec2,
+  IsCapitalize: () => IsCapitalize,
+  IsCall: () => IsCall2,
+  IsBoolean: () => IsBoolean,
+  IsBigInt: () => IsBigInt,
+  IsBase: () => IsBase2,
+  IsAwaited: () => IsAwaited,
+  IsAsyncIterator: () => IsAsyncIterator,
+  IsArray: () => IsArray,
+  IsAny: () => IsAny
+});
+function isKind(schema, kind) {
+  return schema["~kind"] === kind;
+}
+function hasFlag(schema, flag) {
+  return typeof schema === "object" && schema !== null && flag in schema;
+}
+function IsSchema(schema) {
+  return typeof schema === "object" && schema !== null && "~kind" in schema;
+}
+function IsKind(schema, kind) {
+  return isKind(schema, kind);
+}
+function IsString(schema) {
+  return isKind(schema, "String");
+}
+function IsNumber(schema) {
+  return isKind(schema, "Number");
+}
+function IsInteger(schema) {
+  return isKind(schema, "Integer");
+}
+function IsBoolean(schema) {
+  return isKind(schema, "Boolean");
+}
+function IsNull(schema) {
+  return isKind(schema, "Null");
+}
+function IsLiteral(schema) {
+  return isKind(schema, "Literal");
+}
+function IsVoid(schema) {
+  return isKind(schema, "Void");
+}
+function IsUndefined(schema) {
+  return isKind(schema, "Undefined");
+}
+function IsUnknown(schema) {
+  return isKind(schema, "Unknown");
+}
+function IsAny(schema) {
+  return isKind(schema, "Any");
+}
+function IsNever(schema) {
+  return isKind(schema, "Never");
+}
+function IsBigInt(schema) {
+  return isKind(schema, "BigInt");
+}
+function IsDate(schema) {
+  return isKind(schema, "Date");
+}
+function IsArray(schema) {
+  return isKind(schema, "Array");
+}
+function IsObject(schema) {
+  return isKind(schema, "Object");
+}
+function IsTuple(schema) {
+  return isKind(schema, "Tuple");
+}
+function IsRecord(schema) {
+  return isKind(schema, "Record");
+}
+function IsUnion(schema) {
+  return isKind(schema, "Union");
+}
+function IsIntersect(schema) {
+  return isKind(schema, "Intersect");
+}
+function IsOptional(schema) {
+  return isKind(schema, "Optional") || hasFlag(schema, "~optional");
+}
+function IsReadonly(schema) {
+  return isKind(schema, "Readonly") || hasFlag(schema, "~readonly");
+}
+function IsEnum(schema) {
+  return isKind(schema, "Enum");
+}
+function IsRef(schema) {
+  return isKind(schema, "Ref");
+}
+function IsRecursive(schema) {
+  return isKind(schema, "Recursive");
+}
+function IsExclude(schema) {
+  return isKind(schema, "Exclude");
+}
+function IsExtract(schema) {
+  return isKind(schema, "Extract");
+}
+function IsKeyOf(schema) {
+  return isKind(schema, "KeyOf");
+}
+function IsPartial(schema) {
+  return isKind(schema, "Partial");
+}
+function IsRequired(schema) {
+  return isKind(schema, "Required");
+}
+function IsPick(schema) {
+  return isKind(schema, "Pick");
+}
+function IsOmit(schema) {
+  return isKind(schema, "Omit");
+}
+function IsNot(schema) {
+  return isKind(schema, "Not");
+}
+function IsIfThenElse(schema) {
+  return isKind(schema, "IfThenElse");
+}
+function IsUnsafe(schema) {
+  return isKind(schema, "Unsafe");
+}
+function IsTemplateLiteral(schema) {
+  return isKind(schema, "TemplateLiteral");
+}
+function IsIndex(schema) {
+  return isKind(schema, "Index");
+}
+function IsMapped(schema) {
+  return isKind(schema, "Mapped");
+}
+function IsConditional(schema) {
+  return isKind(schema, "Conditional");
+}
+function IsFunction(schema) {
+  return isKind(schema, "Function");
+}
+function IsConstructor(schema) {
+  return isKind(schema, "Constructor");
+}
+function IsPromise(schema) {
+  return isKind(schema, "Promise");
+}
+function IsIterator(schema) {
+  return isKind(schema, "Iterator");
+}
+function IsAsyncIterator(schema) {
+  return isKind(schema, "AsyncIterator");
+}
+function IsSymbol(schema) {
+  return isKind(schema, "Symbol");
+}
+function IsUint8Array(schema) {
+  return isKind(schema, "Uint8Array");
+}
+function IsRegExpInstance(schema) {
+  return isKind(schema, "RegExpInstance");
+}
+function IsDecode(schema) {
+  return isKind(schema, "Decode");
+}
+function IsEncode(schema) {
+  return isKind(schema, "Encode");
+}
+function IsAwaited(schema) {
+  return isKind(schema, "Awaited");
+}
+function IsReturnType(schema) {
+  return isKind(schema, "ReturnType");
+}
+function IsParameters(schema) {
+  return isKind(schema, "Parameters");
+}
+function IsInstanceType(schema) {
+  return isKind(schema, "InstanceType");
+}
+function IsConstructorParameters(schema) {
+  return isKind(schema, "ConstructorParameters");
+}
+function IsModule(schema) {
+  return isKind(schema, "Module");
+}
+function IsRest(schema) {
+  return isKind(schema, "Rest");
+}
+function IsCapitalize(schema) {
+  return isKind(schema, "Capitalize");
+}
+function IsLowercase(schema) {
+  return isKind(schema, "Lowercase");
+}
+function IsUppercase(schema) {
+  return isKind(schema, "Uppercase");
+}
+function IsUncapitalize(schema) {
+  return isKind(schema, "Uncapitalize");
+}
+function IsInterface(schema) {
+  return IsIntersect(schema);
+}
+function IsNonNullable(schema) {
+  return IsExclude(schema);
+}
+function IsOptions(schema) {
+  return IsSchema(schema);
+}
+function IsReadonlyType(schema) {
+  return IsReadonly(schema);
+}
+function IsIdentifier(schema) {
+  return isKind(schema, "Identifier");
+}
+function IsParameter(schema) {
+  return isKind(schema, "Parameter");
+}
+function IsThis(schema) {
+  return isKind(schema, "This");
+}
+function IsCodec2(schema) {
+  return isKind(schema, "Codec");
+}
+function IsImmutable2(schema) {
+  return isKind(schema, "Immutable") || hasFlag(schema, "~immutable");
+}
+function IsRefine2(schema) {
+  return isKind(schema, "Refine") || hasFlag(schema, "~refine");
+}
+function IsBase2(schema) {
+  return isKind(schema, "Base");
+}
+function IsCall2(schema) {
+  return isKind(schema, "Call");
+}
+function IsCyclic2(schema) {
+  return isKind(schema, "Cyclic");
+}
+function IsGeneric2(schema) {
+  return isKind(schema, "Generic");
+}
+function IsInfer2(schema) {
+  return isKind(schema, "Infer");
+}
+// src/type/kind.ts
+var StringKind = "String";
+var NumberKind = "Number";
+var IntegerKind = "Integer";
+var BooleanKind = "Boolean";
+var NullKind = "Null";
+var LiteralKind = "Literal";
+var ArrayKind = "Array";
+var ObjectKind = "Object";
+var TupleKind = "Tuple";
+var RecordKind = "Record";
+var UnionKind = "Union";
+var IntersectKind = "Intersect";
+var OptionalKind = "Optional";
+var ReadonlyKind = "Readonly";
+var EnumKind = "Enum";
+var RefKind = "Ref";
+var PartialKind = "Partial";
+var RequiredKind = "Required";
+var PickKind = "Pick";
+var OmitKind = "Omit";
+var KeyOfKind = "KeyOf";
+var ExcludeKind = "Exclude";
+var ExtractKind = "Extract";
+var TemplateLiteralKind = "TemplateLiteral";
+var UnsafeKind = "Unsafe";
+var VoidKind = "Void";
+var UndefinedKind = "Undefined";
+var UnknownKind = "Unknown";
+var AnyKind = "Any";
+var NeverKind = "Never";
+var SelfKind = "Self";
+var PromiseKind = "Promise";
+var IteratorKind = "Iterator";
+var AsyncIteratorKind = "AsyncIterator";
+var UuidKind = "UUID";
+var EmailKind = "Email";
+var HostnameKind = "Hostname";
+var UriKind = "Uri";
+var Base64Kind = "Base64";
+var HexKind = "Hex";
+var HexColorKind = "HexColor";
+var IpKind = "Ip";
+var CreditCardKind = "CreditCard";
+var DateFormatKind = "DateFormat";
+var DateTimeKind = "DateTime";
+var TimeKind = "Time";
+var DurationKind = "Duration";
+var JsonKind = "Json";
+var Uint8ArrayKind = "Uint8Array";
+var RegExpKind = "RegExp";
+var FunctionKind = "Function";
+var ConstructorKind = "Constructor";
+var SymbolKind = "Symbol";
+var TemplateElementKind = "TemplateElement";
+var NotKind = "Not";
+var IfThenElseKind = "IfThenElse";
+var IndexKind = "Index";
+var MappedKind = "Mapped";
+var ConditionalKind = "Conditional";
+var RestKind = "Rest";
+var CapitalizeKind = "Capitalize";
+var LowercaseKind = "Lowercase";
+var UppercaseKind = "Uppercase";
+var UncapitalizeKind = "Uncapitalize";
+var BigIntKind = "BigInt";
+var DateKind = "Date";
+var DecodeKind = "Decode";
+var EncodeKind = "Encode";
+var RecursiveKind = "Recursive";
+var ModuleKind = "Module";
+var AwaitedKind = "Awaited";
+var ReturnTypeKind = "ReturnType";
+var ParametersKind = "Parameters";
+var InstanceTypeKind = "InstanceType";
+var ConstructorParametersKind = "ConstructorParameters";
+// src/type/root-shared.ts
+function isObjectValue(value) {
+  return typeof value === "object" && value !== null;
+}
+function isSchemaLike(value) {
+  return isObjectValue(value) && typeof value["~kind"] === "string";
+}
+function getKind(schema) {
+  const kind = schema["~kind"];
+  return typeof kind === "string" ? kind : undefined;
+}
+function discardKeys(value, keys) {
+  const result = { ...value };
+  for (const key of keys) {
+    delete result[key];
+  }
+  return result;
+}
+function mergeOptions(schema, options = {}) {
+  return { ...schema, ...options };
+}
+function isLiteralValue(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint";
+}
+function getLiteralConst(schema) {
+  if (getKind(schema) !== "Literal") {
+    return;
+  }
+  const value = schema.const;
+  return isLiteralValue(value) ? value : undefined;
+}
+function escapePattern(value) {
+  return value.replace(/[|\\{}()[\]^$+*?.-]/g, "\\$&");
+}
+function stripAnchors(pattern) {
+  return pattern.startsWith("^") && pattern.endsWith("$") ? pattern.slice(1, -1) : pattern;
+}
+
+// src/type/root-constants.ts
+var BigIntPattern = "-?(?:0|[1-9][0-9]*)n";
+var IntegerPattern = "-?(?:0|[1-9][0-9]*)";
+var NumberPattern = "-?(?:0|[1-9][0-9]*)(?:\\.[0-9]+)?";
+var StringPattern = ".*";
+var NeverPattern = "(?!)";
+var IntegerKey = `^${IntegerPattern}$`;
+var NumberKey = `^${NumberPattern}$`;
+var StringKey = `^${StringPattern}$`;
+var ResultEqual = "equal";
+var ResultDisjoint = "disjoint";
+var ResultLeftInside = "left-inside";
+var ResultRightInside = "right-inside";
+function schemaOptions(type, keys) {
+  return discardKeys(type, keys);
+}
+function ArrayOptions(type) {
+  return schemaOptions(type, ["~kind", "items"]);
+}
+function AsyncIteratorOptions(type) {
+  return schemaOptions(type, ["~kind", "item"]);
+}
+function ConstructorOptions(type) {
+  return schemaOptions(type, ["~kind", "parameters", "returns"]);
+}
+function FunctionOptions(type) {
+  return schemaOptions(type, ["~kind", "parameters", "returns"]);
+}
+function IntersectOptions(type) {
+  return schemaOptions(type, ["~kind", "variants"]);
+}
+function IteratorOptions(type) {
+  return schemaOptions(type, ["~kind", "item"]);
+}
+function ObjectOptions(type) {
+  return schemaOptions(type, ["~kind", "properties"]);
+}
+function PromiseOptions(type) {
+  return schemaOptions(type, ["~kind", "item"]);
+}
+function RecordOptions(type) {
+  return schemaOptions(type, ["~kind", "key", "value"]);
+}
+function TupleOptions(type) {
+  return schemaOptions(type, ["~kind", "items", "minItems", "maxItems", "additionalItems"]);
+}
+function UnionOptions(type) {
+  return schemaOptions(type, ["~kind", "variants"]);
+}
+function CyclicOptions(type) {
+  return schemaOptions(type, ["~kind", "$defs", "$ref"]);
+}
+function isOptionalSchema(schema) {
+  return getKind(schema) === "Optional" || isObjectValue(schema) && schema["~optional"] === true;
+}
+function RequiredArray(properties) {
+  return Object.keys(properties).filter((key) => !isOptionalSchema(properties[key]));
+}
+function PropertyKeys(properties) {
+  return Object.keys(properties);
+}
+function PropertyValues(properties) {
+  return Object.values(properties);
+}
+function OptionalAddAction(type) {
+  return { "~kind": "OptionalAddAction", type };
+}
+function OptionalRemoveAction(type) {
+  return { "~kind": "OptionalRemoveAction", type };
+}
+function ReadonlyAddAction(type) {
+  return { "~kind": "ReadonlyAddAction", type };
+}
+function ReadonlyRemoveAction(type) {
+  return { "~kind": "ReadonlyRemoveAction", type };
+}
+function removeModifier(type, key) {
+  return discardKeys(type, [key]);
+}
+function OptionalAdd(type) {
+  return { ...type, "~optional": true };
+}
+function OptionalRemove(type) {
+  return removeModifier(type, "~optional");
+}
+function ReadonlyAdd(type) {
+  return { ...type, "~readonly": true };
+}
+function ReadonlyRemove(type) {
+  return removeModifier(type, "~readonly");
+}
+function ImmutableAdd(type) {
+  return { ...type, "~immutable": true };
+}
+function ImmutableRemove(type) {
+  return removeModifier(type, "~immutable");
+}
+function RefineAdd(type, refinement) {
+  const existing = isObjectValue(type) && Array.isArray(type["~refine"]) ? type["~refine"] : [];
+  return { ...type, "~refine": [...existing, refinement] };
+}
+// src/type/root-deferred.ts
+function Deferred(action, parameters, options = {}) {
+  return { "~kind": "Deferred", action, parameters, options };
+}
+var AwaitedDeferred = (type, options = {}) => Deferred("Awaited", [type], options);
+var CapitalizeDeferred = (type, options = {}) => Deferred("Capitalize", [type], options);
+var ConditionalDeferred = (left, right, trueType, falseType, options = {}) => Deferred("Conditional", [left, right, trueType, falseType], options);
+var ConstructorParametersDeferred = (type, options = {}) => Deferred("ConstructorParameters", [type], options);
+var EvaluateDeferred = (type, options = {}) => Deferred("Evaluate", [type], options);
+var ExcludeDeferred = (left, right, options = {}) => Deferred("Exclude", [left, right], options);
+var ExtractDeferred = (left, right, options = {}) => Deferred("Extract", [left, right], options);
+var IndexDeferred = (type, indexer, options = {}) => Deferred("Index", [type, indexer], options);
+var InstanceTypeDeferred = (type, options = {}) => Deferred("InstanceType", [type], options);
+var InterfaceDeferred = (heritage, properties, options = {}) => Deferred("Interface", [heritage, properties], options);
+var KeyOfDeferred = (type, options = {}) => Deferred("KeyOf", [type], options);
+var LowercaseDeferred = (type, options = {}) => Deferred("Lowercase", [type], options);
+var MappedDeferred = (identifier, key, asType, property, options = {}) => Deferred("Mapped", [identifier, key, asType, property], options);
+var ModuleDeferred = (definitions, options = {}) => Deferred("Module", [definitions], options);
+var NonNullableDeferred = (type, options = {}) => Deferred("NonNullable", [type], options);
+var OmitDeferred = (type, indexer, options = {}) => Deferred("Omit", [type, indexer], options);
+var OptionsDeferred = (type, options) => Deferred("Options", [type, options], {});
+var ParametersDeferred = (type, options = {}) => Deferred("Parameters", [type], options);
+var PartialDeferred = (type, options = {}) => Deferred("Partial", [type], options);
+var PickDeferred = (type, indexer, options = {}) => Deferred("Pick", [type, indexer], options);
+var ReadonlyTypeDeferred = (type, options = {}) => Deferred("ReadonlyType", [type], options);
+var RecordDeferred = (key, value, options = {}) => Deferred("Record", [key, value], options);
+var RequiredDeferred = (type, options = {}) => Deferred("Required", [type], options);
+var ReturnTypeDeferred = (type, options = {}) => Deferred("ReturnType", [type], options);
+var TemplateLiteralDeferred = (types, options = {}) => Deferred("TemplateLiteral", [types], options);
+var UncapitalizeDeferred = (type, options = {}) => Deferred("Uncapitalize", [type], options);
+var UppercaseDeferred = (type, options = {}) => Deferred("Uppercase", [type], options);
+function IsDeferred(value) {
+  return isObjectValue(value) && value["~kind"] === "Deferred" && typeof value.action === "string" && Array.isArray(value.parameters) && isObjectValue(value.options);
+}
+function IsInterfaceDeferred(value) {
+  if (!IsDeferred(value) || value.action !== "Interface") {
+    return false;
+  }
+  const [heritage, properties] = value.parameters;
+  return Array.isArray(heritage) && heritage.every((entry) => isSchemaLike(entry)) && isObjectValue(properties) && Object.values(properties).every((entry) => isSchemaLike(entry));
+}
+// src/type/root-guards.ts
+function hasActionKind(value, kind) {
+  return isObjectValue(value) && value["~kind"] === kind && isSchemaLike(value.type);
+}
+function IsLiteralValue(value) {
+  return isLiteralValue(value);
+}
+function IsLiteralBigInt(value) {
+  return isObjectValue(value) && value["~kind"] === "Literal" && typeof value.const === "bigint";
+}
+function IsLiteralBoolean(value) {
+  return isObjectValue(value) && value["~kind"] === "Literal" && typeof value.const === "boolean";
+}
+function IsLiteralNumber(value) {
+  return isObjectValue(value) && value["~kind"] === "Literal" && typeof value.const === "number";
+}
+function IsLiteralString(value) {
+  return isObjectValue(value) && value["~kind"] === "Literal" && typeof value.const === "string";
+}
+function isFiniteTemplateType(type) {
+  if (getKind(type) === "Literal") {
+    return true;
+  }
+  if (getKind(type) === "Union") {
+    const variants = type.variants;
+    return variants.length > 0 && variants.every((variant) => isFiniteTemplateType(variant));
+  }
+  return false;
+}
+function IsTemplateLiteralFinite(types) {
+  return types.length > 0 && types.every((type) => isFiniteTemplateType(type));
+}
+function IsTemplateLiteralPattern(pattern) {
+  const inner = stripAnchors(pattern);
+  return pattern === StringPattern || pattern === NumberPattern || pattern === IntegerPattern || pattern === BigIntPattern || pattern === NeverPattern || pattern.startsWith("^") && pattern.endsWith("$") || inner.includes("|");
+}
+function IsTypeScriptEnumLike(value) {
+  if (!isObjectValue(value) || Array.isArray(value)) {
+    return false;
+  }
+  return Object.keys(value).every((key) => {
+    const entry = value[key];
+    return typeof entry === "string" || typeof entry === "number";
+  });
+}
+function IsOptionalAddAction(value) {
+  return hasActionKind(value, "OptionalAddAction");
+}
+function IsOptionalRemoveAction(value) {
+  return hasActionKind(value, "OptionalRemoveAction");
+}
+function IsReadonlyAddAction(value) {
+  return hasActionKind(value, "ReadonlyAddAction");
+}
+function IsReadonlyRemoveAction(value) {
+  return hasActionKind(value, "ReadonlyRemoveAction");
+}
+// src/type/root-helpers.ts
+class InvalidLiteralValue extends Error {
+  value;
+  constructor(value) {
+    super("Invalid Literal value");
+    this.value = value;
+  }
+}
+function LiteralTypeName(value) {
+  if (typeof value === "bigint")
+    return "bigint";
+  if (typeof value === "boolean")
+    return "boolean";
+  if (typeof value === "number")
+    return "number";
+  if (typeof value === "string")
+    return "string";
+  throw new InvalidLiteralValue(value);
+}
+function literalSchema(value) {
+  return { "~kind": "Literal", const: value };
+}
+function ConvertToIntegerKey(value) {
+  const normal = `${value}`;
+  return /^(?:0|[1-9][0-9]*)$/.test(normal) ? globalThis.Number.parseInt(normal, 10) : value;
+}
+function KeysToIndexer(keys) {
+  const literals = keys.filter((key) => isLiteralValue(key)).map((key) => literalSchema(key));
+  return EvaluateUnionFast(literals);
+}
+function EnumValuesToVariants(values) {
+  return values.flatMap((value) => {
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+      return [literalSchema(value)];
+    }
+    return [];
+  });
+}
+function EnumValuesToUnion(values) {
+  return EvaluateUnionFast(EnumValuesToVariants(values));
+}
+function EnumToUnion(type) {
+  const schema = type;
+  const values = Array.isArray(schema.values) ? schema.values : Array.isArray(schema.enum) ? schema.enum : [];
+  return EnumValuesToUnion(values);
+}
+function TypeScriptEnumToEnumValues(type) {
+  return Object.keys(type).filter((key) => globalThis.Number.isNaN(globalThis.Number(key))).map((key) => type[key]);
+}
+function Compare(left, right) {
+  const leftExtendsRight = Extends(left, right);
+  const rightExtendsLeft = Extends(right, left);
+  return ExtendsResult.IsExtendsTrueLike(leftExtendsRight) && ExtendsResult.IsExtendsTrueLike(rightExtendsLeft) ? ResultEqual : ExtendsResult.IsExtendsTrueLike(leftExtendsRight) && ExtendsResult.IsExtendsFalse(rightExtendsLeft) ? ResultLeftInside : ExtendsResult.IsExtendsFalse(leftExtendsRight) && ExtendsResult.IsExtendsTrueLike(rightExtendsLeft) ? ResultRightInside : ResultDisjoint;
+}
+function Flatten(types) {
+  return types.flatMap((type) => getKind(type) === "Union" ? Flatten(type.variants) : [type]);
+}
+function Narrow(left, right) {
+  const result = Compare(left, right);
+  return result === ResultLeftInside ? left : result === ResultRightInside || result === ResultEqual ? right : Never();
+}
+function broadenFilter(type, types) {
+  return types.filter((candidate) => Compare(type, candidate) !== ResultRightInside);
+}
+function isBroadestType(type, types) {
+  return !types.some((candidate) => {
+    const result = Compare(type, candidate);
+    return result === ResultLeftInside || result === ResultEqual;
+  });
+}
+function broadenType(type, types) {
+  const evaluated = EvaluateType(type);
+  return getKind(evaluated) === "Any" ? [evaluated] : isBroadestType(evaluated, types) ? [...broadenFilter(evaluated, types), evaluated] : [...types];
+}
+function Broaden(types) {
+  const broadened = types.reduce((result, type) => {
+    if (getKind(type) === "Object") {
+      return [...result, type];
+    }
+    if (getKind(type) === "Never") {
+      return result;
+    }
+    return broadenType(type, result);
+  }, []);
+  const flattened = Flatten(broadened);
+  return flattened.length === 0 ? Never() : flattened.length === 1 ? flattened[0] : Union(flattened);
+}
+function isObjectLike(type) {
+  const kind = getKind(type);
+  return kind === "Object" || kind === "Tuple";
+}
+function distributeOperation(left, right) {
+  const evaluatedLeft = EvaluateType(left);
+  const evaluatedRight = EvaluateType(right);
+  if (getKind(evaluatedLeft) === "Union" || getKind(evaluatedRight) === "Union") {
+    return EvaluateIntersect([evaluatedLeft, evaluatedRight]);
+  }
+  if (isObjectLike(evaluatedLeft) && isObjectLike(evaluatedRight)) {
+    return Composite([CollapseToObject(evaluatedLeft), CollapseToObject(evaluatedRight)]);
+  }
+  if (isObjectLike(evaluatedLeft))
+    return evaluatedLeft;
+  if (isObjectLike(evaluatedRight))
+    return evaluatedRight;
+  return Narrow(evaluatedLeft, evaluatedRight);
+}
+function distributeType(type, types, result = []) {
+  const [left, ...right] = types;
+  return left !== undefined ? distributeType(type, right, [...result, distributeOperation(type, left)]) : result.length === 0 ? [type] : result;
+}
+function distributeUnion(types, distribution, result = []) {
+  const [left, ...right] = types;
+  return left !== undefined ? distributeUnion(right, distribution, [...result, ...Distribute([left], distribution)]) : result;
+}
+function Distribute(types, result = []) {
+  const [left, ...right] = types;
+  if (left === undefined) {
+    return [...result];
+  }
+  return getKind(left) === "Union" ? Distribute(right, distributeUnion(left.variants, result)) : Distribute(right, distributeType(left, result));
+}
+function EvaluateIntersect(types) {
+  return Broaden(Distribute(types));
+}
+function EvaluateUnion(types) {
+  return Broaden(types);
+}
+function EvaluateType(type) {
+  return getKind(type) === "Intersect" ? EvaluateIntersect(type.variants) : getKind(type) === "Union" ? EvaluateUnion(type.variants) : type;
+}
+function EvaluateUnionFast(types) {
+  return types.length === 0 ? Never() : types.length === 1 ? types[0] : Union([...types]);
+}
+function CollapseToObject(type) {
+  if (getKind(type) === "Object") {
+    return type;
+  }
+  if (getKind(type) === "Intersect") {
+    const variants = type.variants.filter((variant) => getKind(variant) === "Object");
+    return variants.length > 0 ? Evaluate(Intersect(variants)) : Object2({});
+  }
+  return Object2({});
+}
+function _Function_(parameters, returnType, options = {}) {
+  return { "~kind": "Function", parameters, returns: returnType, ...options };
+}
+function _Object_(properties, options = {}) {
+  const required = RequiredArray(properties);
+  const optional = Object.keys(properties).filter((key) => !required.includes(key));
+  return Object2(properties, {
+    ...options,
+    ...required.length > 0 ? { required } : {},
+    ...optional.length > 0 ? { optional } : {}
+  });
+}
+function CallConstruct(target, arguments_) {
+  return { "~kind": "Call", target, arguments: arguments_ };
+}
+function KeyOfAction(type) {
+  switch (getKind(type)) {
+    case "Any":
+      return Union([Number2(), String2(), Symbol2()]);
+    case "Array":
+      return Number2();
+    case "Object": {
+      const keys = Object.keys(type.properties).map((key) => ConvertToIntegerKey(key));
+      return EvaluateUnionFast(keys.map((key) => literalSchema(key)));
+    }
+    case "Record":
+      return type.key;
+    case "Tuple": {
+      const variants = type.items.map((_, index) => literalSchema(index));
+      return EvaluateUnionFast(variants);
+    }
+    default:
+      return Never();
+  }
+}
+// src/type/root-template.ts
+function parseTemplateExpression(expression) {
+  const trimmed = expression.trim();
+  if (trimmed.includes("|")) {
+    return Union(trimmed.split("|").map((entry) => parseTemplateExpression(entry)));
+  }
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return Literal(trimmed.slice(1, -1));
+  }
+  if (trimmed === "string")
+    return String2();
+  if (trimmed === "number")
+    return Number2();
+  if (trimmed === "integer")
+    return Integer();
+  if (trimmed === "bigint")
+    return BigInt();
+  if (trimmed === "true")
+    return Literal(true);
+  if (trimmed === "false")
+    return Literal(false);
+  if (/^-?\d+$/.test(trimmed))
+    return Literal(globalThis.Number.parseInt(trimmed, 10));
+  if (/^-?\d+\.\d+$/.test(trimmed))
+    return Literal(globalThis.Number.parseFloat(trimmed));
+  return Ref(trimmed);
+}
+function TemplateLiteralCreate(pattern) {
+  return TemplateLiteral([pattern]);
+}
+function ParseTemplateIntoTypes(template) {
+  const result = [];
+  let index = 0;
+  let current = "";
+  while (index < template.length) {
+    const character = template[index];
+    if (character === "$" && template[index + 1] === "{") {
+      if (current.length > 0) {
+        result.push(Literal(current));
+        current = "";
+      }
+      let depth = 1;
+      let cursor = index + 2;
+      while (cursor < template.length && depth > 0) {
+        const inner = template[cursor];
+        if (inner === "{")
+          depth += 1;
+        if (inner === "}")
+          depth -= 1;
+        cursor += 1;
+      }
+      result.push(parseTemplateExpression(template.slice(index + 2, cursor - 1)));
+      index = cursor;
+      continue;
+    }
+    current += character;
+    index += 1;
+  }
+  if (current.length > 0 || result.length === 0) {
+    result.push(Literal(current));
+  }
+  return result;
+}
+function encodeUnionPattern(variants) {
+  return `(${variants.map((variant) => encodeTypePattern(variant)).join("|")})`;
+}
+function encodeTypePattern(type) {
+  const literal = getLiteralConst(type);
+  if (literal !== undefined) {
+    return escapePattern(globalThis.String(literal));
+  }
+  switch (getKind(type)) {
+    case "String":
+      return StringPattern;
+    case "Number":
+      return NumberPattern;
+    case "Integer":
+      return IntegerPattern;
+    case "BigInt":
+      return BigIntPattern;
+    case "Boolean":
+      return "(false|true)";
+    case "Enum":
+      return encodeUnionPattern(type.values.map((value) => Literal(value)));
+    case "Union":
+      return encodeUnionPattern(type.variants);
+    case "TemplateLiteral": {
+      const patterns = type.patterns.map((pattern) => stripAnchors(pattern));
+      return patterns.length === 1 ? patterns[0] : `(${patterns.join("|")})`;
+    }
+    default:
+      return NeverPattern;
+  }
+}
+function TemplateLiteralEncode(types) {
+  return TemplateLiteralCreate(`^${types.map((type) => encodeTypePattern(type)).join("")}$`);
+}
+function decodeLiteralPattern(pattern) {
+  if (pattern.length === 0 || /[()[\]{}+*?]/.test(pattern) || pattern.includes("|")) {
+    return;
+  }
+  return pattern.replace(/\\(.)/g, "$1");
+}
+function decodeAlternationPattern(pattern) {
+  const match = /^\(([^()]+)\)$/.exec(pattern);
+  if (!match) {
+    return;
+  }
+  const parts = match[1].split("|").map((entry) => decodeLiteralPattern(entry));
+  return parts.every((entry) => entry !== undefined) ? parts : undefined;
+}
+function TemplateLiteralDecodeUnsafe(pattern) {
+  const inner = stripAnchors(pattern);
+  if (inner === StringPattern)
+    return String2();
+  if (inner === NumberPattern)
+    return Number2();
+  if (inner === IntegerPattern)
+    return Integer();
+  if (inner === BigIntPattern)
+    return BigInt();
+  if (inner === "(false|true)")
+    return Union([Literal("false"), Literal("true")]);
+  const alternates = decodeAlternationPattern(inner);
+  if (alternates) {
+    return Union(alternates.map((value) => Literal(value)));
+  }
+  const literal = decodeLiteralPattern(inner);
+  if (literal !== undefined) {
+    return Literal(literal);
+  }
+  return TemplateLiteralCreate(pattern);
+}
+function TemplateLiteralDecode(pattern) {
+  const decoded = TemplateLiteralDecodeUnsafe(pattern);
+  return getKind(decoded) === "TemplateLiteral" ? String2() : decoded;
+}
+function ParsePatternIntoTypes(pattern) {
+  const decoded = TemplateLiteralDecodeUnsafe(pattern);
+  return getKind(decoded) === "Union" ? decoded.variants : [decoded];
+}
+function TemplateLiteralFromTypes(types) {
+  return TemplateLiteralEncode(types);
+}
+function TemplateLiteralFromString(template) {
+  return TemplateLiteralFromTypes(ParseTemplateIntoTypes(template));
+}
+function RecordConstruct(key, value, options = {}) {
+  return Record(key, value, options);
+}
+function RecordFromPattern(keyPattern, value) {
+  return RecordConstruct(TemplateLiteralDecode(keyPattern), value);
+}
+function RecordPattern(type) {
+  const key = type.key;
+  const literal = getLiteralConst(key);
+  if (literal !== undefined) {
+    return `^${escapePattern(globalThis.String(literal))}$`;
+  }
+  switch (getKind(key)) {
+    case "String":
+      return StringKey;
+    case "Number":
+      return NumberKey;
+    case "Integer":
+      return IntegerKey;
+    case "Enum":
+      return `^(${key.values.map((value) => escapePattern(value)).join("|")})$`;
+    case "TemplateLiteral": {
+      const patterns = key.patterns;
+      return patterns.length === 1 ? patterns[0] : `^(${patterns.map((pattern) => stripAnchors(pattern)).join("|")})$`;
+    }
+    default:
+      return StringKey;
+  }
+}
+function RecordKey(type) {
+  return type.key;
+}
+function RecordValue(type) {
+  return type.value;
+}
+// src/type/root-cyclic.ts
+function getRefName(schema) {
+  const value = schema;
+  return typeof value.name === "string" ? value.name : typeof value.$ref === "string" ? value.$ref : undefined;
+}
+function resolve(defs, ref) {
+  const target = defs[ref];
+  if (target === undefined) {
+    return Never();
+  }
+  const nextRef = getKind(target) === "Ref" ? getRefName(target) : undefined;
+  return typeof nextRef === "string" ? resolve(defs, nextRef) : target;
+}
+function CyclicTarget(defs, ref) {
+  return resolve(defs, ref);
+}
+function fromProperties(properties, mapper, seed) {
+  return Object.values(properties).reduce((result, type) => mapper(type, result), seed);
+}
+function dependencyWalk(context, type, result) {
+  const ref = getKind(type) === "Ref" ? getRefName(type) : undefined;
+  if (typeof ref === "string") {
+    if (result.includes(ref) || context[ref] === undefined) {
+      return result;
+    }
+    return dependencyWalk(context, context[ref], [...result, ref]);
+  }
+  switch (getKind(type)) {
+    case "Array":
+    case "Promise":
+    case "Iterator":
+    case "AsyncIterator":
+    case "Rest":
+      return dependencyWalk(context, type.item, result);
+    case "Function":
+    case "Constructor": {
+      const schema = type;
+      return schema.parameters.reduce((next, entry) => dependencyWalk(context, entry, next), dependencyWalk(context, schema.returns, result));
+    }
+    case "Object":
+      return fromProperties(type.properties, (entry, next) => dependencyWalk(context, entry, next), result);
+    case "Union":
+    case "Intersect":
+      return type.variants.reduce((next, entry) => dependencyWalk(context, entry, next), result);
+    case "Tuple":
+      return type.items.reduce((next, entry) => dependencyWalk(context, entry, next), result);
+    case "Record":
+      return dependencyWalk(context, RecordValue(type), result);
+    default:
+      return result;
+  }
+}
+function CyclicDependencies(context, key, type) {
+  return dependencyWalk(context, type, [key]);
+}
+function checkWalk(stack, context, type) {
+  const ref = getKind(type) === "Ref" ? getRefName(type) : undefined;
+  if (typeof ref === "string") {
+    return stack.includes(ref) ? true : context[ref] !== undefined && checkWalk([...stack, ref], context, context[ref]);
+  }
+  switch (getKind(type)) {
+    case "Array":
+    case "Promise":
+    case "Iterator":
+    case "AsyncIterator":
+    case "Rest":
+      return checkWalk(stack, context, type.item);
+    case "Function":
+    case "Constructor": {
+      const schema = type;
+      return schema.parameters.some((entry) => checkWalk(stack, context, entry)) || checkWalk(stack, context, schema.returns);
+    }
+    case "Object":
+      return Object.values(type.properties).some((entry) => checkWalk(stack, context, entry));
+    case "Union":
+    case "Intersect":
+      return type.variants.some((entry) => checkWalk(stack, context, entry));
+    case "Tuple":
+      return type.items.some((entry) => checkWalk(stack, context, entry));
+    case "Record":
+      return checkWalk(stack, context, RecordValue(type));
+    default:
+      return false;
+  }
+}
+function CyclicCheck(stack, context, type) {
+  return checkWalk(stack, context, type);
+}
+function CyclicCandidates(context) {
+  return Object.keys(context).filter((key) => CyclicCheck([key], context, context[key]));
+}
+function extendsWalk(type) {
+  const ref = getKind(type) === "Ref" ? getRefName(type) : undefined;
+  if (typeof ref === "string") {
+    return Any();
+  }
+  switch (getKind(type)) {
+    case "Array":
+      return { ...type, items: extendsWalk(type.items) };
+    case "Promise":
+    case "Iterator":
+    case "AsyncIterator":
+    case "Rest":
+      return { ...type, item: extendsWalk(type.item) };
+    case "Function":
+    case "Constructor": {
+      const schema = type;
+      return _Function_(schema.parameters.map((entry) => extendsWalk(entry)), extendsWalk(schema.returns));
+    }
+    case "Object": {
+      const properties = Object.fromEntries(Object.entries(type.properties).map(([key, value]) => [key, extendsWalk(value)]));
+      return _Object_(properties);
+    }
+    case "Union":
+    case "Intersect":
+      return { ...type, variants: type.variants.map((entry) => extendsWalk(entry)) };
+    case "Tuple":
+      return { ...type, items: type.items.map((entry) => extendsWalk(entry)) };
+    case "Record":
+      return { ...type, key: RecordKey(type), value: extendsWalk(RecordValue(type)) };
+    default:
+      return type;
+  }
+}
+function CyclicExtends(type) {
+  const target = type.$defs[type.$ref];
+  return target === undefined ? Any() : extendsWalk(target);
+}
+function InstantiateCyclic(context, ref, type) {
+  const dependencies = CyclicDependencies(context, ref, type);
+  const definitions = Object.fromEntries(Object.entries(context).filter(([key]) => dependencies.includes(key)));
+  return Cyclic(definitions, ref);
+}
+// src/type/root-instantiate.ts
+function extractLiteralKeys(indexer) {
+  if (getKind(indexer) === "Literal") {
+    const literal = getLiteralConst(indexer);
+    return literal === undefined ? [] : [String(literal)];
+  }
+  if (getKind(indexer) === "Union") {
+    return indexer.variants.flatMap((variant) => extractLiteralKeys(variant));
+  }
+  return [];
+}
+function instantiateType(context, type) {
+  return Instantiate(context, type);
+}
+function instantiateObject2(context, type) {
+  const resolved = instantiateType(context, type);
+  return getKind(resolved) === "Object" ? resolved : undefined;
+}
+function filterUnionVariants(context, left, right, includeMatches) {
+  const resolvedLeft = instantiateType(context, left);
+  const resolvedRight = instantiateType(context, right);
+  if (getKind(resolvedLeft) === "Union") {
+    const variants = resolvedLeft.variants.filter((variant) => {
+      const matches2 = ExtendsResult.IsExtendsTrueLike(Extends(context, variant, resolvedRight));
+      return includeMatches ? matches2 : !matches2;
+    });
+    return variants.length === 0 ? Never() : variants.length === 1 ? variants[0] : Union(variants);
+  }
+  const matches = ExtendsResult.IsExtendsTrueLike(Extends(context, resolvedLeft, resolvedRight));
+  return includeMatches ? matches ? resolvedLeft : Never() : matches ? Never() : resolvedLeft;
+}
+function AwaitedInstantiate(context, _state, type, options = {}) {
+  const resolved = instantiateType(context, type);
+  const unwrapped = getKind(resolved) === "Promise" ? AwaitedInstantiate(context, _state, resolved.item, options) : resolved;
+  return mergeOptions(unwrapped, options);
+}
+function CapitalizeInstantiate(context, _state, type, options = {}) {
+  return getKind(type) === "Ref" && getKind(instantiateType(context, type)) === "Ref" ? CapitalizeDeferred(type, options) : mergeOptions({ "~kind": "Capitalize", item: instantiateType(context, type) }, options);
+}
+function ConditionalInstantiate(context, _state, left, right, trueType, falseType, options = {}) {
+  return getKind(left) === "Ref" && context[left.name ?? ""] === undefined ? ConditionalDeferred(left, right, trueType, falseType, options) : mergeOptions(instantiateType(context, ExtendsResult.IsExtendsTrueLike(Extends(context, instantiateType(context, left), instantiateType(context, right))) ? trueType : falseType), options);
+}
+function ConstructorParametersInstantiate(context, _state, type, options = {}) {
+  const resolved = instantiateType(context, type);
+  return getKind(resolved) === "Constructor" ? mergeOptions(Tuple(resolved.parameters), options) : ConstructorParametersDeferred(type, options);
+}
+function EvaluateInstantiate(context, _state, type, options = {}) {
+  return mergeOptions(EvaluateType(instantiateType(context, type)), options);
+}
+function ExcludeInstantiate(context, _state, left, right, options = {}) {
+  return getKind(left) === "Ref" && context[left.name ?? ""] === undefined ? ExcludeDeferred(left, right, options) : mergeOptions(filterUnionVariants(context, left, right, false), options);
+}
+function ExtractInstantiate(context, _state, left, right, options = {}) {
+  return getKind(left) === "Ref" && context[left.name ?? ""] === undefined ? ExtractDeferred(left, right, options) : mergeOptions(filterUnionVariants(context, left, right, true), options);
+}
+function IndexInstantiate(context, _state, type, indexer, options = {}) {
+  const object = instantiateObject2(context, type);
+  if (!object) {
+    return IndexDeferred(type, indexer, options);
+  }
+  const keys = extractLiteralKeys(instantiateType(context, indexer));
+  const variants = keys.flatMap((key) => object.properties[key] ? [instantiateType(context, object.properties[key])] : []);
+  return mergeOptions(variants.length === 0 ? Index(object, instantiateType(context, indexer)) : variants.length === 1 ? variants[0] : Union(variants), options);
+}
+function InstanceTypeImmediate(context, _state, type, options = {}) {
+  const resolved = instantiateType(context, type);
+  return getKind(resolved) === "Constructor" ? mergeOptions(resolved.returns, options) : mergeOptions(Never(), options);
+}
+function InstanceTypeInstantiate(context, state, type, options = {}) {
+  const resolved = instantiateType(context, type);
+  return getKind(resolved) === "Constructor" ? InstanceTypeImmediate(context, state, resolved, options) : InstanceTypeDeferred(type, options);
+}
+function InterfaceInstantiate(context, _state, heritage, properties, options = {}) {
+  const nextHeritage = heritage.map((entry) => instantiateType(context, entry));
+  const nextProperties = Object.fromEntries(Object.entries(properties).map(([key, value]) => [key, instantiateType(context, value)]));
+  return mergeOptions(Interface(nextHeritage, nextProperties, options), options);
+}
+function KeyOfImmediate(context, _state, type, options = {}) {
+  return mergeOptions(KeyOfAction(instantiateType(context, type)), options);
+}
+function KeyOfInstantiate(context, state, type, options = {}) {
+  return getKind(type) === "Ref" && context[type.name ?? ""] === undefined ? KeyOfDeferred(type, options) : KeyOfImmediate(context, state, type, options);
+}
+function LowercaseInstantiate(context, _state, type, options = {}) {
+  return getKind(type) === "Ref" && context[type.name ?? ""] === undefined ? LowercaseDeferred(type, options) : mergeOptions({ "~kind": "Lowercase", item: instantiateType(context, type) }, options);
+}
+function MappedInstantiate(context, _state, identifier, key, _asType, property, options = {}) {
+  const keys = extractLiteralKeys(instantiateType(context, key));
+  if (keys.length === 0) {
+    return MappedDeferred(identifier, key, _asType, property, options);
+  }
+  const name = getKind(identifier) === "Identifier" ? identifier.name : "K";
+  const properties = Object.fromEntries(keys.map((keyName) => [keyName, instantiateType({ ...context, [name]: { "~kind": "Literal", const: keyName } }, property)]));
+  return mergeOptions({ "~kind": "Object", properties }, options);
+}
+function ModuleInstantiate(context, _state, definitions, options = {}) {
+  const instantiated = Object.fromEntries(Object.entries(definitions).map(([key, value]) => [key, instantiateType(context, value)]));
+  return mergeOptions({ "~kind": "Module", definitions: instantiated }, options);
+}
+function NonNullableInstantiate(context, state, type, options = {}) {
+  const resolved = instantiateType(context, type);
+  return getKind(type) === "Ref" && context[type.name ?? ""] === undefined ? NonNullableDeferred(type, options) : mergeOptions(ExcludeInstantiate(context, state, resolved, Union([Null(), Undefined()]), options), options);
+}
+function OmitInstantiate(context, _state, type, indexer, options = {}) {
+  const object = instantiateObject2(context, type);
+  if (!object) {
+    return OmitDeferred(type, indexer, options);
+  }
+  const keys = extractLiteralKeys(instantiateType(context, indexer));
+  return mergeOptions(deriveObjectSchema(object, { omitKeys: keys }), options);
+}
+function OptionsInstantiate(context, _state, type, options) {
+  return mergeOptions(Options(instantiateType(context, type), options), options);
+}
+function ParametersInstantiate(context, _state, type, options = {}) {
+  const resolved = instantiateType(context, type);
+  return getKind(resolved) === "Function" ? mergeOptions(Tuple(resolved.parameters), options) : ParametersDeferred(type, options);
+}
+function PartialInstantiate(context, _state, type, options = {}) {
+  const object = instantiateObject2(context, type);
+  return object ? mergeOptions(deriveObjectSchema(object, { requiredMode: "none" }), options) : PartialDeferred(type, options);
+}
+function PickInstantiate(context, _state, type, indexer, options = {}) {
+  const object = instantiateObject2(context, type);
+  if (!object) {
+    return PickDeferred(type, indexer, options);
+  }
+  const keys = extractLiteralKeys(instantiateType(context, indexer));
+  return mergeOptions(deriveObjectSchema(object, { pickKeys: keys }), options);
+}
+function ReadonlyTypeInstantiate(context, _state, type, options = {}) {
+  return getKind(type) === "Ref" && context[type.name ?? ""] === undefined ? ReadonlyTypeDeferred(type, options) : mergeOptions(ReadonlyType(instantiateType(context, type), options), options);
+}
+function RecordInstantiate(context, _state, key, value, options = {}) {
+  return mergeOptions({ "~kind": "Record", key: instantiateType(context, key), value: instantiateType(context, value) }, options);
+}
+function RefInstantiate(context, _state, type, ref) {
+  return context[ref] ?? type;
+}
+function RequiredInstantiate(context, _state, type, options = {}) {
+  const object = instantiateObject2(context, type);
+  return object ? mergeOptions(deriveObjectSchema(object, { requiredMode: "all" }), options) : RequiredDeferred(type, options);
+}
+function ReturnTypeInstantiate(context, _state, type, options = {}) {
+  const resolved = instantiateType(context, type);
+  return getKind(resolved) === "Function" ? mergeOptions(resolved.returns, options) : ReturnTypeDeferred(type, options);
+}
+function TemplateLiteralInstantiate(context, _state, types, options = {}) {
+  return mergeOptions(TemplateLiteralFromTypes(types.map((type) => instantiateType(context, type))), options);
+}
+function UncapitalizeInstantiate(context, _state, type, options = {}) {
+  return getKind(type) === "Ref" && context[type.name ?? ""] === undefined ? UncapitalizeDeferred(type, options) : mergeOptions({ "~kind": "Uncapitalize", item: instantiateType(context, type) }, options);
+}
+function UppercaseInstantiate(context, _state, type, options = {}) {
+  return getKind(type) === "Ref" && context[type.name ?? ""] === undefined ? UppercaseDeferred(type, options) : mergeOptions({ "~kind": "Uppercase", item: instantiateType(context, type) }, options);
+}
+// src/shared/bytes.ts
+import { dlopen, ptr } from "bun:ffi";
+var libcPath = process.platform === "darwin" ? "/usr/lib/libSystem.B.dylib" : process.platform === "linux" ? "libc.so.6" : process.platform === "win32" ? "msvcrt.dll" : "";
+var memcmp = libcPath === "" ? undefined : dlopen(libcPath, {
+  memcmp: {
+    args: ["ptr", "ptr", "usize"],
+    returns: "i32"
+  }
+}).symbols.memcmp;
+function encodeUint8ArrayBase64(value) {
+  return Buffer.from(value.buffer, value.byteOffset, value.byteLength).toString("base64");
+}
+function decodeUint8ArrayBase64(value) {
+  const bunWithBase64 = Bun;
+  if (typeof bunWithBase64.base64ToBytes === "function") {
+    return bunWithBase64.base64ToBytes(value);
+  }
+  return new Uint8Array(Buffer.from(value, "base64"));
+}
+function getBase64DecodedByteLength(value) {
+  const padding = value.endsWith("==") ? 2 : value.endsWith("=") ? 1 : 0;
+  return value.length / 4 * 3 - padding;
+}
+function areUint8ArraysEqual(left, right) {
+  if (left.byteLength !== right.byteLength) {
+    return false;
+  }
+  if (left.byteLength === 0) {
+    return true;
+  }
+  if (memcmp !== undefined) {
+    return memcmp(ptr(left), ptr(right), left.byteLength) === 0;
+  }
+  for (let index = 0;index < left.length; index += 1) {
+    if (left[index] !== right[index]) {
+      return false;
+    }
+  }
+  return true;
+}
+function isUint8ArrayWithinBounds(value, minByteLength, maxByteLength) {
+  if (minByteLength !== undefined && value.byteLength < minByteLength)
+    return false;
+  return maxByteLength === undefined || value.byteLength <= maxByteLength;
+}
+function isUint8ArrayBase64String(value, minByteLength, maxByteLength, constBytes, constBase64) {
+  if (typeof value !== "string" || !validateFormat(value, "base64")) {
+    return false;
+  }
+  if (!isUint8ArrayWithinBounds({ byteLength: getBase64DecodedByteLength(value) }, minByteLength, maxByteLength)) {
+    return false;
+  }
+  return constBytes === undefined ? true : value === (constBase64 ?? encodeUint8ArrayBase64(constBytes));
+}
+
+// src/type/uint8array-codec.ts
+function Uint8ArrayCodec(options = {}) {
+  const constBase64 = options.constBytes === undefined ? undefined : encodeUint8ArrayBase64(options.constBytes);
+  const codec = Codec(String2({
+    format: "base64",
+    ...options.title === undefined ? {} : { title: options.title },
+    ...options.description === undefined ? {} : { description: options.description }
+  })).Decode((input) => decodeUint8ArrayBase64(input)).Encode((input) => encodeUint8ArrayBase64(input));
+  return {
+    ...Refine(codec, (input) => isUint8ArrayBase64String(input, options.minByteLength, options.maxByteLength, options.constBytes, constBase64), "Expected a base64-encoded Uint8Array value"),
+    "~uint8arrayCodec": true,
+    ...options.minByteLength === undefined ? {} : { minByteLength: options.minByteLength },
+    ...options.maxByteLength === undefined ? {} : { maxByteLength: options.maxByteLength },
+    ...options.constBytes === undefined ? {} : { constBytes: options.constBytes },
+    ...constBase64 === undefined ? {} : { constBase64 }
+  };
+}
+// src/type/codec-builtins.ts
+var bigintPattern = "^-?(0|[1-9][0-9]*)$";
+function BigIntCodec() {
+  return Codec(String2({ pattern: bigintPattern })).Decode((input) => globalThis.BigInt(input)).Encode((input) => input.toString());
+}
+function DateCodec() {
+  return Codec(String2({ format: "datetime" })).Decode((input) => new globalThis.Date(input)).Encode((input) => input.toISOString());
+}
+function URLCodec() {
+  return Codec(String2({ format: "uri" })).Decode((input) => new URL(input)).Encode((input) => input.toString());
+}
+// src/script/shared.ts
+function parseIdentifier(input) {
+  const match = /^[a-zA-Z_$][a-zA-Z0-9_$]*/.exec(input);
+  return match ? match[0] : null;
+}
+function resolveType(name, defs) {
+  const definition = defs[name];
+  switch (name) {
+    case "string":
+      return String2();
+    case "number":
+      return Number2();
+    case "integer":
+      return Integer();
+    case "boolean":
+      return Boolean();
+    case "null":
+      return Null();
+    case "undefined":
+      return Undefined();
+    case "void":
+      return Void();
+    case "unknown":
+      return Unknown();
+    case "any":
+      return Any();
+    case "never":
+      return Never();
+    case "bigint":
+      return BigInt();
+    case "symbol":
+      return Symbol2();
+    case "Date":
+      return Date();
+    case "Uint8Array":
+      return Uint8Array2();
+    default:
+      return definition ?? Ref(name);
+  }
+}
+function findMatchingParen(input) {
+  return findMatching(input, "(", ")");
+}
+function findMatchingBrace(input) {
+  return findMatching(input, "{", "}");
+}
+function findMatchingBracket(input) {
+  return findMatching(input, "[", "]");
+}
+function findMatchingAngle(input) {
+  return findMatching(input, "<", ">");
+}
+function findMatching(input, open, close) {
+  let depth = 0;
+  let index = 0;
+  while (index < input.length) {
+    const character = input[index];
+    if (character === open)
+      depth += 1;
+    if (character === close) {
+      depth -= 1;
+      if (depth === 0) {
+        return input.slice(1, index);
+      }
+    }
+    index += 1;
+  }
+  return input.slice(1);
+}
+function splitTopLevel(input, delimiter) {
+  const result = [];
+  let depth = 0;
+  let current = "";
+  for (const character of input) {
+    if (character === "(" || character === "{" || character === "[" || character === "<")
+      depth += 1;
+    if (character === ")" || character === "}" || character === "]" || character === ">")
+      depth -= 1;
+    if (character === delimiter && depth === 0) {
+      result.push(current);
+      current = "";
+      continue;
+    }
+    current += character;
+  }
+  if (current.trim().length > 0) {
+    result.push(current);
+  }
+  return result;
+}
+
+// src/script/generic.ts
+function isObjectSchema(schema) {
+  return schema["~kind"] === "Object";
+}
+function getLiteralString(schema) {
+  if (schema["~kind"] !== "Literal") {
+    return "";
+  }
+  const literal = schema;
+  return typeof literal.const === "string" ? literal.const : "";
+}
+function parseGeneric(name, rest, defs, parseScript) {
+  const argumentSource = findMatchingAngle(rest);
+  const arguments_ = splitTopLevel(argumentSource, ",").map((entry) => parseScript(entry.trim(), defs));
+  const afterArguments = rest.slice(argumentSource.length + 2).trim();
+  switch (name) {
+    case "Array":
+      return { schema: Array2(arguments_[0] ?? Unknown()), rest: afterArguments };
+    case "Record":
+      return {
+        schema: Record(arguments_[0] ?? String2(), arguments_[1] ?? Unknown()),
+        rest: afterArguments
+      };
+    case "Partial": {
+      const object = arguments_[0];
+      return {
+        schema: object !== undefined && isObjectSchema(object) ? Partial(object) : object ?? Unknown(),
+        rest: afterArguments
+      };
+    }
+    case "Required": {
+      const object = arguments_[0];
+      return {
+        schema: object !== undefined && isObjectSchema(object) ? Required(object) : object ?? Unknown(),
+        rest: afterArguments
+      };
+    }
+    case "Pick": {
+      const object = arguments_[0];
+      const keys = arguments_.slice(1).map(getLiteralString);
+      return {
+        schema: object !== undefined && isObjectSchema(object) ? Pick(object, keys) : object ?? Unknown(),
+        rest: afterArguments
+      };
+    }
+    case "Omit": {
+      const object = arguments_[0];
+      const keys = arguments_.slice(1).map(getLiteralString);
+      return {
+        schema: object !== undefined && isObjectSchema(object) ? Omit(object, keys) : object ?? Unknown(),
+        rest: afterArguments
+      };
+    }
+    case "Promise":
+      return { schema: Promise2(arguments_[0] ?? Unknown()), rest: afterArguments };
+    case "Iterator":
+      return { schema: Iterator(arguments_[0] ?? Unknown()), rest: afterArguments };
+    case "AsyncIterator":
+      return { schema: AsyncIterator(arguments_[0] ?? Unknown()), rest: afterArguments };
+    case "Exclude":
+      return { schema: Exclude(arguments_[0] ?? Unknown(), arguments_[1] ?? Unknown()), rest: afterArguments };
+    case "Extract":
+      return { schema: Extract(arguments_[0] ?? Unknown(), arguments_[1] ?? Unknown()), rest: afterArguments };
+    default:
+      return { schema: resolveType(name, defs), rest: afterArguments };
+  }
+}
+
+// src/script/literals.ts
+function parseObjectLiteral(input, defs, parseScript) {
+  const body = findMatchingBrace(input);
+  const entries = splitTopLevel(body, ";").filter((entry) => entry.trim().length > 0);
+  const properties = {};
+  const required = [];
+  const optional = [];
+  for (const entry of entries) {
+    const trimmed = entry.trim();
+    const optionalMatch = /^(\w+)\?\s*:\s*(.+)$/.exec(trimmed);
+    if (optionalMatch) {
+      const key2 = optionalMatch[1];
+      const typeText2 = optionalMatch[2].trim();
+      properties[key2] = parseScript(typeText2, defs);
+      optional.push(key2);
+      continue;
+    }
+    const requiredMatch = /^(\w+)\s*:\s*(.+)$/.exec(trimmed);
+    if (!requiredMatch) {
+      continue;
+    }
+    const key = requiredMatch[1];
+    const typeText = requiredMatch[2].trim();
+    properties[key] = parseScript(typeText, defs);
+    required.push(key);
+  }
+  const objectOptions = {
+    ...required.length > 0 ? { required } : {},
+    ...optional.length > 0 ? { optional } : {}
+  };
+  return {
+    schema: Object2(properties, objectOptions),
+    rest: input.slice(body.length + 2).trim()
+  };
+}
+function parseTupleLiteral(input, defs, parseScript) {
+  const body = findMatchingBracket(input);
+  const elements = splitTopLevel(body, ",").filter((entry) => entry.trim().length > 0);
+  const items = elements.map((entry) => parseScript(entry.trim(), defs));
+  return {
+    schema: Tuple(items),
+    rest: input.slice(body.length + 2).trim()
+  };
+}
+function parseStringLiteral(input) {
+  const quote = input.charAt(0);
+  let index = 1;
+  while (index < input.length && input[index] !== quote) {
+    if (input[index] === "\\") {
+      index += 1;
+    }
+    index += 1;
+  }
+  return {
+    schema: Literal(input.slice(1, index)),
+    rest: input.slice(index + 1).trim()
+  };
+}
+
+// src/script/index.ts
+function Script(input) {
+  return parseScript(input.trim(), {});
+}
+function ScriptWithDefinitions(input, definitions) {
+  return parseScript(input.trim(), definitions);
+}
+function parseScript(input, defs) {
+  return parseUnionOrIntersect(input, defs).schema;
+}
+function parseUnionOrIntersect(input, defs) {
+  const left = parsePrimary(input, defs);
+  let rest = left.rest.trim();
+  if (rest.startsWith("|")) {
+    const variants = [left.schema];
+    while (rest.startsWith("|")) {
+      rest = rest.slice(1).trim();
+      const next = parsePrimary(rest, defs);
+      variants.push(next.schema);
+      rest = next.rest.trim();
+    }
+    return { schema: Union(variants), rest };
+  }
+  if (rest.startsWith("&")) {
+    const variants = [left.schema];
+    while (rest.startsWith("&")) {
+      rest = rest.slice(1).trim();
+      const next = parsePrimary(rest, defs);
+      variants.push(next.schema);
+      rest = next.rest.trim();
+    }
+    return { schema: Intersect(variants), rest };
+  }
+  return left;
+}
+function parsePrimary(input, defs) {
+  let result = parseAtom(input, defs);
+  let rest = result.rest.trim();
+  while (rest.startsWith("[]")) {
+    result = { schema: Array2(result.schema), rest: rest.slice(2).trim() };
+    rest = result.rest;
+  }
+  return result;
+}
+function parseAtom(input, defs) {
+  if (input.startsWith("(")) {
+    const inner = findMatchingParen(input);
+    return {
+      schema: parseScript(inner, defs),
+      rest: input.slice(inner.length + 2).trim()
+    };
+  }
+  if (input.startsWith("{")) {
+    return parseObjectLiteral(input, defs, parseScript);
+  }
+  if (input.startsWith("[")) {
+    return parseTupleLiteral(input, defs, parseScript);
+  }
+  if (input.startsWith('"') || input.startsWith("'")) {
+    return parseStringLiteral(input);
+  }
+  const numericMatch = /^(-?\d+(?:\.\d+)?)/.exec(input);
+  if (numericMatch) {
+    const literal = numericMatch[1];
+    return {
+      schema: Literal(Number.parseFloat(literal)),
+      rest: input.slice(literal.length).trim()
+    };
+  }
+  if (input.startsWith("true")) {
+    return { schema: Literal(true), rest: input.slice(4).trim() };
+  }
+  if (input.startsWith("false")) {
+    return { schema: Literal(false), rest: input.slice(5).trim() };
+  }
+  const identifier = parseIdentifier(input);
+  if (!identifier) {
+    return { schema: Unknown(), rest: input };
+  }
+  const rest = input.slice(identifier.length).trim();
+  if (rest.startsWith("<")) {
+    return parseGeneric(identifier, rest, defs, parseScript);
+  }
+  return { schema: resolveType(identifier, defs), rest };
+}
+
+// src/typebox.ts
+var exports_typebox = {};
+__export(exports_typebox, {
+  _Object_: () => _Object_,
+  _Function_: () => _Function_,
+  VoidKind: () => VoidKind,
+  Void: () => Void,
+  Variant: () => Variant,
+  UuidKind: () => UuidKind,
+  Uuid: () => Uuid,
+  UriKind: () => UriKind,
+  Uri: () => Uri,
+  UppercaseKind: () => UppercaseKind,
+  UppercaseInstantiate: () => UppercaseInstantiate,
+  UppercaseDeferred: () => UppercaseDeferred,
+  Uppercase: () => Uppercase,
+  UnsafeKind: () => UnsafeKind,
+  Unsafe: () => Unsafe,
+  UnknownKind: () => UnknownKind,
+  Unknown: () => Unknown,
+  UnionOptions: () => UnionOptions,
+  UnionKind: () => UnionKind,
+  Union: () => Union,
+  UndefinedKind: () => UndefinedKind,
+  Undefined: () => Undefined,
+  UncapitalizeKind: () => UncapitalizeKind,
+  UncapitalizeInstantiate: () => UncapitalizeInstantiate,
+  UncapitalizeDeferred: () => UncapitalizeDeferred,
+  Uncapitalize: () => Uncapitalize,
+  Uint8ArrayKind: () => Uint8ArrayKind,
+  Uint8ArrayCodec: () => Uint8ArrayCodec,
+  Uint8Array: () => Uint8Array2,
+  URLCodec: () => URLCodec,
+  TypeScriptEnumToEnumValues: () => TypeScriptEnumToEnumValues,
+  TupleOptions: () => TupleOptions,
+  TupleKind: () => TupleKind,
+  Tuple: () => Tuple,
+  TimeKind: () => TimeKind,
+  Time: () => Time,
+  This: () => This,
+  TemplateLiteralKind: () => TemplateLiteralKind,
+  TemplateLiteralInstantiate: () => TemplateLiteralInstantiate,
+  TemplateLiteralFromTypes: () => TemplateLiteralFromTypes,
+  TemplateLiteralFromString: () => TemplateLiteralFromString,
+  TemplateLiteralEncode: () => TemplateLiteralEncode,
+  TemplateLiteralDeferred: () => TemplateLiteralDeferred,
+  TemplateLiteralDecodeUnsafe: () => TemplateLiteralDecodeUnsafe,
+  TemplateLiteralDecode: () => TemplateLiteralDecode,
+  TemplateLiteralCreate: () => TemplateLiteralCreate,
+  TemplateLiteral: () => TemplateLiteral,
+  TemplateElementKind: () => TemplateElementKind,
+  SymbolKind: () => SymbolKind,
+  Symbol: () => Symbol2,
+  StringPattern: () => StringPattern,
+  StringKind: () => StringKind,
+  StringKey: () => StringKey,
+  String: () => String2,
+  SelfKind: () => SelfKind,
+  ScriptWithDefinitions: () => ScriptWithDefinitions,
+  Script: () => Script,
+  ReturnTypeKind: () => ReturnTypeKind,
+  ReturnTypeInstantiate: () => ReturnTypeInstantiate,
+  ReturnTypeDeferred: () => ReturnTypeDeferred,
+  ReturnType: () => ReturnType,
+  ResultRightInside: () => ResultRightInside,
+  ResultLeftInside: () => ResultLeftInside,
+  ResultEqual: () => ResultEqual,
+  ResultDisjoint: () => ResultDisjoint,
+  RestKind: () => RestKind,
+  Rest: () => Rest,
+  RequiredKind: () => RequiredKind,
+  RequiredInstantiate: () => RequiredInstantiate,
+  RequiredDeferred: () => RequiredDeferred,
+  RequiredArray: () => RequiredArray,
+  Required: () => Required,
+  RegExpKind: () => RegExpKind,
+  RegExpInstance: () => RegExpInstance,
+  RegExp: () => RegExp2,
+  RefineAdd: () => RefineAdd,
+  Refine: () => Refine,
+  RefKind: () => RefKind,
+  RefInstantiate: () => RefInstantiate,
+  Ref: () => Ref,
+  RecursiveKind: () => RecursiveKind,
+  Recursive: () => Recursive,
+  RecordValue: () => RecordValue,
+  RecordPattern: () => RecordPattern,
+  RecordOptions: () => RecordOptions,
+  RecordKind: () => RecordKind,
+  RecordKeyAsPattern: () => RecordPattern,
+  RecordKey: () => RecordKey,
+  RecordInstantiate: () => RecordInstantiate,
+  RecordFromPattern: () => RecordFromPattern,
+  RecordDeferred: () => RecordDeferred,
+  RecordConstruct: () => RecordConstruct,
+  Record: () => Record,
+  ReadonlyTypeInstantiate: () => ReadonlyTypeInstantiate,
+  ReadonlyTypeDeferred: () => ReadonlyTypeDeferred,
+  ReadonlyType: () => ReadonlyType,
+  ReadonlyRemoveAction: () => ReadonlyRemoveAction,
+  ReadonlyRemove: () => ReadonlyRemove,
+  ReadonlyKind: () => ReadonlyKind,
+  ReadonlyAddAction: () => ReadonlyAddAction,
+  ReadonlyAdd: () => ReadonlyAdd,
+  Readonly: () => Readonly,
+  PropertyValues: () => PropertyValues,
+  PropertyKeys: () => PropertyKeys,
+  PromiseOptions: () => PromiseOptions,
+  PromiseKind: () => PromiseKind,
+  Promise: () => Promise2,
+  PickKind: () => PickKind,
+  PickInstantiate: () => PickInstantiate,
+  PickDeferred: () => PickDeferred,
+  Pick: () => Pick,
+  PartialKind: () => PartialKind,
+  PartialInstantiate: () => PartialInstantiate,
+  PartialDeferred: () => PartialDeferred,
+  Partial: () => Partial,
+  ParseTemplateIntoTypes: () => ParseTemplateIntoTypes,
+  ParsePatternIntoTypes: () => ParsePatternIntoTypes,
+  ParametersKind: () => ParametersKind,
+  ParametersInstantiate: () => ParametersInstantiate,
+  ParametersDeferred: () => ParametersDeferred,
+  Parameters: () => Parameters,
+  Parameter: () => Parameter,
+  OptionsInstantiate: () => OptionsInstantiate,
+  OptionsDeferred: () => OptionsDeferred,
+  Options: () => Options,
+  OptionalRemoveAction: () => OptionalRemoveAction,
+  OptionalRemove: () => OptionalRemove,
+  OptionalKind: () => OptionalKind,
+  OptionalAddAction: () => OptionalAddAction,
+  OptionalAdd: () => OptionalAdd,
+  Optional: () => Optional,
+  OmitKind: () => OmitKind,
+  OmitInstantiate: () => OmitInstantiate,
+  OmitDeferred: () => OmitDeferred,
+  Omit: () => Omit,
+  ObjectOptions: () => ObjectOptions,
+  ObjectKind: () => ObjectKind,
+  Object: () => Object2,
+  NumberPattern: () => NumberPattern,
+  NumberKind: () => NumberKind,
+  NumberKey: () => NumberKey,
+  Number: () => Number2,
+  NullKind: () => NullKind,
+  Null: () => Null,
+  NotKind: () => NotKind,
+  Not: () => Not,
+  NonNullableInstantiate: () => NonNullableInstantiate,
+  NonNullableDeferred: () => NonNullableDeferred,
+  NonNullable: () => NonNullable,
+  NeverPattern: () => NeverPattern,
+  NeverKind: () => NeverKind,
+  Never: () => Never,
+  Narrow: () => Narrow,
+  ModuleKind: () => ModuleKind,
+  ModuleInstantiate: () => ModuleInstantiate,
+  ModuleDeferred: () => ModuleDeferred,
+  Module: () => Module,
+  MappedKind: () => MappedKind,
+  MappedInstantiate: () => MappedInstantiate,
+  MappedDeferred: () => MappedDeferred,
+  Mapped: () => Mapped,
+  LowercaseKind: () => LowercaseKind,
+  LowercaseInstantiate: () => LowercaseInstantiate,
+  LowercaseDeferred: () => LowercaseDeferred,
+  Lowercase: () => Lowercase,
+  LiteralTypeName: () => LiteralTypeName,
+  LiteralKind: () => LiteralKind,
+  Literal: () => Literal,
+  KeysToIndexer: () => KeysToIndexer,
+  KeyOfKind: () => KeyOfKind,
+  KeyOfInstantiate: () => KeyOfInstantiate,
+  KeyOfImmediate: () => KeyOfImmediate,
+  KeyOfDeferred: () => KeyOfDeferred,
+  KeyOfAction: () => KeyOfAction,
+  KeyOf: () => KeyOf,
+  JsonKind: () => JsonKind,
+  Json: () => Json,
+  IteratorOptions: () => IteratorOptions,
+  IteratorKind: () => IteratorKind,
+  Iterator: () => Iterator,
+  IsVoid: () => IsVoid,
+  IsUppercase: () => IsUppercase,
+  IsUnsafe: () => IsUnsafe,
+  IsUnknown: () => IsUnknown,
+  IsUnion: () => IsUnion,
+  IsUndefined: () => IsUndefined,
+  IsUncapitalize: () => IsUncapitalize,
+  IsUint8Array: () => IsUint8Array,
+  IsTypeScriptEnumLike: () => IsTypeScriptEnumLike,
+  IsTuple: () => IsTuple,
+  IsThis: () => IsThis,
+  IsTemplateLiteralPattern: () => IsTemplateLiteralPattern,
+  IsTemplateLiteralFinite: () => IsTemplateLiteralFinite,
+  IsTemplateLiteral: () => IsTemplateLiteral,
+  IsSymbol: () => IsSymbol,
+  IsString: () => IsString,
+  IsSchema: () => IsSchema,
+  IsReturnType: () => IsReturnType,
+  IsRest: () => IsRest,
+  IsRequired: () => IsRequired,
+  IsRegExpInstance: () => IsRegExpInstance,
+  IsRefine: () => IsRefine,
+  IsRef: () => IsRef,
+  IsRecursive: () => IsRecursive,
+  IsRecord: () => IsRecord,
+  IsReadonlyType: () => IsReadonlyType,
+  IsReadonlyRemoveAction: () => IsReadonlyRemoveAction,
+  IsReadonlyAddAction: () => IsReadonlyAddAction,
+  IsReadonly: () => IsReadonly,
+  IsPromise: () => IsPromise,
+  IsPick: () => IsPick,
+  IsPartial: () => IsPartial,
+  IsParameters: () => IsParameters,
+  IsParameter: () => IsParameter,
+  IsOptions: () => IsOptions,
+  IsOptionalRemoveAction: () => IsOptionalRemoveAction,
+  IsOptionalAddAction: () => IsOptionalAddAction,
+  IsOptional: () => IsOptional,
+  IsOmit: () => IsOmit,
+  IsObject: () => IsObject,
+  IsNumber: () => IsNumber,
+  IsNull: () => IsNull,
+  IsNot: () => IsNot,
+  IsNonNullable: () => IsNonNullable,
+  IsNever: () => IsNever,
+  IsModule: () => IsModule,
+  IsMapped: () => IsMapped,
+  IsLowercase: () => IsLowercase,
+  IsLiteralValue: () => IsLiteralValue,
+  IsLiteralString: () => IsLiteralString,
+  IsLiteralNumber: () => IsLiteralNumber,
+  IsLiteralBoolean: () => IsLiteralBoolean,
+  IsLiteralBigInt: () => IsLiteralBigInt,
+  IsLiteral: () => IsLiteral,
+  IsKind: () => IsKind,
+  IsKeyOf: () => IsKeyOf,
+  IsIterator: () => IsIterator,
+  IsIntersect: () => IsIntersect,
+  IsInterfaceDeferred: () => IsInterfaceDeferred,
+  IsInterface: () => IsInterface,
+  IsInteger: () => IsInteger,
+  IsInstanceType: () => IsInstanceType,
+  IsInfer: () => IsInfer,
+  IsIndex: () => IsIndex,
+  IsImmutable: () => IsImmutable,
+  IsIfThenElse: () => IsIfThenElse,
+  IsIdentifier: () => IsIdentifier,
+  IsGeneric: () => IsGeneric,
+  IsFunction: () => IsFunction,
+  IsExtract: () => IsExtract,
+  IsExclude: () => IsExclude,
+  IsEnum: () => IsEnum,
+  IsEncode: () => IsEncode,
+  IsDeferred: () => IsDeferred,
+  IsDecode: () => IsDecode,
+  IsDate: () => IsDate,
+  IsCyclic: () => IsCyclic,
+  IsConstructorParameters: () => IsConstructorParameters,
+  IsConstructor: () => IsConstructor,
+  IsConditional: () => IsConditional,
+  IsCodec: () => IsCodec,
+  IsCapitalize: () => IsCapitalize,
+  IsCall: () => IsCall,
+  IsBoolean: () => IsBoolean,
+  IsBigInt: () => IsBigInt,
+  IsBase: () => IsBase,
+  IsAwaited: () => IsAwaited,
+  IsAsyncIterator: () => IsAsyncIterator,
+  IsArray: () => IsArray,
+  IsAny: () => IsAny,
+  IpKind: () => IpKind,
+  Ip: () => Ip,
+  InvalidLiteralValue: () => InvalidLiteralValue,
+  IntersectOptions: () => IntersectOptions,
+  IntersectKind: () => IntersectKind,
+  Intersect: () => Intersect,
+  InterfaceInstantiate: () => InterfaceInstantiate,
+  InterfaceDeferred: () => InterfaceDeferred,
+  Interface: () => Interface,
+  IntegerPattern: () => IntegerPattern,
+  IntegerKind: () => IntegerKind,
+  IntegerKey: () => IntegerKey,
+  Integer: () => Integer,
+  InstantiateCyclic: () => InstantiateCyclic,
+  Instantiate: () => Instantiate,
+  InstanceTypeKind: () => InstanceTypeKind,
+  InstanceTypeInstantiate: () => InstanceTypeInstantiate,
+  InstanceTypeImmediate: () => InstanceTypeImmediate,
+  InstanceTypeDeferred: () => InstanceTypeDeferred,
+  InstanceType: () => InstanceType,
+  Infer: () => Infer,
+  IndexKind: () => IndexKind,
+  IndexInstantiate: () => IndexInstantiate,
+  IndexDeferred: () => IndexDeferred,
+  Index: () => Index,
+  Import: () => Import,
+  ImmutableRemove: () => ImmutableRemove,
+  ImmutableAdd: () => ImmutableAdd,
+  Immutable: () => Immutable,
+  IfThenElseKind: () => IfThenElseKind,
+  IfThenElse: () => IfThenElse,
+  Identifier: () => Identifier,
+  HostnameKind: () => HostnameKind,
+  Hostname: () => Hostname,
+  HexKind: () => HexKind,
+  HexColorKind: () => HexColorKind,
+  HexColor: () => HexColor,
+  Hex: () => Hex,
+  Generic: () => Generic,
+  FunctionOptions: () => FunctionOptions,
+  FunctionKind: () => FunctionKind,
+  Function: () => Function,
+  Flatten: () => Flatten,
+  ExtractKind: () => ExtractKind,
+  ExtractInstantiate: () => ExtractInstantiate,
+  ExtractDeferred: () => ExtractDeferred,
+  Extract: () => Extract,
+  ExtendsResult: () => ExtendsResult,
+  Extends: () => Extends,
+  ExcludeKind: () => ExcludeKind,
+  ExcludeInstantiate: () => ExcludeInstantiate,
+  ExcludeDeferred: () => ExcludeDeferred,
+  Exclude: () => Exclude,
+  EvaluateUnionFast: () => EvaluateUnionFast,
+  EvaluateUnion: () => EvaluateUnion,
+  EvaluateType: () => EvaluateType,
+  EvaluateIntersect: () => EvaluateIntersect,
+  EvaluateInstantiate: () => EvaluateInstantiate,
+  EvaluateDeferred: () => EvaluateDeferred,
+  Evaluate: () => Evaluate,
+  EnumValuesToVariants: () => EnumValuesToVariants,
+  EnumValuesToUnion: () => EnumValuesToUnion,
+  EnumToUnion: () => EnumToUnion,
+  EnumKind: () => EnumKind,
+  Enum: () => Enum,
+  EncodeKind: () => EncodeKind,
+  EncodeBuilder: () => EncodeBuilder,
+  Encode: () => Encode,
+  EmailKind: () => EmailKind,
+  Email: () => Email,
+  DurationKind: () => DurationKind,
+  Duration: () => Duration,
+  Distribute: () => Distribute,
+  Deferred: () => Deferred,
+  DecodeKind: () => DecodeKind,
+  DecodeBuilder: () => DecodeBuilder,
+  Decode: () => Decode,
+  DateTimeKind: () => DateTimeKind,
+  DateTime: () => DateTime,
+  DateKind: () => DateKind,
+  DateFormatKind: () => DateFormatKind,
+  DateFormat: () => DateFormat,
+  DateCodec: () => DateCodec,
+  Date: () => Date,
+  CyclicTarget: () => CyclicTarget,
+  CyclicOptions: () => CyclicOptions,
+  CyclicExtends: () => CyclicExtends,
+  CyclicDependencies: () => CyclicDependencies,
+  CyclicCheck: () => CyclicCheck,
+  CyclicCandidates: () => CyclicCandidates,
+  Cyclic: () => Cyclic,
+  CreditCardKind: () => CreditCardKind,
+  CreditCard: () => CreditCard,
+  ConvertToIntegerKey: () => ConvertToIntegerKey,
+  ConstructorParametersKind: () => ConstructorParametersKind,
+  ConstructorParametersInstantiate: () => ConstructorParametersInstantiate,
+  ConstructorParametersDeferred: () => ConstructorParametersDeferred,
+  ConstructorParameters: () => ConstructorParameters,
+  ConstructorOptions: () => ConstructorOptions,
+  ConstructorKind: () => ConstructorKind,
+  Constructor: () => Constructor,
+  ConditionalKind: () => ConditionalKind,
+  ConditionalInstantiate: () => ConditionalInstantiate,
+  ConditionalDeferred: () => ConditionalDeferred,
+  Conditional: () => Conditional,
+  Composite: () => Composite,
+  Compare: () => Compare,
+  CollapseToObject: () => CollapseToObject,
+  Codec: () => Codec,
+  Clone: () => Clone2,
+  CapitalizeKind: () => CapitalizeKind,
+  CapitalizeInstantiate: () => CapitalizeInstantiate,
+  CapitalizeDeferred: () => CapitalizeDeferred,
+  Capitalize: () => Capitalize,
+  CallConstruct: () => CallConstruct,
+  Call: () => Call,
+  Broaden: () => Broaden,
+  BooleanKind: () => BooleanKind,
+  Boolean: () => Boolean,
+  BigIntPattern: () => BigIntPattern,
+  BigIntKind: () => BigIntKind,
+  BigIntCodec: () => BigIntCodec,
+  BigInt: () => BigInt,
+  Base64Kind: () => Base64Kind,
+  Base64: () => Base64,
+  Base: () => Base,
+  AwaitedKind: () => AwaitedKind,
+  AwaitedInstantiate: () => AwaitedInstantiate,
+  AwaitedDeferred: () => AwaitedDeferred,
+  Awaited: () => Awaited,
+  AsyncIteratorOptions: () => AsyncIteratorOptions,
+  AsyncIteratorKind: () => AsyncIteratorKind,
+  AsyncIterator: () => AsyncIterator,
+  ArrayOptions: () => ArrayOptions,
+  ArrayKind: () => ArrayKind,
+  Array: () => Array2,
+  AnyKind: () => AnyKind,
+  Any: () => Any
+});
+export {
+  _Object_,
+  _Function_,
+  VoidKind,
+  Void,
+  Variant,
+  UuidKind,
+  Uuid,
+  UriKind,
+  Uri,
+  UppercaseKind,
+  UppercaseInstantiate,
+  UppercaseDeferred,
+  Uppercase,
+  UnsafeKind,
+  Unsafe,
+  UnknownKind,
+  Unknown,
+  UnionOptions,
+  UnionKind,
+  Union,
+  UndefinedKind,
+  Undefined,
+  UncapitalizeKind,
+  UncapitalizeInstantiate,
+  UncapitalizeDeferred,
+  Uncapitalize,
+  Uint8ArrayKind,
+  Uint8ArrayCodec,
+  Uint8Array2 as Uint8Array,
+  URLCodec,
+  TypeScriptEnumToEnumValues,
+  TupleOptions,
+  TupleKind,
+  Tuple,
+  TimeKind,
+  Time,
+  This,
+  TemplateLiteralKind,
+  TemplateLiteralInstantiate,
+  TemplateLiteralFromTypes,
+  TemplateLiteralFromString,
+  TemplateLiteralEncode,
+  TemplateLiteralDeferred,
+  TemplateLiteralDecodeUnsafe,
+  TemplateLiteralDecode,
+  TemplateLiteralCreate,
+  TemplateLiteral,
+  TemplateElementKind,
+  SymbolKind,
+  Symbol2 as Symbol,
+  StringPattern,
+  StringKind,
+  StringKey,
+  String2 as String,
+  SelfKind,
+  ScriptWithDefinitions,
+  Script,
+  ReturnTypeKind,
+  ReturnTypeInstantiate,
+  ReturnTypeDeferred,
+  ReturnType,
+  ResultRightInside,
+  ResultLeftInside,
+  ResultEqual,
+  ResultDisjoint,
+  RestKind,
+  Rest,
+  RequiredKind,
+  RequiredInstantiate,
+  RequiredDeferred,
+  RequiredArray,
+  Required,
+  RegExpKind,
+  RegExpInstance,
+  RegExp2 as RegExp,
+  RefineAdd,
+  Refine,
+  RefKind,
+  RefInstantiate,
+  Ref,
+  RecursiveKind,
+  Recursive,
+  RecordValue,
+  RecordPattern,
+  RecordOptions,
+  RecordKind,
+  RecordPattern as RecordKeyAsPattern,
+  RecordKey,
+  RecordInstantiate,
+  RecordFromPattern,
+  RecordDeferred,
+  RecordConstruct,
+  Record,
+  ReadonlyTypeInstantiate,
+  ReadonlyTypeDeferred,
+  ReadonlyType,
+  ReadonlyRemoveAction,
+  ReadonlyRemove,
+  ReadonlyKind,
+  ReadonlyAddAction,
+  ReadonlyAdd,
+  Readonly,
+  PropertyValues,
+  PropertyKeys,
+  PromiseOptions,
+  PromiseKind,
+  Promise2 as Promise,
+  PickKind,
+  PickInstantiate,
+  PickDeferred,
+  Pick,
+  PartialKind,
+  PartialInstantiate,
+  PartialDeferred,
+  Partial,
+  ParseTemplateIntoTypes,
+  ParsePatternIntoTypes,
+  ParametersKind,
+  ParametersInstantiate,
+  ParametersDeferred,
+  Parameters,
+  Parameter,
+  OptionsInstantiate,
+  OptionsDeferred,
+  Options,
+  OptionalRemoveAction,
+  OptionalRemove,
+  OptionalKind,
+  OptionalAddAction,
+  OptionalAdd,
+  Optional,
+  OmitKind,
+  OmitInstantiate,
+  OmitDeferred,
+  Omit,
+  ObjectOptions,
+  ObjectKind,
+  Object2 as Object,
+  NumberPattern,
+  NumberKind,
+  NumberKey,
+  Number2 as Number,
+  NullKind,
+  Null,
+  NotKind,
+  Not,
+  NonNullableInstantiate,
+  NonNullableDeferred,
+  NonNullable,
+  NeverPattern,
+  NeverKind,
+  Never,
+  Narrow,
+  ModuleKind,
+  ModuleInstantiate,
+  ModuleDeferred,
+  Module,
+  MappedKind,
+  MappedInstantiate,
+  MappedDeferred,
+  Mapped,
+  LowercaseKind,
+  LowercaseInstantiate,
+  LowercaseDeferred,
+  Lowercase,
+  LiteralTypeName,
+  LiteralKind,
+  Literal,
+  KeysToIndexer,
+  KeyOfKind,
+  KeyOfInstantiate,
+  KeyOfImmediate,
+  KeyOfDeferred,
+  KeyOfAction,
+  KeyOf,
+  JsonKind,
+  Json,
+  IteratorOptions,
+  IteratorKind,
+  Iterator,
+  IsVoid,
+  IsUppercase,
+  IsUnsafe,
+  IsUnknown,
+  IsUnion,
+  IsUndefined,
+  IsUncapitalize,
+  IsUint8Array,
+  IsTypeScriptEnumLike,
+  IsTuple,
+  IsThis,
+  IsTemplateLiteralPattern,
+  IsTemplateLiteralFinite,
+  IsTemplateLiteral,
+  IsSymbol,
+  IsString,
+  IsSchema,
+  IsReturnType,
+  IsRest,
+  IsRequired,
+  IsRegExpInstance,
+  IsRefine,
+  IsRef,
+  IsRecursive,
+  IsRecord,
+  IsReadonlyType,
+  IsReadonlyRemoveAction,
+  IsReadonlyAddAction,
+  IsReadonly,
+  IsPromise,
+  IsPick,
+  IsPartial,
+  IsParameters,
+  IsParameter,
+  IsOptions,
+  IsOptionalRemoveAction,
+  IsOptionalAddAction,
+  IsOptional,
+  IsOmit,
+  IsObject,
+  IsNumber,
+  IsNull,
+  IsNot,
+  IsNonNullable,
+  IsNever,
+  IsModule,
+  IsMapped,
+  IsLowercase,
+  IsLiteralValue,
+  IsLiteralString,
+  IsLiteralNumber,
+  IsLiteralBoolean,
+  IsLiteralBigInt,
+  IsLiteral,
+  IsKind,
+  IsKeyOf,
+  IsIterator,
+  IsIntersect,
+  IsInterfaceDeferred,
+  IsInterface,
+  IsInteger,
+  IsInstanceType,
+  IsInfer,
+  IsIndex,
+  IsImmutable,
+  IsIfThenElse,
+  IsIdentifier,
+  IsGeneric,
+  IsFunction,
+  IsExtract,
+  IsExclude,
+  IsEnum,
+  IsEncode,
+  IsDeferred,
+  IsDecode,
+  IsDate,
+  IsCyclic,
+  IsConstructorParameters,
+  IsConstructor,
+  IsConditional,
+  IsCodec,
+  IsCapitalize,
+  IsCall,
+  IsBoolean,
+  IsBigInt,
+  IsBase,
+  IsAwaited,
+  IsAsyncIterator,
+  IsArray,
+  IsAny,
+  IpKind,
+  Ip,
+  InvalidLiteralValue,
+  IntersectOptions,
+  IntersectKind,
+  Intersect,
+  InterfaceInstantiate,
+  InterfaceDeferred,
+  Interface,
+  IntegerPattern,
+  IntegerKind,
+  IntegerKey,
+  Integer,
+  InstantiateCyclic,
+  Instantiate,
+  InstanceTypeKind,
+  InstanceTypeInstantiate,
+  InstanceTypeImmediate,
+  InstanceTypeDeferred,
+  InstanceType,
+  Infer,
+  IndexKind,
+  IndexInstantiate,
+  IndexDeferred,
+  Index,
+  Import,
+  ImmutableRemove,
+  ImmutableAdd,
+  Immutable,
+  IfThenElseKind,
+  IfThenElse,
+  Identifier,
+  HostnameKind,
+  Hostname,
+  HexKind,
+  HexColorKind,
+  HexColor,
+  Hex,
+  Generic,
+  FunctionOptions,
+  FunctionKind,
+  Function,
+  Flatten,
+  ExtractKind,
+  ExtractInstantiate,
+  ExtractDeferred,
+  Extract,
+  ExtendsResult,
+  Extends,
+  ExcludeKind,
+  ExcludeInstantiate,
+  ExcludeDeferred,
+  Exclude,
+  EvaluateUnionFast,
+  EvaluateUnion,
+  EvaluateType,
+  EvaluateIntersect,
+  EvaluateInstantiate,
+  EvaluateDeferred,
+  Evaluate,
+  EnumValuesToVariants,
+  EnumValuesToUnion,
+  EnumToUnion,
+  EnumKind,
+  Enum,
+  EncodeKind,
+  EncodeBuilder,
+  Encode,
+  EmailKind,
+  Email,
+  DurationKind,
+  Duration,
+  Distribute,
+  Deferred,
+  DecodeKind,
+  DecodeBuilder,
+  Decode,
+  DateTimeKind,
+  DateTime,
+  DateKind,
+  DateFormatKind,
+  DateFormat,
+  DateCodec,
+  Date,
+  CyclicTarget,
+  CyclicOptions,
+  CyclicExtends,
+  CyclicDependencies,
+  CyclicCheck,
+  CyclicCandidates,
+  Cyclic,
+  CreditCardKind,
+  CreditCard,
+  ConvertToIntegerKey,
+  ConstructorParametersKind,
+  ConstructorParametersInstantiate,
+  ConstructorParametersDeferred,
+  ConstructorParameters,
+  ConstructorOptions,
+  ConstructorKind,
+  Constructor,
+  ConditionalKind,
+  ConditionalInstantiate,
+  ConditionalDeferred,
+  Conditional,
+  Composite,
+  Compare,
+  CollapseToObject,
+  Codec,
+  Clone2 as Clone,
+  CapitalizeKind,
+  CapitalizeInstantiate,
+  CapitalizeDeferred,
+  Capitalize,
+  CallConstruct,
+  Call,
+  Broaden,
+  BooleanKind,
+  Boolean,
+  BigIntPattern,
+  BigIntKind,
+  BigIntCodec,
+  BigInt,
+  Base64Kind,
+  Base64,
+  Base,
+  AwaitedKind,
+  AwaitedInstantiate,
+  AwaitedDeferred,
+  Awaited,
+  AsyncIteratorOptions,
+  AsyncIteratorKind,
+  AsyncIterator,
+  ArrayOptions,
+  ArrayKind,
+  Array2 as Array,
+  AnyKind,
+  Any
+};
+
+//# debugId=5A7E3CC9B970AD7064756E2164756E21
+//# sourceMappingURL=typebox.js.map