@sinclair/typebox 0.31.28 → 0.32.0-dev-1

package/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/value/guard/index.d.ts

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

package/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/{hash.d.ts → hash/hash.d.ts}

@@ -2,18 +2,5 @@ export declare class ValueHashError extends Error {
     readonly value: unknown;
     constructor(value: unknown);
 }
-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;

package/value/{hash.js → 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_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_1.IsArray)(value))
         return ArrayType(value);
-    if ((0, guard_1.IsBoolean)(value))
+    if ((0, index_1.IsBoolean)(value))
         return BooleanType(value);
-    if ((0, guard_1.IsBigInt)(value))
+    if ((0, index_1.IsBigInt)(value))
         return BigIntType(value);
-    if ((0, guard_1.IsDate)(value))
+    if ((0, index_1.IsDate)(value))
         return DateType(value);
-    if ((0, guard_1.IsNull)(value))
+    if ((0, index_1.IsNull)(value))
         return NullType(value);
-    if ((0, guard_1.IsNumber)(value))
+    if ((0, index_1.IsNumber)(value))
         return NumberType(value);
-    if ((0, guard_1.IsPlainObject)(value))
+    if ((0, index_1.IsPlainObject)(value))
         return ObjectType(value);
-    if ((0, guard_1.IsString)(value))
+    if ((0, index_1.IsString)(value))
         return StringType(value);
-    if ((0, guard_1.IsSymbol)(value))
+    if ((0, index_1.IsSymbol)(value))
         return SymbolType(value);
-    if ((0, guard_1.IsUint8Array)(value))
+    if ((0, index_1.IsUint8Array)(value))
         return Uint8ArrayType(value);
