@sinclair/typebox 0.32.14 → 0.32.16

package/build/require/type/indexed/indexed.js

@@ -27,7 +27,9 @@ function FromIntersect(T, K) {
 }
 // prettier-ignore
 function FromUnionRest(T) {
-    return T; // review this
+    return (T.some(L => (0, type_2.IsNever)(L))
+        ? []
+        : T);
 }
 // prettier-ignore
 function FromUnion(T, K) {

package/build/require/type/template-literal/parse.js

@@ -9,23 +9,42 @@ const index_1 = require("../error/index");
 class TemplateLiteralParserError extends index_1.TypeBoxError {
 }
 exports.TemplateLiteralParserError = TemplateLiteralParserError;
+// -------------------------------------------------------------------
+// Unescape
+//
+// Unescape for these control characters specifically. Note that this
+// function is only called on non union group content, and where we
+// still want to allow the user to embed control characters in that
+// content. For review.
+// -------------------------------------------------------------------
 // prettier-ignore
+function Unescape(pattern) {
+    return pattern
+        .replace(/\\\$/g, '$')
+        .replace(/\\\*/g, '*')
+        .replace(/\\\^/g, '^')
+        .replace(/\\\|/g, '|')
+        .replace(/\\\(/g, '(')
+        .replace(/\\\)/g, ')');
+}
+// -------------------------------------------------------------------
+// Control Characters
+// -------------------------------------------------------------------
 function IsNonEscaped(pattern, index, char) {
     return pattern[index] === char && pattern.charCodeAt(index - 1) !== 92;
 }
-// prettier-ignore
 function IsOpenParen(pattern, index) {
     return IsNonEscaped(pattern, index, '(');
 }
-// prettier-ignore
 function IsCloseParen(pattern, index) {
     return IsNonEscaped(pattern, index, ')');
 }
-// prettier-ignore
 function IsSeparator(pattern, index) {
     return IsNonEscaped(pattern, index, '|');
 }
-// prettier-ignore
+// -------------------------------------------------------------------
+// Control Groups
+// -------------------------------------------------------------------
 function IsGroup(pattern) {
     if (!(IsOpenParen(pattern, 0) && IsCloseParen(pattern, pattern.length - 1)))
         return false;
@@ -142,7 +161,7 @@ function TemplateLiteralParse(pattern) {
     return (IsGroup(pattern) ? TemplateLiteralParse(InGroup(pattern)) :
         IsPrecedenceOr(pattern) ? Or(pattern) :
             IsPrecedenceAnd(pattern) ? And(pattern) :
-                { type: 'const', const: pattern });
+                { type: 'const', const: Unescape(pattern) });
 }
 exports.TemplateLiteralParse = TemplateLiteralParse;
 // ------------------------------------------------------------------

package/build/require/type/template-literal/syntax.d.ts

@@ -12,7 +12,7 @@ type FromUnionLiteral<T extends string> = T extends `${infer L}|${infer R}` ? [T
 ];
 type FromUnion<T extends string> = TUnionEvaluated<FromUnionLiteral<T>>;
 type FromTerminal<T extends string> = T extends 'boolean' ? TBoolean : T extends 'bigint' ? TBigInt : T extends 'number' ? TNumber : T extends 'string' ? TString : FromUnion<T>;
-type FromString<T extends string> = T extends `{${infer L}}${infer R}` ? [FromTerminal<L>, ...FromString<R>] : T extends `${infer L}$${infer R}` ? [TLiteral<L>, ...FromString<R>] : T extends `${infer L}` ? [TLiteral<L>] : [
+type FromString<T extends string> = T extends `{${infer L}}${infer R}` ? [FromTerminal<L>, ...FromString<R>] : T extends `${infer L}$\{${infer R1}\}${infer R2}` ? [TLiteral<L>, ...FromString<`{${R1}}`>, ...FromString<R2>] : T extends `${infer L}$\{${infer R1}\}` ? [TLiteral<L>, ...FromString<`{${R1}}`>] : T extends `${infer L}` ? [TLiteral<L>] : [
 ];
 export type TTemplateLiteralSyntax<T extends string> = (TTemplateLiteral<Assert<FromString<T>, TTemplateLiteralKind[]>>);
 /** Parses TemplateLiteralSyntax and returns a tuple of TemplateLiteralKinds */

package/build/require/value/cast/cast.js

@@ -104,7 +104,7 @@ function FromConstructor(schema, references, value) {
 }
 function FromIntersect(schema, references, value) {
     const created = (0, index_4.Create)(schema, references);
-    const mapped = (0, index_1.IsPlainObject)(created) && (0, index_1.IsPlainObject)(value) ? { ...created, ...value } : value;
+    const mapped = (0, index_1.IsStandardObject)(created) && (0, index_1.IsStandardObject)(value) ? { ...created, ...value } : value;
     return (0, index_5.Check)(schema, references, mapped) ? mapped : (0, index_4.Create)(schema, references);
 }
 function FromNever(schema, references, value) {

package/build/require/value/clone/clone.js

@@ -34,7 +34,7 @@ function Clone(value) {
         return ArrayType(value);
     if ((0, index_1.IsDate)(value))
         return DateType(value);
-    if ((0, index_1.IsPlainObject)(value))
+    if ((0, index_1.IsStandardObject)(value))
         return ObjectType(value);
     if ((0, index_1.IsTypedArray)(value))
         return TypedArrayType(value);

package/build/require/value/convert/convert.js

@@ -3,44 +3,41 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Convert = void 0;
 const index_1 = require("../clone/index");
-const index_2 = require("../check/index");
-const index_3 = require("../deref/index");
-const type_1 = require("../../type/guard/type");
-const index_4 = require("../../type/symbols/index");
-const index_5 = require("../../type/composite/index");
+const index_2 = require("../deref/index");
+const index_3 = require("../../type/symbols/index");
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-const index_6 = require("../guard/index");
+const index_4 = require("../guard/index");
 // ------------------------------------------------------------------
 // Conversions
 // ------------------------------------------------------------------
 function IsStringNumeric(value) {
-    return (0, index_6.IsString)(value) && !isNaN(value) && !isNaN(parseFloat(value));
+    return (0, index_4.IsString)(value) && !isNaN(value) && !isNaN(parseFloat(value));
 }
 function IsValueToString(value) {
-    return (0, index_6.IsBigInt)(value) || (0, index_6.IsBoolean)(value) || (0, index_6.IsNumber)(value);
+    return (0, index_4.IsBigInt)(value) || (0, index_4.IsBoolean)(value) || (0, index_4.IsNumber)(value);
 }
 function IsValueTrue(value) {
-    return value === true || ((0, index_6.IsNumber)(value) && value === 1) || ((0, index_6.IsBigInt)(value) && value === BigInt('1')) || ((0, index_6.IsString)(value) && (value.toLowerCase() === 'true' || value === '1'));
+    return value === true || ((0, index_4.IsNumber)(value) && value === 1) || ((0, index_4.IsBigInt)(value) && value === BigInt('1')) || ((0, index_4.IsString)(value) && (value.toLowerCase() === 'true' || value === '1'));
 }
 function IsValueFalse(value) {
-    return value === false || ((0, index_6.IsNumber)(value) && (value === 0 || Object.is(value, -0))) || ((0, index_6.IsBigInt)(value) && value === BigInt('0')) || ((0, index_6.IsString)(value) && (value.toLowerCase() === 'false' || value === '0' || value === '-0'));
+    return value === false || ((0, index_4.IsNumber)(value) && (value === 0 || Object.is(value, -0))) || ((0, index_4.IsBigInt)(value) && value === BigInt('0')) || ((0, index_4.IsString)(value) && (value.toLowerCase() === 'false' || value === '0' || value === '-0'));
 }
 function IsTimeStringWithTimeZone(value) {
-    return (0, index_6.IsString)(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i.test(value);
+    return (0, index_4.IsString)(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i.test(value);
 }
 function IsTimeStringWithoutTimeZone(value) {
-    return (0, index_6.IsString)(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value);
+    return (0, index_4.IsString)(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value);
 }
 function IsDateTimeStringWithTimeZone(value) {
-    return (0, index_6.IsString)(value) && /^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i.test(value);
+    return (0, index_4.IsString)(value) && /^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i.test(value);
 }
 function IsDateTimeStringWithoutTimeZone(value) {
-    return (0, index_6.IsString)(value) && /^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value);
+    return (0, index_4.IsString)(value) && /^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value);
 }
 function IsDateString(value) {
-    return (0, index_6.IsString)(value) && /^\d\d\d\d-[0-1]\d-[0-3]\d$/i.test(value);
+    return (0, index_4.IsString)(value) && /^\d\d\d\d-[0-1]\d-[0-3]\d$/i.test(value);
 }
 // ------------------------------------------------------------------
 // Convert
@@ -59,31 +56,31 @@ function TryConvertLiteralBoolean(value, target) {
 }
 // prettier-ignore
 function TryConvertLiteral(schema, value) {
-    return ((0, index_6.IsString)(schema.const) ? TryConvertLiteralString(value, schema.const) :
-        (0, index_6.IsNumber)(schema.const) ? TryConvertLiteralNumber(value, schema.const) :
-            (0, index_6.IsBoolean)(schema.const) ? TryConvertLiteralBoolean(value, schema.const) :
+    return ((0, index_4.IsString)(schema.const) ? TryConvertLiteralString(value, schema.const) :
+        (0, index_4.IsNumber)(schema.const) ? TryConvertLiteralNumber(value, schema.const) :
+            (0, index_4.IsBoolean)(schema.const) ? TryConvertLiteralBoolean(value, schema.const) :
                 (0, index_1.Clone)(value));
 }
 function TryConvertBoolean(value) {
     return IsValueTrue(value) ? true : IsValueFalse(value) ? false : value;
 }
 function TryConvertBigInt(value) {
-    return IsStringNumeric(value) ? BigInt(parseInt(value)) : (0, index_6.IsNumber)(value) ? BigInt(value | 0) : IsValueFalse(value) ? BigInt(0) : IsValueTrue(value) ? BigInt(1) : value;
+    return IsStringNumeric(value) ? BigInt(parseInt(value)) : (0, index_4.IsNumber)(value) ? BigInt(value | 0) : IsValueFalse(value) ? BigInt(0) : IsValueTrue(value) ? BigInt(1) : value;
 }
 function TryConvertString(value) {
-    return IsValueToString(value) ? value.toString() : (0, index_6.IsSymbol)(value) && value.description !== undefined ? value.description.toString() : value;
+    return IsValueToString(value) ? value.toString() : (0, index_4.IsSymbol)(value) && value.description !== undefined ? value.description.toString() : value;
 }
 function TryConvertNumber(value) {
     return IsStringNumeric(value) ? parseFloat(value) : IsValueTrue(value) ? 1 : IsValueFalse(value) ? 0 : value;
 }
 function TryConvertInteger(value) {
-    return IsStringNumeric(value) ? parseInt(value) : (0, index_6.IsNumber)(value) ? value | 0 : IsValueTrue(value) ? 1 : IsValueFalse(value) ? 0 : value;
+    return IsStringNumeric(value) ? parseInt(value) : (0, index_4.IsNumber)(value) ? value | 0 : IsValueTrue(value) ? 1 : IsValueFalse(value) ? 0 : value;
 }
 function TryConvertNull(value) {
-    return (0, index_6.IsString)(value) && value.toLowerCase() === 'null' ? null : value;
+    return (0, index_4.IsString)(value) && value.toLowerCase() === 'null' ? null : value;
 }
 function TryConvertUndefined(value) {
-    return (0, index_6.IsString)(value) && value === 'undefined' ? undefined : value;
+    return (0, index_4.IsString)(value) && value === 'undefined' ? undefined : value;
 }
 // ------------------------------------------------------------------
 // note: this function may return an invalid dates for the regex
@@ -94,8 +91,8 @@ function TryConvertUndefined(value) {
 // ------------------------------------------------------------------
 // prettier-ignore
 function TryConvertDate(value) {
-    return ((0, index_6.IsDate)(value) ? value :
-        (0, index_6.IsNumber)(value) ? new Date(value) :
+    return ((0, index_4.IsDate)(value) ? value :
+        (0, index_4.IsNumber)(value) ? new Date(value) :
             IsValueTrue(value) ? new Date(1) :
                 IsValueFalse(value) ? new Date(0) :
                     IsStringNumeric(value) ? new Date(parseInt(value)) :
@@ -116,7 +113,7 @@ function Default(value) {
 // Convert
 // ------------------------------------------------------------------
 function FromArray(schema, references, value) {
-    if ((0, index_6.IsArray)(value)) {
+    if ((0, index_4.IsArray)(value)) {
         return value.map((value) => Visit(schema.items, references, value));
     }
     return value;
@@ -133,12 +130,8 @@ function FromDate(schema, references, value) {
 function FromInteger(schema, references, value) {
     return TryConvertInteger(value);
 }
-// prettier-ignore
 function FromIntersect(schema, references, value) {
-    const allObjects = schema.allOf.every(schema => (0, type_1.IsObject)(schema));
-    if (allObjects)
-        return Visit((0, index_5.Composite)(schema.allOf), references, value);
-    return Visit(schema.allOf[0], references, value); // todo: fix this
+    return schema.allOf.reduce((value, schema) => Visit(schema, references, value), value);
 }
 function FromLiteral(schema, references, value) {
     return TryConvertLiteral(schema, value);
@@ -151,11 +144,11 @@ function FromNumber(schema, references, value) {
 }
 // prettier-ignore
 function FromObject(schema, references, value) {
-    const isConvertable = (0, index_6.IsObject)(value);
+    const isConvertable = (0, index_4.IsObject)(value);
     if (!isConvertable)
         return value;
     return Object.getOwnPropertyNames(schema.properties).reduce((value, key) => {
-        return !(0, index_6.IsUndefined)(value[key])
+        return !(0, index_4.IsUndefined)(value[key])
             ? ({ ...value, [key]: Visit(schema.properties[key], references, value[key]) })
             : ({ ...value });
     }, value);
@@ -170,20 +163,20 @@ function FromRecord(schema, references, value) {
     return result;
 }
 function FromRef(schema, references, value) {
-    return Visit((0, index_3.Deref)(schema, references), references, value);
+    return Visit((0, index_2.Deref)(schema, references), references, value);
 }
 function FromString(schema, references, value) {
     return TryConvertString(value);
 }
 function FromSymbol(schema, references, value) {
-    return (0, index_6.IsString)(value) || (0, index_6.IsNumber)(value) ? Symbol(value) : value;
+    return (0, index_4.IsString)(value) || (0, index_4.IsNumber)(value) ? Symbol(value) : value;
 }
 function FromThis(schema, references, value) {
-    return Visit((0, index_3.Deref)(schema, references), references, value);
+    return Visit((0, index_2.Deref)(schema, references), references, value);
 }
 // prettier-ignore
 function FromTuple(schema, references, value) {
-    const isConvertable = (0, index_6.IsArray)(value) && !(0, index_6.IsUndefined)(schema.items);
+    const isConvertable = (0, index_4.IsArray)(value) && !(0, index_4.IsUndefined)(schema.items);
     if (!isConvertable)
         return value;
     return value.map((value, index) => {
@@ -196,18 +189,12 @@ function FromUndefined(schema, references, value) {
     return TryConvertUndefined(value);
 }
 function FromUnion(schema, references, value) {
-    for (const subschema of schema.anyOf) {
-        const converted = Visit(subschema, references, value);
-        if ((0, index_2.Check)(subschema, references, converted)) {
-            return converted;
-        }
-    }
-    return value;
+    return schema.anyOf.reduce((value, schema) => Visit(schema, references, value), value);
 }
 function Visit(schema, references, value) {
-    const references_ = (0, index_6.IsString)(schema.$id) ? [...references, schema] : references;
+    const references_ = (0, index_4.IsString)(schema.$id) ? [...references, schema] : references;
     const schema_ = schema;
-    switch (schema[index_4.Kind]) {
+    switch (schema[index_3.Kind]) {
         case 'Array':
             return FromArray(schema_, references_, value);
         case 'BigInt':

package/build/require/value/delta/delta.d.ts

@@ -1,34 +1,34 @@
 import type { Static } from '../../type/static/index';
 import { TypeBoxError } from '../../type/error/index';
 export type Insert = Static<typeof Insert>;
-export declare const Insert: import("../../type/object/object").TObject<{
-    type: import("../../type/literal/literal").TLiteral<"insert">;
-    path: import("../../type/string/string").TString;
-    value: import("../../type/unknown/unknown").TUnknown;
+export declare const Insert: import("src/type/object/object").TObject<{
+    type: import("src/type/literal/literal").TLiteral<"insert">;
+    path: import("src/type/string/string").TString;
+    value: import("src/type/unknown/unknown").TUnknown;
 }>;
 export type Update = Static<typeof Update>;
-export declare const Update: import("../../type/object/object").TObject<{
-    type: import("../../type/literal/literal").TLiteral<"update">;
-    path: import("../../type/string/string").TString;
-    value: import("../../type/unknown/unknown").TUnknown;
+export declare const Update: import("src/type/object/object").TObject<{
+    type: import("src/type/literal/literal").TLiteral<"update">;
+    path: import("src/type/string/string").TString;
+    value: import("src/type/unknown/unknown").TUnknown;
 }>;
 export type Delete = Static<typeof Delete>;
-export declare const Delete: import("../../type/object/object").TObject<{
-    type: import("../../type/literal/literal").TLiteral<"delete">;
-    path: import("../../type/string/string").TString;
+export declare const Delete: import("src/type/object/object").TObject<{
+    type: import("src/type/literal/literal").TLiteral<"delete">;
+    path: import("src/type/string/string").TString;
 }>;
 export type Edit = Static<typeof Edit>;
-export declare const Edit: import("../../type/union/union-type").TUnion<[import("../../type/object/object").TObject<{
-    type: import("../../type/literal/literal").TLiteral<"insert">;
-    path: import("../../type/string/string").TString;
-    value: import("../../type/unknown/unknown").TUnknown;
-}>, import("../../type/object/object").TObject<{
-    type: import("../../type/literal/literal").TLiteral<"update">;
-    path: import("../../type/string/string").TString;
-    value: import("../../type/unknown/unknown").TUnknown;
-}>, import("../../type/object/object").TObject<{
-    type: import("../../type/literal/literal").TLiteral<"delete">;
-    path: import("../../type/string/string").TString;
+export declare const Edit: import("src/type/union/union-type").TUnion<[import("src/type/object/object").TObject<{
+    type: import("src/type/literal/literal").TLiteral<"insert">;
+    path: import("src/type/string/string").TString;
+    value: import("src/type/unknown/unknown").TUnknown;
+}>, import("src/type/object/object").TObject<{
+    type: import("src/type/literal/literal").TLiteral<"update">;
+    path: import("src/type/string/string").TString;
+    value: import("src/type/unknown/unknown").TUnknown;
+}>, import("src/type/object/object").TObject<{
+    type: import("src/type/literal/literal").TLiteral<"delete">;
+    path: import("src/type/string/string").TString;
 }>]>;
 export declare class ValueDeltaError extends TypeBoxError {
     readonly value: unknown;

package/build/require/value/delta/delta.js

@@ -59,7 +59,7 @@ function CreateDelete(path) {
 // Diffing Generators
 // ------------------------------------------------------------------
 function* ObjectType(path, current, next) {
-    if (!(0, index_1.IsPlainObject)(next))
+    if (!(0, index_1.IsStandardObject)(next))
         return yield CreateUpdate(path, next);
     const currentKeys = [...globalThis.Object.keys(current), ...globalThis.Object.getOwnPropertySymbols(current)];
     const nextKeys = [...globalThis.Object.keys(next), ...globalThis.Object.getOwnPropertySymbols(next)];
@@ -119,7 +119,7 @@ function* ValueType(path, current, next) {
     yield CreateUpdate(path, next);
 }
 function* Visit(path, current, next) {
-    if ((0, index_1.IsPlainObject)(current))
+    if ((0, index_1.IsStandardObject)(current))
         return yield* ObjectType(path, current, next);
     if ((0, index_1.IsArray)(current))
         return yield* ArrayType(path, current, next);

package/build/require/value/equal/equal.js

@@ -7,7 +7,7 @@ const index_1 = require("../guard/index");
 // Equality Checks
 // ------------------------------------------------------------------
 function ObjectType(left, right) {
-    if (!(0, index_1.IsPlainObject)(right))
+    if (!(0, index_1.IsStandardObject)(right))
         return false;
     const leftKeys = [...Object.keys(left), ...Object.getOwnPropertySymbols(left)];
     const rightKeys = [...Object.keys(right), ...Object.getOwnPropertySymbols(right)];
@@ -36,7 +36,7 @@ function ValueType(left, right) {
 // ------------------------------------------------------------------
 /** Returns true if the left value deep-equals the right */
 function Equal(left, right) {
-    if ((0, index_1.IsPlainObject)(left))
+    if ((0, index_1.IsStandardObject)(left))
         return ObjectType(left, right);
     if ((0, index_1.IsDate)(left))
         return DateType(left, right);

package/build/require/value/guard/guard.d.ts

@@ -6,18 +6,46 @@ export type TypedArrayType = Int8Array | Uint8Array | Uint8ClampedArray | Int16A
 export declare function IsAsyncIterator(value: unknown): value is AsyncIterableIterator<any>;
 /** Returns true if this value is an iterator */
 export declare function IsIterator(value: unknown): value is IterableIterator<any>;
-/** Returns true if this value is a typed array */
-export declare function IsTypedArray(value: unknown): value is TypedArrayType;
+/** Returns true if this value is not an instance of a class */
+export declare function IsStandardObject(value: unknown): value is ObjectType;
+/** Returns true if this value is an instance of a class */
+export declare function IsInstanceObject(value: unknown): value is ObjectType;
 /** Returns true if this value is a Promise */
 export declare function IsPromise(value: unknown): value is Promise<unknown>;
-/** Returns true if the value is a Uint8Array */
-export declare function IsUint8Array(value: unknown): value is Uint8Array;
 /** Returns true if this value is a Date */
 export declare function IsDate(value: unknown): value is Date;
+/** Returns true if this value is an instance of Map<K, T> */
+export declare function IsMap(value: unknown): value is Map<unknown, unknown>;
+/** Returns true if this value is an instance of Set<T> */
+export declare function IsSet(value: unknown): value is Set<unknown>;
+/** Returns true if this value is RegExp */
+export declare function IsRegExp(value: unknown): value is RegExp;
+/** Returns true if this value is a typed array */
+export declare function IsTypedArray(value: unknown): value is TypedArrayType;
+/** 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 this value has this property key */
 export declare function HasPropertyKey<K extends PropertyKey>(value: Record<any, unknown>, key: K): value is ObjectType & Record<K, unknown>;
-/** Returns true if this object is not an instance of any other type */
-export declare function IsPlainObject(value: unknown): value is ObjectType;
 /** Returns true of this value is an object type */
 export declare function IsObject(value: unknown): value is ObjectType;
 /** Returns true if this value is an array, but not a typed array */

package/build/require/value/guard/guard.js

@@ -1,7 +1,7 @@
 "use strict";
 
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IsValueType = exports.IsSymbol = exports.IsFunction = exports.IsString = exports.IsBigInt = exports.IsInteger = exports.IsNumber = exports.IsBoolean = exports.IsNull = exports.IsUndefined = exports.IsArray = exports.IsObject = exports.IsPlainObject = exports.HasPropertyKey = exports.IsDate = exports.IsUint8Array = exports.IsPromise = exports.IsTypedArray = exports.IsIterator = exports.IsAsyncIterator = void 0;
+exports.IsValueType = exports.IsSymbol = exports.IsFunction = exports.IsString = exports.IsBigInt = exports.IsInteger = exports.IsNumber = exports.IsBoolean = exports.IsNull = exports.IsUndefined = exports.IsArray = exports.IsObject = exports.HasPropertyKey = exports.IsBigUint64Array = exports.IsBigInt64Array = exports.IsFloat64Array = exports.IsFloat32Array = exports.IsUint32Array = exports.IsInt32Array = exports.IsUint16Array = exports.IsInt16Array = exports.IsUint8ClampedArray = exports.IsUint8Array = exports.IsInt8Array = exports.IsTypedArray = exports.IsRegExp = exports.IsSet = exports.IsMap = exports.IsDate = exports.IsPromise = exports.IsInstanceObject = exports.IsStandardObject = exports.IsIterator = exports.IsAsyncIterator = void 0;
 // --------------------------------------------------------------------------
 // Iterators
 // --------------------------------------------------------------------------
@@ -16,28 +16,106 @@ function IsIterator(value) {
 }
 exports.IsIterator = IsIterator;
 // --------------------------------------------------------------------------
-// Nominal
+// Object Instances
 // --------------------------------------------------------------------------
-/** Returns true if this value is a typed array */
-function IsTypedArray(value) {
-    return ArrayBuffer.isView(value);
+/** Returns true if this value is not an instance of a class */
+function IsStandardObject(value) {
+    return IsObject(value) && !IsArray(value) && IsFunction(value.constructor) && value.constructor.name === 'Object';
 }
-exports.IsTypedArray = IsTypedArray;
+exports.IsStandardObject = IsStandardObject;
+/** Returns true if this value is an instance of a class */
+function IsInstanceObject(value) {
+    return IsObject(value) && !IsArray(value) && IsFunction(value.constructor) && value.constructor.name !== 'Object';
+}
+exports.IsInstanceObject = IsInstanceObject;
+// --------------------------------------------------------------------------
+// JavaScript
+// --------------------------------------------------------------------------
 /** Returns true if this value is a Promise */
 function IsPromise(value) {
     return value instanceof Promise;
 }
 exports.IsPromise = IsPromise;
-/** Returns true if the value is a Uint8Array */
-function IsUint8Array(value) {
-    return value instanceof Uint8Array;
-}
-exports.IsUint8Array = IsUint8Array;
 /** Returns true if this value is a Date */
 function IsDate(value) {
     return value instanceof Date && Number.isFinite(value.getTime());
 }
 exports.IsDate = IsDate;
+/** Returns true if this value is an instance of Map<K, T> */
+function IsMap(value) {
+    return value instanceof globalThis.Map;
+}
+exports.IsMap = IsMap;
+/** Returns true if this value is an instance of Set<T> */
+function IsSet(value) {
+    return value instanceof globalThis.Set;
+}
+exports.IsSet = IsSet;
+/** Returns true if this value is RegExp */
+function IsRegExp(value) {
+    return value instanceof globalThis.RegExp;
+}
+exports.IsRegExp = IsRegExp;
+/** Returns true if this value is a typed array */
+function IsTypedArray(value) {
+    return ArrayBuffer.isView(value);
+}
+exports.IsTypedArray = IsTypedArray;
+/** Returns true if the value is a Int8Array */
+function IsInt8Array(value) {
+    return value instanceof globalThis.Int8Array;
+}
+exports.IsInt8Array = IsInt8Array;
+/** Returns true if the value is a Uint8Array */
+function IsUint8Array(value) {
+    return value instanceof globalThis.Uint8Array;
+}
+exports.IsUint8Array = IsUint8Array;
+/** Returns true if the value is a Uint8ClampedArray */
+function IsUint8ClampedArray(value) {
+    return value instanceof globalThis.Uint8ClampedArray;
+}
+exports.IsUint8ClampedArray = IsUint8ClampedArray;
+/** Returns true if the value is a Int16Array */
+function IsInt16Array(value) {
+    return value instanceof globalThis.Int16Array;
+}
+exports.IsInt16Array = IsInt16Array;
+/** Returns true if the value is a Uint16Array */
+function IsUint16Array(value) {
+    return value instanceof globalThis.Uint16Array;
+}
+exports.IsUint16Array = IsUint16Array;
+/** Returns true if the value is a Int32Array */
+function IsInt32Array(value) {
+    return value instanceof globalThis.Int32Array;
+}
+exports.IsInt32Array = IsInt32Array;
+/** Returns true if the value is a Uint32Array */
+function IsUint32Array(value) {
+    return value instanceof globalThis.Uint32Array;
+}
+exports.IsUint32Array = IsUint32Array;
+/** Returns true if the value is a Float32Array */
+function IsFloat32Array(value) {
+    return value instanceof globalThis.Float32Array;
+}
+exports.IsFloat32Array = IsFloat32Array;
+/** Returns true if the value is a Float64Array */
+function IsFloat64Array(value) {
+    return value instanceof globalThis.Float64Array;
+}
+exports.IsFloat64Array = IsFloat64Array;
+/** Returns true if the value is a BigInt64Array */
+function IsBigInt64Array(value) {
+    return value instanceof globalThis.BigInt64Array;
+}
+exports.IsBigInt64Array = IsBigInt64Array;
+/** Returns true if the value is a BigUint64Array */
+function IsBigUint64Array(value) {
+    return value instanceof globalThis.BigUint64Array;
+}
+exports.IsBigUint64Array = IsBigUint64Array;
 // --------------------------------------------------------------------------
 // Standard
 // --------------------------------------------------------------------------
@@ -46,11 +124,6 @@ function HasPropertyKey(value, key) {
     return key in value;
 }
 exports.HasPropertyKey = HasPropertyKey;
-/** Returns true if this object is not an instance of any other type */
-function IsPlainObject(value) {
-    return IsObject(value) && IsFunction(value.constructor) && value.constructor.name === 'Object';
-}
-exports.IsPlainObject = IsPlainObject;
 /** Returns true of this value is an object type */
 function IsObject(value) {
     return value !== null && typeof value === 'object';

package/build/require/value/hash/hash.js

@@ -124,7 +124,7 @@ function Visit(value) {
         return NullType(value);
     if ((0, index_1.IsNumber)(value))
         return NumberType(value);
-    if ((0, index_1.IsPlainObject)(value))
+    if ((0, index_1.IsStandardObject)(value))
         return ObjectType(value);
     if ((0, index_1.IsString)(value))
         return StringType(value);

package/build/require/value/index.d.ts

@@ -1,16 +1,16 @@
 export { ValueError, ValueErrorType, ValueErrorIterator } from '../errors/index';
-export { Cast, ValueCastError } from './cast/index';
-export { Check } from './check/index';
-export { Clean } from './clean/index';
-export { Clone } from './clone/index';
-export { Convert } from './convert/index';
-export { Create, ValueCreateError } from './create/index';
-export { Default } from './default/index';
-export { Diff, Patch, Edit, Delete, Insert, Update, ValueDeltaError } from './delta/index';
-export { Equal } from './equal/index';
-export { Hash, ValueHashError } from './hash/index';
-export { Mutate, ValueMutateError, type Mutable } from './mutate/index';
-export { ValuePointer } from './pointer/index';
-export { TransformDecode, TransformEncode, HasTransform, TransformDecodeCheckError, TransformDecodeError, TransformEncodeCheckError, TransformEncodeError } from './transform/index';
-export { ArrayType, HasPropertyKey, IsArray, IsAsyncIterator, IsBigInt, IsBoolean, IsDate, IsFunction, IsInteger, IsIterator, IsNull, IsNumber, IsObject, IsPlainObject, IsPromise, IsString, IsSymbol, IsTypedArray, IsUint8Array, IsUndefined, IsValueType, type ObjectType, type TypedArrayType, type ValueType, } from './guard/index';
+export * from './guard/index';
+export * from './cast/index';
+export * from './check/index';
+export * from './clean/index';
+export * from './clone/index';
+export * from './convert/index';
+export * from './create/index';
+export * from './default/index';
+export * from './delta/index';
+export * from './equal/index';
+export * from './hash/index';
+export * from './mutate/index';
+export * from './pointer/index';
+export * from './transform/index';
 export { Value } from './value/index';