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

package/node_modules/typebox/build/guard/emit.mjs

@@ -1,191 +0,0 @@
-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 `(${value}.length >= ${(+length) << 1} || (${value}.length >= ${length} && Guard.CodePointCount(${value}) >= ${length}))`;
-}
-export function IsMaxLength(value, length) {
-    return `(${value}.length <= ${length} || (${value}.length <= ${(+length) << 1} && Guard.CodePointCount(${value}) <= ${length}))`;
-}
-// --------------------------------------------------------------------------
-// Array
-// --------------------------------------------------------------------------
-export function Every(value, offset, params, expression) {
-    return G.IsEqual(offset, '0') ? `${value}.every((${params[0]}, ${params[1]}) => (${expression}))` : `${value}.every((${params[0]}, ${params[1]}) => (${params[1]} < ${offset}) || (${expression}))`;
-}
-export function Some(value, params, expression) {
-    return `${value}.some((${params[0]}, ${params[1]}) => ${expression})`;
-}
-export function SomeAll(value, params, expression) {
-    return `((value) => { let result = false; value.forEach((${params[0]}, ${params[1]}) => { if (${expression}) result = true }); return result })(${value})`;
-}
-export function Counted(value, params, expression) {
-    return `${value}.reduce((result, ${params[0]}, ${params[1]}) => (${expression}) ? ++result : result, 0)`;
-}
-// --------------------------------------------------------------------------
-// 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) {
-    if (!G.IsValueLike(value))
-        throw Error('Unsupported Constant');
-    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) {
-    return G.IsEqual(operands.length, 0) ? 'false' : operands.reduce((left, right) => Or(left, right));
-}
-// --------------------------------------------------------------------------
-// MultipleOf
-// --------------------------------------------------------------------------
-export function MultipleOf(dividend, divisor) {
-    return `Guard.IsMultipleOf(${dividend}, ${divisor})`;
-}

package/node_modules/typebox/build/guard/globals.d.mts

@@ -1,35 +0,0 @@
-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/typebox/build/guard/globals.mjs

@@ -1,90 +0,0 @@
-// --------------------------------------------------------------------------
-// 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/node_modules/typebox/build/guard/guard.d.mts

@@ -1,73 +0,0 @@
-/** Returns true if this value is an array */
-export declare function IsArray(value: unknown): value is 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 globalThis.Function;
-/** Returns true if this value is integer */
-export declare function IsInteger(value: unknown): value is number;
-/** 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;
-/** Returns true if the value appears to be an instance of a class. */
-export declare function IsClassInstance(value: unknown): boolean;
-export declare function IsValueLike(value: unknown): value is bigint | boolean | null | number | string | undefined;
-/** Returns the total number of visual grapheme clusters in the string. */
-export declare function GraphemeCount(value: string): number;
-/** Returns the total number of Unicode code points in the string. */
-export declare function CodePointCount(value: string): number;
-/** Returns true if the string length in Unicode code points does not exceed maxLength */
-export declare function IsMaxLength(value: string, maxLength: number): boolean;
-/** Returns true if the string length in Unicode code points is at least minLength */
-export declare function IsMinLength(value: string, minLength: number): boolean;
-/** Returns true if every element from offset satisfies the callback, short-circuiting on the first failure */
-export declare function Every<T>(value: T[], offset: number, callback: (value: T, index: number) => boolean): boolean;
-/** Returns true if every element from offset satisfies the callback, using exhaustive enumeration */
-export declare function EveryAll<T>(value: T[], offset: number, callback: (value: T, index: number) => boolean): boolean;
-/** Returns true if some element satisfies the callback, short-circuiting on the first success */
-export declare function Some<T>(value: T[], callback: (value: T, index: number) => boolean): boolean;
-/** Returns true if some element satisfies the callback, using exhaustive enumeration */
-export declare function SomeAll<T>(value: T[], callback: (value: T, index: number) => boolean): boolean;
-/** Returns the count of elements that satisfy the callback */
-export declare function Counted(value: unknown[], callback: (value: unknown, index: number) => boolean): number;
-/** Shifts the left-most element from an array and dispatches to the true arm, or the false arm if empty */
-export declare function ShiftLeft<T, True extends (left: T, right: T[]) => unknown, False extends () => unknown>(array: T[], true_: True, false_: False): ReturnType<True> | ReturnType<False>;
-/** Returns true if the PropertyKey is Unsafe (ref: prototype-pollution). */
-export declare function IsUnsafePropertyKey(key: PropertyKey): 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 property keys for this object via `Object.getOwnPropertyNames({ ... })` */
-export declare function Keys(value: Record<PropertyKey, unknown>): string[];
-/** Returns the property keys for this object via `Object.getOwnPropertySymbols({ ... })` */
-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[];
-/** Returns true if left and right values are structurally equal */
-export declare function IsDeepEqual(left: unknown, right: unknown): boolean;

