@openclaw/facetime 0.0.0 → 2026.9.6

package/node_modules/typebox/build/error/errors.d.mts

@@ -0,0 +1,208 @@
+export type TValidationError = TAdditionalPropertiesError | TAnyOfError | TBooleanError | TConstError | TContainsError | TDependenciesError | TDependentRequiredError | TEnumError | TExclusiveMaximumError | TExclusiveMinimumError | TFormatError | TIfError | TMaximumError | TMaxItemsError | TMaxLengthError | TMaxPropertiesError | TMinimumError | TMinItemsError | TMinLengthError | TMinPropertiesError | TMultipleOfError | TNotError | TOneOfError | TPatternError | TPropertyNamesError | TRefineError | TRequiredError | TTypeError | TUnevaluatedItemsError | TUnevaluatedPropertiesError | TUniqueItemsError;
+export declare function IsValidationError(value: unknown): value is TValidationError;
+export type TLocalizedValidationError = TValidationError & {
+    message: string;
+};
+export declare function IsLocalizedValidationError(value: unknown): value is TLocalizedValidationError;
+export type TLocalizedValidationMessageCallback = (error: TValidationError) => string;
+export interface TValidationErrorBase {
+    keyword: string;
+    schemaPath: string;
+    instancePath: string;
+    params: object;
+}
+export interface TAdditionalPropertiesError extends TValidationErrorBase {
+    keyword: 'additionalProperties';
+    params: {
+        additionalProperties: string[];
+    };
+}
+export interface TAnyOfError extends TValidationErrorBase {
+    keyword: 'anyOf';
+    params: {};
+}
+export interface TBooleanError extends TValidationErrorBase {
+    keyword: 'boolean';
+    params: {};
+}
+export interface TConstError extends TValidationErrorBase {
+    keyword: 'const';
+    params: {
+        allowedValue: unknown;
+    };
+}
+export interface TContainsError extends TValidationErrorBase {
+    keyword: 'contains';
+    params: {
+        minContains: number;
+        maxContains?: number;
+    };
+}
+export interface TDependenciesError extends TValidationErrorBase {
+    keyword: 'dependencies';
+    params: {
+        property: string;
+        dependencies: string[];
+    };
+}
+export interface TDependentRequiredError extends TValidationErrorBase {
+    keyword: 'dependentRequired';
+    params: {
+        property: string;
+        dependencies: string[];
+    };
+}
+export interface TEnumError extends TValidationErrorBase {
+    keyword: 'enum';
+    params: {
+        allowedValues: unknown[];
+    };
+}
+export interface TExclusiveMaximumError extends TValidationErrorBase {
+    keyword: 'exclusiveMaximum';
+    params: {
+        comparison: '<';
+        limit: number | bigint;
+    };
+}
+export interface TExclusiveMinimumError extends TValidationErrorBase {
+    keyword: 'exclusiveMinimum';
+    params: {
+        comparison: '>';
+        limit: number | bigint;
+    };
+}
+export interface TFormatError extends TValidationErrorBase {
+    keyword: 'format';
+    params: {
+        format: string;
+    };
+}
+export interface TIfError extends TValidationErrorBase {
+    keyword: 'if';
+    params: {
+        failingKeyword: 'then' | 'else';
+    };
+}
+export interface TMaximumError extends TValidationErrorBase {
+    keyword: 'maximum';
+    params: {
+        comparison: '<=';
+        limit: number | bigint;
+    };
+}
+export interface TMaxItemsError extends TValidationErrorBase {
+    keyword: 'maxItems';
+    params: {
+        limit: number;
+    };
+}
+export interface TMaxLengthError extends TValidationErrorBase {
+    keyword: 'maxLength';
+    params: {
+        limit: number;
+    };
+}
+export interface TMaxPropertiesError extends TValidationErrorBase {
+    keyword: 'maxProperties';
+    params: {
+        limit: number;
+    };
+}
+export interface TMinimumError extends TValidationErrorBase {
+    keyword: 'minimum';
+    params: {
+        comparison: '>=';
+        limit: number | bigint;
+    };
+}
+export interface TMinItemsError extends TValidationErrorBase {
+    keyword: 'minItems';
+    params: {
+        limit: number;
+    };
+}
+export interface TMinLengthError extends TValidationErrorBase {
+    keyword: 'minLength';
+    params: {
+        limit: number;
+    };
+}
+export interface TMinPropertiesError extends TValidationErrorBase {
+    keyword: 'minProperties';
+    params: {
+        limit: number;
+    };
+}
+export interface TMultipleOfError extends TValidationErrorBase {
+    keyword: 'multipleOf';
+    params: {
+        multipleOf: number | bigint;
+    };
+}
+export interface TMinimumError extends TValidationErrorBase {
+    keyword: 'minimum';
+    params: {
+        comparison: '>=';
+        limit: number | bigint;
+    };
+}
+export interface TNotError extends TValidationErrorBase {
+    keyword: 'not';
+    params: {};
+}
+export interface TOneOfError extends TValidationErrorBase {
+    keyword: 'oneOf';
+    params: {
+        passingSchemas: number[];
+    };
+}
+export interface TPatternError extends TValidationErrorBase {
+    keyword: 'pattern';
+    params: {
+        pattern: string | RegExp;
+    };
+}
+export interface TPropertyNamesError extends TValidationErrorBase {
+    keyword: 'propertyNames';
+    params: {
+        propertyNames: string[];
+    };
+}
+export interface TRefineError extends TValidationErrorBase {
+    keyword: '~refine';
+    params: {
+        index: number;
+        message: string;
+    };
+}
+export interface TRequiredError extends TValidationErrorBase {
+    keyword: 'required';
+    params: {
+        requiredProperties: string[];
+    };
+}
+export interface TTypeError extends TValidationErrorBase {
+    keyword: 'type';
+    params: {
+        type: string | string[];
+    };
+}
+export interface TUnevaluatedItemsError extends TValidationErrorBase {
+    keyword: 'unevaluatedItems';
+    params: {
+        unevaluatedItems: number[];
+    };
+}
+export interface TUnevaluatedPropertiesError extends TValidationErrorBase {
+    keyword: 'unevaluatedProperties';
+    params: {
+        unevaluatedProperties: PropertyKey[];
+    };
+}
+export interface TUniqueItemsError extends TValidationErrorBase {
+    keyword: 'uniqueItems';
+    params: {
+        duplicateItems: number[];
+    };
+}

