@openclaw/slack 2026.8.1-beta.3 → 2026.8.2

package/node_modules/typebox/build/format/idna/idn-hostname.mjs

@@ -0,0 +1,41 @@
+import * as FormatBidi from './format/bidi.mjs';
+import * as LabelUnicode from './label/unicode.mjs';
+import * as LabelPuny from './label/puny.mjs';
+// ------------------------------------------------------------------
+// IsLabel
+// ------------------------------------------------------------------
+function IsValidLabelLength(value) {
+    return value.length > 0 && value.length <= 63;
+}
+function IsLabel(value) {
+    return IsValidLabelLength(value) && (LabelPuny.IsPunyLabel(value) ||
+        LabelUnicode.IsUnicodeLabel(value));
+}
+// ------------------------------------------------------------------
+// NormalizeHostname
+//
+// Normalizes a hostname for label validation. Normalizes for NFC
+// such that equivalent codepoint sequences can be uniformly
+// compared. It also removes codepoints that IDNA mapping ignores,
+// and converts full stop variants to ASCII '.' so the hostname can
+// be split into labels.
+// ------------------------------------------------------------------
+function NormalizeHostname(value) {
+    return value
+        .normalize('NFC')
+        .replace(/[\u00ad\u034f\u180b-\u180d\u200b\ufe00-\ufe0f\u{e0100}-\u{e01ef}]/gu, '') // RE_IGNORED_MAPPING
+        .replace(/[\u002E\u3002\uFF0E\uFF61]/g, '.'); // RE_FULL_STOP_MAPPING
+}
+// ------------------------------------------------------------------
+// IsIdnHostname
+// ------------------------------------------------------------------
+export function IsIdnHostname(value) {
+    if (value.length === 0 || value.includes(' '))
+        return false;
+    const normalized = NormalizeHostname(value);
+    if (normalized.length > 253)
+        return false;
+    const labels = normalized.split('.');
+    const hasBidiChars = labels.some((label) => FormatBidi.HasBidiChars(label));
+    return labels.every((label) => IsLabel(label) && (!hasBidiChars || FormatBidi.SatisfiesBidiRule(label)));
+}

package/node_modules/typebox/build/format/idna/index.d.mts

@@ -0,0 +1,2 @@
+export * from './hostname.mjs';
+export * from './idn-hostname.mjs';

package/node_modules/typebox/build/format/idna/index.mjs

@@ -0,0 +1,2 @@
+export * from './hostname.mjs';
+export * from './idn-hostname.mjs';

package/node_modules/typebox/build/format/idna/label/ascii.d.mts

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

package/node_modules/typebox/build/format/idna/label/ascii.mjs

@@ -0,0 +1,9 @@
+import * as Pattern from '../pattern/pattern.mjs';
+// -------------------------------------------------------------------
+// Validates an ASCII LDH label per RFC 5891 §4.2.3.1
+// -------------------------------------------------------------------
+export function IsAsciiLabel(value) {
+    return (Pattern.RE_RULE_HYPHEN_PLACEMENT.test(value) &&
+        Pattern.RE_RULE_NOT_RESERVED_ACE.test(value) &&
+        Pattern.RE_ASCII_LDH.test(value));
+}

package/node_modules/typebox/build/format/idna/label/puny.d.mts

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

package/node_modules/typebox/build/format/idna/label/puny.mjs