-    if ((0, guard_1.IsUndefined)(value))
+    if ((0, index_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');

package/value/hash/index.d.ts

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

package/value/hash/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("./hash"), exports);

package/value/index.d.ts

@@ -1,5 +1,18 @@
 export { ValueError, ValueErrorType, ValueErrorIterator } from '../errors/index';
-export { Edit, Insert, Update, Delete } from './delta';
-export { Mutable } from './mutate';
-export { ValuePointer } from './pointer';
-export { Value } from './value';
+export { Cast, ValueCastArrayUniqueItemsTypeError, ValueCastNeverTypeError, ValueCastRecursiveTypeError, ValueCastUnknownTypeError } from './cast/index';
+export { Check } from './check/index';
+export { Clean } from './clean/index';
+export { Clone } from './clone/index';
+export { Convert, ValueConvertUnknownTypeError } from './convert/index';
+export { Create, ValueCreateIntersectTypeError, ValueCreateNeverTypeError, ValueCreateNotTypeError, ValueCreateRecursiveInstantiationError, ValueCreateTempateLiteralTypeError, ValueCreateUnknownTypeError } from './create/index';
+export { Default } from './default/index';
+export { Diff, Patch, Edit, Delete, Insert, Update, ValueDeltaObjectWithSymbolKeyError, ValueDeltaUnableToDiffUnknownValue } from './delta/index';
+export { Equal } from './equal/index';
+export { Hash, ValueHashError } from './hash/index';
+export { Mutate, type Mutable, ValueMutateInvalidRootMutationError, ValueMutateTypeMismatchError } from './mutate/index';
+export { ValuePointer } from './pointer/index';
+export { Decode, Encode, 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, ObjectType, TypedArrayType, ValueType, } from './guard/index';
+import { Value } from './value/index';
+export { Value };
+export default Value;

package/value/index.js

@@ -27,16 +27,97 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Value = exports.ValuePointer = exports.Delete = exports.Update = exports.Insert = exports.Edit = exports.ValueErrorIterator = exports.ValueErrorType = void 0;
+exports.IsInteger = exports.IsFunction = exports.IsDate = exports.IsBoolean = exports.IsBigInt = exports.IsAsyncIterator = exports.IsArray = exports.HasPropertyKey = exports.TransformEncodeError = exports.TransformEncodeCheckError = exports.TransformDecodeError = exports.TransformDecodeCheckError = exports.HasTransform = exports.Encode = exports.Decode = exports.ValuePointer = exports.ValueMutateTypeMismatchError = exports.ValueMutateInvalidRootMutationError = exports.Mutate = exports.ValueHashError = exports.Hash = exports.Equal = exports.ValueDeltaUnableToDiffUnknownValue = exports.ValueDeltaObjectWithSymbolKeyError = exports.Update = exports.Insert = exports.Delete = exports.Edit = exports.Patch = exports.Diff = exports.Default = exports.ValueCreateUnknownTypeError = exports.ValueCreateTempateLiteralTypeError = exports.ValueCreateRecursiveInstantiationError = exports.ValueCreateNotTypeError = exports.ValueCreateNeverTypeError = exports.ValueCreateIntersectTypeError = exports.Create = exports.ValueConvertUnknownTypeError = exports.Convert = exports.Clone = exports.Clean = exports.Check = exports.ValueCastUnknownTypeError = exports.ValueCastRecursiveTypeError = exports.ValueCastNeverTypeError = exports.ValueCastArrayUniqueItemsTypeError = exports.Cast = exports.ValueErrorIterator = exports.ValueErrorType = void 0;
+exports.Value = exports.IsValueType = exports.IsUndefined = exports.IsUint8Array = exports.IsTypedArray = exports.IsSymbol = exports.IsString = exports.IsPromise = exports.IsPlainObject = exports.IsObject = exports.IsNumber = exports.IsNull = exports.IsIterator = void 0;
+// ------------------------------------------------------------------
+// Value Errors (re-export)
+// ------------------------------------------------------------------
 var index_1 = require("../errors/index");
 Object.defineProperty(exports, "ValueErrorType", { enumerable: true, get: function () { return index_1.ValueErrorType; } });
 Object.defineProperty(exports, "ValueErrorIterator", { enumerable: true, get: function () { return index_1.ValueErrorIterator; } });
-var delta_1 = require("./delta");
-Object.defineProperty(exports, "Edit", { enumerable: true, get: function () { return delta_1.Edit; } });
-Object.defineProperty(exports, "Insert", { enumerable: true, get: function () { return delta_1.Insert; } });
-Object.defineProperty(exports, "Update", { enumerable: true, get: function () { return delta_1.Update; } });
-Object.defineProperty(exports, "Delete", { enumerable: true, get: function () { return delta_1.Delete; } });
-var pointer_1 = require("./pointer");
-Object.defineProperty(exports, "ValuePointer", { enumerable: true, get: function () { return pointer_1.ValuePointer; } });
-var value_1 = require("./value");
-Object.defineProperty(exports, "Value", { enumerable: true, get: function () { return value_1.Value; } });
+// ------------------------------------------------------------------
+// Value Operators
+// ------------------------------------------------------------------
+var index_2 = require("./cast/index");
+Object.defineProperty(exports, "Cast", { enumerable: true, get: function () { return index_2.Cast; } });
+Object.defineProperty(exports, "ValueCastArrayUniqueItemsTypeError", { enumerable: true, get: function () { return index_2.ValueCastArrayUniqueItemsTypeError; } });
+Object.defineProperty(exports, "ValueCastNeverTypeError", { enumerable: true, get: function () { return index_2.ValueCastNeverTypeError; } });
+Object.defineProperty(exports, "ValueCastRecursiveTypeError", { enumerable: true, get: function () { return index_2.ValueCastRecursiveTypeError; } });
+Object.defineProperty(exports, "ValueCastUnknownTypeError", { enumerable: true, get: function () { return index_2.ValueCastUnknownTypeError; } });
+var index_3 = require("./check/index");
+Object.defineProperty(exports, "Check", { enumerable: true, get: function () { return index_3.Check; } });
+var index_4 = require("./clean/index");
+Object.defineProperty(exports, "Clean", { enumerable: true, get: function () { return index_4.Clean; } });
+var index_5 = require("./clone/index");
+Object.defineProperty(exports, "Clone", { enumerable: true, get: function () { return index_5.Clone; } });
+var index_6 = require("./convert/index");
+Object.defineProperty(exports, "Convert", { enumerable: true, get: function () { return index_6.Convert; } });
+Object.defineProperty(exports, "ValueConvertUnknownTypeError", { enumerable: true, get: function () { return index_6.ValueConvertUnknownTypeError; } });
+var index_7 = require("./create/index");
+Object.defineProperty(exports, "Create", { enumerable: true, get: function () { return index_7.Create; } });
+Object.defineProperty(exports, "ValueCreateIntersectTypeError", { enumerable: true, get: function () { return index_7.ValueCreateIntersectTypeError; } });
+Object.defineProperty(exports, "ValueCreateNeverTypeError", { enumerable: true, get: function () { return index_7.ValueCreateNeverTypeError; } });
+Object.defineProperty(exports, "ValueCreateNotTypeError", { enumerable: true, get: function () { return index_7.ValueCreateNotTypeError; } });
+Object.defineProperty(exports, "ValueCreateRecursiveInstantiationError", { enumerable: true, get: function () { return index_7.ValueCreateRecursiveInstantiationError; } });
+Object.defineProperty(exports, "ValueCreateTempateLiteralTypeError", { enumerable: true, get: function () { return index_7.ValueCreateTempateLiteralTypeError; } });
+Object.defineProperty(exports, "ValueCreateUnknownTypeError", { enumerable: true, get: function () { return index_7.ValueCreateUnknownTypeError; } });
+var index_8 = require("./default/index");
+Object.defineProperty(exports, "Default", { enumerable: true, get: function () { return index_8.Default; } });
+var index_9 = require("./delta/index");
+Object.defineProperty(exports, "Diff", { enumerable: true, get: function () { return index_9.Diff; } });
+Object.defineProperty(exports, "Patch", { enumerable: true, get: function () { return index_9.Patch; } });
+Object.defineProperty(exports, "Edit", { enumerable: true, get: function () { return index_9.Edit; } });
+Object.defineProperty(exports, "Delete", { enumerable: true, get: function () { return index_9.Delete; } });
+Object.defineProperty(exports, "Insert", { enumerable: true, get: function () { return index_9.Insert; } });
+Object.defineProperty(exports, "Update", { enumerable: true, get: function () { return index_9.Update; } });
+Object.defineProperty(exports, "ValueDeltaObjectWithSymbolKeyError", { enumerable: true, get: function () { return index_9.ValueDeltaObjectWithSymbolKeyError; } });
+Object.defineProperty(exports, "ValueDeltaUnableToDiffUnknownValue", { enumerable: true, get: function () { return index_9.ValueDeltaUnableToDiffUnknownValue; } });
+var index_10 = require("./equal/index");
+Object.defineProperty(exports, "Equal", { enumerable: true, get: function () { return index_10.Equal; } });
+var index_11 = require("./hash/index");
+Object.defineProperty(exports, "Hash", { enumerable: true, get: function () { return index_11.Hash; } });
+Object.defineProperty(exports, "ValueHashError", { enumerable: true, get: function () { return index_11.ValueHashError; } });
+var index_12 = require("./mutate/index");
+Object.defineProperty(exports, "Mutate", { enumerable: true, get: function () { return index_12.Mutate; } });
+Object.defineProperty(exports, "ValueMutateInvalidRootMutationError", { enumerable: true, get: function () { return index_12.ValueMutateInvalidRootMutationError; } });
+Object.defineProperty(exports, "ValueMutateTypeMismatchError", { enumerable: true, get: function () { return index_12.ValueMutateTypeMismatchError; } });
+var index_13 = require("./pointer/index");
+Object.defineProperty(exports, "ValuePointer", { enumerable: true, get: function () { return index_13.ValuePointer; } });
+var index_14 = require("./transform/index");
+Object.defineProperty(exports, "Decode", { enumerable: true, get: function () { return index_14.Decode; } });
+Object.defineProperty(exports, "Encode", { enumerable: true, get: function () { return index_14.Encode; } });
+Object.defineProperty(exports, "HasTransform", { enumerable: true, get: function () { return index_14.HasTransform; } });
+Object.defineProperty(exports, "TransformDecodeCheckError", { enumerable: true, get: function () { return index_14.TransformDecodeCheckError; } });
+Object.defineProperty(exports, "TransformDecodeError", { enumerable: true, get: function () { return index_14.TransformDecodeError; } });
+Object.defineProperty(exports, "TransformEncodeCheckError", { enumerable: true, get: function () { return index_14.TransformEncodeCheckError; } });
+Object.defineProperty(exports, "TransformEncodeError", { enumerable: true, get: function () { return index_14.TransformEncodeError; } });
+// ------------------------------------------------------------------
+// Value Guards
+// ------------------------------------------------------------------
+var index_15 = require("./guard/index");
+Object.defineProperty(exports, "HasPropertyKey", { enumerable: true, get: function () { return index_15.HasPropertyKey; } });
+Object.defineProperty(exports, "IsArray", { enumerable: true, get: function () { return index_15.IsArray; } });
+Object.defineProperty(exports, "IsAsyncIterator", { enumerable: true, get: function () { return index_15.IsAsyncIterator; } });
+Object.defineProperty(exports, "IsBigInt", { enumerable: true, get: function () { return index_15.IsBigInt; } });
+Object.defineProperty(exports, "IsBoolean", { enumerable: true, get: function () { return index_15.IsBoolean; } });
+Object.defineProperty(exports, "IsDate", { enumerable: true, get: function () { return index_15.IsDate; } });
+Object.defineProperty(exports, "IsFunction", { enumerable: true, get: function () { return index_15.IsFunction; } });
+Object.defineProperty(exports, "IsInteger", { enumerable: true, get: function () { return index_15.IsInteger; } });
+Object.defineProperty(exports, "IsIterator", { enumerable: true, get: function () { return index_15.IsIterator; } });
+Object.defineProperty(exports, "IsNull", { enumerable: true, get: function () { return index_15.IsNull; } });
+Object.defineProperty(exports, "IsNumber", { enumerable: true, get: function () { return index_15.IsNumber; } });
+Object.defineProperty(exports, "IsObject", { enumerable: true, get: function () { return index_15.IsObject; } });
+Object.defineProperty(exports, "IsPlainObject", { enumerable: true, get: function () { return index_15.IsPlainObject; } });
+Object.defineProperty(exports, "IsPromise", { enumerable: true, get: function () { return index_15.IsPromise; } });
+Object.defineProperty(exports, "IsString", { enumerable: true, get: function () { return index_15.IsString; } });
+Object.defineProperty(exports, "IsSymbol", { enumerable: true, get: function () { return index_15.IsSymbol; } });
+Object.defineProperty(exports, "IsTypedArray", { enumerable: true, get: function () { return index_15.IsTypedArray; } });
+Object.defineProperty(exports, "IsUint8Array", { enumerable: true, get: function () { return index_15.IsUint8Array; } });
+Object.defineProperty(exports, "IsUndefined", { enumerable: true, get: function () { return index_15.IsUndefined; } });
+Object.defineProperty(exports, "IsValueType", { enumerable: true, get: function () { return index_15.IsValueType; } });
+// ------------------------------------------------------------------
+// Value Namespace
+// ------------------------------------------------------------------
+const index_16 = require("./value/index");
+Object.defineProperty(exports, "Value", { enumerable: true, get: function () { return index_16.Value; } });
+exports.default = index_16.Value;

package/value/mutate/index.d.ts

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

package/value/mutate/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("./mutate"), exports);