package/node_modules/typebox/build/error/errors.mjs

@@ -0,0 +1,18 @@
+// deno-lint-ignore-file ban-types
+import { Guard } from '../guard/index.mjs';
+export function IsValidationError(value) {
+    return Guard.IsObject(value) &&
+        Guard.HasPropertyKey(value, 'keyword') &&
+        Guard.HasPropertyKey(value, 'schemaPath') &&
+        Guard.HasPropertyKey(value, 'instancePath') &&
+        Guard.HasPropertyKey(value, 'params') &&
+        Guard.IsString(value.keyword) &&
+        Guard.IsString(value.schemaPath) &&
+        Guard.IsString(value.instancePath) &&
+        Guard.IsObject(value.params);
+}
+export function IsLocalizedValidationError(value) {
+    return IsValidationError(value) &&
+        Guard.HasPropertyKey(value, 'message') &&
+        Guard.IsString(value.message);
+}

package/node_modules/typebox/build/error/index.d.mts

@@ -0,0 +1 @@
+export * from './errors.mjs';

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

@@ -0,0 +1 @@
+export * from './errors.mjs';

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

@@ -0,0 +1,15 @@
+export type TFormatCheckFunction = (value: string) => boolean;
+/** Clears all entries */
+export declare function Clear(): void;
+/** Returns format entries in this registry */
+export declare function Entries(): [string, TFormatCheckFunction][];
+/** Sets a format */
+export declare function Set(format: string, check: TFormatCheckFunction): void;
+/** Returns true if the registry has this format */
+export declare function Has(format: string): boolean;
+/** Gets a format or undefined if not exists */
+export declare function Get(format: string): TFormatCheckFunction | undefined;
+/** Tests a value against a format, if the format is not registered, true */
+export declare function Test(format: string, value: string): boolean;
+/** Resets all formats to defaults */
+export declare function Reset(): void;

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

