typebox 1.1.15 → 1.1.17

package/build/format/_idna.d.mts

@@ -0,0 +1,2 @@
+export declare function IsIdnLabel(value: string): boolean;
+export declare function IsLabel(value: string): boolean;

package/build/format/_idna.mjs

@@ -0,0 +1,216 @@
+import * as Puny from './_puny.mjs';
+// ------------------------------------------------------------------
+// Unicode General Category Helper (RFC 5892)
+// ------------------------------------------------------------------
+function IsNonspacingMark(cp) {
+    return /\p{Mn}/u.test(String.fromCodePoint(cp));
+}
+function IsSpacingCombiningMark(cp) {
+    return /\p{Mc}/u.test(String.fromCodePoint(cp));
+}
+function IsEnclosingMark(cp) {
+    return /\p{Me}/u.test(String.fromCodePoint(cp));
+}
+function IsCombiningMark(cp) {
+    return IsNonspacingMark(cp) || IsSpacingCombiningMark(cp) || IsEnclosingMark(cp);
+}
+// ------------------------------------------------------------------
+// RFC 5892 §2.6 DISALLOWED exceptions
+//
+// https://tools.ietf.org/html/rfc5892#section-2.6
+// ------------------------------------------------------------------
+const RFC5892_DISALLOWED = new Set([
+    0x0640, // ARABIC TATWEEL
+    0x07fa, // NKO LAJANYALAN
+    0x302e, // HANGUL SINGLE DOT TONE MARK
+    0x302f, // HANGUL DOUBLE DOT TONE MARK
+    0x3031, // VERTICAL KANA REPEAT MARK
+    0x3032, // VERTICAL KANA REPEAT WITH VOICED ITERATION MARK
+    0x3033, // VERTICAL KANA REPEAT MARK UPPER HALF
+    0x3034, // VERTICAL KANA REPEAT WITH VOICED ITERATION MARK UPPER HALF
+    0x3035, // VERTICAL KANA REPEAT MARK LOWER HALF
+    0x303b // VERTICAL IDEOGRAPHIC ITERATION MARK
+]);
+// ------------------------------------------------------------------
+// A set of Virama (halant) code points used to validate CONTEXTJ
+// rules (RFC 5892 Appendix A.1). These characters allow a subsequent
+// Zero Width Joiner (U+200D) to be valid in a label.
+// ------------------------------------------------------------------
+const VIRAMA_CPS = new Set([
+    0x094d,
+    0x09cd,
+    0x0a4d,
+    0x0acd,
+    0x0b4d,
+    0x0bcd,
+    0x0c4d,
+    0x0ccd,
+    0x0d3b,
+    0x0d3c,
+    0x0d4d,
+    0x0dca,
+    0x1b44,
+    0x1baa,
+    0x1bab,
+    0xa9c0,
+    0x11046,
+    0x1107f,
+    0x110b9,
+    0x11133,
+    0x11134,
+    0x111c0,
+    0x11235,
+    0x1134d,
+    0x11442,
+    0x114c2,
+    0x115bf,
+    0x1163f,
+    0x116b6,
+    0x11c3f,
+    0x11d44,
+    0x11d45
+]);
+// ------------------------------------------------------------------
+// Guards for CONTEXTO rules (RFC 5892 Appendix A)
+// ------------------------------------------------------------------
+function IsGreek(cp) {
+    return /\p{Script=Greek}/u.test(String.fromCodePoint(cp));
+}
+function IsHebrew(cp) {
+    return /\p{Script=Hebrew}/u.test(String.fromCodePoint(cp));
+}
+function IsHiragana(cp) {
+    return /\p{Script=Hiragana}/u.test(String.fromCodePoint(cp));
+}
+function IsKatakana(cp) {
+    return /\p{Script=Katakana}/u.test(String.fromCodePoint(cp));
+}
+function IsHan(cp) {
+    return /\p{Script=Han}/u.test(String.fromCodePoint(cp));
+}
+function IsArabicIndicDigit(cp) {
+    return cp >= 0x0660 && cp <= 0x0669;
+}
+function IsExtendedArabicIndicDigit(cp) {
+    return cp >= 0x06f0 && cp <= 0x06f9;
+}
+function IsVirama(cp) {
+    return VIRAMA_CPS.has(cp);
+}
+// ------------------------------------------------------------------
+// IsUnicodeLabel
+// ------------------------------------------------------------------
+function IsUnicodeLabel(value) {
+    if (value.length === 0)
+        return false;
+    // Use spread to handle surrogate pairs and provide O(1) neighbor access
+    const cps = [...value].map((c) => c.codePointAt(0));
+    const len = cps.length;
+    // RFC 5891 §4.2.3.2: Hyphen rules
+    if (cps[0] === 0x2d || cps[len - 1] === 0x2d)
+        return false;
+    if (len >= 4 && cps[2] === 0x2d && cps[3] === 0x2d)
+        return false;
+    // RFC 5891 §4.2.3.2 - Must not begin with a combining mark
+    if (IsCombiningMark(cps[0]))
+        return false;
+    let hasJapanese = false;
+    let hasArabicIndic = false;
+    let hasExtendedArabicIndic = false;
+    for (let i = 0; i < len; i++) {
+        const cp = cps[i];
+        // 1. DISALLOWED exceptions
+        if (RFC5892_DISALLOWED.has(cp))
+            return false;
+        // 2. Collect Flags
+        if (IsHiragana(cp) || IsKatakana(cp) || IsHan(cp))
+            hasJapanese = true;
+        if (IsArabicIndicDigit(cp))
+            hasArabicIndic = true;
+        if (IsExtendedArabicIndicDigit(cp))
+            hasExtendedArabicIndic = true;
+        // 3. CONTEXTO / CONTEXTJ Neighbor Rules
+        const prev = cps[i - 1], next = cps[i + 1];
+        switch (cp) {
+            case 0x00b7:
+                if (prev !== 0x006c || next !== 0x006c)
+                    return false;
+                break; // MIDDLE DOT (Catalan)
+            case 0x0375:
+                if (next === undefined || !IsGreek(next))
+                    return false;
+                break; // Greek KERAIA
+            case 0x05f3:
+            case 0x05f4:
+                if (prev === undefined || !IsHebrew(prev))
+                    return false;
+                break; // Hebrew GERESH
+            case 0x200d:
+                if (prev === undefined || !IsVirama(prev))
+                    return false;
+                break; // ZWJ
+            case 0x30fb: /* Checked at end via hasJapanese */
+                break; // KATAKANA MIDDLE DOT
+        }
+    }
+    // 4. Global Context Validations (Post-loop)
+    // RFC 5892 Appendix A.7 - Katakana Middle Dot requirement
+    if (value.includes('\u30fb') && !hasJapanese)
+        return false;
+    // RFC 5892 Appendix A.8/A.9 - Mixing Arabic Digits
+    if (hasArabicIndic && hasExtendedArabicIndic)
+        return false;
+    return true;
+}
+// ------------------------------------------------------------------
+// IsAsciiLabel
+// ------------------------------------------------------------------
+function IsAsciiLabel(value) {
+    // Must not start or end with a hyphen
+    if (value.charCodeAt(0) === 45 || value.charCodeAt(value.length - 1) === 45)
+        return false;
+    // RFC 5891 §4.2.3.1 : "--" at positions 3-4 is reserved for A-labels only
+    if (value.length >= 4 && value.charCodeAt(2) === 45 && value.charCodeAt(3) === 45)
+        return false;
+    // All characters must be alphanumeric or hyphen
+    for (let i = 0; i < value.length; i++) {
+        const ch = value.charCodeAt(i);
+        if (!((ch >= 97 && ch <= 122) || // a-z
+            (ch >= 65 && ch <= 90) || // A-Z
+            (ch >= 48 && ch <= 57) || // 0-9
+            ch === 45 // '-'
+        ))
+            return false;
+    }
+    return true;
+}
+// ------------------------------------------------------------------
+// IsPunyLabel
+// ------------------------------------------------------------------
+function IsPuny(value) {
+    return value.toLowerCase().startsWith('xn--');
+}
+function IsPunyLabel(value) {
+    try {
+        return IsUnicodeLabel(Puny.Decode(value.slice(4)));
+    }
+    catch {
+        return false; // invalid punycode encoding
+    }
+}
+// ------------------------------------------------------------------
+// IsIdnLabel
+// ------------------------------------------------------------------
+export function IsIdnLabel(value) {
+    if (value.length === 0 || value.length > 63)
+        return false;
+    return IsPuny(value) ? IsPunyLabel(value) : IsUnicodeLabel(value);
+}
+// ------------------------------------------------------------------
+// IsLabel
+// ------------------------------------------------------------------
+export function IsLabel(value) {
+    if (value.length === 0 || value.length > 63)
+        return false;
+    return IsPuny(value) ? IsPunyLabel(value) : IsAsciiLabel(value);
+}