package/value/{mutate.d.ts → mutate/mutate.d.ts}

@@ -7,5 +7,5 @@ export declare class ValueMutateInvalidRootMutationError extends Error {
 export type Mutable = {
     [key: string]: unknown;
 } | unknown[];
-/** Performs a deep mutable value assignment while retaining internal references */
+/** `[Mutable]` Performs a deep mutable value assignment while retaining internal references */
 export declare function Mutate(current: Mutable, next: Mutable): void;

package/value/{mutate.js → mutate/mutate.js}

@@ -28,12 +28,12 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Mutate = exports.ValueMutateInvalidRootMutationError = exports.ValueMutateTypeMismatchError = void 0;
-const guard_1 = require("./guard");
-const pointer_1 = require("./pointer");
-const clone_1 = require("./clone");
-// --------------------------------------------------------------------------
+const index_1 = require("../guard/index");
+const index_2 = require("../pointer/index");
+const index_3 = require("../clone/index");
+// ------------------------------------------------------------------
 // Errors
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 class ValueMutateTypeMismatchError extends Error {
     constructor() {
         super('Cannot assign due type mismatch of assignable values');
@@ -47,8 +47,8 @@ class ValueMutateInvalidRootMutationError extends Error {
 }
 exports.ValueMutateInvalidRootMutationError = ValueMutateInvalidRootMutationError;
 function ObjectType(root, path, current, next) {
-    if (!(0, guard_1.IsPlainObject)(current)) {
-        pointer_1.ValuePointer.Set(root, path, (0, clone_1.Clone)(next));
+    if (!(0, index_1.IsPlainObject)(current)) {
+        index_2.ValuePointer.Set(root, path, (0, index_3.Clone)(next));
     }
     else {
         const currentKeys = Object.keys(current);
@@ -69,8 +69,8 @@ function ObjectType(root, path, current, next) {
     }
 }
 function ArrayType(root, path, current, next) {
-    if (!(0, guard_1.IsArray)(current)) {
-        pointer_1.ValuePointer.Set(root, path, (0, clone_1.Clone)(next));
+    if (!(0, index_1.IsArray)(current)) {
+        index_2.ValuePointer.Set(root, path, (0, index_3.Clone)(next));
     }
     else {
         for (let index = 0; index < next.length; index++) {
@@ -80,45 +80,45 @@ function ArrayType(root, path, current, next) {
     }
 }
 function TypedArrayType(root, path, current, next) {
-    if ((0, guard_1.IsTypedArray)(current) && current.length === next.length) {
+    if ((0, index_1.IsTypedArray)(current) && current.length === next.length) {
         for (let i = 0; i < current.length; i++) {
             current[i] = next[i];
         }
     }
     else {
-        pointer_1.ValuePointer.Set(root, path, (0, clone_1.Clone)(next));
+        index_2.ValuePointer.Set(root, path, (0, index_3.Clone)(next));
     }
 }
 function ValueType(root, path, current, next) {
     if (current === next)
         return;
-    pointer_1.ValuePointer.Set(root, path, next);
+    index_2.ValuePointer.Set(root, path, next);
 }
 function Visit(root, path, current, next) {
-    if ((0, guard_1.IsArray)(next))
+    if ((0, index_1.IsArray)(next))
         return ArrayType(root, path, current, next);
-    if ((0, guard_1.IsTypedArray)(next))
+    if ((0, index_1.IsTypedArray)(next))
         return TypedArrayType(root, path, current, next);
-    if ((0, guard_1.IsPlainObject)(next))
+    if ((0, index_1.IsPlainObject)(next))
         return ObjectType(root, path, current, next);
-    if ((0, guard_1.IsValueType)(next))
+    if ((0, index_1.IsValueType)(next))
         return ValueType(root, path, current, next);
 }
-// --------------------------------------------------------------------------
-// Mutate
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
+// IsNonMutableValue
+// ------------------------------------------------------------------
 function IsNonMutableValue(value) {
-    return (0, guard_1.IsTypedArray)(value) || (0, guard_1.IsValueType)(value);
+    return (0, index_1.IsTypedArray)(value) || (0, index_1.IsValueType)(value);
 }
 function IsMismatchedValue(current, next) {
     // prettier-ignore
-    return (((0, guard_1.IsPlainObject)(current) && (0, guard_1.IsArray)(next)) ||
-        ((0, guard_1.IsArray)(current) && (0, guard_1.IsPlainObject)(next)));
+    return (((0, index_1.IsPlainObject)(current) && (0, index_1.IsArray)(next)) ||
+        ((0, index_1.IsArray)(current) && (0, index_1.IsPlainObject)(next)));
 }
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Mutate
-// --------------------------------------------------------------------------
-/** Performs a deep mutable value assignment while retaining internal references */
+// ------------------------------------------------------------------
+/** `[Mutable]` Performs a deep mutable value assignment while retaining internal references */
 function Mutate(current, next) {
     if (IsNonMutableValue(current) || IsNonMutableValue(next))
         throw new ValueMutateInvalidRootMutationError();

package/value/pointer/index.d.ts

@@ -0,0 +1 @@
+export * as ValuePointer from './pointer';

package/value/pointer/index.js

@@ -0,0 +1,31 @@
+"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.ValuePointer = void 0;
+exports.ValuePointer = require("./pointer");

package/value/pointer/pointer.d.ts

@@ -0,0 +1,21 @@
+export declare class ValuePointerRootSetError extends Error {
+    readonly value: unknown;
+    readonly path: string;
+    readonly update: unknown;
+    constructor(value: unknown, path: string, update: unknown);
+}
+export declare class ValuePointerRootDeleteError extends Error {
+    readonly value: unknown;
+    readonly path: string;
+    constructor(value: unknown, path: string);
+}
+/** Formats the given pointer into navigable key components */
+export declare function Format(pointer: string): IterableIterator<string>;
+/** Sets the value at the given pointer. If the value at the pointer does not exist it is created */
+export declare function Set(value: any, pointer: string, update: unknown): void;
+/** Deletes a value at the given pointer */
+export declare function Delete(value: any, pointer: string): void;
+/** Returns true if a value exists at the given pointer */
+export declare function Has(value: any, pointer: string): boolean;
+/** Gets the value at the given pointer */
+export declare function Get(value: any, pointer: string): any;