@depup/sinclair__typebox 0.34.48-depup.0

package/build/cjs/value/default/default.js

@@ -0,0 +1,176 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Default = Default;
+const index_1 = require("../check/index");
+const index_2 = require("../clone/index");
+const index_3 = require("../deref/index");
+const index_4 = require("../../type/symbols/index");
+// ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
+const index_5 = require("../guard/index");
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+const kind_1 = require("../../type/guard/kind");
+// ------------------------------------------------------------------
+// ValueOrDefault
+// ------------------------------------------------------------------
+function ValueOrDefault(schema, value) {
+    const defaultValue = (0, index_5.HasPropertyKey)(schema, 'default') ? schema.default : undefined;
+    const clone = (0, index_5.IsFunction)(defaultValue) ? defaultValue() : (0, index_2.Clone)(defaultValue);
+    return (0, index_5.IsUndefined)(value) ? clone : (0, index_5.IsObject)(value) && (0, index_5.IsObject)(clone) ? Object.assign(clone, value) : value;
+}
+// ------------------------------------------------------------------
+// HasDefaultProperty
+// ------------------------------------------------------------------
+function HasDefaultProperty(schema) {
+    return (0, kind_1.IsKind)(schema) && 'default' in schema;
+}
+// ------------------------------------------------------------------
+// Types
+// ------------------------------------------------------------------
+function FromArray(schema, references, value) {
+    // if the value is an array, we attempt to initialize it's elements
+    if ((0, index_5.IsArray)(value)) {
+        for (let i = 0; i < value.length; i++) {
+            value[i] = Visit(schema.items, references, value[i]);
+        }
+        return value;
+    }
+    // ... otherwise use default initialization
+    const defaulted = ValueOrDefault(schema, value);
+    if (!(0, index_5.IsArray)(defaulted))
+        return defaulted;
+    for (let i = 0; i < defaulted.length; i++) {
+        defaulted[i] = Visit(schema.items, references, defaulted[i]);
+    }
+    return defaulted;
+}
+function FromDate(schema, references, value) {
+    // special case intercept for dates
+    return (0, index_5.IsDate)(value) ? value : ValueOrDefault(schema, value);
+}
+function FromImport(schema, references, value) {
+    const definitions = globalThis.Object.values(schema.$defs);
+    const target = schema.$defs[schema.$ref];
+    return Visit(target, [...references, ...definitions], value);
+}
+function FromIntersect(schema, references, value) {
+    const defaulted = ValueOrDefault(schema, value);
+    return schema.allOf.reduce((acc, schema) => {
+        const next = Visit(schema, references, defaulted);
+        return (0, index_5.IsObject)(next) ? { ...acc, ...next } : next;
+    }, {});
+}
+function FromObject(schema, references, value) {
+    const defaulted = ValueOrDefault(schema, value);
+    // return defaulted
+    if (!(0, index_5.IsObject)(defaulted))
+        return defaulted;
+    const knownPropertyKeys = Object.getOwnPropertyNames(schema.properties);
+    // properties
+    for (const key of knownPropertyKeys) {
+        // note: we need to traverse into the object and test if the return value
+        // yielded a non undefined result. Here we interpret an undefined result as
+        // a non assignable property and continue.
+        const propertyValue = Visit(schema.properties[key], references, defaulted[key]);
+        if ((0, index_5.IsUndefined)(propertyValue))
+            continue;
+        defaulted[key] = Visit(schema.properties[key], references, defaulted[key]);
+    }
+    // return if not additional properties
+    if (!HasDefaultProperty(schema.additionalProperties))
+        return defaulted;
+    // additional properties
+    for (const key of Object.getOwnPropertyNames(defaulted)) {
+        if (knownPropertyKeys.includes(key))
+            continue;
+        defaulted[key] = Visit(schema.additionalProperties, references, defaulted[key]);
+    }
+    return defaulted;
+}
+function FromRecord(schema, references, value) {
+    const defaulted = ValueOrDefault(schema, value);
+    if (!(0, index_5.IsObject)(defaulted))
+        return defaulted;
+    const additionalPropertiesSchema = schema.additionalProperties;
+    const [propertyKeyPattern, propertySchema] = Object.entries(schema.patternProperties)[0];
+    const knownPropertyKey = new RegExp(propertyKeyPattern);
+    // properties
+    for (const key of Object.getOwnPropertyNames(defaulted)) {
+        if (!(knownPropertyKey.test(key) && HasDefaultProperty(propertySchema)))
+            continue;
+        defaulted[key] = Visit(propertySchema, references, defaulted[key]);
+    }
+    // return if not additional properties
+    if (!HasDefaultProperty(additionalPropertiesSchema))
+        return defaulted;
+    // additional properties
+    for (const key of Object.getOwnPropertyNames(defaulted)) {
+        if (knownPropertyKey.test(key))
+            continue;
+        defaulted[key] = Visit(additionalPropertiesSchema, references, defaulted[key]);
+    }
+    return defaulted;
+}
+function FromRef(schema, references, value) {
+    return Visit((0, index_3.Deref)(schema, references), references, ValueOrDefault(schema, value));
+}
+function FromThis(schema, references, value) {
+    return Visit((0, index_3.Deref)(schema, references), references, value);
+}
+function FromTuple(schema, references, value) {
+    const defaulted = ValueOrDefault(schema, value);
+    if (!(0, index_5.IsArray)(defaulted) || (0, index_5.IsUndefined)(schema.items))
+        return defaulted;
+    const [items, max] = [schema.items, Math.max(schema.items.length, defaulted.length)];
+    for (let i = 0; i < max; i++) {
+        if (i < items.length)
+            defaulted[i] = Visit(items[i], references, defaulted[i]);
+    }
+    return defaulted;
+}
+function FromUnion(schema, references, value) {
+    const defaulted = ValueOrDefault(schema, value);
+    for (const inner of schema.anyOf) {
+        const result = Visit(inner, references, (0, index_2.Clone)(defaulted));
+        if ((0, index_1.Check)(inner, references, result)) {
+            return result;
+        }
+    }
+    return defaulted;
+}
+function Visit(schema, references, value) {
+    const references_ = (0, index_3.Pushref)(schema, references);
+    const schema_ = schema;
+    switch (schema_[index_4.Kind]) {
+        case 'Array':
+            return FromArray(schema_, references_, value);
+        case 'Date':
+            return FromDate(schema_, references_, value);
+        case 'Import':
+            return FromImport(schema_, references_, value);
+        case 'Intersect':
+            return FromIntersect(schema_, references_, value);
+        case 'Object':
+            return FromObject(schema_, references_, value);
+        case 'Record':
+            return FromRecord(schema_, references_, value);
+        case 'Ref':
+            return FromRef(schema_, references_, value);
+        case 'This':
+            return FromThis(schema_, references_, value);
+        case 'Tuple':
+            return FromTuple(schema_, references_, value);
+        case 'Union':
+            return FromUnion(schema_, references_, value);
+        default:
+            return ValueOrDefault(schema_, value);
+    }
+}
+/** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
+function Default(...args) {
+    return args.length === 3 ? Visit(args[0], args[1], args[2]) : Visit(args[0], [], args[1]);
+}

package/build/cjs/value/default/index.d.ts

@@ -0,0 +1 @@
+export * from './default';

package/build/cjs/value/default/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./default"), exports);

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

@@ -0,0 +1,32 @@
+import type { Static } from '../../type/static/index';
+import { TypeBoxError } from '../../type/error/index';
+import { type TLiteral } from '../../type/literal/index';
+import { type TObject } from '../../type/object/index';
+import { type TString } from '../../type/string/index';
+import { type TUnknown } from '../../type/unknown/index';
+import { type TUnion } from '../../type/union/index';
+export type Insert = Static<typeof Insert>;
+export declare const Insert: TObject<{
+    type: TLiteral<'insert'>;
+    path: TString;
+    value: TUnknown;
+}>;
+export type Update = Static<typeof Update>;
+export declare const Update: TObject<{
+    type: TLiteral<'update'>;
+    path: TString;
+    value: TUnknown;
+}>;
+export type Delete = Static<typeof Delete>;
+export declare const Delete: TObject<{
+    type: TLiteral<'delete'>;
+    path: TString;
+}>;
+export type Edit = Static<typeof Edit>;
+export declare const Edit: TUnion<[typeof Insert, typeof Update, typeof Delete]>;
+export declare class ValueDiffError extends TypeBoxError {
+    readonly value: unknown;
+    constructor(value: unknown, message: string);
+}
+export declare function Diff(current: unknown, next: unknown): Edit[];
+export declare function Patch<T = any>(current: unknown, edits: Edit[]): T;

package/build/cjs/value/delta/delta.js

@@ -0,0 +1,178 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueDiffError = exports.Edit = exports.Delete = exports.Update = exports.Insert = void 0;
+exports.Diff = Diff;
+exports.Patch = Patch;
+const index_1 = require("../guard/index");
+const index_2 = require("../pointer/index");
+const index_3 = require("../clone/index");
+const equal_1 = require("../equal/equal");
+const index_4 = require("../../type/error/index");
+const index_5 = require("../../type/literal/index");
+const index_6 = require("../../type/object/index");
+const index_7 = require("../../type/string/index");
+const index_8 = require("../../type/unknown/index");
+const index_9 = require("../../type/union/index");
+exports.Insert = (0, index_6.Object)({
+    type: (0, index_5.Literal)('insert'),
+    path: (0, index_7.String)(),
+    value: (0, index_8.Unknown)(),
+});
+exports.Update = (0, index_6.Object)({
+    type: (0, index_5.Literal)('update'),
+    path: (0, index_7.String)(),
+    value: (0, index_8.Unknown)(),
+});
+exports.Delete = (0, index_6.Object)({
+    type: (0, index_5.Literal)('delete'),
+    path: (0, index_7.String)(),
+});
+exports.Edit = (0, index_9.Union)([exports.Insert, exports.Update, exports.Delete]);
+// ------------------------------------------------------------------
+// Errors
+// ------------------------------------------------------------------
+class ValueDiffError extends index_4.TypeBoxError {
+    constructor(value, message) {
+        super(message);
+        this.value = value;
+    }
+}
+exports.ValueDiffError = ValueDiffError;
+// ------------------------------------------------------------------
+// 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 };
+}
+// ------------------------------------------------------------------
+// AssertDiffable
+// ------------------------------------------------------------------
+function AssertDiffable(value) {
+    if (globalThis.Object.getOwnPropertySymbols(value).length > 0)
+        throw new ValueDiffError(value, 'Cannot diff objects with symbols');
+}
+// ------------------------------------------------------------------
+// Diffing Generators
+// ------------------------------------------------------------------
+function* ObjectType(path, current, next) {
+    AssertDiffable(current);
+    AssertDiffable(next);
+    if (!(0, index_1.IsStandardObject)(next))
+        return yield CreateUpdate(path, next);
+    const currentKeys = globalThis.Object.getOwnPropertyNames(current);
+    const nextKeys = globalThis.Object.getOwnPropertyNames(next);
+    // ----------------------------------------------------------------
+    // inserts
+    // ----------------------------------------------------------------
+    for (const key of nextKeys) {
+        if ((0, index_1.HasPropertyKey)(current, key))
+            continue;
+        yield CreateInsert(`${path}/${key}`, next[key]);
+    }
+    // ----------------------------------------------------------------
+    // updates
+    // ----------------------------------------------------------------
+    for (const key of currentKeys) {
+        if (!(0, index_1.HasPropertyKey)(next, key))
+            continue;
+        if ((0, equal_1.Equal)(current, next))
+            continue;
+        yield* Visit(`${path}/${key}`, current[key], next[key]);
+    }
+    // ----------------------------------------------------------------
+    // deletes
+    // ----------------------------------------------------------------
+    for (const key of currentKeys) {
+        if ((0, index_1.HasPropertyKey)(next, key))
+            continue;
+        yield CreateDelete(`${path}/${key}`);
+    }
+}
+function* ArrayType(path, current, next) {
+    if (!(0, index_1.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]);
+    }
+    for (let i = 0; i < next.length; i++) {
+        if (i < current.length)
+            continue;
+        yield CreateInsert(`${path}/${i}`, next[i]);
+    }
+    for (let i = current.length - 1; i >= 0; i--) {
+        if (i < next.length)
+            continue;
+        yield CreateDelete(`${path}/${i}`);
+    }
+}
+function* TypedArrayType(path, current, next) {
+    if (!(0, index_1.IsTypedArray)(next) || current.length !== next.length || globalThis.Object.getPrototypeOf(current).constructor.name !== globalThis.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]);
+    }
+}
+function* ValueType(path, current, next) {
+    if (current === next)
+        return;
+    yield CreateUpdate(path, next);
+}
+function* Visit(path, current, next) {
+    if ((0, index_1.IsStandardObject)(current))
+        return yield* ObjectType(path, current, next);
+    if ((0, index_1.IsArray)(current))
+        return yield* ArrayType(path, current, next);
+    if ((0, index_1.IsTypedArray)(current))
+        return yield* TypedArrayType(path, current, next);
+    if ((0, index_1.IsValueType)(current))
+        return yield* ValueType(path, current, next);
+    throw new ValueDiffError(current, 'Unable to diff value');
+}
+// ------------------------------------------------------------------
+// Diff
+// ------------------------------------------------------------------
+function Diff(current, next) {
+    return [...Visit('', current, next)];
+}
+// ------------------------------------------------------------------
+// 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 (0, index_3.Clone)(edits[0].value);
+    }
+    if (IsIdentity(edits)) {
+        return (0, index_3.Clone)(current);
+    }
+    const clone = (0, index_3.Clone)(current);
+    for (const edit of edits) {
+        switch (edit.type) {
+            case 'insert': {
+                index_2.ValuePointer.Set(clone, edit.path, edit.value);
+                break;
+            }
+            case 'update': {
+                index_2.ValuePointer.Set(clone, edit.path, edit.value);
+                break;
+            }
+            case 'delete': {
+                index_2.ValuePointer.Delete(clone, edit.path);
+                break;
+            }
+        }
+    }
+    return clone;
+}

package/build/cjs/value/delta/index.d.ts

@@ -0,0 +1 @@
+export * from './delta';

package/build/cjs/value/delta/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./delta"), exports);

package/build/cjs/value/deref/deref.d.ts

@@ -0,0 +1,12 @@
+import type { TSchema } from '../../type/schema/index';
+import type { TRef } from '../../type/ref/index';
+import type { TThis } from '../../type/recursive/index';
+import { TypeBoxError } from '../../type/error/index';
+export declare class TypeDereferenceError extends TypeBoxError {
+    readonly schema: TRef | TThis;
+    constructor(schema: TRef | TThis);
+}
+/** `[Internal]` Pushes a schema onto references if the schema has an $id and does not exist on references */
+export declare function Pushref(schema: TSchema, references: TSchema[]): TSchema[];
+/** `[Internal]` Dereferences a schema from the references array or throws if not found */
+export declare function Deref(schema: TSchema, references: TSchema[]): TSchema;

