typebox 1.0.33 → 1.0.34

package/build/cjs/format/json-pointer.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IsJsonPointer = IsJsonPointer;
-const JsonPointer = /^(?:\/(?:[^~/]|~0|~1)*)*$/;
-/**
- * Returns true if the value is a json pointer
- * @specification
- * @source ajv-formats
- */
-function IsJsonPointer(value) {
-    return JsonPointer.test(value);
-}

package/build/cjs/format/regex.d.ts

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

package/build/cjs/format/regex.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IsRegex = IsRegex;
-/**
- * Returns true if the value is a regular expression string pattern
- * @specification
- * @source ajv-formats
- */
-function IsRegex(value) {
-    if (value.length === 0) {
-        return false;
-    }
-    try {
-        new RegExp(value);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}

package/build/cjs/format/relative-json-pointer.d.ts

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

package/build/cjs/format/relative-json-pointer.js

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

package/build/cjs/format/time.d.ts

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

package/build/cjs/format/time.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IsTime = IsTime;
-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
- */
-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/build/cjs/format/uri-reference.d.ts

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

package/build/cjs/format/uri-reference.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IsUriReference = IsUriReference;
-const UriReference = /^(?:(?:[a-z][a-z0-9+\-.]*:)?\/?\/)?(?:[^\\\s#][^\s#]*)?(?:#[^\\\s]*)?$/i;
-/**
- * Returns true if the value is a uri reference
- * @specification
- * @source ajv-formats
- */
-function IsUriReference(value) {
-    return UriReference.test(value);
-}

package/build/cjs/format/uri-template.d.ts

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

package/build/cjs/format/uri-template.js

@@ -1,13 +0,0 @@
-"use strict";
-// deno-lint-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IsUriTemplate = IsUriTemplate;
-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
- */
-function IsUriTemplate(value) {
-    return UriTemplate.test(value);
-}

package/build/cjs/format/uri.d.ts

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

package/build/cjs/format/uri.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IsUri = IsUri;
-const Uri = /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/)?[^\s]*$/i;
-/**
- * Returns true if the value is a uri
- * @specification
- * @source ajv-formats
- */
-function IsUri(value) {
-    return Uri.test(value);
-}

package/build/cjs/format/url.d.ts

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

package/build/cjs/format/url.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IsUrl = IsUrl;
-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
- */
-function IsUrl(value) {
-    return Url.test(value);
-}

package/build/cjs/format/uuid.d.ts

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

package/build/cjs/format/uuid.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IsUuid = IsUuid;
-const Uuid = /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i;
-/**
- * Returns true if the value is a uuid
- * @specification
- * @source ajv-formats
- */
-function IsUuid(value) {
-    return Uuid.test(value);
-}

package/build/cjs/guard/emit.d.ts

@@ -1,57 +0,0 @@
-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 an async iterator */
-export declare function IsAsyncIterator(value: unknown): 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 an iterator */
-export declare function IsIterator(value: unknown): 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 StringGraphemeCount(value: 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/build/cjs/guard/emit.js

@@ -1,237 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.And = And;
-exports.Or = Or;
-exports.Not = Not;
-exports.IsArray = IsArray;
-exports.IsAsyncIterator = IsAsyncIterator;
-exports.IsBigInt = IsBigInt;
-exports.IsBoolean = IsBoolean;
-exports.IsInteger = IsInteger;
-exports.IsIterator = IsIterator;
-exports.IsNull = IsNull;
-exports.IsNumber = IsNumber;
-exports.IsObjectNotArray = IsObjectNotArray;
-exports.IsObject = IsObject;
-exports.IsString = IsString;
-exports.IsSymbol = IsSymbol;
-exports.IsUndefined = IsUndefined;
-exports.IsFunction = IsFunction;
-exports.IsConstructor = IsConstructor;
-exports.IsEqual = IsEqual;
-exports.IsGreaterThan = IsGreaterThan;
-exports.IsLessThan = IsLessThan;
-exports.IsLessEqualThan = IsLessEqualThan;
-exports.IsGreaterEqualThan = IsGreaterEqualThan;
-exports.StringGraphemeCount = StringGraphemeCount;
-exports.Every = Every;
-exports.Entries = Entries;
-exports.Keys = Keys;
-exports.HasPropertyKey = HasPropertyKey;
-exports.IsDeepEqual = IsDeepEqual;
-exports.ArrayLiteral = ArrayLiteral;
-exports.ArrowFunction = ArrowFunction;
-exports.Call = Call;
-exports.New = New;
-exports.Member = Member;
-exports.Constant = Constant;
-exports.Ternary = Ternary;
-exports.Statements = Statements;
-exports.ConstDeclaration = ConstDeclaration;
-exports.If = If;
-exports.Return = Return;
-exports.ReduceAnd = ReduceAnd;
-exports.ReduceOr = ReduceOr;
-exports.PrefixIncrement = PrefixIncrement;
-exports.MultipleOf = MultipleOf;
-const G = require("./guard");
-// ------------------------------------------------------------------
-// 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
-// ------------------------------------------------------------------
-function And(left, right) {
-    return `(${left} && ${right})`;
-}
-function Or(left, right) {
-    return `(${left} || ${right})`;
-}
-function Not(expr) {
-    return `!(${expr})`;
-}
-// --------------------------------------------------------------------------
-// Guards
-// --------------------------------------------------------------------------
-/** Returns true if this value is an array */
-function IsArray(value) {
-    return `Array.isArray(${value})`;
-}
-/** Returns true if this value is an async iterator */
-function IsAsyncIterator(value) {
-    return `Guard.IsAsyncIterator(${value})`;
-}
-/** Returns true if this value is bigint */
-function IsBigInt(value) {
-    return `typeof ${value} === "bigint"`;
-}
-/** Returns true if this value is a boolean */
-function IsBoolean(value) {
-    return `typeof ${value} === "boolean"`;
-}
-/** Returns true if this value is integer */
-function IsInteger(value) {
-    return `Number.isInteger(${value})`;
-}
-/** Returns true if this value is an iterator */
-function IsIterator(value) {
-    return `Guard.IsIterator(${value})`;
-}
-/** Returns true if this value is null */
-function IsNull(value) {
-    return `${value} === null`;
-}
-/** Returns true if this value is number */
-function IsNumber(value) {
-    return `Number.isFinite(${value})`;
-}
-/** Returns true if this value is an object but not an array */
-function IsObjectNotArray(value) {
-    return And(IsObject(value), Not(IsArray(value)));
-}
-/** Returns true if this value is an object */
-function IsObject(value) {
-    return `typeof ${value} === "object" && ${value} !== null`;
-}
-/** Returns true if this value is string */
-function IsString(value) {
-    return `typeof ${value} === "string"`;
-}
-/** Returns true if this value is symbol */
-function IsSymbol(value) {
-    return `typeof ${value} === "symbol"`;
-}
-/** Returns true if this value is undefined */
-function IsUndefined(value) {
-    return `${value} === undefined`;
-}
-// ------------------------------------------------------------------
-// Functions and Constructors
-// ------------------------------------------------------------------
-function IsFunction(value) {
-    return `typeof ${value} === "function"`;
-}
-function IsConstructor(value) {
-    return `Guard.IsConstructor(${value})`;
-}
-// ------------------------------------------------------------------
-// Relational
-// ------------------------------------------------------------------
-function IsEqual(left, right) {
-    return `${left} === ${right}`;
-}
-function IsGreaterThan(left, right) {
-    return `${left} > ${right}`;
-}
-function IsLessThan(left, right) {
-    return `${left} < ${right}`;
-}
-function IsLessEqualThan(left, right) {
-    return `${left} <= ${right}`;
-}
-function IsGreaterEqualThan(left, right) {
-    return `${left} >= ${right}`;
-}
-// --------------------------------------------------------------------------
-// String
-// --------------------------------------------------------------------------
-function StringGraphemeCount(value) {
-    return `Guard.StringGraphemeCount(${value})`;
-}
-// --------------------------------------------------------------------------
-// Array
-// --------------------------------------------------------------------------
-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
-// --------------------------------------------------------------------------
-function Entries(value) {
-    return `Object.entries(${value})`;
-}
-function Keys(value) {
-    return `Object.getOwnPropertyNames(${value})`;
-}
-function HasPropertyKey(value, key) {
-    const isProtoField = G.IsEqual(key, '"__proto__"') || G.IsEqual(key, '"toString"') || G.IsEqual(key, '"constructor"');
-    return isProtoField ? `Object.prototype.hasOwnProperty.call(${value}, ${key})` : `${key} in ${value}`;
-}
-function IsDeepEqual(left, right) {
-    return `Guard.IsDeepEqual(${left}, ${right})`;
-}
-// ------------------------------------------------------------------
-// Expressions
-// ------------------------------------------------------------------
-function ArrayLiteral(elements) {
-    return `[${elements.join(', ')}]`;
-}
-function ArrowFunction(parameters, body) {
-    return `((${parameters.join(', ')}) => ${body})`;
-}
-function Call(value, arguments_) {
-    return `${value}(${arguments_.join(', ')})`;
-}
-function New(value, arguments_) {
-    return `new ${value}(${arguments_.join(', ')})`;
-}
-function Member(left, right) {
-    return `${left}${IsIdentifier(right) ? `.${right}` : `[${Constant(right)}]`}`;
-}
-function Constant(value) {
-    return G.IsString(value) ? JSON.stringify(value) : `${value}`;
-}
-function Ternary(condition, true_, false_) {
-    return `${condition} ? ${true_} : ${false_}`;
-}
-// ------------------------------------------------------------------
-// Statements
-// ------------------------------------------------------------------
-function Statements(statements) {
-    return `{ ${statements.join('; ')}; }`;
-}
-function ConstDeclaration(identifier, expression) {
-    return `const ${identifier} = ${expression}`;
-}
-function If(condition, then) {
-    return `if(${condition}) { ${then} }`;
-}
-function Return(expression) {
-    return `return ${expression}`;
-}
-// ------------------------------------------------------------------
-// Logical
-// ------------------------------------------------------------------
-function ReduceAnd(operands) {
-    return G.IsEqual(operands.length, 0) ? 'true' : operands.reduce((left, right) => And(left, right));
-}
-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));
-}
-// --------------------------------------------------------------------------
-// Arithmatic
-// --------------------------------------------------------------------------
-function PrefixIncrement(expression) {
-    return `++${expression}`;
-}
-function MultipleOf(dividend, divisor) {
-    return `Guard.IsMultipleOf(${dividend}, ${divisor})`;
-}

package/build/cjs/guard/globals.d.ts

@@ -1,35 +0,0 @@
-export declare function IsBoolean(value: unknown): value is Boolean;
-export declare function IsNumber(value: unknown): value is Number;
-export declare function IsString(value: unknown): value is 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/build/cjs/guard/globals.js

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