@@ -0,0 +1,28 @@
+import * as FormatPuny from '../format/puny.mjs';
+import * as LabelUnicode from './unicode.mjs';
+import * as Pattern from '../pattern/pattern.mjs';
+// ------------------------------------------------------------------
+// IsPunyLabel
+// ------------------------------------------------------------------
+export function IsPunyLabel(value) {
+    if (!FormatPuny.IsAcePrefixed(value))
+        return false;
+    try {
+        const body = value.slice(4).toLowerCase();
+        // A payload consisting of only a hyphen, or starting with the delimiter
+        // (like "-9uc"), has 0 basic ASCII characters preceding it and is malformed.
+        if (body.lastIndexOf('-') === 0)
+            return false;
+        const decoded = FormatPuny.Decode(body);
+        // RFC 5890 §2.3.2.1 - a U-label must contain at least one non-ASCII
+        // character. Code-unit level check: any non-ASCII codepoint has at least
+        // one UTF-16 unit >= 0x80 (surrogate halves included), so no need to
+        // decode codepoints or allocate a character array to answer this.
+        if (!Pattern.RE_NON_ASCII.test(decoded))
+            return false;
+        return LabelUnicode.IsUnicodeLabel(decoded);
+    }
+    catch {
+        return false;
+    }
+}

package/node_modules/typebox/build/format/idna/label/unicode.d.mts

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

package/node_modules/typebox/build/format/idna/label/unicode.mjs