package/build/cjs/value/deref/deref.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeDereferenceError = void 0;
+exports.Pushref = Pushref;
+exports.Deref = Deref;
+const index_1 = require("../../type/error/index");
+const index_2 = require("../../type/symbols/index");
+const guard_1 = require("../guard/guard");
+class TypeDereferenceError extends index_1.TypeBoxError {
+    constructor(schema) {
+        super(`Unable to dereference schema with $id '${schema.$ref}'`);
+        this.schema = schema;
+    }
+}
+exports.TypeDereferenceError = TypeDereferenceError;
+function Resolve(schema, references) {
+    const target = references.find((target) => target.$id === schema.$ref);
+    if (target === undefined)
+        throw new TypeDereferenceError(schema);
+    return Deref(target, references);
+}
+/** `[Internal]` Pushes a schema onto references if the schema has an $id and does not exist on references */
+function Pushref(schema, references) {
+    if (!(0, guard_1.IsString)(schema.$id) || references.some((target) => target.$id === schema.$id))
+        return references;
+    references.push(schema);
+    return references;
+}
+/** `[Internal]` Dereferences a schema from the references array or throws if not found */
+function Deref(schema, references) {
+    // prettier-ignore
+    return (schema[index_2.Kind] === 'This' || schema[index_2.Kind] === 'Ref')
+        ? Resolve(schema, references)
+        : schema;
+}