@@ -0,0 +1,96 @@
+import { IsDateTime } from './date_time.mjs';
+import { IsDate } from './date.mjs';
+import { IsDuration } from './duration.mjs';
+import { IsEmail } from './email.mjs';
+import { IsHostname } from './hostname.mjs';
+import { IsIdnEmail } from './idn_email.mjs';
+import { IsIdnHostname } from './idn_hostname.mjs';
+import { IsIPv4 } from './ipv4.mjs';
+import { IsIPv6 } from './ipv6.mjs';
+import { IsIriReference } from './iri_reference.mjs';
+import { IsIri } from './iri.mjs';
+import { IsJsonPointerUriFragment } from './json_pointer_uri_fragment.mjs';
+import { IsJsonPointer } from './json_pointer.mjs';
+import { IsRegex } from './regex.mjs';
+import { IsRelativeJsonPointer } from './relative_json_pointer.mjs';
+import { IsTime } from './time.mjs';
+import { IsUriReference } from './uri_reference.mjs';
+import { IsUriTemplate } from './uri_template.mjs';
+import { IsUri } from './uri.mjs';
+import { IsUrl } from './url.mjs';
+import { IsUuid } from './uuid.mjs';
+// ------------------------------------------------------------------
+// Formats
+// ------------------------------------------------------------------
+const formats = new Map();
+// ------------------------------------------------------------------
+// Clear
+// ------------------------------------------------------------------
+/** Clears all entries */
+export function Clear() {
+    formats.clear();
+}
+// ------------------------------------------------------------------
+// Entries
+// ------------------------------------------------------------------
+/** Returns format entries in this registry */
+export function Entries() {
+    return [...formats.entries()];
+}
+// ------------------------------------------------------------------
+// Set
+// ------------------------------------------------------------------
+/** Sets a format */
+export function Set(format, check) {
+    formats.set(format, check);
+}
+// ------------------------------------------------------------------
+// Has
+// ------------------------------------------------------------------
+/** Returns true if the registry has this format */
+export function Has(format) {
+    return formats.has(format);
+}
+// ------------------------------------------------------------------
+// Get
+// ------------------------------------------------------------------
+/** Gets a format or undefined if not exists */
+export function Get(format) {
+    return formats.get(format);
+}
+// ------------------------------------------------------------------
+// Test
+// ------------------------------------------------------------------
+/** Tests a value against a format, if the format is not registered, true */
+export function Test(format, value) {
+    return formats.get(format)?.(value) ?? true;
+}
+// ------------------------------------------------------------------
+// Reset
+// ------------------------------------------------------------------
+/** Resets all formats to defaults */
+export function Reset() {
+    Clear();
+    formats.set('date-time', IsDateTime);
+    formats.set('date', IsDate);
+    formats.set('duration', IsDuration);
+    formats.set('email', IsEmail);
+    formats.set('hostname', IsHostname);
+    formats.set('idn-email', IsIdnEmail);
+    formats.set('idn-hostname', IsIdnHostname);
+    formats.set('ipv4', IsIPv4);
+    formats.set('ipv6', IsIPv6);
+    formats.set('iri-reference', IsIriReference);
+    formats.set('iri', IsIri);
+    formats.set('json-pointer-uri-fragment', IsJsonPointerUriFragment);
+    formats.set('json-pointer', IsJsonPointer);
+    formats.set('regex', IsRegex);
+    formats.set('relative-json-pointer', IsRelativeJsonPointer);
+    formats.set('time', IsTime);
+    formats.set('uri-reference', IsUriReference);
+    formats.set('uri-template', IsUriTemplate);
+    formats.set('uri', IsUri);
+    formats.set('url', IsUrl);
+    formats.set('uuid', IsUuid);
+}
+Reset();

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

