@sinclair/typebox 0.29.6 → 0.30.0-dev-1

package/value/delta.d.ts

@@ -37,7 +37,5 @@ export declare class ValueDeltaUnableToDiffUnknownValue extends Error {
     readonly value: unknown;
     constructor(value: unknown);
 }
-export declare namespace ValueDelta {
-    function Diff(current: unknown, next: unknown): Edit[];
-    function Patch<T = any>(current: unknown, edits: Edit[]): T;
-}
+export declare function Diff(current: unknown, next: unknown): Edit[];
+export declare function Patch<T = any>(current: unknown, edits: Edit[]): T;

package/value/delta.js

@@ -27,11 +27,11 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueDelta = exports.ValueDeltaUnableToDiffUnknownValue = exports.ValueDeltaObjectWithSymbolKeyError = exports.Edit = exports.Delete = exports.Update = exports.Insert = void 0;
+exports.Patch = exports.Diff = exports.ValueDeltaUnableToDiffUnknownValue = exports.ValueDeltaObjectWithSymbolKeyError = exports.Edit = exports.Delete = exports.Update = exports.Insert = void 0;
 const typebox_1 = require("../typebox");
-const is_1 = require("./is");
-const clone_1 = require("./clone");
 const pointer_1 = require("./pointer");
+const ValueGuard = require("./guard");
+const ValueClone = require("./clone");
 exports.Insert = typebox_1.Type.Object({
     type: typebox_1.Type.Literal('insert'),
     path: typebox_1.Type.String(),
@@ -47,9 +47,9 @@ exports.Delete = typebox_1.Type.Object({
     path: typebox_1.Type.String(),
 });
 exports.Edit = typebox_1.Type.Union([exports.Insert, exports.Update, exports.Delete]);
-// ---------------------------------------------------------------------
+// --------------------------------------------------------------------------
 // Errors
-// ---------------------------------------------------------------------
+// --------------------------------------------------------------------------
 class ValueDeltaObjectWithSymbolKeyError extends Error {
     constructor(key) {
         super('ValueDelta: Cannot diff objects with symbol keys');
@@ -64,141 +64,132 @@ class ValueDeltaUnableToDiffUnknownValue extends Error {
     }
 }
 exports.ValueDeltaUnableToDiffUnknownValue = ValueDeltaUnableToDiffUnknownValue;
-// ---------------------------------------------------------------------
-// ValueDelta
-// ---------------------------------------------------------------------
-var ValueDelta;
-(function (ValueDelta) {
-    // ---------------------------------------------------------------------
-    // Edits
-    // ---------------------------------------------------------------------
-    function Update(path, value) {
-        return { type: 'update', path, value };
+// --------------------------------------------------------------------------
+// Command Factory
+// --------------------------------------------------------------------------
+function CreateUpdate(path, value) {
+    return { type: 'update', path, value };
+}
+function CreateInsert(path, value) {
+    return { type: 'insert', path, value };
+}
+function CreateDelete(path) {
+    return { type: 'delete', path };
+}
+// --------------------------------------------------------------------------
+// Diffing Generators
+// --------------------------------------------------------------------------
+function* ObjectType(path, current, next) {
+    if (!ValueGuard.IsPlainObject(next))
+        return yield CreateUpdate(path, next);
+    const currentKeys = [...Object.keys(current), ...Object.getOwnPropertySymbols(current)];
+    const nextKeys = [...Object.keys(next), ...Object.getOwnPropertySymbols(next)];
+    for (const key of currentKeys) {
+        if (ValueGuard.IsSymbol(key))
+            throw new ValueDeltaObjectWithSymbolKeyError(key);
+        if (ValueGuard.IsUndefined(next[key]) && nextKeys.includes(key))
+            yield CreateUpdate(`${path}/${String(key)}`, undefined);
     }
-    function Insert(path, value) {
-        return { type: 'insert', path, value };
+    for (const key of nextKeys) {
+        if (ValueGuard.IsUndefined(current[key]) || ValueGuard.IsUndefined(next[key]))
+            continue;
+        if (ValueGuard.IsSymbol(key))
+            throw new ValueDeltaObjectWithSymbolKeyError(key);
+        yield* Visit(`${path}/${String(key)}`, current[key], next[key]);
     }
-    function Delete(path) {
-        return { type: 'delete', path };
+    for (const key of nextKeys) {
+        if (ValueGuard.IsSymbol(key))
+            throw new ValueDeltaObjectWithSymbolKeyError(key);
+        if (ValueGuard.IsUndefined(current[key]))
+            yield CreateInsert(`${path}/${String(key)}`, next[key]);
     }
-    // ---------------------------------------------------------------------
-    // Diff
-    // ---------------------------------------------------------------------
-    function* Object(path, current, next) {
-        if (!is_1.Is.Object(next))
-            return yield Update(path, next);
-        const currentKeys = [...globalThis.Object.keys(current), ...globalThis.Object.getOwnPropertySymbols(current)];
-        const nextKeys = [...globalThis.Object.keys(next), ...globalThis.Object.getOwnPropertySymbols(next)];
-        for (const key of currentKeys) {
-            if (typeof key === 'symbol')
-                throw new ValueDeltaObjectWithSymbolKeyError(key);
-            if (next[key] === undefined && nextKeys.includes(key))
-                yield Update(`${path}/${String(key)}`, undefined);
-        }
-        for (const key of nextKeys) {
-            if (current[key] === undefined || next[key] === undefined)
-                continue;
-            if (typeof key === 'symbol')
-                throw new ValueDeltaObjectWithSymbolKeyError(key);
-            yield* Visit(`${path}/${String(key)}`, current[key], next[key]);
-        }
-        for (const key of nextKeys) {
-            if (typeof key === 'symbol')
-                throw new ValueDeltaObjectWithSymbolKeyError(key);
-            if (current[key] === undefined)
-                yield Insert(`${path}/${String(key)}`, next[key]);
-        }
-        for (const key of currentKeys.reverse()) {
-            if (typeof key === 'symbol')
-                throw new ValueDeltaObjectWithSymbolKeyError(key);
-            if (next[key] === undefined && !nextKeys.includes(key))
-                yield Delete(`${path}/${String(key)}`);
-        }
-    }
-    function* Array(path, current, next) {
-        if (!is_1.Is.Array(next))
-            return yield Update(path, next);
-        for (let i = 0; i < Math.min(current.length, next.length); i++) {
-            yield* Visit(`${path}/${i}`, current[i], next[i]);
-        }
-        for (let i = 0; i < next.length; i++) {
-            if (i < current.length)
-                continue;
-            yield Insert(`${path}/${i}`, next[i]);
-        }
-        for (let i = current.length - 1; i >= 0; i--) {
-            if (i < next.length)
-                continue;
-            yield Delete(`${path}/${i}`);
-        }
+    for (const key of currentKeys.reverse()) {
+        if (ValueGuard.IsSymbol(key))
+            throw new ValueDeltaObjectWithSymbolKeyError(key);
+        if (ValueGuard.IsUndefined(next[key]) && !nextKeys.includes(key))
+            yield CreateDelete(`${path}/${String(key)}`);
     }
-    function* TypedArray(path, current, next) {
-        if (!is_1.Is.TypedArray(next) || current.length !== next.length || globalThis.Object.getPrototypeOf(current).constructor.name !== globalThis.Object.getPrototypeOf(next).constructor.name)
-            return yield Update(path, next);
-        for (let i = 0; i < Math.min(current.length, next.length); i++) {
-            yield* Visit(`${path}/${i}`, current[i], next[i]);
-        }
+}
+function* ArrayType(path, current, next) {
+    if (!ValueGuard.IsArray(next))
+        return yield CreateUpdate(path, next);
+    for (let i = 0; i < Math.min(current.length, next.length); i++) {
+        yield* Visit(`${path}/${i}`, current[i], next[i]);
     }
-    function* Value(path, current, next) {
-        if (current === next)
-            return;
-        yield Update(path, next);
+    for (let i = 0; i < next.length; i++) {
+        if (i < current.length)
+            continue;
+        yield CreateInsert(`${path}/${i}`, next[i]);
     }
-    function* Visit(path, current, next) {
-        if (is_1.Is.Object(current)) {
-            return yield* Object(path, current, next);
-        }
-        else if (is_1.Is.Array(current)) {
-            return yield* Array(path, current, next);
-        }
-        else if (is_1.Is.TypedArray(current)) {
-            return yield* TypedArray(path, current, next);
-        }
-        else if (is_1.Is.Value(current)) {
-            return yield* Value(path, current, next);
-        }
-        else {
-            throw new ValueDeltaUnableToDiffUnknownValue(current);
-        }
+    for (let i = current.length - 1; i >= 0; i--) {
+        if (i < next.length)
+            continue;
+        yield CreateDelete(`${path}/${i}`);
     }
-    function Diff(current, next) {
-        return [...Visit('', current, next)];
+}
+function* TypedArrayType(path, current, next) {
+    if (!ValueGuard.IsTypedArray(next) || current.length !== next.length || Object.getPrototypeOf(current).constructor.name !== Object.getPrototypeOf(next).constructor.name)
+        return yield CreateUpdate(path, next);
+    for (let i = 0; i < Math.min(current.length, next.length); i++) {
+        yield* Visit(`${path}/${i}`, current[i], next[i]);
     }
-    ValueDelta.Diff = Diff;
-    // ---------------------------------------------------------------------
-    // Patch
-    // ---------------------------------------------------------------------
-    function IsRootUpdate(edits) {
-        return edits.length > 0 && edits[0].path === '' && edits[0].type === 'update';
+}
+function* ValueType(path, current, next) {
+    if (current === next)
+        return;
+    yield CreateUpdate(path, next);
+}
+function* Visit(path, current, next) {
+    if (ValueGuard.IsPlainObject(current))
+        return yield* ObjectType(path, current, next);
+    if (ValueGuard.IsArray(current))
+        return yield* ArrayType(path, current, next);
+    if (ValueGuard.IsTypedArray(current))
+        return yield* TypedArrayType(path, current, next);
+    if (ValueGuard.IsValueType(current))
+        return yield* ValueType(path, current, next);
+    throw new ValueDeltaUnableToDiffUnknownValue(current);
+}
+// ---------------------------------------------------------------------
+// Diff
+// ---------------------------------------------------------------------
+function Diff(current, next) {
+    return [...Visit('', current, next)];
+}
+exports.Diff = Diff;
+// ---------------------------------------------------------------------
+// Patch
+// ---------------------------------------------------------------------
+function IsRootUpdate(edits) {
+    return edits.length > 0 && edits[0].path === '' && edits[0].type === 'update';
+}
+function IsIdentity(edits) {
+    return edits.length === 0;
+}
+function Patch(current, edits) {
+    if (IsRootUpdate(edits)) {
+        return ValueClone.Clone(edits[0].value);
     }
-    function IsIdentity(edits) {
-        return edits.length === 0;
+    if (IsIdentity(edits)) {
+        return ValueClone.Clone(current);
     }
-    function Patch(current, edits) {
-        if (IsRootUpdate(edits)) {
-            return clone_1.ValueClone.Clone(edits[0].value);
-        }
-        if (IsIdentity(edits)) {
-            return clone_1.ValueClone.Clone(current);
-        }
-        const clone = clone_1.ValueClone.Clone(current);
-        for (const edit of edits) {
-            switch (edit.type) {
-                case 'insert': {
-                    pointer_1.ValuePointer.Set(clone, edit.path, edit.value);
-                    break;
-                }
-                case 'update': {
-                    pointer_1.ValuePointer.Set(clone, edit.path, edit.value);
-                    break;
-                }
-                case 'delete': {
-                    pointer_1.ValuePointer.Delete(clone, edit.path);
-                    break;
-                }
+    const clone = ValueClone.Clone(current);
+    for (const edit of edits) {
+        switch (edit.type) {
+            case 'insert': {
+                pointer_1.ValuePointer.Set(clone, edit.path, edit.value);
+                break;
+            }
+            case 'update': {
+                pointer_1.ValuePointer.Set(clone, edit.path, edit.value);
+                break;
+            }
+            case 'delete': {
+                pointer_1.ValuePointer.Delete(clone, edit.path);
+                break;
             }
         }
-        return clone;
     }
-    ValueDelta.Patch = Patch;
-})(ValueDelta || (exports.ValueDelta = ValueDelta = {}));
+    return clone;
+}
+exports.Patch = Patch;

package/value/equal.d.ts

@@ -1,3 +1,2 @@
-export declare namespace ValueEqual {
-    function Equal<T>(left: T, right: unknown): right is T;
-}
+/** Returns true if the left value deep-equals the right */
+export declare function Equal<T>(left: T, right: unknown): right is T;

package/value/equal.js

@@ -27,54 +27,51 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueEqual = void 0;
-const is_1 = require("./is");
-var ValueEqual;
-(function (ValueEqual) {
-    function Object(left, right) {
-        if (!is_1.Is.Object(right))
-            return false;
-        const leftKeys = [...globalThis.Object.keys(left), ...globalThis.Object.getOwnPropertySymbols(left)];
-        const rightKeys = [...globalThis.Object.keys(right), ...globalThis.Object.getOwnPropertySymbols(right)];
-        if (leftKeys.length !== rightKeys.length)
-            return false;
-        return leftKeys.every((key) => Equal(left[key], right[key]));
-    }
-    function Date(left, right) {
-        return is_1.Is.Date(right) && left.getTime() === right.getTime();
-    }
-    function Array(left, right) {
-        if (!is_1.Is.Array(right) || left.length !== right.length)
-            return false;
-        return left.every((value, index) => Equal(value, right[index]));
-    }
-    function TypedArray(left, right) {
-        if (!is_1.Is.TypedArray(right) || left.length !== right.length || globalThis.Object.getPrototypeOf(left).constructor.name !== globalThis.Object.getPrototypeOf(right).constructor.name)
-            return false;
-        return left.every((value, index) => Equal(value, right[index]));
-    }
-    function Value(left, right) {
-        return left === right;
-    }
-    function Equal(left, right) {
-        if (is_1.Is.Object(left)) {
-            return Object(left, right);
-        }
-        else if (is_1.Is.Date(left)) {
-            return Date(left, right);
-        }
-        else if (is_1.Is.TypedArray(left)) {
-            return TypedArray(left, right);
-        }
-        else if (is_1.Is.Array(left)) {
-            return Array(left, right);
-        }
-        else if (is_1.Is.Value(left)) {
-            return Value(left, right);
-        }
-        else {
-            throw new Error('ValueEquals: Unable to compare value');
-        }
-    }
-    ValueEqual.Equal = Equal;
-})(ValueEqual || (exports.ValueEqual = ValueEqual = {}));
+exports.Equal = void 0;
+const ValueGuard = require("./guard");
+// --------------------------------------------------------------------------
+// Equality Checks
+// --------------------------------------------------------------------------
+function ObjectType(left, right) {
+    if (!ValueGuard.IsPlainObject(right))
+        return false;
+    const leftKeys = [...Object.keys(left), ...Object.getOwnPropertySymbols(left)];
+    const rightKeys = [...Object.keys(right), ...Object.getOwnPropertySymbols(right)];
+    if (leftKeys.length !== rightKeys.length)
+        return false;
+    return leftKeys.every((key) => Equal(left[key], right[key]));
+}
+function DateType(left, right) {
+    return ValueGuard.IsDate(right) && left.getTime() === right.getTime();
+}
+function ArrayType(left, right) {
+    if (!ValueGuard.IsArray(right) || left.length !== right.length)
+        return false;
+    return left.every((value, index) => Equal(value, right[index]));
+}
+function TypedArrayType(left, right) {
+    if (!ValueGuard.IsTypedArray(right) || left.length !== right.length || Object.getPrototypeOf(left).constructor.name !== Object.getPrototypeOf(right).constructor.name)
+        return false;
+    return left.every((value, index) => Equal(value, right[index]));
+}
+function ValueType(left, right) {
+    return left === right;
+}
+// --------------------------------------------------------------------------
+// Equal
+// --------------------------------------------------------------------------
+/** Returns true if the left value deep-equals the right */
+function Equal(left, right) {
+    if (ValueGuard.IsPlainObject(left))
+        return ObjectType(left, right);
+    if (ValueGuard.IsDate(left))
+        return DateType(left, right);
+    if (ValueGuard.IsTypedArray(left))
+        return TypedArrayType(left, right);
+    if (ValueGuard.IsArray(left))
+        return ArrayType(left, right);
+    if (ValueGuard.IsValueType(left))
+        return ValueType(left, right);
+    throw new Error('ValueEquals: Unable to compare value');
+}
+exports.Equal = Equal;

package/value/guard.d.ts

@@ -0,0 +1,44 @@
+export type ObjectType = Record<PropertyKey, unknown>;
+export type ArrayType = unknown[];
+export type ValueType = null | undefined | symbol | bigint | number | boolean | string;
+export type TypedArrayType = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
+/** Returns true if this value is an async iterator */
+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 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 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 */
+export declare function IsArray(value: unknown): value is ArrayType;
+/** Returns true if this value is an undefined */
+export declare function IsUndefined(value: unknown): value is undefined;
+/** Returns true if this value is an null */
+export declare function IsNull(value: unknown): value is null;
+/** Returns true if this value is an boolean */
+export declare function IsBoolean(value: unknown): value is boolean;
+/** Returns true if this value is an number */
+export declare function IsNumber(value: unknown): value is number;
+/** Returns true if this value is an integer */
+export declare function IsInteger(value: unknown): value is number;
+/** Returns true if this value is bigint */
+export declare function IsBigInt(value: unknown): value is bigint;
+/** Returns true if this value is string */
+export declare function IsString(value: unknown): value is string;
+/** Returns true if this value is a function */
+export declare function IsFunction(value: unknown): value is Function;
+/** Returns true if this value is a symbol */
+export declare function IsSymbol(value: unknown): value is symbol;
+/** Returns true if this value is a value type such as number, string, boolean */
+export declare function IsValueType(value: unknown): value is ValueType;

package/value/guard.js

@@ -0,0 +1,146 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+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;
+// --------------------------------------------------------------------------
+// Iterators
+// --------------------------------------------------------------------------
+/** Returns true if this value is an async iterator */
+function IsAsyncIterator(value) {
+    return IsObject(value) && Symbol.asyncIterator in value;
+}
+exports.IsAsyncIterator = IsAsyncIterator;
+/** Returns true if this value is an iterator */
+function IsIterator(value) {
+    return IsObject(value) && Symbol.iterator in value;
+}
+exports.IsIterator = IsIterator;
+// --------------------------------------------------------------------------
+// Nominal
+// --------------------------------------------------------------------------
+/** Returns true if this value is a typed array */
+function IsTypedArray(value) {
+    return ArrayBuffer.isView(value);
+}
+exports.IsTypedArray = IsTypedArray;
+/** 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;
+}
+exports.IsDate = IsDate;
+// --------------------------------------------------------------------------
+// Standard
+// --------------------------------------------------------------------------
+/** Returns true if this value has this property key */
+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';
+}
+exports.IsObject = IsObject;
+/** Returns true if this value is an array, but not a typed array */
+function IsArray(value) {
+    return Array.isArray(value) && !ArrayBuffer.isView(value);
+}
+exports.IsArray = IsArray;
+/** Returns true if this value is an undefined */
+function IsUndefined(value) {
+    return value === undefined;
+}
+exports.IsUndefined = IsUndefined;
+/** Returns true if this value is an null */
+function IsNull(value) {
+    return value === null;
+}
+exports.IsNull = IsNull;
+/** Returns true if this value is an boolean */
+function IsBoolean(value) {
+    return typeof value === 'boolean';
+}
+exports.IsBoolean = IsBoolean;
+/** Returns true if this value is an number */
+function IsNumber(value) {
+    return typeof value === 'number';
+}
+exports.IsNumber = IsNumber;
+/** Returns true if this value is an integer */
+function IsInteger(value) {
+    return IsNumber(value) && Number.isInteger(value);
+}
+exports.IsInteger = IsInteger;
+/** Returns true if this value is bigint */
+function IsBigInt(value) {
+    return typeof value === 'bigint';
+}
+exports.IsBigInt = IsBigInt;
+/** Returns true if this value is string */
+function IsString(value) {
+    return typeof value === 'string';
+}
+exports.IsString = IsString;
+/** Returns true if this value is a function */
+function IsFunction(value) {
+    return typeof value === 'function';
+}
+exports.IsFunction = IsFunction;
+/** Returns true if this value is a symbol */
+function IsSymbol(value) {
+    return typeof value === 'symbol';
+}
+exports.IsSymbol = IsSymbol;
+/** Returns true if this value is a value type such as number, string, boolean */
+function IsValueType(value) {
+    // prettier-ignore
+    return (IsBigInt(value) ||
+        IsBoolean(value) ||
+        IsNull(value) ||
+        IsNumber(value) ||
+        IsString(value) ||
+        IsSymbol(value) ||
+        IsUndefined(value));
+}
+exports.IsValueType = IsValueType;

package/value/hash.d.ts

@@ -2,7 +2,18 @@ export declare class ValueHashError extends Error {
     readonly value: unknown;
     constructor(value: unknown);
 }
-export declare namespace ValueHash {
-    /** Creates a FNV1A-64 non cryptographic hash of the given value */
-    function Create(value: unknown): bigint;
+export declare enum ByteMarker {
+    Undefined = 0,
+    Null = 1,
+    Boolean = 2,
+    Number = 3,
+    String = 4,
+    Object = 5,
+    Array = 6,
+    Date = 7,
+    Uint8Array = 8,
+    Symbol = 9,
+    BigInt = 10
 }
+/** Creates a FNV1A-64 non cryptographic hash of the given value */
+export declare function Hash(value: unknown): bigint;