package/build/format/_puny.d.mts

@@ -0,0 +1 @@
+export declare function Decode(value: string): string;

package/build/format/_puny.mjs

@@ -0,0 +1,74 @@
+// ------------------------------------------------------------------
+// PunyCode (RFC 3492)
+// ------------------------------------------------------------------
+const PUNYCODE_BASE = 36;
+const PUNYCODE_TMIN = 1;
+const PUNYCODE_TMAX = 26;
+const PUNYCODE_SKEW = 38;
+const PUNYCODE_DAMP = 700;
+const PUNYCODE_INITIAL_BIAS = 72;
+const PUNYCODE_INITIAL_N = 128;
+// ------------------------------------------------------------------
+// Adapt
+// ------------------------------------------------------------------
+function Adapt(delta, numPoints, firstTime) {
+    delta = firstTime ? Math.floor(delta / PUNYCODE_DAMP) : delta >> 1;
+    delta += Math.floor(delta / numPoints);
+    let k = 0;
+    while (delta > (((PUNYCODE_BASE - PUNYCODE_TMIN) * PUNYCODE_TMAX) >> 1)) {
+        delta = Math.floor(delta / (PUNYCODE_BASE - PUNYCODE_TMIN));
+        k += PUNYCODE_BASE;
+    }
+    return k + Math.floor(((PUNYCODE_BASE - PUNYCODE_TMIN + 1) * delta) / (delta + PUNYCODE_SKEW));
+}
+// ------------------------------------------------------------------
+// Decode
+// ------------------------------------------------------------------
+export function Decode(value) {
+    const output = [];
+    let n = PUNYCODE_INITIAL_N;
+    let i = 0;
+    let bias = PUNYCODE_INITIAL_BIAS;
+    const delimIdx = value.lastIndexOf('-');
+    if (delimIdx > 0) {
+        for (let j = 0; j < delimIdx; j++) {
+            const cp = value.charCodeAt(j);
+            if (cp >= 128)
+                throw new Error('Invalid punycode: non-basic before delimiter');
+            output.push(cp);
+        }
+    }
+    let inIdx = delimIdx < 0 ? 0 : delimIdx + 1;
+    while (inIdx < value.length) {
+        const oldi = i;
+        let w = 1;
+        let k = PUNYCODE_BASE;
+        while (true) {
+            if (inIdx >= value.length)
+                throw new Error('Invalid punycode: unexpected end of input');
+            const ch = value.charCodeAt(inIdx++);
+            let digit;
+            if (ch >= 0x61 && ch <= 0x7a)
+                digit = ch - 0x61; // a-z => 0-25
+            else if (ch >= 0x30 && ch <= 0x39)
+                digit = ch - 0x30 + 26; // 0-9 => 26-35
+            else if (ch >= 0x41 && ch <= 0x5a)
+                digit = ch - 0x41; // A-Z => 0-25
+            else
+                throw new Error('Invalid punycode: bad digit character');
+            i += digit * w;
+            const t = k <= bias ? PUNYCODE_TMIN : k >= bias + PUNYCODE_TMAX ? PUNYCODE_TMAX : k - bias;
+            if (digit < t)
+                break;
+            w *= PUNYCODE_BASE - t;
+            k += PUNYCODE_BASE;
+        }
+        const outLen = output.length + 1;
+        bias = Adapt(i - oldi, outLen, oldi === 0);
+        n += Math.floor(i / outLen);
+        i %= outLen;
+        output.splice(i, 0, n);
+        i++;
+    }
+    return globalThis.String.fromCodePoint(...output);
+}

package/build/format/duration.d.mts