@@ -0,0 +1,106 @@
+import * as Pattern from '../pattern/pattern.mjs';
+import * as FormatBidi from '../format/bidi.mjs';
+import * as FormatPuny from '../format/puny.mjs';
+// ------------------------------------------------------------------
+// ExceedsMaxALabelLength
+//
+// RFC 5890 §2.3.2.1: an A-label (the ACE-encoded form of a label,
+// "xn--" + punycode) must not exceed 63 octets. Only labels
+// containing non-ASCII characters need checking - a pure-ASCII label
+// has no "xn--" prefix and is used as-is, so its punycode-encoded
+// length is irrelevant. The ASCII check is a cheap short-circuit that
+// avoids running the punycode encoder on labels that don't need it.
+// ------------------------------------------------------------------
+function ExceedsMaxALabelLength(value) {
+    return Pattern.RE_NON_ASCII.test(value) && FormatPuny.Encode(value).length + 4 > 63;
+}
+// ------------------------------------------------------------------
+// HasInvalidHyphens
+//
+// RFC 5891 §4.2.3.2: label must not start or end with a hyphen, and
+// must not have hyphens in the 3rd and 4th codepoint positions (the
+// ACE prefix reservation, e.g. "xn--"). Operates on `chars` (the
+// per-codepoint string array) rather than raw string indices so
+// supplementary-plane characters earlier in the label don't throw
+// off the codepoint-position count.
+// ------------------------------------------------------------------
+function HasInvalidHyphens(chars) {
+    if (chars[0] === '-' || chars[chars.length - 1] === '-')
+        return true;
+    return chars.slice(2).join('').startsWith('--');
+}
+// ------------------------------------------------------------------
+// IsUnicodeLabel
+// ------------------------------------------------------------------
+export function IsUnicodeLabel(value) {
+    // RFC 5890 §2.3.2.1: Ensure Max Length
+    if (ExceedsMaxALabelLength(value))
+        return false;
+    // RFC 5893 - Bidi Rule (applies whenever this label itself is RTL)
+    if (FormatBidi.HasRightToLeftCharacters(value) && !FormatBidi.SatisfiesBidiRule(value))
+        return false;
+    const chars = [...value];
+    const codePoints = chars.map((c) => c.codePointAt(0));
+    const length = codePoints.length;
+    // RFC 5891 §4.2.3.2: Hyphen rules
+    if (HasInvalidHyphens(chars))
+        return false;
+    // RFC 5891 §4.2.3.2 - Must not begin with a combining mark
+    if (Pattern.RE_COMBINING_MARK.test(chars[0]))
+        return false;
+    let hasJapanese = false;
+    // let hasArabicIndic = false // (no-spec-coverage)
+    // let hasExtendedArabicIndic = false // (no-spec-coverage)
+    for (let i = 0; i < length; i++) {
+        const codePoint = codePoints[i];
+        const char = chars[i];
+        // 1. DISALLOWED exceptions
+        if (Pattern.RE_RFC5892_DISALLOWED.test(char))
+            return false;
+        // 1b. General category (PVALID) enforcement
+        if (!Pattern.RE_PERMITTED_CATEGORY.test(char))
+            return false;
+        // 2. Collect Flags
+        if (Pattern.RE_SCRIPT_JAPANESE.test(char))
+            hasJapanese = true;
+        // if (Pattern.RE_ARABIC_INDIC_DIGIT.test(char)) hasArabicIndic = true  // (no-spec-coverage)
+        // if (Pattern.RE_EXT_ARABIC_INDIC_DIGIT.test(char)) hasExtendedArabicIndic = true  // (no-spec-coverage)
+        // 3. CONTEXTO / CONTEXTJ Neighbor Rules
+        const prev = codePoints[i - 1], next = codePoints[i + 1];
+        switch (codePoint) {
+            case 0x00b7:
+                if (prev !== 0x006c || next !== 0x006c)
+                    return false;
+                break; // MIDDLE DOT (Catalan)
+            case 0x0375:
+                if (!next || !Pattern.RE_SCRIPT_GREEK.test(chars[i + 1]))
+                    return false;
+                break; // Greek KERAIA
+            case 0x05f3:
+            case 0x05f4:
+                if (!prev || !Pattern.RE_SCRIPT_HEBREW.test(chars[i - 1]))
+                    return false;
+                break; // Hebrew GERESH
+            case 0x200c: // ZWNJ - RFC 5892 Appendix A.1
+                // Note: Full validation requires a Unicode joining type table. We reject
+                // only when preceded by ASCII (U+0000-U+007F), which can never satisfy
+                // the Virama or cursive-joining rules.
+                if (!prev || (prev < 0x0080 && !Pattern.RE_VIRAMA.test(chars[i - 1])))
+                    return false;
+                break;
+            case 0x200d: // ZWJ: RFC 5892 Appendix A.2
+                if (!prev || !Pattern.RE_VIRAMA.test(chars[i - 1]))
+                    return false;
+                break;
+            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 // (no-spec-coverage)
+    return true;
+}

package/node_modules/typebox/build/format/idna/pattern/pattern.d.mts

@@ -0,0 +1,30 @@
+export declare const RE_RULE_HYPHEN_PLACEMENT: RegExp;
+export declare const RE_RULE_NOT_RESERVED_ACE: RegExp;
+export declare const RE_ASCII_LDH: RegExp;
+export declare const RE_ASCII: RegExp;
+export declare const RE_NON_ASCII: RegExp;
+export declare const RE_HIGH_SURROGATE: RegExp;
+export declare const RE_REGIONAL_INDICATOR: RegExp;
+export declare const RE_VARIATION_SELECTOR: RegExp;
+export declare const RE_ZERO_WIDTH_JOINER: RegExp;
+export declare const RE_ASCII_DIGIT: RegExp;
+export declare const RE_ARABIC_INDIC_DIGIT: RegExp;
+export declare const RE_EXT_ARABIC_INDIC_DIGIT: RegExp;
+export declare const RE_COMMON_SEPARATOR: RegExp;
+export declare const RE_EUROPEAN_SEPARATOR: RegExp;
+export declare const RE_MARK_NONSPACING: RegExp;
+export declare const RE_MARK_SPACING_COMBINING: RegExp;
+export declare const RE_MARK_ENCLOSING: RegExp;
+export declare const RE_COMBINING_MARK: RegExp;
+export declare const RE_LETTER: RegExp;
+export declare const RE_NUMBER_DECIMAL: RegExp;
+export declare const RE_SCRIPT_GREEK: RegExp;
+export declare const RE_SCRIPT_HEBREW: RegExp;
+export declare const RE_SCRIPT_JAPANESE: RegExp;
+export declare const RE_SCRIPT_ARABIC_LETTER: RegExp;
+export declare const RE_VIRAMA: RegExp;
+export declare const RE_RFC5892_DISALLOWED: RegExp;
+export declare const RE_CONTEXTO_EXCEPTIONS: RegExp;
+export declare const RE_PVALID_EXCEPTIONS: RegExp;
+export declare const RE_EUROPEAN_NUMBER: RegExp;
+export declare const RE_PERMITTED_CATEGORY: RegExp;

package/node_modules/typebox/build/format/idna/pattern/pattern.mjs

@@ -0,0 +1,70 @@
+// deno-fmt-ignore-file
+// -------------------------------------------------------------------
+// Validation Rules
+// -------------------------------------------------------------------
+export const RE_RULE_HYPHEN_PLACEMENT = /^(?!-).*(?<!-)$/;
+export const RE_RULE_NOT_RESERVED_ACE = /^(?!..--)/;
+export const RE_ASCII_LDH = /^[a-zA-Z0-9-]*$/;
+// -------------------------------------------------------------------
+// ASCII & Encoding
+// -------------------------------------------------------------------
+export const RE_ASCII = /^\p{ASCII}*$/u;
+export const RE_NON_ASCII = /[^\p{ASCII}]/u;
+// -------------------------------------------------------------------
+// Structural & Unicode Controls
+// -------------------------------------------------------------------
+export const RE_HIGH_SURROGATE = /[\u{d800}-\u{dbff}]/u;
+export const RE_REGIONAL_INDICATOR = /[\u{1f1e6}-\u{1f1ff}]/u;
+export const RE_VARIATION_SELECTOR = /[\u{fe00}-\u{fe0f}]/u;
+export const RE_ZERO_WIDTH_JOINER = /\u{200d}/u;
+// -------------------------------------------------------------------
+// Numbers & Digits
+// -------------------------------------------------------------------
+export const RE_ASCII_DIGIT = /[0-9]/;
+export const RE_ARABIC_INDIC_DIGIT = /[\u{0660}-\u{0669}]/u;
+export const RE_EXT_ARABIC_INDIC_DIGIT = /[\u{06f0}-\u{06f9}]/u;
+// -------------------------------------------------------------------
+// Separators
+// -------------------------------------------------------------------
+export const RE_COMMON_SEPARATOR = /[\u{002e}\u{002c}\u{003a}\u{002f}]/u;
+export const RE_EUROPEAN_SEPARATOR = /[\u{002d}\u{002b}]/u;
+// -------------------------------------------------------------------
+// General Categories
+// -------------------------------------------------------------------
+export const RE_MARK_NONSPACING = /\p{Mn}/u;
+export const RE_MARK_SPACING_COMBINING = /\p{Mc}/u;
+export const RE_MARK_ENCLOSING = /\p{Me}/u;
+export const RE_COMBINING_MARK = /[\p{Mn}\p{Mc}\p{Me}]/u;
+export const RE_LETTER = /\p{L}/u;
+export const RE_NUMBER_DECIMAL = /\p{Nd}/u;
+// -------------------------------------------------------------------
+// Scripts
+// -------------------------------------------------------------------
+export const RE_SCRIPT_GREEK = /\p{Script=Greek}/u;
+export const RE_SCRIPT_HEBREW = /\p{Script=Hebrew}/u;
+export const RE_SCRIPT_JAPANESE = /[\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Han}]/u;
+export const RE_SCRIPT_ARABIC_LETTER = /[\p{Script=Arabic}\p{Script=Syriac}\p{Script=Thaana}\p{Script=Mandaic}]/u;
+// -------------------------------------------------------------------
+// RFC Specifications & Context Exceptions
+// -------------------------------------------------------------------
+export const RE_VIRAMA = /[\u{094d}\u{09cd}\u{0a4d}\u{0acd}\u{0b4d}\u{0bcd}\u{0c4d}\u{0ccd}\u{0d3b}\u{0d3c}\u{0d4d}\u{0dca}\u{1b44}\u{1baa}\u{1bab}\u{a9c0}\u{11046}\u{1107f}\u{110b9}\u{11133}\u{11134}\u{111c0}\u{11235}\u{1134d}\u{11442}\u{114c2}\u{115bf}\u{1163f}\u{116b6}\u{11c3f}\u{11d44}\u{11d45}]/u;
+export const RE_RFC5892_DISALLOWED = /[\u{0640}\u{07fa}\u{302e}\u{302f}\u{3031}\u{3032}\u{3033}\u{3034}\u{3035}\u{303b}]/u;
+export const RE_CONTEXTO_EXCEPTIONS = /[\u{00b7}\u{0375}\u{05f3}\u{05f4}\u{200c}\u{200d}\u{30fb}]/u;
+export const RE_PVALID_EXCEPTIONS = /[\u{00df}\u{03c2}\u{06fd}\u{06fe}\u{0f0b}\u{3007}]/u;
+// -------------------------------------------------------------------
+// Composite Patterns
+// -------------------------------------------------------------------
+export const RE_EUROPEAN_NUMBER = new RegExp([
+    RE_ASCII_DIGIT,
+    RE_EXT_ARABIC_INDIC_DIGIT
+].map((regexp) => regexp.source).join('|'), 'u');
+export const RE_PERMITTED_CATEGORY = new RegExp([
+    RE_LETTER,
+    RE_EUROPEAN_SEPARATOR,
+    RE_COMMON_SEPARATOR,
+    RE_NUMBER_DECIMAL,
+    RE_MARK_NONSPACING,
+    RE_MARK_SPACING_COMBINING,
+    RE_CONTEXTO_EXCEPTIONS,
+    RE_PVALID_EXCEPTIONS
+].map((regexp) => regexp.source).join('|'), 'u');

package/node_modules/typebox/build/format/ipv4.d.mts

@@ -1,4 +1,3 @@
-export declare function IsIPv4Internal(value: string, start: number, end: number): boolean;
 /**
  * Returns true if the value is a IPV4 address
  * @specification http://tools.ietf.org/html/rfc2673#section-3.2

package/node_modules/typebox/build/format/ipv4.mjs

@@ -1,38 +1,8 @@
-// ------------------------------------------------------------------
-// Ranged Fast Path
-// ------------------------------------------------------------------
-/* Returns true if the value is a IPV4 address from index range offsets */
-export function IsIPv4Internal(value, start, end) {
-    let dots = 0;
-    let num = 0;
-    let digits = 0;
-    let leading = 0;
-    for (let i = start; i < end; i++) {
-        const ch = value.charCodeAt(i);
-        if (ch === 46) { // '.'
-            if (digits === 0 || num > 255 || (leading === 48 && digits > 1))
-                return false;
-            dots++;
-            num = 0;
-            digits = 0;
-            leading = 0;
-        }
-        else if (ch >= 48 && ch <= 57) { // '0'-'9'
-            if (digits === 0)
-                leading = ch;
-            num = num * 10 + (ch - 48);
-            digits++;
-        }
-        else {
-            return false;
-        }
-    }
-    return dots === 3 && digits > 0 && num <= 255 && !(leading === 48 && digits > 1);
-}
+const IPv4 = /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/;
 /**
  * Returns true if the value is a IPV4 address
  * @specification http://tools.ietf.org/html/rfc2673#section-3.2
  */
 export function IsIPv4(value) {
-    return IsIPv4Internal(value, 0, value.length);
+    return IPv4.test(value);
 }

package/node_modules/typebox/build/format/ipv6.mjs

@@ -1,67 +1,8 @@
-import { IsIPv4Internal } from './ipv4.mjs';
-function InRange(ch) {
-    return (ch >= 48 && ch <= 57) || // 0-9
-        (ch >= 65 && ch <= 70) || // A-F
-        (ch >= 97 && ch <= 102); // a-f
-}
+const IPv6 = /^(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:)?[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)$/i;
 /**
  * Returns true if the value is an IPv6 address
  * @specification http://tools.ietf.org/html/rfc2373#section-2.2
  */
 export function IsIPv6(value) {
-    const length = value.length;
-    if (length === 0)
-        return false;
-    let groups = 0;
-    let compressed = false;
-    let i = 0;
-    // handle leading '::'
-    if (value.charCodeAt(0) === 58 && value.charCodeAt(1) === 58) {
-        if (length === 2)
-            return true; // '::' is valid
-        compressed = true;
-        i = 2;
-    }
-    while (i < length) {
-        // read hex digits
-        let digits = 0;
-        const start = i;
-        while (i < length && InRange(value.charCodeAt(i))) {
-            i++;
-            digits++;
-        }
-        if (digits === 0)
-            return false;
-        const next = value.charCodeAt(i);
-        // check for embedded IPv4 at the end
-        if (next === 46) { // '.'
-            if (!IsIPv4Internal(value, start, length))
-                return false;
-            groups += 2;
-            i = length;
-            break;
-        }
-        if (digits > 4)
-            return false;
-        groups++;
-        if (i === length)
-            break;
-        // expect ':' separator
-        if (next !== 58)
-            return false;
-        i++;
-        // check for '::' compression
-        if (value.charCodeAt(i) === 58) {
-            if (compressed)
-                return false; // only one '::' allowed
-            // check for ':::'
-            if (value.charCodeAt(i + 1) === 58)
-                return false;
-            compressed = true;
-            i++;
-            if (i === length)
-                break; // trailing '::'
-        }
-    }
-    return compressed ? groups <= 7 : groups === 8;
+    return IPv6.test(value);
 }

package/node_modules/typebox/build/format/iri.d.mts

@@ -1,5 +1,5 @@
 /**
- * Returns true if the value is a Iri
- * @specification
+ * Returns true if the value is a valid Internationalized Resource Identifier.
+ * @specification https://datatracker.ietf.org/doc/html/rfc3987
  */
 export declare function IsIri(value: string): boolean;

package/node_modules/typebox/build/format/iri.mjs

@@ -1,13 +1,31 @@
+// deno-lint-ignore-file no-control-regex
+const IpvFutureMatchMaxLength = 2048;
+const IpvFutureMatch = /\[[vV][0-9a-fA-F]+\.[^\]]+\]/; // Guarded By IpvFutureMatchMaxLength
+const InvalidIriChars = /[\x00-\x20<>\^`{|}\\]/;
+// ------------------------------------------------------------------
+// NarrowIpvFuture
+//
+// Substitutes an IPvFuture address with a standard IPv6 loopback
+// address ([::1]). We do this because the native URL.canParse
+// (WHATWG standard) rejects IPvFuture literals, which are
+// otherwise valid in RFC 3987. Because regex substitution can
+// be expensive on large strings, this operation is strictly
+// limited to inputs under a defined length threshold.
+//
+// (review-optimization)
+//
+// ------------------------------------------------------------------
+function NarrowIpvFuture(value) {
+    return value.length < IpvFutureMatchMaxLength ? value.replace(IpvFutureMatch, '[::1]') : value;
+}
 /**
- * Returns true if the value is a Iri
- * @specification
+ * Returns true if the value is a valid Internationalized Resource Identifier.
+ * @specification https://datatracker.ietf.org/doc/html/rfc3987
  */
 export function IsIri(value) {
-    try {
-        new URL(value);
-        return true;
-    }
-    catch {
+    // 1. Reject strings containing unencoded whitespace or illegal control characters.
+    if (InvalidIriChars.test(value))
         return false;
-    }
+    // 2. Delegate to the native URL parser, patching the IPvFuture edge case beforehand.
+    return URL.canParse(NarrowIpvFuture(value));
 }

package/node_modules/typebox/build/format/iri_reference.d.mts

@@ -1,5 +1,5 @@
 /**
- * Returns true if the value is a Iri reference
- * @specification
+ * Returns true if the value is an IRI reference
+ * @specification https://tools.ietf.org/html/rfc3987
  */
 export declare function IsIriReference(value: string): boolean;

package/node_modules/typebox/build/format/iri_reference.mjs

@@ -1,60 +1,14 @@
 // deno-lint-ignore-file no-control-regex
-// deno-coverage-ignore-start
-function TryUrl(value) {
-    try {
-        new URL(value, 'http://example.com'); // This handles relative paths correctly
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-// deno-coverage-ignore-stop
+// Rejects unencoded spaces (0x20), backslashes, control characters (0x00-0x1F, 0x7F), or malformed percent-encodings
+const InvalidIriChars = /[\x00-\x20\x7F\\]|%(?![0-9a-fA-F]{2})/;
+// Detects malformed scheme/authority patterns lacking a colon (e.g. "httpx//example.com")
+const MalformedScheme = /^[a-zA-Z][a-zA-Z0-9+\-.]*\/\//;
 /**
- * Returns true if the value is a Iri reference
- * @specification
+ * Returns true if the value is an IRI reference
+ * @specification https://tools.ietf.org/html/rfc3987
  */
 export function IsIriReference(value) {
-    // 1. Basic forbidden character checks (must be percent-encoded or not exist)
-    // RFC 3987 excludes space, backslash, and control characters from being unencoded.
-    if (value.includes(' ')) { // Unencoded space (U+0020)
-        return false;
-    }
-    if (value.includes('\\')) { // Backslash (U+005C)
-        return false;
-    }
-    // ASCII control characters (U+0000-U+001F and U+007F)
-    if (/[\x00-\x1F\x7F]/.test(value)) {
-        return false;
-    }
-    // 2. Check for invalid percent-encoding
-    // A percent sign '%' must always be followed by exactly two hexadecimal characters.
-    // This regex finds a '%' that is NOT followed by two hexadecimal characters.
-    //   - `%` matches a literal percent sign.
-    //   - `(?!...)` is a negative lookahead, asserting that what follows is NOT.
-    //   - `[0-9a-fA-F]{2}` matches exactly two hexadecimal digits.
-    // So, if a '%' is found that is not immediately followed by two hex digits, this regex will match.
-    if (/%(?![0-9a-fA-F]{2})/.test(value)) {
-        return false;
-    }
-    // 3. Handle empty string (valid relative reference to the current document)
-    if (value === '') {
-        return true;
-    }
-    // 4. Determine if it's attempting to be an absolute IRI or a relative IRI, and parse.
-    const colonIndex = value.indexOf(':');
-    const hasValidSchemePrefix = colonIndex > 0 && // Colon must not be at the very beginning (e.g., ":foo")
-        /^[a-zA-Z][a-zA-Z0-9+\-.]*$/.test(value.substring(0, colonIndex));
-    if (hasValidSchemePrefix) {
-        return TryUrl(value);
-    }
-    else {
-        // This handles cases like `httpx//example.com/path` which look like malformed absolute URIs.
-        const looksLikeMalformedSchemeAndAuthority = value.match(/^([a-zA-Z][a-zA-Z0-9+\-.]*)(\/\/)/);
-        if (looksLikeMalformedSchemeAndAuthority && colonIndex === -1) {
-            return false;
-        }
-        // Otherwise, it's a relative IRI reference.
-        return TryUrl(value);
-    }
+    return (!InvalidIriChars.test(value) &&
+        !MalformedScheme.test(value) &&
+        URL.canParse(value, 'http://example.com'));
 }