@@ -0,0 +1,6 @@
+/**
+ * Returns true if the value is a ISO8601 Date component string
+ * @description https://datatracker.ietf.org/doc/html/rfc3339
+ * @example `2020-12-12`
+ */
+export declare function IsDate(value: string): boolean;

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

@@ -0,0 +1,19 @@
+const DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+const DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
+function IsLeapYear(year) {
+    return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+}
+/**
+ * Returns true if the value is a ISO8601 Date component string
+ * @description https://datatracker.ietf.org/doc/html/rfc3339
+ * @example `2020-12-12`
+ */
+export function IsDate(value) {
+    const matches = DATE.exec(value);
+    if (!matches)
+        return false;
+    const year = +matches[1];
+    const month = +matches[2];
+    const day = +matches[3];
+    return month >= 1 && month <= 12 && day >= 1 && day <= (month === 2 && IsLeapYear(year) ? 29 : DAYS[month]);
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Returns true if the value is a ISO8601 DateTime string
+ * @specification https://datatracker.ietf.org/doc/html/rfc3339
+ * @example `2020-12-12T20:20:40+00:00`
+ */
+export declare function IsDateTime(value: string): boolean;

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

@@ -0,0 +1,11 @@
+import { IsDate } from './date.mjs';
+import { IsTime } from './time.mjs';
+/**
+ * Returns true if the value is a ISO8601 DateTime string
+ * @specification https://datatracker.ietf.org/doc/html/rfc3339
+ * @example `2020-12-12T20:20:40+00:00`
+ */
+export function IsDateTime(value) {
+    const dateTime = value.split(/T/i);
+    return dateTime.length === 2 && IsDate(dateTime[0]) && IsTime(dateTime[1]);
+}

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

@@ -0,0 +1,5 @@
+/**
+ * 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/node_modules/typebox/build/format/duration.mjs

@@ -0,0 +1,8 @@
+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 valid ISO-8601 duration.
+ * @specification https://tools.ietf.org/html/rfc3339
+ */
+export function IsDuration(value) {
+    return Duration.test(value);
+}

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

@@ -0,0 +1,5 @@
+/**
+ * Returns true if the value is an Email
+ * @specification https://datatracker.ietf.org/doc/html/rfc5322
+ */
+export declare function IsEmail(value: string): boolean;

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

@@ -0,0 +1,8 @@
+const Email = /^(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[^"\\]|\\[\x20-\x7e])*")@(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*|\[(?:IPv6:[a-f0-9:]+|(?:25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(?:\.(?:25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3})\])$/i;
+/**
+ * Returns true if the value is an Email
+ * @specification https://datatracker.ietf.org/doc/html/rfc5322
+ */
+export function IsEmail(value) {
+    return Email.test(value);
+}

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

@@ -0,0 +1,22 @@
+export * from './_registry.mjs';
+export { IsDateTime } from './date_time.mjs';
+export { IsDate } from './date.mjs';
+export { IsDuration } from './duration.mjs';
+export { IsEmail } from './email.mjs';
+export { IsHostname } from './hostname.mjs';
+export { IsIdnEmail } from './idn_email.mjs';
+export { IsIdnHostname } from './idn_hostname.mjs';
+export { IsIPv4 } from './ipv4.mjs';
+export { IsIPv6 } from './ipv6.mjs';
+export { IsIriReference } from './iri_reference.mjs';
+export { IsIri } from './iri.mjs';
+export { IsJsonPointerUriFragment } from './json_pointer_uri_fragment.mjs';
+export { IsJsonPointer } from './json_pointer.mjs';
+export { IsRegex } from './regex.mjs';
+export { IsRelativeJsonPointer } from './relative_json_pointer.mjs';
+export { IsTime } from './time.mjs';
+export { IsUriReference } from './uri_reference.mjs';
+export { IsUriTemplate } from './uri_template.mjs';
+export { IsUri } from './uri.mjs';
+export { IsUrl } from './url.mjs';
+export { IsUuid } from './uuid.mjs';

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

@@ -0,0 +1,22 @@
+export * from './_registry.mjs';
+export { IsDateTime } from './date_time.mjs';
+export { IsDate } from './date.mjs';
+export { IsDuration } from './duration.mjs';
+export { IsEmail } from './email.mjs';
+export { IsHostname } from './hostname.mjs';
+export { IsIdnEmail } from './idn_email.mjs';
+export { IsIdnHostname } from './idn_hostname.mjs';
+export { IsIPv4 } from './ipv4.mjs';
+export { IsIPv6 } from './ipv6.mjs';
+export { IsIriReference } from './iri_reference.mjs';
+export { IsIri } from './iri.mjs';
+export { IsJsonPointerUriFragment } from './json_pointer_uri_fragment.mjs';
+export { IsJsonPointer } from './json_pointer.mjs';
+export { IsRegex } from './regex.mjs';
+export { IsRelativeJsonPointer } from './relative_json_pointer.mjs';
+export { IsTime } from './time.mjs';
+export { IsUriReference } from './uri_reference.mjs';
+export { IsUriTemplate } from './uri_template.mjs';
+export { IsUri } from './uri.mjs';
+export { IsUrl } from './url.mjs';
+export { IsUuid } from './uuid.mjs';

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

@@ -0,0 +1,7 @@
+/**
+ * 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/node_modules/typebox/build/format/hostname.mjs

@@ -0,0 +1,10 @@
+import * as Idna from './idna/index.mjs';
+/**
+ * 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) {
+    return Idna.IsHostname(value);
+}

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

@@ -0,0 +1,5 @@
+/**
+ * Returns true if the value is an IdnEmail
+ * @specification https://datatracker.ietf.org/doc/html/rfc4952
+ */
+export declare function IsIdnEmail(value: string): boolean;

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

@@ -0,0 +1,8 @@
+const IdnEmail = /^(?:[A-Za-z0-9!#$%&'*+\/=?^_`{|}~\u{0080}-\u{10FFFF}-]+(?:\.[A-Za-z0-9!#$%&'*+\/=?^_`{|}~\u{0080}-\u{10FFFF}-]+)*|"(?:[^"\\]|\\.)*")@[\p{L}\p{N}](?:[\p{L}\p{N}-]{0,62})(?<!-)(?:\.[\p{L}\p{N}](?:[\p{L}\p{N}-]{0,62})(?<!-))*$/iu;
+/**
+ * Returns true if the value is an IdnEmail
+ * @specification https://datatracker.ietf.org/doc/html/rfc4952
+ */
+export function IsIdnEmail(value) {
+    return IdnEmail.test(value.normalize('NFC'));
+}

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

@@ -0,0 +1,8 @@
+/**
+ * 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
+ * @specification https://tools.ietf.org/html/rfc5893
+ */
+export declare function IsIdnHostname(value: string): boolean;

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

@@ -0,0 +1,11 @@
+import * as Idna from './idna/index.mjs';
+/**
+ * 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
+ * @specification https://tools.ietf.org/html/rfc5893
+ */
+export function IsIdnHostname(value) {
+    return Idna.IsIdnHostname(value);
+}

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

@@ -0,0 +1,3 @@
+export declare function HasBidiChars(value: string): boolean;
+export declare function HasRightToLeftCharacters(value: string): boolean;
+export declare function SatisfiesBidiRule(value: string): boolean;

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

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

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