pi-proactive 0.2.0-beta.3 → 0.2.0-beta.4

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

@@ -1,98 +0,0 @@
-// deno-fmt-ignore-file
-import * as FormatPuny from './puny.mjs';
-import * as Pattern from '../pattern/pattern.mjs';
-// ------------------------------------------------------------------
-// LOCAL REGEX: Allowed Bidi classes per direction (RFC 5893)
-// ------------------------------------------------------------------
-const RE_RTL_ALLOWED = /^(?:R|AL|AN|EN|ES|CS|ET|ON|BN|NSM)$/;
-const RE_LTR_ALLOWED = /^(?:L|EN|ES|CS|ET|ON|BN|NSM)$/;
-const RE_RTL_CLASSES = /^(?:R|AL|AN)$/;
-// ------------------------------------------------------------------
-// HasBidiChars
-//
-// Decodes a punycode label to its Unicode form (if it is one) and
-// checks whether the result is an RTL label per RFC 5893 §1.4.
-// ------------------------------------------------------------------
-export function HasBidiChars(value) {
-    if (FormatPuny.IsAcePrefixed(value)) {
-        try {
-            return HasRightToLeftCharacters(FormatPuny.Decode(value.slice(4).toLowerCase()));
-        }
-        catch {
-            return false;
-        }
-    }
-    return HasRightToLeftCharacters(value);
-}
-// ------------------------------------------------------------------
-// GetBidiClass
-// ------------------------------------------------------------------
-function GetBidiClass(codePoint) {
-    const char = String.fromCodePoint(codePoint);
-    return (Pattern.RE_EUROPEAN_NUMBER.test(char) ? 'EN' :
-        Pattern.RE_ARABIC_INDIC_DIGIT.test(char) ? 'AN' :
-            // Pattern.RE_EUROPEAN_SEPARATOR.test(char) ? 'ES' : // (no-spec-coverage)
-            // Pattern.RE_COMMON_SEPARATOR.test(char) ? 'CS' : // (no-spec-coverage)
-            Pattern.RE_MARK_NONSPACING.test(char) ? 'NSM' :
-                Pattern.RE_SCRIPT_HEBREW.test(char) ? 'R' :
-                    Pattern.RE_SCRIPT_ARABIC_LETTER.test(char) ? 'AL' :
-                        Pattern.RE_LETTER.test(char) ? 'L' :
-                            'ON');
-}
-// ------------------------------------------------------------------
-// HasRightToLeftCharacters
-//
-// Per RFC 5893 §1.4: "An RTL label is a label that contains at least
-// one character of type R, AL, or AN." Used to determine whether a
-// domain name is a "Bidi domain name" (RFC 5893 §1.4), in which case
-// the Bidi Rule applies to every label in the domain.
-// ------------------------------------------------------------------
-export function HasRightToLeftCharacters(value) {
-    for (const ch of value)
-        if (RE_RTL_CLASSES.test(GetBidiClass(ch.codePointAt(0))))
-            return true;
-    return false;
-}
-// ------------------------------------------------------------------
-// SatisfiesBidiRule
-// ------------------------------------------------------------------
-export function SatisfiesBidiRule(value) {
-    let isRtl = false;
-    let allowed = RE_LTR_ALLOWED;
-    let sawEN = false;
-    let sawAN = false;
-    let isFirst = true;
-    // let lastClass: string | null = null // (no-spec-coverage)
-    for (const ch of value) {
-        const bidiClass = GetBidiClass(ch.codePointAt(0));
-        if (isFirst) {
-            // 1. The first character must be a character with Bidi property L, R, or AL.
-            if (bidiClass !== 'L' && bidiClass !== 'R' && bidiClass !== 'AL')
-                return false;
-            isRtl = bidiClass === 'R' || bidiClass === 'AL';
-            allowed = isRtl ? RE_RTL_ALLOWED : RE_LTR_ALLOWED;
-            isFirst = false;
-        }
-        // 2 / 5. Only characters in the allowed set for this direction may appear.
-        if (!allowed.test(bidiClass))
-            return false;
-        if (bidiClass === 'EN')
-            sawEN = true;
-        else if (bidiClass === 'AN')
-            sawAN = true;
-        // if (bidiClass !== 'NSM') lastClass = bidiClass // (no-spec-coverage)
-    }
-    if (isRtl && sawEN && sawAN)
-        return false; // spec coverage path
-    // (no-spec-coverage)
-    // if (isRtl) {
-    //   // 3. The end of the label must be R, AL, EN, or AN (ignoring trailing NSM).
-    //   // if (lastClass !== 'R' && lastClass !== 'AL' && lastClass !== 'EN' && lastClass !== 'AN') return false
-    //   // 4. If an EN is present, no AN may be present, and vice versa.
-    //   if (sawEN && sawAN) return false
-    // } else {
-    //   // 6. The end of the label must be L or EN (ignoring trailing NSM).
-    //   // if (lastClass !== 'L' && lastClass !== 'EN') return false
-    // }
-    return true;
-}

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

@@ -1,3 +0,0 @@
-export declare function IsAcePrefixed(value: string): boolean;
-export declare function Decode(value: string): string;
-export declare function Encode(input: string): string;

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