package/node_modules/typebox/build/format/regex.d.mts

@@ -1,6 +1,5 @@
 /**
  * Returns true if the value is a regular expression string pattern
- * @specification
- * @source ajv-formats
+ * @specification https://ecma-international.org/ecma-262
  */
 export declare function IsRegex(value: string): boolean;

package/node_modules/typebox/build/format/regex.mjs

@@ -1,14 +1,10 @@
 /**
  * Returns true if the value is a regular expression string pattern
- * @specification
- * @source ajv-formats
+ * @specification https://ecma-international.org/ecma-262
  */
 export function IsRegex(value) {
-    if (value.length === 0) {
-        return false;
-    }
     try {
-        new RegExp(value);
+        new RegExp(value, 'u');
         return true;
     }
     catch {

package/node_modules/typebox/build/format/time.d.mts

@@ -1,5 +1,5 @@
 /**
- * Returns true if the value is a ISO time string
- * @specification
+ * Returns true if the value is an ISO time string
+ * @specification https://datatracker.ietf.org/doc/html/rfc3339
  */
 export declare function IsTime(value: string, strictTimeZone?: boolean): boolean;

package/node_modules/typebox/build/format/time.mjs

@@ -1,27 +1,32 @@
-const TIME = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(?:Z|([+-])(\d\d):(\d\d))?$/i;
+const TIME = /^(\d\d):(\d\d):(\d\d)(?:\.\d+)?(?:([Zz])|([+-])(\d\d):(\d\d))?$/;
 /**
- * Returns true if the value is a ISO time string
- * @specification
+ * Returns true if the value is an ISO time string
+ * @specification https://datatracker.ietf.org/doc/html/rfc3339
  */
 export function IsTime(value, strictTimeZone = true) {
     const matches = TIME.exec(value);
     if (!matches)
         return false;
+    // Require timezone offset or 'Z'/'z' when strictTimeZone is true
+    if (strictTimeZone && !matches[4] && !matches[5])
+        return false;
     const hr = +matches[1];
     const min = +matches[2];
     const sec = +matches[3];
-    const tzSign = matches[4] === '-' ? -1 : 1; // Use matches[4] for sign
-    const tzH = +(matches[5] || 0); // tzH is now matches[5]
-    const tzM = +(matches[6] || 0); // tzM is now matches[6]
-    if (tzH > 23 || tzM > 59)
-        return false; // Check for valid hour/minute range in offset
-    if (strictTimeZone && !matches[4] && value.toLowerCase().indexOf('z') === -1) {
-        // If strictTimeZone is true, and neither 'Z' nor a '+/-' offset was found
+    if (hr > 23 || min > 59 || sec > 60)
         return false;
+    if (matches[5]) {
+        const tzH = +matches[6];
+        const tzM = +matches[7];
+        if (tzH > 23 || tzM > 59)
+            return false;
     }
-    if (hr <= 23 && min <= 59 && sec < 60)
+    if (sec < 60)
         return true;
-    const utcMin = min - tzM * tzSign;
-    const utcHr = hr - tzH * tzSign - (utcMin < 0 ? 1 : 0);
-    return (utcHr === 23 || utcHr === -1) && (utcMin === 59 || utcMin === -1) && sec < 61;
+    // Leap second handling: must normalize to 23:59:60 UTC (1439 total UTC minutes)
+    const tzSign = matches[5] === '-' ? -1 : 1;
+    const tzH = +(matches[6] || 0);
+    const tzM = +(matches[7] || 0);
+    const totalUtcMin = (hr * 60 + min) - tzSign * (tzH * 60 + tzM);
+    return (totalUtcMin % 1440 + 1440) % 1440 === 1439;
 }

package/node_modules/typebox/build/format/uri.d.mts

@@ -1,5 +1,5 @@
 /**
- * Returns true if the value matches RFC 3986 URI syntax.
+ * Returns true if the value is a valid Uniform Resource Identifier.
  * @specification https://tools.ietf.org/html/rfc3986
  */
 export declare function IsUri(value: string): boolean;