package/node_modules/typebox/build/guard/guard.mjs

@@ -1,226 +0,0 @@
-// deno-fmt-ignore-file
-import * as UnicodeSegmentGuard from './unicode/unicode_segment.mjs';
-import * as UnicodeGuard from './unicode/unicode.mjs';
-// --------------------------------------------------------------------------
-// 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 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 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), Math.abs(mod + divisor)) < tolerance;
-}
-// ------------------------------------------------------------------
-// IsClassInstance
-// ------------------------------------------------------------------
-/** Returns true if the value appears to be an instance of a class. */
-export function IsClassInstance(value) {
-    if (!IsObject(value))
-        return false;
-    const proto = globalThis.Object.getPrototypeOf(value);
-    if (IsNull(proto))
-        return false;
-    return IsEqual(typeof proto.constructor, 'function') &&
-        !(IsEqual(proto.constructor, globalThis.Object) ||
-            IsEqual(proto.constructor.name, 'Object'));
-}
-// ------------------------------------------------------------------
-// IsValueLike
-// ------------------------------------------------------------------
-export function IsValueLike(value) {
-    return IsBigInt(value) ||
-        IsBoolean(value) ||
-        IsNull(value) ||
-        IsNumber(value) ||
-        IsString(value) ||
-        IsUndefined(value);
-}
-// --------------------------------------------------------------------------
-// String
-// --------------------------------------------------------------------------
-/** Returns the total number of visual grapheme clusters in the string. */
-export function GraphemeCount(value) {
-    return UnicodeSegmentGuard.GraphemeCount(value);
-}
-/** Returns the total number of Unicode code points in the string. */
-export function CodePointCount(value) {
-    return UnicodeGuard.CodePointCount(value);
-}
-/** Returns true if the string length in Unicode code points does not exceed maxLength */
-export function IsMaxLength(value, maxLength) {
-    return UnicodeGuard.IsMaxLength(value, maxLength);
-}
-/** Returns true if the string length in Unicode code points is at least minLength */
-export function IsMinLength(value, minLength) {
-    return UnicodeGuard.IsMinLength(value, minLength);
-}
-// --------------------------------------------------------------------------
-// Array
-// --------------------------------------------------------------------------
-/** Returns true if every element from offset satisfies the callback, short-circuiting on the first failure */
-export function Every(value, offset, callback) {
-    return value.every((item, index) => (index < offset) || callback(item, index));
-}
-/** Returns true if every element from offset satisfies the callback, using exhaustive enumeration */
-export function EveryAll(value, offset, callback) {
-    let result = true;
-    value.forEach((item, index) => { if ((index >= offset) && !callback(item, index))
-        result = false; });
-    return result;
-}
-/** Returns true if some element satisfies the callback, short-circuiting on the first success */
-export function Some(value, callback) {
-    return value.some((value, index) => callback(value, index));
-}
-/** Returns true if some element satisfies the callback, using exhaustive enumeration */
-export function SomeAll(value, callback) {
-    let result = false;
-    value.forEach((item, index) => { if (callback(item, index))
-        result = true; });
-    return result;
-}
-/** Returns the count of elements that satisfy the callback */
-export function Counted(value, callback) {
-    return value.reduce((result, value, index) => callback(value, index) ? ++result : result, 0);
-}
-/** Shifts the left-most element from an array and dispatches to the true arm, or the false arm if empty */
-export function ShiftLeft(array, true_, false_) {
-    return (IsEqual(array.length, 0) ? false_() : true_(array[0], array.slice(1)));
-}
-// --------------------------------------------------------------------------
-// Object
-// --------------------------------------------------------------------------
-/** Returns true if the PropertyKey is Unsafe (ref: prototype-pollution). */
-export function IsUnsafePropertyKey(key) {
-    return IsEqual(key, '__proto__') || IsEqual(key, 'constructor') || IsEqual(key, 'prototype');
-}
-/** Returns true if this value has this property key */
-export function HasPropertyKey(value, key) {
-    return IsUnsafePropertyKey(key) ? Object.prototype.hasOwnProperty.call(value, key) : key in value;
-}
-/** 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 property keys for this object via `Object.getOwnPropertyNames({ ... })` */
-export function Keys(value) {
-    return Object.getOwnPropertyNames(value);
-}
-/** Returns the property keys for this object via `Object.getOwnPropertySymbols({ ... })` */
-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]));
-}
-/** Returns true if left and right values are structurally equal */
-export function IsDeepEqual(left, right) {
-    return (IsArray(left) ? DeepEqualArray(left, right) :
-        IsObject(left) ? DeepEqualObject(left, right) :
-            IsEqual(left, right));
-}

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

@@ -1,6 +0,0 @@
-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/node_modules/typebox/build/guard/index.mjs

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

package/node_modules/typebox/build/guard/native.d.mts

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