@daniel156161/prism 0.2.76 → 0.2.78

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/format/regex.d.mts

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

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/format/regex.mjs

@@ -0,0 +1,17 @@
+/**
+ * Returns true if the value is a regular expression string pattern
+ * @specification
+ * @source ajv-formats
+ */
+export function IsRegex(value) {
+    if (value.length === 0) {
+        return false;
+    }
+    try {
+        new RegExp(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/format/relative_json_pointer.d.mts

@@ -0,0 +1,6 @@
+/**
+ * Returns true if the value is a relative json pointer
+ * @specification
+ * @source ajv-formats
+ */
+export declare function IsRelativeJsonPointer(value: string): boolean;

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/format/relative_json_pointer.mjs

@@ -0,0 +1,9 @@
+const RelativeJsonPointer = /^(?:0|[1-9][0-9]*)(?:#|(?:\/(?:[^~/]|~0|~1)*)*)$/;
+/**
+ * Returns true if the value is a relative json pointer
+ * @specification
+ * @source ajv-formats
+ */
+export function IsRelativeJsonPointer(value) {
+    return RelativeJsonPointer.test(value);
+}

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/format/time.d.mts

@@ -0,0 +1,5 @@
+/**
+ * Returns true if the value is a ISO time string
+ * @specification
+ */
+export declare function IsTime(value: string, strictTimeZone?: boolean): boolean;

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/format/time.mjs

@@ -0,0 +1,27 @@
+const TIME = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(?:Z|([+-])(\d\d):(\d\d))?$/i;
+/**
+ * Returns true if the value is a ISO time string
+ * @specification
+ */
+export function IsTime(value, strictTimeZone = true) {
+    const matches = TIME.exec(value);
+    if (!matches)
+        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
+        return false;
+    }
+    if (hr <= 23 && min <= 59 && 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;
+}

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/format/uri.d.mts

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

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/format/uri.mjs

@@ -0,0 +1,135 @@
+function IsAlpha(ch) {
+    return (ch >= 97 && ch <= 122) || (ch >= 65 && ch <= 90); // a-z, A-Z
+}
+function IsAlphaNumeric(ch) {
+    return IsAlpha(ch) || (ch >= 48 && ch <= 57); // a-z, A-Z, 0-9
+}
+function IsHex(ch) {
+    return (ch >= 48 && ch <= 57) || // 0-9
+        (ch >= 65 && ch <= 70) || // A-F
+        (ch >= 97 && ch <= 102); // a-f
+}
+function IsSchemeChar(ch) {
+    return IsAlphaNumeric(ch) ||
+        ch === 43 || ch === 45 || ch === 46; // '+', '-', '.'
+}
+function IsUnreserved(ch) {
+    return IsAlphaNumeric(ch) ||
+        ch === 45 || ch === 46 || // '-', '.'
+        ch === 95 || ch === 126; // '_', '~'
+}
+function IsSubDelim(ch) {
+    return ch === 33 || ch === 36 || ch === 38 || ch === 39 ||
+        ch === 40 || ch === 41 || ch === 42 || ch === 43 ||
+        ch === 44 || ch === 59 || ch === 61; // ! $ & ' ( ) * + , ; =
+}
+function IsPchar(ch) {
+    return IsUnreserved(ch) || IsSubDelim(ch) || ch === 58 || ch === 64; // ':', '@'
+}
+/**
+ * Returns true if the value matches RFC 3986 URI syntax.
+ * @specification https://tools.ietf.org/html/rfc3986
+ */
+export function IsUri(value) {
+    const length = value.length;
+    if (length === 0)
+        return false;
+    // Scheme: must start with a letter
+    if (!IsAlpha(value.charCodeAt(0)))
+        return false;
+    // Scheme: continues until ':'
+    let i = 1;
+    while (i < length) {
+        const ch = value.charCodeAt(i);
+        if (ch === 58)
+            break; // ':'
+        if (!IsSchemeChar(ch))
+            return false;
+        i++;
+    }
+    // Ensure scheme is terminated by ':'
+    if (value.charCodeAt(i) !== 58)
+        return false;
+    i++;
+    // Authority: optional '//'
+    if (value.charCodeAt(i) === 47 && value.charCodeAt(i + 1) === 47) {
+        i += 2;
+        // Userinfo: check for '@' before path/query/fragment delimiters
+        const authorityStart = i;
+        let atPos = -1;
+        for (let j = i; j < length; j++) {
+            const ch = value.charCodeAt(j);
+            if (ch === 64) {
+                atPos = j;
+                break;
+            } // '@'
+            if (ch === 47 || ch === 63 || ch === 35)
+                break; // '/', '?', '#'
+        }
+        if (atPos !== -1) {
+            // Userinfo: validate allowed chars and percent-encoding
+            for (let j = authorityStart; j < atPos; j++) {
+                const ch = value.charCodeAt(j);
+                if (ch === 91 || ch === 93)
+                    return false; // No '[' or ']' in userinfo
+                if (ch === 37) { // '%' percent-encoding
+                    if (j + 2 >= atPos || !IsHex(value.charCodeAt(j + 1)) || !IsHex(value.charCodeAt(j + 2)))
+                        return false;
+                    j += 2;
+                }
+                else if (!IsUnreserved(ch) && !IsSubDelim(ch) && ch !== 58)
+                    return false;
+            }
+            i = atPos + 1;
+        }
+        // Host: IP-literal [addr] or reg-name
+        if (value.charCodeAt(i) === 91) { // '['
+            i++;
+            while (i < length && value.charCodeAt(i) !== 93)
+                i++;
+            if (value.charCodeAt(i) !== 93)
+                return false; // ']'
+            i++;
+        }
+        else {
+            // Host: validate ASCII; skip validation for non-ASCII (Unicode hosts)
+            while (i < length) {
+                const ch = value.charCodeAt(i);
+                if (ch === 47 || ch === 63 || ch === 35 || ch === 58)
+                    break;
+                if (ch < 128 && !IsUnreserved(ch) && !IsSubDelim(ch))
+                    return false;
+                i++;
+            }
+        }
+        // Port: optional digits after ':'
+        if (value.charCodeAt(i) === 58) { // ':'
+            i++;
+            while (i < length) {
+                const ch = value.charCodeAt(i);
+                if (ch === 47 || ch === 63 || ch === 35)
+                    break;
+                if (ch < 48 || ch > 57)
+                    return false; // 0-9
+                i++;
+            }
+        }
+    }
+    // Path, Query, and Fragment
+    while (i < length) {
+        const ch = value.charCodeAt(i);
+        if (ch === 37) { // '%' percent-encoding
+            if (i + 2 >= length || !IsHex(value.charCodeAt(i + 1)) || !IsHex(value.charCodeAt(i + 2)))
+                return false;
+            i += 2;
+        }
+        else if (ch > 127) {
+            return false; // URI is ASCII-only
+        }
+        else if (!(IsPchar(ch) || ch === 47 || ch === 63 || ch === 35)) {
+            return false; // '/', '?', '#'
+        }
+        i++;
+    }
+    return true;
+}

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/format/uri_reference.d.mts

@@ -0,0 +1,5 @@
+/**
+ * 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/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/format/uri_reference.mjs

@@ -0,0 +1,9 @@
+// deno-lint-ignore-file no-control-regex
+const UriReference = /^(?!.*[^\x00-\x7F])(?!.*\\)(?:(?:[a-z][a-z0-9+\-.]*:)?(?:\/\/[^\s[\]{}<>^`|]*)?|[^\s[\]{}<>^`|]*)(?:\?[^\s[\]{}<>^`|]*)?(?:#[^\s[\]{}<>^`|]*)?$/i;
+/**
+ * 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/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/format/uri_template.d.mts

@@ -0,0 +1,6 @@
+/**
+ * Returns true if the value is a uri template
+ * @specification
+ * @source ajv-formats
+ */
+export declare function IsUriTemplate(value: string): boolean;

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/format/uri_template.mjs

@@ -0,0 +1,10 @@
+// deno-lint-ignore-file
+const UriTemplate = /^(?:(?:[^\x00-\x20"'<>%\\^`{|}]|%[0-9a-f]{2})|\{[+#./;?&=,!@|]?(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?(?:,(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?)*\})*$/i;
+/**
+ * Returns true if the value is a uri template
+ * @specification
+ * @source ajv-formats
+ */
+export function IsUriTemplate(value) {
+    return UriTemplate.test(value);
+}

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/format/url.d.mts

@@ -0,0 +1,6 @@
+/**
+ * Returns true if the value is a Url
+ * @specification
+ * @source ajv-formats
+ */
+export declare function IsUrl(value: string): boolean;

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/format/url.mjs

@@ -0,0 +1,9 @@
+const Url = /^(?:https?|ftp):\/\/(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)(?:\.(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)*(?:\.(?:[a-z\u{00a1}-\u{ffff}]{2,})))(?::\d{2,5})?(?:\/[^\s]*)?$/iu;
+/**
+ * Returns true if the value is a Url
+ * @specification
+ * @source ajv-formats
+ */
+export function IsUrl(value) {
+    return Url.test(value);
+}

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/format/uuid.d.mts

@@ -0,0 +1,6 @@
+/**
+ * Returns true if the value is a uuid
+ * @specification https://www.rfc-editor.org/info/rfc4122/
+ * @specification https://www.rfc-editor.org/info/rfc9562/
+ */
+export declare function IsUuid(value: string): boolean;

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/format/uuid.mjs

@@ -0,0 +1,9 @@
+const Uuid = /^[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i;
+/**
+ * Returns true if the value is a uuid
+ * @specification https://www.rfc-editor.org/info/rfc4122/
+ * @specification https://www.rfc-editor.org/info/rfc9562/
+ */
+export function IsUuid(value) {
+    return Uuid.test(value);
+}

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/guard/emit.d.mts

@@ -0,0 +1,54 @@
+export declare function And(left: string, right: string): string;
+export declare function Or(left: string, right: string): string;
+export declare function Not(expr: string): string;
+/** Returns true if this value is an array */
+export declare function IsArray(value: string): string;
+/** Returns true if this value is bigint */
+export declare function IsBigInt(value: string): string;
+/** Returns true if this value is a boolean */
+export declare function IsBoolean(value: string): string;
+/** Returns true if this value is integer */
+export declare function IsInteger(value: string): string;
+/** Returns true if this value is null */
+export declare function IsNull(value: string): string;
+/** Returns true if this value is number */
+export declare function IsNumber(value: string): string;
+/** Returns true if this value is an object but not an array */
+export declare function IsObjectNotArray(value: string): string;
+/** Returns true if this value is an object */
+export declare function IsObject(value: string): string;
+/** Returns true if this value is string */
+export declare function IsString(value: string): string;
+/** Returns true if this value is symbol */
+export declare function IsSymbol(value: string): string;
+/** Returns true if this value is undefined */
+export declare function IsUndefined(value: string): string;
+export declare function IsFunction(value: unknown): string;
+export declare function IsConstructor(value: unknown): string;
+export declare function IsEqual(left: string, right: string): string;
+export declare function IsGreaterThan(left: string, right: string): string;
+export declare function IsLessThan(left: string, right: string): string;
+export declare function IsLessEqualThan(left: string, right: string): string;
+export declare function IsGreaterEqualThan(left: string, right: string): string;
+export declare function IsMinLength(value: string, length: string): string;
+export declare function IsMaxLength(value: string, length: string): string;
+export declare function Every(value: string, offset: string, params: [value: string, index: string], expression: string): string;
+export declare function Entries(value: string): string;
+export declare function Keys(value: string): string;
+export declare function HasPropertyKey(value: string, key: string): string;
+export declare function IsDeepEqual(left: string, right: string): string;
+export declare function ArrayLiteral(elements: string[]): string;
+export declare function ArrowFunction(parameters: string[], body: string): string;
+export declare function Call(value: string, arguments_: string[]): string;
+export declare function New(value: string, arguments_: string[]): string;
+export declare function Member(left: string, right: string): string;
+export declare function Constant(value: bigint | boolean | null | number | string | undefined): string;
+export declare function Ternary(condition: string, true_: string, false_: string): string;
+export declare function Statements(statements: string[]): string;
+export declare function ConstDeclaration(identifier: string, expression: string): string;
+export declare function If(condition: string, then: string): string;
+export declare function Return(expression: string): string;
+export declare function ReduceAnd(operands: string[]): string;
+export declare function ReduceOr(operands: string[]): string;
+export declare function PrefixIncrement(expression: string): string;
+export declare function MultipleOf(dividend: string, divisor: string): string;

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/guard/emit.mjs

@@ -0,0 +1,186 @@
+import * as G from './guard.mjs';
+// ------------------------------------------------------------------
+// Identifier
+// ------------------------------------------------------------------
+const identifierRegExp = /^[\p{ID_Start}_$][\p{ID_Continue}_$\u200C\u200D]*$/u;
+/** Returns true if this value is a valid JavaScript identifier */
+function IsIdentifier(value) {
+    return identifierRegExp.test(value);
+}
+// ------------------------------------------------------------------
+// Logical
+// ------------------------------------------------------------------
+export function And(left, right) {
+    return `(${left} && ${right})`;
+}
+export function Or(left, right) {
+    return `(${left} || ${right})`;
+}
+export function Not(expr) {
+    return `!(${expr})`;
+}
+// --------------------------------------------------------------------------
+// Guards
+// --------------------------------------------------------------------------
+/** Returns true if this value is an array */
+export function IsArray(value) {
+    return `Array.isArray(${value})`;
+}
+/** Returns true if this value is bigint */
+export function IsBigInt(value) {
+    return `typeof ${value} === "bigint"`;
+}
+/** Returns true if this value is a boolean */
+export function IsBoolean(value) {
+    return `typeof ${value} === "boolean"`;
+}
+/** Returns true if this value is integer */
+export function IsInteger(value) {
+    return `Number.isInteger(${value})`;
+}
+/** Returns true if this value is null */
+export function IsNull(value) {
+    return `${value} === null`;
+}
+/** Returns true if this value is number */
+export function IsNumber(value) {
+    return `Number.isFinite(${value})`;
+}
+/** Returns true if this value is an object but not an array */
+export function IsObjectNotArray(value) {
+    return And(IsObject(value), Not(IsArray(value)));
+}
+/** Returns true if this value is an object */
+export function IsObject(value) {
+    return `typeof ${value} === "object" && ${value} !== null`;
+}
+/** Returns true if this value is string */
+export function IsString(value) {
+    return `typeof ${value} === "string"`;
+}
+/** Returns true if this value is symbol */
+export function IsSymbol(value) {
+    return `typeof ${value} === "symbol"`;
+}
+/** Returns true if this value is undefined */
+export function IsUndefined(value) {
+    return `${value} === undefined`;
+}
+// ------------------------------------------------------------------
+// Functions and Constructors
+// ------------------------------------------------------------------
+export function IsFunction(value) {
+    return `typeof ${value} === "function"`;
+}
+export function IsConstructor(value) {
+    return `Guard.IsConstructor(${value})`;
+}
+// ------------------------------------------------------------------
+// Relational
+// ------------------------------------------------------------------
+export function IsEqual(left, right) {
+    return `${left} === ${right}`;
+}
+export function IsGreaterThan(left, right) {
+    return `${left} > ${right}`;
+}
+export function IsLessThan(left, right) {
+    return `${left} < ${right}`;
+}
+export function IsLessEqualThan(left, right) {
+    return `${left} <= ${right}`;
+}
+export function IsGreaterEqualThan(left, right) {
+    return `${left} >= ${right}`;
+}
+// --------------------------------------------------------------------------
+// String
+// --------------------------------------------------------------------------
+export function IsMinLength(value, length) {
+    return `Guard.IsMinLength(${value}, ${length})`;
+}
+export function IsMaxLength(value, length) {
+    return `Guard.IsMaxLength(${value}, ${length})`;
+}
+// --------------------------------------------------------------------------
+// Array
+// --------------------------------------------------------------------------
+export function Every(value, offset, params, expression) {
+    return G.IsEqual(offset, '0')
+        ? `${value}.every((${params[0]}, ${params[1]}) => ${expression})`
+        : `((value, callback) => { for(let index = ${offset}; index < value.length; index++) if (!callback(value[index], index)) return false; return true })(${value}, (${params[0]}, ${params[1]}) => ${expression})`;
+}
+// --------------------------------------------------------------------------
+// Objects
+// --------------------------------------------------------------------------
+export function Entries(value) {
+    return `Object.entries(${value})`;
+}
+export function Keys(value) {
+    return `Object.getOwnPropertyNames(${value})`;
+}
+export function HasPropertyKey(value, key) {
+    const isProtoField = G.IsEqual(key, '"__proto__"') || G.IsEqual(key, '"constructor"');
+    return isProtoField ? `Object.prototype.hasOwnProperty.call(${value}, ${key})` : `${key} in ${value}`;
+}
+export function IsDeepEqual(left, right) {
+    return `Guard.IsDeepEqual(${left}, ${right})`;
+}
+// ------------------------------------------------------------------
+// Expressions
+// ------------------------------------------------------------------
+export function ArrayLiteral(elements) {
+    return `[${elements.join(', ')}]`;
+}
+export function ArrowFunction(parameters, body) {
+    return `((${parameters.join(', ')}) => ${body})`;
+}
+export function Call(value, arguments_) {
+    return `${value}(${arguments_.join(', ')})`;
+}
+export function New(value, arguments_) {
+    return `new ${value}(${arguments_.join(', ')})`;
+}
+export function Member(left, right) {
+    return `${left}${IsIdentifier(right) ? `.${right}` : `[${Constant(right)}]`}`;
+}
+export function Constant(value) {
+    return G.IsString(value) ? JSON.stringify(value) : `${value}`;
+}
+export function Ternary(condition, true_, false_) {
+    return `(${condition} ? ${true_} : ${false_})`;
+}
+// ------------------------------------------------------------------
+// Statements
+// ------------------------------------------------------------------
+export function Statements(statements) {
+    return `{ ${statements.join('; ')}; }`;
+}
+export function ConstDeclaration(identifier, expression) {
+    return `const ${identifier} = ${expression}`;
+}
+export function If(condition, then) {
+    return `if(${condition}) { ${then} }`;
+}
+export function Return(expression) {
+    return `return ${expression}`;
+}
+// ------------------------------------------------------------------
+// Logical
+// ------------------------------------------------------------------
+export function ReduceAnd(operands) {
+    return G.IsEqual(operands.length, 0) ? 'true' : operands.reduce((left, right) => And(left, right));
+}
+export function ReduceOr(operands) {
+    // deno-coverage-ignore - we never observe 0 operands
+    return G.IsEqual(operands.length, 0) ? 'false' : operands.reduce((left, right) => Or(left, right));
+}
+// --------------------------------------------------------------------------
+// Arithmetic
+// --------------------------------------------------------------------------
+export function PrefixIncrement(expression) {
+    return `++${expression}`;
+}
+export function MultipleOf(dividend, divisor) {
+    return `Guard.IsMultipleOf(${dividend}, ${divisor})`;
+}

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/guard/globals.d.mts

@@ -0,0 +1,35 @@
+export declare function IsBoolean(value: unknown): value is globalThis.Boolean;
+export declare function IsNumber(value: unknown): value is globalThis.Number;
+export declare function IsString(value: unknown): value is globalThis.String;
+export type TTypeArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
+export declare function IsTypeArray(value: unknown): value is TTypeArray;
+/** Returns true if the value is a Int8Array */
+export declare function IsInt8Array(value: unknown): value is Int8Array;
+/** Returns true if the value is a Uint8Array */
+export declare function IsUint8Array(value: unknown): value is Uint8Array;
+/** Returns true if the value is a Uint8ClampedArray */
+export declare function IsUint8ClampedArray(value: unknown): value is Uint8ClampedArray;
+/** Returns true if the value is a Int16Array */
+export declare function IsInt16Array(value: unknown): value is Int16Array;
+/** Returns true if the value is a Uint16Array */
+export declare function IsUint16Array(value: unknown): value is Uint16Array;
+/** Returns true if the value is a Int32Array */
+export declare function IsInt32Array(value: unknown): value is Int32Array;
+/** Returns true if the value is a Uint32Array */
+export declare function IsUint32Array(value: unknown): value is Uint32Array;
+/** Returns true if the value is a Float32Array */
+export declare function IsFloat32Array(value: unknown): value is Float32Array;
+/** Returns true if the value is a Float64Array */
+export declare function IsFloat64Array(value: unknown): value is Float64Array;
+/** Returns true if the value is a BigInt64Array */
+export declare function IsBigInt64Array(value: unknown): value is BigInt64Array;
+/** Returns true if the value is a BigUint64Array */
+export declare function IsBigUint64Array(value: unknown): value is BigUint64Array;
+/** Returns true if the value is a RegExp */
+export declare function IsRegExp(value: unknown): value is globalThis.RegExp;
+/** Returns true if the value is a Date */
+export declare function IsDate(value: unknown): value is globalThis.Date;
+/** Returns true if the value is a Set */
+export declare function IsSet(value: unknown): value is globalThis.Set<unknown>;
+/** Returns true if the value is a Map */
+export declare function IsMap(value: unknown): value is globalThis.Map<unknown, unknown>;

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/guard/globals.mjs

@@ -0,0 +1,90 @@
+// --------------------------------------------------------------------------
+// Primitives
+// --------------------------------------------------------------------------
+export function IsBoolean(value) {
+    return value instanceof Boolean;
+}
+export function IsNumber(value) {
+    return value instanceof Number;
+}
+export function IsString(value) {
+    return value instanceof String;
+}
+// --------------------------------------------------------------------------
+// TypeArray
+// --------------------------------------------------------------------------
+export function IsTypeArray(value) {
+    return globalThis.ArrayBuffer.isView(value);
+}
+/** Returns true if the value is a Int8Array */
+export function IsInt8Array(value) {
+    return value instanceof globalThis.Int8Array;
+}
+/** Returns true if the value is a Uint8Array */
+export function IsUint8Array(value) {
+    return value instanceof globalThis.Uint8Array;
+}
+/** Returns true if the value is a Uint8ClampedArray */
+export function IsUint8ClampedArray(value) {
+    return value instanceof globalThis.Uint8ClampedArray;
+}
+/** Returns true if the value is a Int16Array */
+export function IsInt16Array(value) {
+    return value instanceof globalThis.Int16Array;
+}
+/** Returns true if the value is a Uint16Array */
+export function IsUint16Array(value) {
+    return value instanceof globalThis.Uint16Array;
+}
+/** Returns true if the value is a Int32Array */
+export function IsInt32Array(value) {
+    return value instanceof globalThis.Int32Array;
+}
+/** Returns true if the value is a Uint32Array */
+export function IsUint32Array(value) {
+    return value instanceof globalThis.Uint32Array;
+}
+/** Returns true if the value is a Float32Array */
+export function IsFloat32Array(value) {
+    return value instanceof globalThis.Float32Array;
+}
+/** Returns true if the value is a Float64Array */
+export function IsFloat64Array(value) {
+    return value instanceof globalThis.Float64Array;
+}
+/** Returns true if the value is a BigInt64Array */
+export function IsBigInt64Array(value) {
+    return value instanceof globalThis.BigInt64Array;
+}
+/** Returns true if the value is a BigUint64Array */
+export function IsBigUint64Array(value) {
+    return value instanceof globalThis.BigUint64Array;
+}
+// ------------------------------------------------------------------
+// RegExp
+// ------------------------------------------------------------------
+/** Returns true if the value is a RegExp */
+export function IsRegExp(value) {
+    return value instanceof globalThis.RegExp;
+}
+// ------------------------------------------------------------------
+// Date
+// ------------------------------------------------------------------
+/** Returns true if the value is a Date */
+export function IsDate(value) {
+    return value instanceof globalThis.Date;
+}
+// ------------------------------------------------------------------
+// Set
+// ------------------------------------------------------------------
+/** Returns true if the value is a Set */
+export function IsSet(value) {
+    return value instanceof globalThis.Set;
+}
+// ------------------------------------------------------------------
+// Map
+// ------------------------------------------------------------------
+/** Returns true if the value is a Map */
+export function IsMap(value) {
+    return value instanceof globalThis.Map;
+}