package/build/cjs/value/deref/index.d.ts

@@ -0,0 +1 @@
+export * from './deref';

package/build/cjs/value/deref/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./deref"), exports);

package/build/cjs/value/encode/encode.d.ts

@@ -0,0 +1,6 @@
+import type { TSchema } from '../../type/schema/index';
+import type { StaticEncode } from '../../type/static/index';
+/** Encodes a value or throws if error */
+export declare function Encode<T extends TSchema, Static = StaticEncode<T>, Result extends Static = Static>(schema: T, references: TSchema[], value: unknown): Result;
+/** Encodes a value or throws if error */
+export declare function Encode<T extends TSchema, Static = StaticEncode<T>, Result extends Static = Static>(schema: T, value: unknown): Result;

package/build/cjs/value/encode/encode.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Encode = Encode;
+const index_1 = require("../transform/index");
+const index_2 = require("../check/index");
+const index_3 = require("../../errors/index");
+/** Encodes a value or throws if error */
+function Encode(...args) {
+    const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
+    const encoded = (0, index_1.HasTransform)(schema, references) ? (0, index_1.TransformEncode)(schema, references, value) : value;
+    if (!(0, index_2.Check)(schema, references, encoded))
+        throw new index_1.TransformEncodeCheckError(schema, encoded, (0, index_3.Errors)(schema, references, encoded).First());
+    return encoded;
+}