@@ -1,5 +1,5 @@
 /**
- * Returns true if the value is a Duration string
- * @source ajv-formats
+ * Returns true if the value is a valid ISO-8601 duration.
+ * @specification https://tools.ietf.org/html/rfc3339
  */
 export declare function IsDuration(value: string): boolean;

package/build/format/duration.mjs

@@ -1,7 +1,7 @@
-const Duration = /^P(?!$)((\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+S)?)?|(\d+W)?)$/;
+const Duration = /^P((\d+Y(\d+M(\d+D)?)?|\d+M(\d+D)?|\d+D)(T(\d+H(\d+M(\d+S)?)?|\d+M(\d+S)?|\d+S))?|T(\d+H(\d+M(\d+S)?)?|\d+M(\d+S)?|\d+S)|\d+W)$/;
 /**
- * Returns true if the value is a Duration string
- * @source ajv-formats
+ * Returns true if the value is a valid ISO-8601 duration.
+ * @specification https://tools.ietf.org/html/rfc3339
  */
 export function IsDuration(value) {
     return Duration.test(value);

package/build/format/hostname.d.mts

@@ -1,5 +1,7 @@
 /**
- * Returns true if the value matches RFC 1123 hostname syntax.
+ * Returns true if the value is a valid hostname.
  * @specification https://tools.ietf.org/html/rfc1123
+ * @specification https://tools.ietf.org/html/rfc5891
+ * @specification https://tools.ietf.org/html/rfc5892
  */
 export declare function IsHostname(value: string): boolean;

package/build/format/hostname.mjs

@@ -1,34 +1,18 @@
+import * as Idna from './_idna.mjs';
 /**
- * Returns true if the value matches RFC 1123 hostname syntax.
+ * Returns true if the value is a valid hostname.
  * @specification https://tools.ietf.org/html/rfc1123
+ * @specification https://tools.ietf.org/html/rfc5891
+ * @specification https://tools.ietf.org/html/rfc5892
  */
 export function IsHostname(value) {
-    if (value.length > 253 || value.length === 0)
+    if (value.length === 0 || value.length > 253)
         return false;
-    let start = 0;
-    let prev = 0;
-    for (let i = 0; i < value.length; i++) {
-        const ch = value.charCodeAt(i);
-        if (ch === 46) { // '.'
-            // trailing dot is valid e.g. "example.com." but not "."
-            if (i === value.length - 1 && start < i)
-                break;
-            const len = i - start;
-            if (len === 0 || len > 63 || value.charCodeAt(start) === 45 || prev === 45)
-                return false;
-            start = i + 1;
-        }
-        else if (!((ch >= 97 && ch <= 122) || // a-z
-            (ch >= 65 && ch <= 90) || // A-Z
-            (ch >= 48 && ch <= 57) || // 0-9
-            ch === 45 // '-'
-        )) {
+    if (value.charCodeAt(value.length - 1) === 46)
+        return false;
+    for (const label of value.split('.')) {
+        if (!Idna.IsLabel(label))
             return false;
-        }
-        prev = ch;
     }
-    const length = value.length - start;
-    const first = value.charCodeAt(start);
-    const last = value.charCodeAt(value.length - 1);
-    return length > 0 && length <= 63 && first !== 45 && last !== 45;
+    return true;
 }

package/build/format/idn-hostname.d.mts

@@ -1,5 +1,7 @@
 /**
- * Returns true if the value is an IDN Hostname
- * @specification Json Schema 2020-12
+ * Returns true if the value is a valid internationalized (IDN) hostname.
+ * @specification https://tools.ietf.org/html/rfc3490
+ * @specification https://tools.ietf.org/html/rfc5891
+ * @specification https://tools.ietf.org/html/rfc5892
  */
 export declare function IsIdnHostname(value: string): boolean;

package/build/format/idn-hostname.mjs

@@ -1,118 +1,18 @@
-function IsValidAdjacentForKatakanaMiddleDot(cp) {
-    return ((cp >= 0x3040 && cp <= 0x309F) || // Hiragana
-        (cp >= 0x30A0 && cp <= 0x30FF && cp !== 0x30FB) || // Katakana (excluding U+30FB)
-        (cp >= 0x4E00 && cp <= 0x9FFF) // Han (CJK Unified Ideographs)
-    );
-}
+import { IsIdnLabel } from './_idna.mjs';
 /**
- * Returns true if the value is an IDN Hostname
- * @specification Json Schema 2020-12
+ * Returns true if the value is a valid internationalized (IDN) hostname.
+ * @specification https://tools.ietf.org/html/rfc3490
+ * @specification https://tools.ietf.org/html/rfc5891
+ * @specification https://tools.ietf.org/html/rfc5892
  */
 export function IsIdnHostname(value) {
     if (value.length === 0 || value.includes(' '))
         return false;
-    // Normalize (NFC) and replace allowed separators with a dot
-    // Allowed label separators per RFC3490: U+002E, U+3002, U+FF0E, U+FF61
-    const normalized = value.normalize('NFC').replace(/[\u002E\u3002\uFF0E\uFF61]/g, '.');
-    if (normalized.length > 253)
+    const canonical = value.normalize('NFC').replace(/[\u002E\u3002\uFF0E\uFF61]/g, '.');
+    if (canonical.length > 253)
         return false;
-    const labels = normalized.split('.');
-    for (const label of labels) {
-        if (label.length === 0 || label.length > 63)
-            return false;
-        // Labels must not begin or end with a hyphen
-        if (label.charCodeAt(0) === 45 || label.charCodeAt(label.length - 1) === 45)
-            return false;
-        // A-label (punycode) checks
-        if ((label.charCodeAt(0) === 120 || label.charCodeAt(0) === 88) && // 'x' or 'X'
-            (label.charCodeAt(1) === 110 || label.charCodeAt(1) === 78) && // 'n' or 'N'
-            label.charCodeAt(2) === 45 && // '-'
-            label.charCodeAt(3) === 45 // '-'
-        ) {
-            const punycodePart = label.slice(4);
-            if (punycodePart.length < 2 || punycodePart.includes('---'))
-                return false;
-            continue;
-        }
-        // U-label checks
-        let hasArabicIndic = false;
-        let hasExtendedArabicIndic = false;
-        for (let i = 0; i < label.length; i++) {
-            // deno-coverage-ignore
-            const cp = label.codePointAt(i) ?? 0;
-            // Disallowed code points
-            if (cp === 0x302E || cp === 0x302F ||
-                cp === 0x3031 || cp === 0x3032 || cp === 0x3033 || cp === 0x3034 || cp === 0x3035 ||
-                cp === 0x303B || cp === 0x0640 || cp === 0x07FA)
-                return false;
-            // Disallow labels starting with certain combining marks
-            if (i === 0 && (cp === 0x0903 || cp === 0x0300 || cp === 0x0488))
-                return false;
-            // MIDDLE DOT (U+00B7) must be flanked by 'l' or 'L'
-            if (cp === 0x00B7) {
-                if (i === 0 || i === label.length - 1)
-                    return false;
-                // deno-coverage-ignore
-                const prev = label.codePointAt(i - 1) ?? 0;
-                // deno-coverage-ignore
-                const next = label.codePointAt(i + 1) ?? 0;
-                if ((prev !== 108 && prev !== 76) || (next !== 108 && next !== 76))
-                    return false;
-            }
-            // KATAKANA MIDDLE DOT (U+30FB) | U+30FB is below U+FFFF so stride is always 1
-            if (cp === 0x30FB) {
-                if (label.length === 1)
-                    return false;
-                if (i === 0) {
-                    // deno-coverage-ignore
-                    const next = label.codePointAt(i + 1) ?? 0;
-                    if (!IsValidAdjacentForKatakanaMiddleDot(next))
-                        return false;
-                }
-                else {
-                    // deno-coverage-ignore
-                    const prev = label.codePointAt(i - 1) ?? 0;
-                    // deno-coverage-ignore
-                    const next = label.codePointAt(i + 1) ?? 0;
-                    if (!IsValidAdjacentForKatakanaMiddleDot(prev) || !IsValidAdjacentForKatakanaMiddleDot(next))
-                        return false;
-                }
-            }
-            // Greek KERAIA (U+0375) | U+0375 is below U+FFFF so stride is always 1
-            if (cp === 0x0375) {
-                if (i === label.length - 1)
-                    return false;
-                // deno-coverage-ignore
-                const next = label.codePointAt(i + 1) ?? 0;
-                if (next < 0x0370 || next > 0x03FF)
-                    return false;
-            }
-            // Hebrew GERESH (U+05F3) and GERSHAYIM (U+05F4)
-            if (cp === 0x05F3 || cp === 0x05F4) {
-                if (i === 0)
-                    return false;
-                // deno-coverage-ignore
-                const prev = label.codePointAt(i - 1) ?? 0;
-                if (prev < 0x05D0 || prev > 0x05EA)
-                    return false;
-            }
-            // ZERO WIDTH JOINER (U+200D)
-            if (cp === 0x200D) {
-                if (i === 0)
-                    return false;
-                // deno-coverage-ignore
-                const prev = label.codePointAt(i - 1) ?? 0;
-                if (prev !== 0x094D)
-                    return false;
-            }
-            // Arabic-Indic digits
-            if (cp >= 0x0660 && cp <= 0x0669)
-                hasArabicIndic = true;
-            // Extended Arabic-Indic digits
-            if (cp >= 0x06F0 && cp <= 0x06F9)
-                hasExtendedArabicIndic = true;
-        }
-        if (hasArabicIndic && hasExtendedArabicIndic)
+    for (const label of canonical.split('.')) {
+        if (!IsIdnLabel(label))
             return false;
     }
     return true;

package/build/format/uri-reference.d.mts

@@ -1,6 +1,5 @@
 /**
- * Returns true if the value is a uri reference
- * @specification
- * @source ajv-formats
+ * Returns true if the value is a valid URI Reference.
+ * @specification https://tools.ietf.org/html/rfc3986
  */
 export declare function IsUriReference(value: string): boolean;

package/build/format/uri-reference.mjs

@@ -1,8 +1,7 @@
-const UriReference = /^(?:(?:[a-z][a-z0-9+\-.]*:)?\/?\/)?(?:[^\\\s#][^\s#]*)?(?:#[^\\\s]*)?$/i;
+const UriReference = /^(?!.*[^\x00-\x7F])(?!.*\\)(?:(?:[a-z][a-z0-9+\-.]*:)?(?:\/\/[^\s[\]{}<>^`|]*)?|[^\s[\]{}<>^`|]*)(?:\?[^\s[\]{}<>^`|]*)?(?:#[^\s[\]{}<>^`|]*)?$/i;
 /**
- * Returns true if the value is a uri reference
- * @specification
- * @source ajv-formats
+ * Returns true if the value is a valid URI Reference.
+ * @specification https://tools.ietf.org/html/rfc3986
  */
 export function IsUriReference(value) {
     return UriReference.test(value);

package/build/guard/string.d.mts

@@ -1,9 +1,5 @@
 /** Returns the number of grapheme clusters in a string */
 export declare function GraphemeCount(value: string): number;
-/** Checks if a string has at least a minimum number of grapheme clusters */
-export declare function IsMinLength(value: string, minLength: number): boolean;
-/** Checks if a string has at most a maximum number of grapheme clusters */
-export declare function IsMaxLength(value: string, maxLength: number): boolean;
 /** Fast check for minimum grapheme length, falls back to full check if needed */
 export declare function IsMinLengthFast(value: string, minLength: number): boolean;
 /** Fast check for maximum grapheme length, falls back to full check if needed */

package/build/guard/string.mjs

@@ -94,9 +94,15 @@ export function GraphemeCount(value) {
 // IsMinLength
 // --------------------------------------------------------------------------
 /** Checks if a string has at least a minimum number of grapheme clusters */
-export function IsMinLength(value, minLength) {
+function IsMinLength(value, minLength) {
+    // ----------------------------------------------------------------
+    // Inaccessible via public interface (review)
+    //
+    // deno-coverage-ignore-start
+    // ----------------------------------------------------------------
     if (minLength === 0)
         return true; // 0-length
+    // deno-coverage-ignore-stop
     let count = 0;
     let index = 0;
     while (index < value.length) {
@@ -111,7 +117,7 @@ export function IsMinLength(value, minLength) {
 // IsMaxLength
 // --------------------------------------------------------------------------
 /** Checks if a string has at most a maximum number of grapheme clusters */
-export function IsMaxLength(value, maxLength) {
+function IsMaxLength(value, maxLength) {
     let count = 0;
     let index = 0;
     while (index < value.length) {

package/build/schema/engine/_context.d.mts

@@ -4,14 +4,17 @@ export declare class BuildContext {
     private readonly hasUnevaluated;
     constructor(hasUnevaluated: boolean);
     UseUnevaluated(): boolean;
+    Push(): string;
+    Pop(): string;
     AddIndex(index: string): string;
     AddKey(key: string): string;
     Merge(results: string): string;
 }
 export declare class CheckContext {
-    private readonly indices;
-    private readonly keys;
+    private readonly stack;
     constructor();
+    Push(): true;
+    Pop(): true;
     AddIndex(index: number): true;
     AddKey(key: string): true;
     GetIndices(): Set<number>;

package/build/schema/engine/_context.mjs

@@ -30,6 +30,18 @@ export class BuildContext {
     UseUnevaluated() {
         return this.hasUnevaluated;
     }
+    // ----------------------------------------------------------------
+    // Stack
+    // ----------------------------------------------------------------
+    Push() {
+        return E.Call(E.Member('context', 'Push'), []);
+    }
+    Pop() {
+        return E.Call(E.Member('context', 'Pop'), []);
+    }
+    // ----------------------------------------------------------------
+    // Top
+    // ----------------------------------------------------------------
     AddIndex(index) {
         return E.Call(E.Member('context', 'AddIndex'), [index]);
     }
@@ -45,27 +57,46 @@ export class BuildContext {
 // ------------------------------------------------------------------
 export class CheckContext {
     constructor() {
-        this.indices = new Set();
-        this.keys = new Set();
+        const indices = new Set();
+        const keys = new Set();
+        this.stack = [{ indices, keys }];
+    }
+    // ----------------------------------------------------------------
+    // Stack
+    // ----------------------------------------------------------------
+    Push() {
+        const indices = new Set();
+        const keys = new Set();
+        this.stack.push({ indices, keys });
+        return true;
+    }
+    Pop() {
+        this.stack.pop();
+        return true;
     }
+    // ----------------------------------------------------------------
+    // Top
+    // ----------------------------------------------------------------
     AddIndex(index) {
-        this.indices.add(index);
+        this.GetIndices().add(index);
         return true;
     }
     AddKey(key) {
-        this.keys.add(key);
+        this.GetKeys().add(key);
         return true;
     }
     GetIndices() {
-        return this.indices;
+        const top = this.stack[this.stack.length - 1];
+        return top.indices;
     }
     GetKeys() {
-        return this.keys;
+        const top = this.stack[this.stack.length - 1];
+        return top.keys;
     }
     Merge(results) {
         for (const context of results) {
-            context.indices.forEach(value => this.indices.add(value));
-            context.keys.forEach(value => this.keys.add(value));
+            context.GetIndices().forEach(value => this.GetIndices().add(value));
+            context.GetKeys().forEach(value => this.GetKeys().add(value));
         }
         return true;
     }

package/build/schema/engine/_externals.d.mts

@@ -1,9 +1,7 @@
 export interface TExternal {
-    /** The name of the variable that holds external variables in generated code */
-    identifier: string;
-    /** An array of external variables */
+    identifier: 'External';
     variables: unknown[];
 }
-export declare function ResetExternal(): void;
 export declare function CreateVariable(value: unknown): string;
+export declare function ResetExternal(): void;
 export declare function GetExternal(): TExternal;

package/build/schema/engine/_externals.mjs

@@ -1,34 +1,25 @@
 // deno-fmt-ignore-file
-const identifier = 'external_';
-let resetCount = 0;
 const state = {
-    identifier: `${identifier}${resetCount}`,
+    identifier: 'External',
     variables: []
 };
 // ------------------------------------------------------------------
-// ResetExternals
-//
-// Each reset results in a new external group identifier. This is done 
-// to prevent variable name overlap when generating and evaluating
-// multiple types in the same scope.
-//
-// ------------------------------------------------------------------
-export function ResetExternal() {
-    state.identifier = `${identifier}${resetCount}`;
-    state.variables = [];
-    resetCount += 1;
-}
-// ------------------------------------------------------------------
 // CreateVariable
 // ------------------------------------------------------------------
 export function CreateVariable(value) {
-    const call = `${state.identifier}[${state.variables.length}]`;
+    const call = `External[${state.variables.length}]`;
     state.variables.push(value);
     return call;
 }
 // ------------------------------------------------------------------
+// ResetExternal
+// ------------------------------------------------------------------
+export function ResetExternal() {
+    state.variables = [];
+}
+// ------------------------------------------------------------------
 // GetExternals
 // ------------------------------------------------------------------
 export function GetExternal() {
-    return state;
+    return { ...state };
 }

package/build/schema/engine/additionalItems.mjs

@@ -2,7 +2,7 @@
 import * as Schema from '../types/index.mjs';
 import { Unique } from './_unique.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
-import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
+import { BuildSchemaPushStack, CheckSchemaPushStack, ErrorSchemaPushStack } from './schema.mjs';
 // ------------------------------------------------------------------
 // Valid
 // ------------------------------------------------------------------
@@ -16,7 +16,7 @@ export function BuildAdditionalItems(stack, context, schema, value) {
     if (!IsValid(schema))
         return E.Constant(true);
     const [item, index] = [Unique(), Unique()];
-    const isSchema = BuildSchema(stack, context, schema.additionalItems, item);
+    const isSchema = BuildSchemaPushStack(stack, context, schema.additionalItems, item);
     const isLength = E.IsLessThan(index, E.Constant(schema.items.length));
     const addIndex = context.AddIndex(index);
     const guarded = context.UseUnevaluated() ? E.Or(isLength, E.And(isSchema, addIndex)) : E.Or(isLength, isSchema);
@@ -30,7 +30,7 @@ export function CheckAdditionalItems(stack, context, schema, value) {
         return true;
     const isAdditionalItems = value.every((item, index) => {
         return G.IsLessThan(index, schema.items.length)
-            || (CheckSchema(stack, context, schema.additionalItems, item) && context.AddIndex(index));
+            || (CheckSchemaPushStack(stack, context, schema.additionalItems, item) && context.AddIndex(index));
     });
     return isAdditionalItems;
 }
@@ -44,7 +44,7 @@ export function ErrorAdditionalItems(stack, context, schemaPath, instancePath, s
         const nextSchemaPath = `${schemaPath}/additionalItems`;
         const nextInstancePath = `${instancePath}/${index}`;
         return G.IsLessThan(index, schema.items.length) ||
-            (ErrorSchema(stack, context, nextSchemaPath, nextInstancePath, schema.additionalItems, item) && context.AddIndex(index));
+            (ErrorSchemaPushStack(stack, context, nextSchemaPath, nextInstancePath, schema.additionalItems, item) && context.AddIndex(index));
     });
     return isAdditionalItems;
 }

package/build/schema/engine/additionalProperties.mjs

@@ -4,7 +4,7 @@ import * as V from './_externals.mjs';
 import { Unique } from './_unique.mjs';
 import { AccumulatedErrorContext } from './_context.mjs';
 import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
-import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
+import { BuildSchemaPushStack, CheckSchemaPushStack, ErrorSchemaPushStack } from './schema.mjs';
 // ------------------------------------------------------------------
 // Common: GetPropertiesPattern
 //
@@ -59,7 +59,7 @@ export function BuildAdditionalPropertiesFast(context, schema, value) {
 export function BuildAdditionalPropertiesStandard(stack, context, schema, value) {
     const [key, _index] = [Unique(), Unique()];
     const regexp = V.CreateVariable(new RegExp(GetPropertiesPattern(schema)));
-    const isSchema = BuildSchema(stack, context, schema.additionalProperties, `${value}[${key}]`);
+    const isSchema = BuildSchemaPushStack(stack, context, schema.additionalProperties, `${value}[${key}]`);
     const isKey = E.Call(E.Member(regexp, 'test'), [key]);
     const addKey = context.AddKey(key);
     const guarded = context.UseUnevaluated() ? E.Or(isKey, E.And(isSchema, addKey)) : E.Or(isKey, isSchema);
@@ -81,7 +81,7 @@ export function CheckAdditionalProperties(stack, context, schema, value) {
     const regexp = new RegExp(GetPropertiesPattern(schema));
     const isAdditionalProperties = G.Every(G.Keys(value), 0, (key, _index) => {
         return regexp.test(key) ||
-            (CheckSchema(stack, context, schema.additionalProperties, value[key]) && context.AddKey(key));
+            (CheckSchemaPushStack(stack, context, schema.additionalProperties, value[key]) && context.AddKey(key));
     });
     return isAdditionalProperties;
 }
@@ -96,7 +96,7 @@ export function ErrorAdditionalProperties(stack, context, schemaPath, instancePa
         const nextInstancePath = `${instancePath}/${key}`;
         const nextContext = new AccumulatedErrorContext();
         const isAdditionalProperty = regexp.test(key) ||
-            (ErrorSchema(stack, nextContext, nextSchemaPath, nextInstancePath, schema.additionalProperties, value[key]) && context.AddKey(key));
+            (ErrorSchemaPushStack(stack, nextContext, nextSchemaPath, nextInstancePath, schema.additionalProperties, value[key]) && context.AddKey(key));
         if (!isAdditionalProperty)
             additionalProperties.push(key);
         return isAdditionalProperty;

package/build/schema/engine/items.mjs

@@ -1,14 +1,14 @@
 // deno-fmt-ignore-file
 import * as Schema from '../types/index.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
-import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
+import { BuildSchemaPushStack, CheckSchemaPushStack, ErrorSchemaPushStack } from './schema.mjs';
 // ------------------------------------------------------------------
 // ItemsSized
 // ------------------------------------------------------------------
 function BuildItemsSized(stack, context, schema, value) {
     return E.ReduceAnd(schema.items.map((schema, index) => {
         const isLength = E.IsLessEqualThan(E.Member(value, 'length'), E.Constant(index));
-        const isSchema = BuildSchema(stack, context, schema, `${value}[${index}]`);
+        const isSchema = BuildSchemaPushStack(stack, context, schema, `${value}[${index}]`);
         const addIndex = context.AddIndex(E.Constant(index));
         const guarded = context.UseUnevaluated() ? E.And(isSchema, addIndex) : isSchema;
         return E.Or(isLength, guarded);
@@ -17,7 +17,7 @@ function BuildItemsSized(stack, context, schema, value) {
 function CheckItemsSized(stack, context, schema, value) {
     return G.Every(schema.items, 0, (schema, index) => {
         return G.IsLessEqualThan(value.length, index)
-            || (CheckSchema(stack, context, schema, value[index]) && context.AddIndex(index));
+            || (CheckSchemaPushStack(stack, context, schema, value[index]) && context.AddIndex(index));
     });
 }
 function ErrorItemsSized(stack, context, schemaPath, instancePath, schema, value) {
@@ -25,7 +25,7 @@ function ErrorItemsSized(stack, context, schemaPath, instancePath, schema, value
         const nextSchemaPath = `${schemaPath}/items/${index}`;
         const nextInstancePath = `${instancePath}/${index}`;
         return G.IsLessEqualThan(value.length, index)
-            || (ErrorSchema(stack, context, nextSchemaPath, nextInstancePath, schema, value[index]) && context.AddIndex(index));
+            || (ErrorSchemaPushStack(stack, context, nextSchemaPath, nextInstancePath, schema, value[index]) && context.AddIndex(index));
     });
 }
 // ------------------------------------------------------------------
@@ -33,7 +33,7 @@ function ErrorItemsSized(stack, context, schemaPath, instancePath, schema, value
 // ------------------------------------------------------------------
 function BuildItemsUnsized(stack, context, schema, value) {
     const offset = Schema.IsPrefixItems(schema) ? schema.prefixItems.length : 0;
-    const isSchema = BuildSchema(stack, context, schema.items, 'element');
+    const isSchema = BuildSchemaPushStack(stack, context, schema.items, 'element');
     const addIndex = context.AddIndex('index');
     const guarded = context.UseUnevaluated() ? E.And(isSchema, addIndex) : isSchema;
     return E.Every(value, E.Constant(offset), ['element', 'index'], guarded);
@@ -41,7 +41,7 @@ function BuildItemsUnsized(stack, context, schema, value) {
 function CheckItemsUnsized(stack, context, schema, value) {
     const offset = Schema.IsPrefixItems(schema) ? schema.prefixItems.length : 0;
     return G.Every(value, offset, (element, index) => {
-        return CheckSchema(stack, context, schema.items, element)
+        return CheckSchemaPushStack(stack, context, schema.items, element)
             && context.AddIndex(index);
     });
 }
@@ -50,7 +50,7 @@ function ErrorItemsUnsized(stack, context, schemaPath, instancePath, schema, val
     return G.EveryAll(value, offset, (element, index) => {
         const nextSchemaPath = `${schemaPath}/items`;
         const nextInstancePath = `${instancePath}/${index}`;
-        return ErrorSchema(stack, context, nextSchemaPath, nextInstancePath, schema.items, element)
+        return ErrorSchemaPushStack(stack, context, nextSchemaPath, nextInstancePath, schema.items, element)
             && context.AddIndex(index);
     });
 }

package/build/schema/engine/patternProperties.mjs

@@ -2,7 +2,7 @@
 import * as Externals from './_externals.mjs';
 import { Unique } from './_unique.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
-import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
+import { BuildSchemaPushStack, CheckSchemaPushStack, ErrorSchemaPushStack } from './schema.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
@@ -11,7 +11,7 @@ export function BuildPatternProperties(stack, context, schema, value) {
         const [key, prop] = [Unique(), Unique()];
         const regexp = Externals.CreateVariable(new RegExp(pattern, 'u'));
         const notKey = E.Not(E.Call(E.Member(regexp, 'test'), [key]));
-        const isSchema = BuildSchema(stack, context, schema, prop);
+        const isSchema = BuildSchemaPushStack(stack, context, schema, prop);
         const addKey = context.AddKey(key);
         const guarded = context.UseUnevaluated() ? E.Or(notKey, E.And(isSchema, addKey)) : E.Or(notKey, isSchema);
         return E.Every(E.Entries(value), E.Constant(0), [`[${key}, ${prop}]`, '_'], guarded);
@@ -24,7 +24,7 @@ export function CheckPatternProperties(stack, context, schema, value) {
     return G.Every(G.Entries(schema.patternProperties), 0, ([pattern, schema]) => {
         const regexp = new RegExp(pattern, 'u');
         return G.Every(G.Entries(value), 0, ([key, prop]) => {
-            return !regexp.test(key) || CheckSchema(stack, context, schema, prop) && context.AddKey(key);
+            return !regexp.test(key) || CheckSchemaPushStack(stack, context, schema, prop) && context.AddKey(key);
         });
     });
 }
@@ -38,7 +38,7 @@ export function ErrorPatternProperties(stack, context, schemaPath, instancePath,
         return G.EveryAll(G.Entries(value), 0, ([key, value]) => {
             const nextInstancePath = `${instancePath}/${key}`;
             const notKey = !regexp.test(key);
-            return notKey || ErrorSchema(stack, context, nextSchemaPath, nextInstancePath, schema, value) && context.AddKey(key);
+            return notKey || ErrorSchemaPushStack(stack, context, nextSchemaPath, nextInstancePath, schema, value) && context.AddKey(key);
         });
     });
 }

package/build/schema/engine/prefixItems.mjs

@@ -1,13 +1,13 @@
 // deno-fmt-ignore-file
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
-import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
+import { BuildSchemaPushStack, CheckSchemaPushStack, ErrorSchemaPushStack } from './schema.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
 export function BuildPrefixItems(stack, context, schema, value) {
     return E.ReduceAnd(schema.prefixItems.map((schema, index) => {
         const isLength = E.IsLessEqualThan(E.Member(value, 'length'), E.Constant(index));
-        const isSchema = BuildSchema(stack, context, schema, `${value}[${index}]`);
+        const isSchema = BuildSchemaPushStack(stack, context, schema, `${value}[${index}]`);
         const addIndex = context.AddIndex(E.Constant(index));
         const guarded = context.UseUnevaluated() ? E.And(isSchema, addIndex) : isSchema;
         return E.Or(isLength, guarded);
@@ -19,7 +19,7 @@ export function BuildPrefixItems(stack, context, schema, value) {
 export function CheckPrefixItems(stack, context, schema, value) {
     return G.IsEqual(value.length, 0) || G.Every(schema.prefixItems, 0, (schema, index) => {
         return G.IsLessEqualThan(value.length, index)
-            || (CheckSchema(stack, context, schema, value[index]) && context.AddIndex(index));
+            || (CheckSchemaPushStack(stack, context, schema, value[index]) && context.AddIndex(index));
     });
 }
 // ------------------------------------------------------------------
@@ -30,6 +30,6 @@ export function ErrorPrefixItems(stack, context, schemaPath, instancePath, schem
         const nextSchemaPath = `${schemaPath}/prefixItems/${index}`;
         const nextInstancePath = `${instancePath}/${index}`;
         return G.IsLessEqualThan(value.length, index)
-            || (ErrorSchema(stack, context, nextSchemaPath, nextInstancePath, schema, value[index]) && context.AddIndex(index));
+            || (ErrorSchemaPushStack(stack, context, nextSchemaPath, nextInstancePath, schema, value[index]) && context.AddIndex(index));
     });
 }

package/build/schema/engine/properties.mjs

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import * as Schema from '../types/index.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
-import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
+import { BuildSchemaPushStack, CheckSchemaPushStack, ErrorSchemaPushStack } from './schema.mjs';
 import { InexactOptionalCheck, InexactOptionalBuild, IsExactOptional } from './_exact_optional.mjs';
 // ------------------------------------------------------------------
 // Build
@@ -10,7 +10,7 @@ export function BuildProperties(stack, context, schema, value) {
     const required = Schema.IsRequired(schema) ? schema.required : [];
     const everyKey = G.Entries(schema.properties).map(([key, schema]) => {
         const notKey = E.Not(E.HasPropertyKey(value, E.Constant(key)));
-        const isSchema = BuildSchema(stack, context, schema, E.Member(value, key));
+        const isSchema = BuildSchemaPushStack(stack, context, schema, E.Member(value, key));
         const addKey = context.AddKey(E.Constant(key));
         const guarded = context.UseUnevaluated() ? E.And(isSchema, addKey) : isSchema;
         // --------------------------------------------------------------
@@ -50,7 +50,7 @@ export function BuildProperties(stack, context, schema, value) {
 export function CheckProperties(stack, context, schema, value) {
     const required = Schema.IsRequired(schema) ? schema.required : [];
     const isProperties = G.Every(G.Entries(schema.properties), 0, ([key, schema]) => {
-        const isProperty = !G.HasPropertyKey(value, key) || (CheckSchema(stack, context, schema, value[key]) && context.AddKey(key));
+        const isProperty = !G.HasPropertyKey(value, key) || (CheckSchemaPushStack(stack, context, schema, value[key]) && context.AddKey(key));
         return IsExactOptional(required, key)
             ? isProperty
             : InexactOptionalCheck(value, key) || isProperty;
@@ -66,7 +66,7 @@ export function ErrorProperties(stack, context, schemaPath, instancePath, schema
         const nextSchemaPath = `${schemaPath}/properties/${key}`;
         const nextInstancePath = `${instancePath}/${key}`;
         // Defer error generation for IsExactOptional
-        const isProperty = () => (!G.HasPropertyKey(value, key) || (ErrorSchema(stack, context, nextSchemaPath, nextInstancePath, schema, value[key]) && context.AddKey(key)));
+        const isProperty = () => (!G.HasPropertyKey(value, key) || (ErrorSchemaPushStack(stack, context, nextSchemaPath, nextInstancePath, schema, value[key]) && context.AddKey(key)));
         return IsExactOptional(required, key)
             ? isProperty()
             : InexactOptionalCheck(value, key) || isProperty();

package/build/schema/engine/schema.d.mts

@@ -1,6 +1,9 @@
 import * as Schema from '../types/index.mjs';
 import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildSchemaPushStack(stack: Stack, context: BuildContext, schema: Schema.XSchema, value: string): string;
 export declare function BuildSchema(stack: Stack, context: BuildContext, schema: Schema.XSchema, value: string): string;
+export declare function CheckSchemaPushStack(stack: Stack, context: CheckContext, schema: Schema.XSchema, value: unknown): boolean;
 export declare function CheckSchema(stack: Stack, context: CheckContext, schema: Schema.XSchema, value: unknown): boolean;
+export declare function ErrorSchemaPushStack(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XSchema, value: unknown): boolean;
 export declare function ErrorSchema(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XSchema, value: unknown): boolean;

package/build/schema/engine/schema.mjs

@@ -117,6 +117,11 @@ function HasNumberKeywords(schema) {
 // ----------------------------------------------------------------
 // Build
 // ----------------------------------------------------------------
+export function BuildSchemaPushStack(stack, context, schema, value) {
+    return context.UseUnevaluated()
+        ? E.And(E.And(context.Push(), BuildSchema(stack, context, schema, value)), context.Pop())
+        : BuildSchema(stack, context, schema, value);
+}
 export function BuildSchema(stack, context, schema, value) {
     stack.Push(schema);
     const conditions = [];
@@ -237,6 +242,9 @@ export function BuildSchema(stack, context, schema, value) {
 // ----------------------------------------------------------------
 // Check
 // ----------------------------------------------------------------
+export function CheckSchemaPushStack(stack, context, schema, value) {
+    return (context.Push() && CheckSchema(stack, context, schema, value)) && context.Pop();
+}
 export function CheckSchema(stack, context, schema, value) {
     stack.Push(schema);
     const result = Schema.IsBooleanSchema(schema) ? CheckBooleanSchema(stack, context, schema, value) : ((!Schema.IsType(schema) || CheckType(stack, context, schema, value)) &&
@@ -287,6 +295,9 @@ export function CheckSchema(stack, context, schema, value) {
 // ----------------------------------------------------------------
 // Error
 // ----------------------------------------------------------------
+export function ErrorSchemaPushStack(stack, context, schemaPath, instancePath, schema, value) {
+    return (context.Push() && ErrorSchema(stack, context, schemaPath, instancePath, schema, value)) && context.Pop();
+}
 export function ErrorSchema(stack, context, schemaPath, instancePath, schema, value) {
     stack.Push(schema);
     const result = (Schema.IsBooleanSchema(schema)) ? ErrorBooleanSchema(stack, context, schemaPath, instancePath, schema, value) : (!!(+(!Schema.IsType(schema) || ErrorType(stack, context, schemaPath, instancePath, schema, value)) &

package/build/type/types/schema.d.mts

@@ -155,30 +155,7 @@ export interface TNumberOptions extends TSchemaOptions {
 export type TFormat = 'date-time' | 'date' | 'duration' | 'email' | 'hostname' | 'idn-email' | 'idn-hostname' | 'ipv4' | 'ipv6' | 'iri-reference' | 'iri' | 'json-pointer-uri-fragment' | 'json-pointer' | 'json-string' | 'regex' | 'relative-json-pointer' | 'time' | 'uri-reference' | 'uri-template' | 'uri' | 'url' | 'uuid' | ({} & string);
 export interface TStringOptions extends TSchemaOptions {
     /**
-     * Specifies the expected string format.
-     *
-     * Common values include:
-     * - `base64` – Base64-encoded string.
-     * - `date-time` – [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date-time format.
-     * - `date` – [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date (YYYY-MM-DD).
-     * - `duration` – [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) duration format.
-     * - `email` – RFC 5321/5322 compliant email address.
-     * - `hostname` – RFC 1034/1035 compliant host name.
-     * - `idn-email` – Internationalized email address.
-     * - `idn-hostname` – Internationalized host name.
-     * - `ipv4` – IPv4 address.
-     * - `ipv6` – IPv6 address.
-     * - `iri` / `iri-reference` – Internationalized Resource Identifier.
-     * - `json-pointer` / `json-pointer-uri-fragment` – JSON Pointer format.
-     * - `json-string` – String containing valid JSON.
-     * - `regex` – Regular expression syntax.
-     * - `relative-json-pointer` – Relative JSON Pointer format.
-     * - `time` – [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) time (HH:MM:SS).
-     * - `uri-reference` / `uri-template` – URI reference or template.
-     * - `url` – Web URL format.
-     * - `uuid` – RFC 4122 UUID string.
-     *
-     * May also be a custom format string.
+     * Specifies the expected string format. May also be a custom format string.
      */
     format?: TFormat;
     /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
-  "version": "1.1.15",
+  "version": "1.1.17",
   "keywords": [
     "typescript",
     "jsonschema"