@sinclair/typebox 0.31.28 → 0.32.0-dev-2

package/cjs/value/default/index.js

@@ -0,0 +1,44 @@
+"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.
+
+---------------------------------------------------------------------------*/
+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/{value → cjs/value/delta}/delta.js

@@ -28,28 +28,32 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Patch = exports.Diff = exports.ValueDeltaUnableToDiffUnknownValue = exports.ValueDeltaObjectWithSymbolKeyError = exports.Edit = exports.Delete = exports.Update = exports.Insert = void 0;
-const guard_1 = require("./guard");
-const typebox_1 = require("../typebox");
-const pointer_1 = require("./pointer");
-const clone_1 = require("./clone");
-exports.Insert = typebox_1.Type.Object({
-    type: typebox_1.Type.Literal('insert'),
-    path: typebox_1.Type.String(),
-    value: typebox_1.Type.Unknown(),
+const index_mjs_1 = require("../guard/index");
+const index_mjs_2 = require("../pointer/index");
+const index_mjs_3 = require("../clone/index");
+const index_mjs_4 = require("../../type/literal/index");
+const index_mjs_5 = require("../../type/object/index");
+const index_mjs_6 = require("../../type/string/index");
+const index_mjs_7 = require("../../type/unknown/index");
+const index_mjs_8 = require("../../type/union/index");
+exports.Insert = (0, index_mjs_5.Object)({
+    type: (0, index_mjs_4.Literal)('insert'),
+    path: (0, index_mjs_6.String)(),
+    value: (0, index_mjs_7.Unknown)(),
 });
-exports.Update = typebox_1.Type.Object({
-    type: typebox_1.Type.Literal('update'),
-    path: typebox_1.Type.String(),
-    value: typebox_1.Type.Unknown(),
+exports.Update = (0, index_mjs_5.Object)({
+    type: (0, index_mjs_4.Literal)('update'),
+    path: (0, index_mjs_6.String)(),
+    value: (0, index_mjs_7.Unknown)(),
 });
-exports.Delete = typebox_1.Type.Object({
-    type: typebox_1.Type.Literal('delete'),
-    path: typebox_1.Type.String(),
+exports.Delete = (0, index_mjs_5.Object)({
+    type: (0, index_mjs_4.Literal)('delete'),
+    path: (0, index_mjs_6.String)(),
 });
-exports.Edit = typebox_1.Type.Union([exports.Insert, exports.Update, exports.Delete]);
-// --------------------------------------------------------------------------
+exports.Edit = (0, index_mjs_8.Union)([exports.Insert, exports.Update, exports.Delete]);
+// ------------------------------------------------------------------
 // Errors
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 class ValueDeltaObjectWithSymbolKeyError extends Error {
     constructor(key) {
         super('Cannot diff objects with symbol keys');
@@ -64,9 +68,9 @@ class ValueDeltaUnableToDiffUnknownValue extends Error {
     }
 }
 exports.ValueDeltaUnableToDiffUnknownValue = ValueDeltaUnableToDiffUnknownValue;
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Command Factory
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 function CreateUpdate(path, value) {
     return { type: 'update', path, value };
 }
@@ -76,42 +80,42 @@ function CreateInsert(path, value) {
 function CreateDelete(path) {
     return { type: 'delete', path };
 }
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Diffing Generators
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 function* ObjectType(path, current, next) {
-    if (!(0, guard_1.IsPlainObject)(next))
+    if (!(0, index_mjs_1.IsPlainObject)(next))
         return yield CreateUpdate(path, next);
-    const currentKeys = [...Object.keys(current), ...Object.getOwnPropertySymbols(current)];
-    const nextKeys = [...Object.keys(next), ...Object.getOwnPropertySymbols(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 ((0, guard_1.IsSymbol)(key))
+        if ((0, index_mjs_1.IsSymbol)(key))
             throw new ValueDeltaObjectWithSymbolKeyError(key);
-        if ((0, guard_1.IsUndefined)(next[key]) && nextKeys.includes(key))
-            yield CreateUpdate(`${path}/${String(key)}`, undefined);
+        if ((0, index_mjs_1.IsUndefined)(next[key]) && nextKeys.includes(key))
+            yield CreateUpdate(`${path}/${globalThis.String(key)}`, undefined);
     }
     for (const key of nextKeys) {
-        if ((0, guard_1.IsUndefined)(current[key]) || (0, guard_1.IsUndefined)(next[key]))
+        if ((0, index_mjs_1.IsUndefined)(current[key]) || (0, index_mjs_1.IsUndefined)(next[key]))
             continue;
-        if ((0, guard_1.IsSymbol)(key))
+        if ((0, index_mjs_1.IsSymbol)(key))
             throw new ValueDeltaObjectWithSymbolKeyError(key);
-        yield* Visit(`${path}/${String(key)}`, current[key], next[key]);
+        yield* Visit(`${path}/${globalThis.String(key)}`, current[key], next[key]);
     }
     for (const key of nextKeys) {
-        if ((0, guard_1.IsSymbol)(key))
+        if ((0, index_mjs_1.IsSymbol)(key))
             throw new ValueDeltaObjectWithSymbolKeyError(key);
-        if ((0, guard_1.IsUndefined)(current[key]))
-            yield CreateInsert(`${path}/${String(key)}`, next[key]);
+        if ((0, index_mjs_1.IsUndefined)(current[key]))
+            yield CreateInsert(`${path}/${globalThis.String(key)}`, next[key]);
     }
     for (const key of currentKeys.reverse()) {
-        if ((0, guard_1.IsSymbol)(key))
+        if ((0, index_mjs_1.IsSymbol)(key))
             throw new ValueDeltaObjectWithSymbolKeyError(key);
-        if ((0, guard_1.IsUndefined)(next[key]) && !nextKeys.includes(key))
-            yield CreateDelete(`${path}/${String(key)}`);
+        if ((0, index_mjs_1.IsUndefined)(next[key]) && !nextKeys.includes(key))
+            yield CreateDelete(`${path}/${globalThis.String(key)}`);
     }
 }
 function* ArrayType(path, current, next) {
-    if (!(0, guard_1.IsArray)(next))
+    if (!(0, index_mjs_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]);
@@ -128,7 +132,7 @@ function* ArrayType(path, current, next) {
     }
 }
 function* TypedArrayType(path, current, next) {
-    if (!(0, guard_1.IsTypedArray)(next) || current.length !== next.length || Object.getPrototypeOf(current).constructor.name !== Object.getPrototypeOf(next).constructor.name)
+    if (!(0, index_mjs_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]);
@@ -140,26 +144,26 @@ function* ValueType(path, current, next) {
     yield CreateUpdate(path, next);
 }
 function* Visit(path, current, next) {
-    if ((0, guard_1.IsPlainObject)(current))
+    if ((0, index_mjs_1.IsPlainObject)(current))
         return yield* ObjectType(path, current, next);
-    if ((0, guard_1.IsArray)(current))
+    if ((0, index_mjs_1.IsArray)(current))
         return yield* ArrayType(path, current, next);
-    if ((0, guard_1.IsTypedArray)(current))
+    if ((0, index_mjs_1.IsTypedArray)(current))
         return yield* TypedArrayType(path, current, next);
-    if ((0, guard_1.IsValueType)(current))
+    if ((0, index_mjs_1.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';
 }
@@ -168,24 +172,24 @@ function IsIdentity(edits) {
 }
 function Patch(current, edits) {
     if (IsRootUpdate(edits)) {
-        return (0, clone_1.Clone)(edits[0].value);
+        return (0, index_mjs_3.Clone)(edits[0].value);
     }
     if (IsIdentity(edits)) {
-        return (0, clone_1.Clone)(current);
+        return (0, index_mjs_3.Clone)(current);
     }
-    const clone = (0, clone_1.Clone)(current);
+    const clone = (0, index_mjs_3.Clone)(current);
     for (const edit of edits) {
         switch (edit.type) {
             case 'insert': {
-                pointer_1.ValuePointer.Set(clone, edit.path, edit.value);
+                index_mjs_2.ValuePointer.Set(clone, edit.path, edit.value);
                 break;
             }
             case 'update': {
-                pointer_1.ValuePointer.Set(clone, edit.path, edit.value);
+                index_mjs_2.ValuePointer.Set(clone, edit.path, edit.value);
                 break;
             }
             case 'delete': {
-                pointer_1.ValuePointer.Delete(clone, edit.path);
+                index_mjs_2.ValuePointer.Delete(clone, edit.path);
                 break;
             }
         }

package/cjs/value/delta/index.js

@@ -0,0 +1,44 @@
+"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.
+
+---------------------------------------------------------------------------*/
+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/{value → cjs/value/deref}/deref.js

@@ -28,8 +28,7 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Deref = exports.TypeDereferenceError = void 0;
-const typebox_1 = require("../typebox");
-class TypeDereferenceError extends typebox_1.TypeBoxError {
+class TypeDereferenceError extends Error {
     constructor(schema) {
         super(`Unable to dereference schema with $id '${schema.$id}'`);
         this.schema = schema;

package/cjs/value/deref/index.js

@@ -0,0 +1,44 @@
+"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.
+
+---------------------------------------------------------------------------*/
+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/{value → cjs/value/equal}/equal.js

@@ -28,12 +28,12 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Equal = void 0;
-const guard_1 = require("./guard");
-// --------------------------------------------------------------------------
+const index_mjs_1 = require("../guard/index");
+// ------------------------------------------------------------------
 // Equality Checks
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 function ObjectType(left, right) {
-    if (!(0, guard_1.IsPlainObject)(right))
+    if (!(0, index_mjs_1.IsPlainObject)(right))
         return false;
     const leftKeys = [...Object.keys(left), ...Object.getOwnPropertySymbols(left)];
     const rightKeys = [...Object.keys(right), ...Object.getOwnPropertySymbols(right)];
@@ -42,35 +42,35 @@ function ObjectType(left, right) {
     return leftKeys.every((key) => Equal(left[key], right[key]));
 }
 function DateType(left, right) {
-    return (0, guard_1.IsDate)(right) && left.getTime() === right.getTime();
+    return (0, index_mjs_1.IsDate)(right) && left.getTime() === right.getTime();
 }
 function ArrayType(left, right) {
-    if (!(0, guard_1.IsArray)(right) || left.length !== right.length)
+    if (!(0, index_mjs_1.IsArray)(right) || left.length !== right.length)
         return false;
     return left.every((value, index) => Equal(value, right[index]));
 }
 function TypedArrayType(left, right) {
-    if (!(0, guard_1.IsTypedArray)(right) || left.length !== right.length || Object.getPrototypeOf(left).constructor.name !== Object.getPrototypeOf(right).constructor.name)
+    if (!(0, index_mjs_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, guard_1.IsPlainObject)(left))
+    if ((0, index_mjs_1.IsPlainObject)(left))
         return ObjectType(left, right);
-    if ((0, guard_1.IsDate)(left))
+    if ((0, index_mjs_1.IsDate)(left))
         return DateType(left, right);
-    if ((0, guard_1.IsTypedArray)(left))
+    if ((0, index_mjs_1.IsTypedArray)(left))
         return TypedArrayType(left, right);
-    if ((0, guard_1.IsArray)(left))
+    if ((0, index_mjs_1.IsArray)(left))
         return ArrayType(left, right);
-    if ((0, guard_1.IsValueType)(left))
+    if ((0, index_mjs_1.IsValueType)(left))
         return ValueType(left, right);
     throw new Error('ValueEquals: Unable to compare value');
 }

package/cjs/value/equal/index.js

@@ -0,0 +1,44 @@
+"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.
+
+---------------------------------------------------------------------------*/
+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);

package/cjs/value/guard/index.js

@@ -0,0 +1,44 @@
+"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.
+
+---------------------------------------------------------------------------*/
+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("./guard"), exports);

package/{value → cjs/value/hash}/hash.js

@@ -27,11 +27,11 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Hash = exports.ByteMarker = exports.ValueHashError = void 0;
-const guard_1 = require("./guard");
-// --------------------------------------------------------------------------
+exports.Hash = exports.ValueHashError = void 0;
+const index_mjs_1 = require("../guard/index");
+// ------------------------------------------------------------------
 // Errors
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 class ValueHashError extends Error {
     constructor(value) {
         super(`Unable to hash value`);
@@ -39,9 +39,9 @@ class ValueHashError extends Error {
     }
 }
 exports.ValueHashError = ValueHashError;
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // ByteMarker
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 var ByteMarker;
 (function (ByteMarker) {
     ByteMarker[ByteMarker["Undefined"] = 0] = "Undefined";
@@ -55,28 +55,28 @@ var ByteMarker;
     ByteMarker[ByteMarker["Uint8Array"] = 8] = "Uint8Array";
     ByteMarker[ByteMarker["Symbol"] = 9] = "Symbol";
     ByteMarker[ByteMarker["BigInt"] = 10] = "BigInt";
-})(ByteMarker || (exports.ByteMarker = ByteMarker = {}));
-// --------------------------------------------------------------------------
+})(ByteMarker || (ByteMarker = {}));
+// ------------------------------------------------------------------
 // State
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 let Accumulator = BigInt('14695981039346656037');
 const [Prime, Size] = [BigInt('1099511628211'), BigInt('2') ** BigInt('64')];
 const Bytes = Array.from({ length: 256 }).map((_, i) => BigInt(i));
 const F64 = new Float64Array(1);
 const F64In = new DataView(F64.buffer);
 const F64Out = new Uint8Array(F64.buffer);
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // NumberToBytes
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 function* NumberToBytes(value) {
     const byteCount = value === 0 ? 1 : Math.ceil(Math.floor(Math.log2(value) + 1) / 8);
     for (let i = 0; i < byteCount; i++) {
         yield (value >> (8 * (byteCount - 1 - i))) & 0xff;
     }
 }
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Hashing Functions
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 function ArrayType(value) {
     FNV1A64(ByteMarker.Array);
     for (const item of value) {
@@ -137,27 +137,27 @@ function UndefinedType(value) {
     return FNV1A64(ByteMarker.Undefined);
 }
 function Visit(value) {
-    if ((0, guard_1.IsArray)(value))
+    if ((0, index_mjs_1.IsArray)(value))
         return ArrayType(value);
-    if ((0, guard_1.IsBoolean)(value))
+    if ((0, index_mjs_1.IsBoolean)(value))
         return BooleanType(value);
-    if ((0, guard_1.IsBigInt)(value))
+    if ((0, index_mjs_1.IsBigInt)(value))
         return BigIntType(value);
-    if ((0, guard_1.IsDate)(value))
+    if ((0, index_mjs_1.IsDate)(value))
         return DateType(value);
-    if ((0, guard_1.IsNull)(value))
+    if ((0, index_mjs_1.IsNull)(value))
         return NullType(value);
-    if ((0, guard_1.IsNumber)(value))
+    if ((0, index_mjs_1.IsNumber)(value))
         return NumberType(value);
-    if ((0, guard_1.IsPlainObject)(value))
+    if ((0, index_mjs_1.IsPlainObject)(value))
         return ObjectType(value);
-    if ((0, guard_1.IsString)(value))
+    if ((0, index_mjs_1.IsString)(value))
         return StringType(value);
-    if ((0, guard_1.IsSymbol)(value))
+    if ((0, index_mjs_1.IsSymbol)(value))
         return SymbolType(value);
-    if ((0, guard_1.IsUint8Array)(value))
+    if ((0, index_mjs_1.IsUint8Array)(value))
         return Uint8ArrayType(value);
-    if ((0, guard_1.IsUndefined)(value))
+    if ((0, index_mjs_1.IsUndefined)(value))
         return UndefinedType(value);
     throw new ValueHashError(value);
 }
@@ -165,9 +165,9 @@ function FNV1A64(byte) {
     Accumulator = Accumulator ^ Bytes[byte];
     Accumulator = (Accumulator * Prime) % Size;
 }
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Hash
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 /** Creates a FNV1A-64 non cryptographic hash of the given value */
 function Hash(value) {
     Accumulator = BigInt('14695981039346656037');