package/build/cjs/value/encode/index.d.ts

@@ -0,0 +1 @@
+export * from './encode';

package/build/cjs/value/encode/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./encode"), exports);

package/build/cjs/value/equal/equal.d.ts

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

package/build/cjs/value/equal/equal.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Equal = Equal;
+const index_1 = require("../guard/index");
+// ------------------------------------------------------------------
+// Equality Checks
+// ------------------------------------------------------------------
+function ObjectType(left, right) {
+    if (!(0, index_1.IsObject)(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 (0, index_1.IsDate)(right) && left.getTime() === right.getTime();
+}
+function ArrayType(left, right) {
+    if (!(0, index_1.IsArray)(right) || left.length !== right.length)
+        return false;
+    return left.every((value, index) => Equal(value, right[index]));
+}
+function TypedArrayType(left, right) {
+    if (!(0, index_1.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 ((0, index_1.IsDate)(left))
+        return DateType(left, right);
+    if ((0, index_1.IsTypedArray)(left))
+        return TypedArrayType(left, right);
+    if ((0, index_1.IsArray)(left))
+        return ArrayType(left, right);
+    if ((0, index_1.IsObject)(left))
+        return ObjectType(left, right);
+    if ((0, index_1.IsValueType)(left))
+        return ValueType(left, right);
+    throw new Error('ValueEquals: Unable to compare value');
+}

package/build/cjs/value/equal/index.d.ts

@@ -0,0 +1 @@
+export * from './equal';

package/build/cjs/value/equal/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./equal"), exports);