typebox 0.0.1 → 1.0.0-rc

package/build/guard/emit.mjs

@@ -0,0 +1,183 @@
+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 an async iterator */
+export function IsAsyncIterator(value) {
+    return `Guard.IsAsyncIterator(${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 an iterator */
+export function IsIterator(value) {
+    return `Guard.IsIterator(${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 StringGraphemeCount(value) {
+    return `Guard.StringGraphemeCount(${value})`;
+}
+// --------------------------------------------------------------------------
+// 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, '"toString"') || 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));
+}
+// --------------------------------------------------------------------------
+// Arithmatic
+// --------------------------------------------------------------------------
+export function PrefixIncrement(expression) {
+    return `++${expression}`;
+}
+export function MultipleOf(dividend, divisor) {
+    return `Guard.IsMultipleOf(${dividend}, ${divisor})`;
+}

package/build/guard/globals.d.mts

@@ -0,0 +1,35 @@
+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/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;
+}

package/build/guard/guard.d.mts

@@ -0,0 +1,57 @@
+/** Returns true if this value is an array */
+export declare function IsArray(value: unknown): value is unknown[];
+/** Returns true if this value is an async iterator */
+export declare function IsAsyncIterator(value: unknown): value is AsyncIterableIterator<unknown>;
+/** Returns true if this value is bigint */
+export declare function IsBigInt(value: unknown): value is bigint;
+/** Returns true if this value is a boolean */
+export declare function IsBoolean(value: unknown): value is boolean;
+/** Returns true if this value is a constructor */
+export declare function IsConstructor(value: unknown): value is new (...args: never[]) => unknown;
+/** Returns true if this value is a function */
+export declare function IsFunction(value: unknown): value is Function;
+/** Returns true if this value is integer */
+export declare function IsInteger(value: unknown): value is number;
+/** Returns true if this value is an iterator */
+export declare function IsIterator(value: unknown): value is IterableIterator<unknown>;
+/** Returns true if this value is null */
+export declare function IsNull(value: unknown): value is null;
+/** Returns true if this value is number */
+export declare function IsNumber(value: unknown): value is number;
+/** Returns true if this value is an object but not an array */
+export declare function IsObjectNotArray(value: unknown): value is Record<PropertyKey, unknown>;
+/** Returns true if this value is an object */
+export declare function IsObject(value: unknown): value is Record<PropertyKey, unknown>;
+/** Returns true if this value is string */
+export declare function IsString(value: unknown): value is string;
+/** Returns true if this value is symbol */
+export declare function IsSymbol(value: unknown): value is symbol;
+/** Returns true if this value is undefined */
+export declare function IsUndefined(value: unknown): value is undefined;
+export declare function IsEqual(left: unknown, right: unknown): boolean;
+export declare function IsGreaterThan<Type extends number | bigint>(left: Type, right: Type): boolean;
+export declare function IsLessThan<Type extends number | bigint>(left: Type, right: Type): boolean;
+export declare function IsLessEqualThan<Type extends number | bigint>(left: Type, right: Type): boolean;
+export declare function IsGreaterEqualThan<Type extends number | bigint>(left: Type, right: Type): boolean;
+export declare function IsMultipleOf(dividend: bigint | number, divisor: bigint | number): boolean;
+export declare function IsValueLike(value: unknown): value is bigint | boolean | null | number | string | undefined;
+/** Returns the number of Unicode Grapheme Clusters */
+export declare function StringGraphemeCount(value: string): number;
+export declare function Every<T>(value: T[], callback: (value: T, index: number) => boolean): boolean;
+export declare function EveryAll<T>(value: T[], callback: (value: T, index: number) => boolean): boolean;
+/** Returns true if this value has this property key */
+export declare function HasPropertyKey<Key extends PropertyKey>(value: object, key: Key): value is {
+    [_ in Key]: unknown;
+};
+/** Returns object entries as `[RegExp, Value][]` */
+export declare function EntriesRegExp<Value extends unknown = unknown>(value: Record<PropertyKey, Value>): [RegExp, Value][];
+/** Returns object entries as `[string, Value][]` */
+export declare function Entries<Value extends unknown = unknown>(value: Record<PropertyKey, Value>): [string, Value][];
+/** Returns the property keys for this object via `Object.getOwnPropertyKeys({ ... })` */
+export declare function Keys(value: Record<PropertyKey, unknown>): string[];
+/** Returns the property keys for this object via `Object.getOwnPropertyKeys({ ... })` */
+export declare function Symbols(value: Record<PropertyKey, unknown>): symbol[];
+/** Returns the property values for the given object via `Object.values()` */
+export declare function Values(value: Record<PropertyKey, unknown>): unknown[];
+/** Tests values for deep equality */
+export declare function IsDeepEqual(left: unknown, right: unknown): boolean;

package/build/guard/guard.mjs

@@ -0,0 +1,180 @@
+// --------------------------------------------------------------------------
+// Guards
+// --------------------------------------------------------------------------
+/** Returns true if this value is an array */
+export function IsArray(value) {
+    return Array.isArray(value);
+}
+/** Returns true if this value is an async iterator */
+export function IsAsyncIterator(value) {
+    return IsObject(value) && Symbol.asyncIterator in value;
+}
+/** Returns true if this value is bigint */
+export function IsBigInt(value) {
+    return IsEqual(typeof value, 'bigint');
+}
+/** Returns true if this value is a boolean */
+export function IsBoolean(value) {
+    return IsEqual(typeof value, 'boolean');
+}
+/** Returns true if this value is a constructor */
+export function IsConstructor(value) {
+    if (IsUndefined(value) || !IsFunction(value))
+        return false;
+    const result = Function.prototype.toString.call(value);
+    if (/^class\s/.test(result))
+        return true;
+    if (/\[native code\]/.test(result))
+        return true;
+    return false;
+}
+/** Returns true if this value is a function */
+export function IsFunction(value) {
+    return IsEqual(typeof value, 'function');
+}
+/** Returns true if this value is integer */
+export function IsInteger(value) {
+    return Number.isInteger(value);
+}
+/** Returns true if this value is an iterator */
+export function IsIterator(value) {
+    return IsObject(value) && Symbol.iterator in value;
+}
+/** Returns true if this value is null */
+export function IsNull(value) {
+    return IsEqual(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 IsObject(value) && !IsArray(value);
+}
+/** Returns true if this value is an object */
+export function IsObject(value) {
+    return IsEqual(typeof value, 'object') && !(IsNull(value));
+}
+/** Returns true if this value is string */
+export function IsString(value) {
+    return IsEqual(typeof value, 'string');
+}
+/** Returns true if this value is symbol */
+export function IsSymbol(value) {
+    return IsEqual(typeof value, 'symbol');
+}
+/** Returns true if this value is undefined */
+export function IsUndefined(value) {
+    return IsEqual(value, undefined);
+}
+// --------------------------------------------------------------------------
+// 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;
+}
+// --------------------------------------------------------------------------
+// MultipleOf
+// --------------------------------------------------------------------------
+export function IsMultipleOf(dividend, divisor) {
+    if (IsBigInt(dividend) || IsBigInt(divisor)) {
+        return BigInt(dividend) % BigInt(divisor) === 0n;
+    }
+    const tolerance = 1e-10;
+    if (!IsNumber(dividend))
+        return true;
+    if (IsInteger(dividend) && (1 / divisor) % 1 === 0)
+        return true;
+    const mod = dividend % divisor;
+    return Math.min(Math.abs(mod), Math.abs(mod - divisor)) < tolerance;
+}
+// ------------------------------------------------------------------
+// IsValueLike
+// ------------------------------------------------------------------
+export function IsValueLike(value) {
+    return IsBigInt(value) ||
+        IsBoolean(value) ||
+        IsNull(value) ||
+        IsNumber(value) ||
+        IsString(value) ||
+        IsUndefined(value);
+}
+// --------------------------------------------------------------------------
+// String
+// --------------------------------------------------------------------------
+/** Returns the number of Unicode Grapheme Clusters */
+export function StringGraphemeCount(value) {
+    return Array.from(value).length;
+}
+// --------------------------------------------------------------------------
+// Array
+// --------------------------------------------------------------------------
+export function Every(value, callback) {
+    return value.every(callback);
+}
+export function EveryAll(value, callback) {
+    let result = true;
+    for (let index = 0; index < value.length; index++) {
+        if (!callback(value[index], index))
+            result = false;
+    }
+    return result;
+}
+// --------------------------------------------------------------------------
+// Object
+// --------------------------------------------------------------------------
+/** Returns true if this value has this property key */
+export function HasPropertyKey(value, key) {
+    return Object.prototype.hasOwnProperty.call(value, key);
+}
+/** Returns object entries as `[RegExp, Value][]` */
+export function EntriesRegExp(value) {
+    return Keys(value).map((key) => [new RegExp(`^${key}$`), value[key]]);
+}
+/** Returns object entries as `[string, Value][]` */
+export function Entries(value) {
+    return Object.entries(value);
+}
+/** Returns the property keys for this object via `Object.getOwnPropertyKeys({ ... })` */
+export function Keys(value) {
+    return Object.getOwnPropertyNames(value);
+}
+/** Returns the property keys for this object via `Object.getOwnPropertyKeys({ ... })` */
+export function Symbols(value) {
+    return Object.getOwnPropertySymbols(value);
+}
+/** Returns the property values for the given object via `Object.values()` */
+export function Values(value) {
+    return Object.values(value);
+}
+// ------------------------------------------------------------------
+// IsDeepEqual
+// ------------------------------------------------------------------
+function DeepEqualObject(left, right) {
+    if (!IsObject(right))
+        return false;
+    const keys = Keys(left);
+    return IsEqual(keys.length, Keys(right).length) &&
+        keys.every((key) => IsDeepEqual(left[key], right[key]));
+}
+function DeepEqualArray(left, right) {
+    return IsArray(right) && IsEqual(left.length, right.length) &&
+        left.every((_, index) => IsDeepEqual(left[index], right[index]));
+}
+/** Tests values for deep equality */
+export function IsDeepEqual(left, right) {
+    return (IsArray(left) ? DeepEqualArray(left, right) : IsObject(left) ? DeepEqualObject(left, right) : IsEqual(left, right));
+}

package/build/guard/index.d.mts

@@ -0,0 +1,6 @@
+export * as EmitGuard from './emit.mjs';
+export * as GlobalsGuard from './globals.mjs';
+export * as NativeGuard from './native.mjs';
+import * as Guard from './guard.mjs';
+export * as Guard from './guard.mjs';
+export default Guard;

package/build/guard/index.mjs

@@ -0,0 +1,6 @@
+export * as EmitGuard from './emit.mjs';
+export * as GlobalsGuard from './globals.mjs';
+export * as NativeGuard from './native.mjs';
+import * as Guard from './guard.mjs';
+export * as Guard from './guard.mjs';
+export default Guard;

package/build/guard/native.d.mts

@@ -0,0 +1,20 @@
+/** Returns true if this value is a F32 */
+export declare function IsF32(value: unknown): value is number;
+/** Returns true if this value is a F64 */
+export declare function IsF64(value: unknown): value is number;
+/** Returns true if this value is a U8 */
+export declare function IsU8(value: unknown): value is number;
+/** Returns true if this value is a U16 */
+export declare function IsU16(value: unknown): value is number;
+/** Returns true if this value is a U32 */
+export declare function IsU32(value: unknown): value is number;
+/** Returns true if this value is a U64 */
+export declare function IsU64(value: unknown): value is number;
+/** Returns true if this value is a I8 */
+export declare function IsI8(value: unknown): value is number;
+/** Returns true if this value is a I16 */
+export declare function IsI16(value: unknown): value is number;
+/** Returns true if this value is a I32 */
+export declare function IsI32(value: unknown): value is number;
+/** Returns true if this value is a I64 */
+export declare function IsI64(value: unknown): value is number | bigint;

package/build/guard/native.mjs

@@ -0,0 +1,60 @@
+import * as Guard from './guard.mjs';
+// --------------------------------------------------------------------------
+// Native
+// --------------------------------------------------------------------------
+/** Returns true if this value is a F32 */
+export function IsF32(value) {
+    return Guard.IsNumber(value) &&
+        Guard.IsEqual(value, Math.fround(value));
+}
+/** Returns true if this value is a F64 */
+export function IsF64(value) {
+    return Guard.IsNumber(value);
+}
+/** Returns true if this value is a U8 */
+export function IsU8(value) {
+    return Guard.IsInteger(value) &&
+        Guard.IsGreaterEqualThan(value, 0) &&
+        Guard.IsLessEqualThan(value, 255);
+}
+/** Returns true if this value is a U16 */
+export function IsU16(value) {
+    return Guard.IsInteger(value) &&
+        Guard.IsGreaterEqualThan(value, 0) &&
+        Guard.IsLessEqualThan(value, 65535);
+}
+/** Returns true if this value is a U32 */
+export function IsU32(value) {
+    return Guard.IsInteger(value) &&
+        Guard.IsGreaterEqualThan(value, 0) &&
+        Guard.IsLessEqualThan(value, 4294967295);
+}
+/** Returns true if this value is a U64 */
+export function IsU64(value) {
+    return Guard.IsInteger(value) &&
+        Guard.IsGreaterEqualThan(value, 0);
+}
+/** Returns true if this value is a I8 */
+export function IsI8(value) {
+    return Guard.IsInteger(value) &&
+        Guard.IsGreaterEqualThan(value, -128) &&
+        Guard.IsLessEqualThan(value, 127);
+}
+/** Returns true if this value is a I16 */
+export function IsI16(value) {
+    return Guard.IsInteger(value) &&
+        Guard.IsGreaterEqualThan(value, -32768) &&
+        Guard.IsLessEqualThan(value, 32767);
+}
+/** Returns true if this value is a I32 */
+export function IsI32(value) {
+    return Guard.IsInteger(value) &&
+        Guard.IsGreaterEqualThan(value, -2147483648) &&
+        Guard.IsLessEqualThan(value, 2147483647);
+}
+/** Returns true if this value is a I64 */
+export function IsI64(value) {
+    return Guard.IsBigInt(value) &&
+        Guard.IsGreaterEqualThan(value, BigInt('-9223372036854775808')) &&
+        Guard.IsLessEqualThan(value, BigInt('9223372036854775807'));
+}

package/build/index.d.mts

@@ -0,0 +1,8 @@
+export * from './type/action/index.mjs';
+export * from './type/engine/index.mjs';
+export * from './type/extends/index.mjs';
+export * from './type/script/index.mjs';
+export * from './type/types/index.mjs';
+export * as Type from './typebox.mjs';
+import * as Type from './typebox.mjs';
+export default Type;

package/build/index.mjs

@@ -0,0 +1,14 @@
+// ------------------------------------------------------------------
+// Standard
+// ------------------------------------------------------------------
+export * from './type/action/index.mjs';
+export * from './type/engine/index.mjs';
+export * from './type/extends/index.mjs';
+export * from './type/script/index.mjs';
+export * from './type/types/index.mjs';
+// ------------------------------------------------------------------
+// TypeBox
+// ------------------------------------------------------------------
+export * as Type from './typebox.mjs';
+import * as Type from './typebox.mjs';
+export default Type;