@@ -1,144 +0,0 @@
-import * as Pattern from '../pattern/pattern.mjs';
-// ------------------------------------------------------------------
-// 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;
-// ------------------------------------------------------------------
-// ThrowDontCare
-// ------------------------------------------------------------------
-function ThrowDontCare() {
-    throw null;
-}
-// ------------------------------------------------------------------
-// IsAcePrefixed
-// ------------------------------------------------------------------
-export function IsAcePrefixed(value) {
-    return value.toLowerCase().startsWith('xn--');
-}
-// ------------------------------------------------------------------
-// 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)
-                ThrowDontCare(); // 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)
-                ThrowDontCare(); // 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 // (no-spec-coverage)
-            else
-                ThrowDontCare(); // 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 String.fromCodePoint(...output);
-}
-// ------------------------------------------------------------------
-// DigitToChar
-// ------------------------------------------------------------------
-function DigitToChar(digit) {
-    return digit < 26 ? String.fromCharCode(digit + 0x61) : String.fromCharCode(digit - 26 + 0x30);
-}
-// ------------------------------------------------------------------
-// Encode
-//
-// Encodes a Unicode string into its Punycode payload (the part that
-// follows the 'xn--' ACE prefix). Used to compute the true A-label
-// length of a U-label, since the 63-octet label length limit (RFC
-// 5891 §4.2.4) applies to the encoded form, not the code point count.
-// ------------------------------------------------------------------
-const RE_REPLACE_NON_ASCII = new RegExp(Pattern.RE_NON_ASCII.source, 'gu');
-export function Encode(input) {
-    // Extract basic ASCII characters and set initial output array state
-    const basic = input.replace(RE_REPLACE_NON_ASCII, '');
-    const basicLength = basic.length;
-    const result = basicLength > 0 ? [basic, '-'] : [];
-    // Extract unicode codepoints
-    const codePoints = Array.from(input, (char) => char.codePointAt(0));
-    let n = PUNYCODE_INITIAL_N;
-    let delta = 0;
-    let bias = PUNYCODE_INITIAL_BIAS;
-    let handledCPCount = basicLength;
-    while (handledCPCount < codePoints.length) {
-        let m = Infinity;
-        for (const cp of codePoints) {
-            if (cp >= n && cp < m)
-                m = cp;
-        }
-        delta += (m - n) * (handledCPCount + 1);
-        n = m;
-        for (const cp of codePoints) {
-            if (cp < n)
-                delta++;
-            if (cp === n) {
-                let q = delta;
-                for (let k = PUNYCODE_BASE;; k += PUNYCODE_BASE) {
-                    const t = k <= bias ? PUNYCODE_TMIN : k >= bias + PUNYCODE_TMAX ? PUNYCODE_TMAX : k - bias;
-                    if (q < t)
-                        break;
-                    const digit = t + ((q - t) % (PUNYCODE_BASE - t));
-                    result.push(DigitToChar(digit));
-                    q = Math.floor((q - t) / (PUNYCODE_BASE - t));
-                }
-                result.push(DigitToChar(q));
-                bias = Adapt(delta, handledCPCount + 1, handledCPCount === basicLength);
-                delta = 0;
-                handledCPCount++;
-            }
-        }
-        delta++;
-        n++;
-    }
-    return result.join('');
-}

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

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

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

@@ -1,16 +0,0 @@
-import * as LabelAscii from './label/ascii.mjs';
-import * as LabelPuny from './label/puny.mjs';
-function IsValidLabelLength(value) {
-    return value.length > 0 && value.length <= 63;
-}
-function IsLabel(value) {
-    return IsValidLabelLength(value) && (LabelPuny.IsPunyLabel(value) ||
-        LabelAscii.IsAsciiLabel(value));
-}
-export function IsHostname(value) {
-    if (value.length === 0 || value.length > 253)
-        return false;
-    if (value.charCodeAt(value.length - 1) === 46)
-        return false;
-    return value.split('.').every((label) => IsLabel(label));
-}

package/node_modules/typebox/build/format/idna/idn-hostname.d.mts

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

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

@@ -1,43 +0,0 @@
-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. Maps fullwidth
-// codepoints to their ASCII equivalent (e.g. 'ａ' U+FF41 maps to
-// 'a'), then 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
-        .replace(/[\uff01-\uff5e]/g, (char) => String.fromCharCode(char.charCodeAt(0) - 0xfee0)) // RE_FULLWIDTH_MAPPING
-        .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

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

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

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

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

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

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

@@ -1,9 +0,0 @@
-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

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

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

@@ -1,28 +0,0 @@
-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

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

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

@@ -1,106 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,70 +0,0 @@
-// 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/index.d.mts

@@ -1,4 +0,0 @@
-export * from './format.mjs';
-export * as Format from './format.mjs';
-import * as Format from './format.mjs';
-export default Format;

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

@@ -1,4 +0,0 @@
-export * from './format.mjs';
-export * as Format from './format.mjs';
-import * as Format from './format.mjs';
-export default Format;

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

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

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

@@ -1,8 +0,0 @@
-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 IPv4.test(value);
-}

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

@@ -1,5 +0,0 @@
-/**
- * Returns true if the value is an IPv6 address
- * @specification http://tools.ietf.org/html/rfc2373#section-2.2
- */
-export declare function IsIPv6(value: string): boolean;

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

@@ -1,8 +0,0 @@
-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) {
-    return IPv6.test(value);
-}

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

@@ -1,5 +0,0 @@
-/**
- * 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;