@sinclair/typebox 0.32.0-dev-3 → 0.32.0-dev-5

package/build/default/value/delta/delta.js

@@ -0,0 +1,157 @@
+"use strict";
+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 index_1 = require("../guard/index");
+const index_2 = require("../pointer/index");
+const index_3 = require("../clone/index");
+const index_4 = require("../../type/literal/index");
+const index_5 = require("../../type/object/index");
+const index_6 = require("../../type/string/index");
+const index_7 = require("../../type/unknown/index");
+const index_8 = require("../../type/union/index");
+exports.Insert = (0, index_5.Object)({
+    type: (0, index_4.Literal)('insert'),
+    path: (0, index_6.String)(),
+    value: (0, index_7.Unknown)(),
+});
+exports.Update = (0, index_5.Object)({
+    type: (0, index_4.Literal)('update'),
+    path: (0, index_6.String)(),
+    value: (0, index_7.Unknown)(),
+});
+exports.Delete = (0, index_5.Object)({
+    type: (0, index_4.Literal)('delete'),
+    path: (0, index_6.String)(),
+});
+exports.Edit = (0, index_8.Union)([exports.Insert, exports.Update, exports.Delete]);
+class ValueDeltaObjectWithSymbolKeyError extends Error {
+    constructor(key) {
+        super('Cannot diff objects with symbol keys');
+        this.key = key;
+    }
+}
+exports.ValueDeltaObjectWithSymbolKeyError = ValueDeltaObjectWithSymbolKeyError;
+class ValueDeltaUnableToDiffUnknownValue extends Error {
+    constructor(value) {
+        super('Unable to create diff edits for unknown value');
+        this.value = value;
+    }
+}
+exports.ValueDeltaUnableToDiffUnknownValue = ValueDeltaUnableToDiffUnknownValue;
+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 };
+}
+function* ObjectType(path, current, next) {
+    if (!(0, index_1.IsPlainObject)(next))
+        return yield CreateUpdate(path, next);
+    const currentKeys = [...globalThis.Object.keys(current), ...globalThis.Object.getOwnPropertySymbols(current)];
+    const nextKeys = [...globalThis.Object.keys(next), ...globalThis.Object.getOwnPropertySymbols(next)];
+    for (const key of currentKeys) {
+        if ((0, index_1.IsSymbol)(key))
+            throw new ValueDeltaObjectWithSymbolKeyError(key);
+        if ((0, index_1.IsUndefined)(next[key]) && nextKeys.includes(key))
+            yield CreateUpdate(`${path}/${globalThis.String(key)}`, undefined);
+    }
+    for (const key of nextKeys) {
+        if ((0, index_1.IsUndefined)(current[key]) || (0, index_1.IsUndefined)(next[key]))
+            continue;
+        if ((0, index_1.IsSymbol)(key))
+            throw new ValueDeltaObjectWithSymbolKeyError(key);
+        yield* Visit(`${path}/${globalThis.String(key)}`, current[key], next[key]);
+    }
+    for (const key of nextKeys) {
+        if ((0, index_1.IsSymbol)(key))
+            throw new ValueDeltaObjectWithSymbolKeyError(key);
+        if ((0, index_1.IsUndefined)(current[key]))
+            yield CreateInsert(`${path}/${globalThis.String(key)}`, next[key]);
+    }
+    for (const key of currentKeys.reverse()) {
+        if ((0, index_1.IsSymbol)(key))
+            throw new ValueDeltaObjectWithSymbolKeyError(key);
+        if ((0, index_1.IsUndefined)(next[key]) && !nextKeys.includes(key))
+            yield CreateDelete(`${path}/${globalThis.String(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.IsPlainObject)(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 ValueDeltaUnableToDiffUnknownValue(current);
+}
+function Diff(current, next) {
+    return [...Visit('', current, next)];
+}
+exports.Diff = Diff;
+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;
+}
+exports.Patch = Patch;

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

@@ -0,0 +1,17 @@
+"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/default/value/deref/deref.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Deref = exports.TypeDereferenceError = void 0;
+class TypeDereferenceError extends Error {
+    constructor(schema) {
+        super(`Unable to dereference schema with $id '${schema.$id}'`);
+        this.schema = schema;
+    }
+}
+exports.TypeDereferenceError = TypeDereferenceError;
+function Deref(schema, references) {
+    const index = references.findIndex((target) => target.$id === schema.$ref);
+    if (index === -1)
+        throw new TypeDereferenceError(schema);
+    return references[index];
+}
+exports.Deref = Deref;

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

@@ -0,0 +1,17 @@
+"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/default/value/equal/equal.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Equal = void 0;
+const index_1 = require("../guard/index");
+function ObjectType(left, right) {
+    if (!(0, index_1.IsPlainObject)(right))
+        return false;
+    const leftKeys = [...Object.keys(left), ...Object.getOwnPropertySymbols(left)];
+    const rightKeys = [...Object.keys(right), ...Object.getOwnPropertySymbols(right)];
+    if (leftKeys.length !== rightKeys.length)
+        return false;
+    return leftKeys.every((key) => Equal(left[key], right[key]));
+}
+function DateType(left, right) {
+    return (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;
+}
+function Equal(left, right) {
+    if ((0, index_1.IsPlainObject)(left))
+        return ObjectType(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.IsValueType)(left))
+        return ValueType(left, right);
+    throw new Error('ValueEquals: Unable to compare value');
+}
+exports.Equal = Equal;

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

@@ -0,0 +1,17 @@
+"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);

package/build/default/value/guard/guard.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsValueType = exports.IsSymbol = exports.IsFunction = exports.IsString = exports.IsBigInt = exports.IsInteger = exports.IsNumber = exports.IsBoolean = exports.IsNull = exports.IsUndefined = exports.IsArray = exports.IsObject = exports.IsPlainObject = exports.HasPropertyKey = exports.IsDate = exports.IsUint8Array = exports.IsPromise = exports.IsTypedArray = exports.IsIterator = exports.IsAsyncIterator = void 0;
+function IsAsyncIterator(value) {
+    return IsObject(value) && Symbol.asyncIterator in value;
+}
+exports.IsAsyncIterator = IsAsyncIterator;
+function IsIterator(value) {
+    return IsObject(value) && Symbol.iterator in value;
+}
+exports.IsIterator = IsIterator;
+function IsTypedArray(value) {
+    return ArrayBuffer.isView(value);
+}
+exports.IsTypedArray = IsTypedArray;
+function IsPromise(value) {
+    return value instanceof Promise;
+}
+exports.IsPromise = IsPromise;
+function IsUint8Array(value) {
+    return value instanceof Uint8Array;
+}
+exports.IsUint8Array = IsUint8Array;
+function IsDate(value) {
+    return value instanceof Date && Number.isFinite(value.getTime());
+}
+exports.IsDate = IsDate;
+function HasPropertyKey(value, key) {
+    return key in value;
+}
+exports.HasPropertyKey = HasPropertyKey;
+function IsPlainObject(value) {
+    return IsObject(value) && IsFunction(value.constructor) && value.constructor.name === 'Object';
+}
+exports.IsPlainObject = IsPlainObject;
+function IsObject(value) {
+    return value !== null && typeof value === 'object';
+}
+exports.IsObject = IsObject;
+function IsArray(value) {
+    return Array.isArray(value) && !ArrayBuffer.isView(value);
+}
+exports.IsArray = IsArray;
+function IsUndefined(value) {
+    return value === undefined;
+}
+exports.IsUndefined = IsUndefined;
+function IsNull(value) {
+    return value === null;
+}
+exports.IsNull = IsNull;
+function IsBoolean(value) {
+    return typeof value === 'boolean';
+}
+exports.IsBoolean = IsBoolean;
+function IsNumber(value) {
+    return typeof value === 'number';
+}
+exports.IsNumber = IsNumber;
+function IsInteger(value) {
+    return IsNumber(value) && Number.isInteger(value);
+}
+exports.IsInteger = IsInteger;
+function IsBigInt(value) {
+    return typeof value === 'bigint';
+}
+exports.IsBigInt = IsBigInt;
+function IsString(value) {
+    return typeof value === 'string';
+}
+exports.IsString = IsString;
+function IsFunction(value) {
+    return typeof value === 'function';
+}
+exports.IsFunction = IsFunction;
+function IsSymbol(value) {
+    return typeof value === 'symbol';
+}
+exports.IsSymbol = IsSymbol;
+function IsValueType(value) {
+    return (IsBigInt(value) ||
+        IsBoolean(value) ||
+        IsNull(value) ||
+        IsNumber(value) ||
+        IsString(value) ||
+        IsSymbol(value) ||
+        IsUndefined(value));
+}
+exports.IsValueType = IsValueType;

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

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

package/build/default/value/hash/hash.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Hash = exports.ValueHashError = void 0;
+const index_1 = require("../guard/index");
+class ValueHashError extends Error {
+    constructor(value) {
+        super(`Unable to hash value`);
+        this.value = value;
+    }
+}
+exports.ValueHashError = ValueHashError;
+var ByteMarker;
+(function (ByteMarker) {
+    ByteMarker[ByteMarker["Undefined"] = 0] = "Undefined";
+    ByteMarker[ByteMarker["Null"] = 1] = "Null";
+    ByteMarker[ByteMarker["Boolean"] = 2] = "Boolean";
+    ByteMarker[ByteMarker["Number"] = 3] = "Number";
+    ByteMarker[ByteMarker["String"] = 4] = "String";
+    ByteMarker[ByteMarker["Object"] = 5] = "Object";
+    ByteMarker[ByteMarker["Array"] = 6] = "Array";
+    ByteMarker[ByteMarker["Date"] = 7] = "Date";
+    ByteMarker[ByteMarker["Uint8Array"] = 8] = "Uint8Array";
+    ByteMarker[ByteMarker["Symbol"] = 9] = "Symbol";
+    ByteMarker[ByteMarker["BigInt"] = 10] = "BigInt";
+})(ByteMarker || (ByteMarker = {}));
+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);
+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;
+    }
+}
+function ArrayType(value) {
+    FNV1A64(ByteMarker.Array);
+    for (const item of value) {
+        Visit(item);
+    }
+}
+function BooleanType(value) {
+    FNV1A64(ByteMarker.Boolean);
+    FNV1A64(value ? 1 : 0);
+}
+function BigIntType(value) {
+    FNV1A64(ByteMarker.BigInt);
+    F64In.setBigInt64(0, value);
+    for (const byte of F64Out) {
+        FNV1A64(byte);
+    }
+}
+function DateType(value) {
+    FNV1A64(ByteMarker.Date);
+    Visit(value.getTime());
+}
+function NullType(value) {
+    FNV1A64(ByteMarker.Null);
+}
+function NumberType(value) {
+    FNV1A64(ByteMarker.Number);
+    F64In.setFloat64(0, value);
+    for (const byte of F64Out) {
+        FNV1A64(byte);
+    }
+}
+function ObjectType(value) {
+    FNV1A64(ByteMarker.Object);
+    for (const key of globalThis.Object.keys(value).sort()) {
+        Visit(key);
+        Visit(value[key]);
+    }
+}
+function StringType(value) {
+    FNV1A64(ByteMarker.String);
+    for (let i = 0; i < value.length; i++) {
+        for (const byte of NumberToBytes(value.charCodeAt(i))) {
+            FNV1A64(byte);
+        }
+    }
+}
+function SymbolType(value) {
+    FNV1A64(ByteMarker.Symbol);
+    Visit(value.description);
+}
+function Uint8ArrayType(value) {
+    FNV1A64(ByteMarker.Uint8Array);
+    for (let i = 0; i < value.length; i++) {
+        FNV1A64(value[i]);
+    }
+}
+function UndefinedType(value) {
+    return FNV1A64(ByteMarker.Undefined);
+}
+function Visit(value) {
+    if ((0, index_1.IsArray)(value))
+        return ArrayType(value);
+    if ((0, index_1.IsBoolean)(value))
+        return BooleanType(value);
+    if ((0, index_1.IsBigInt)(value))
+        return BigIntType(value);
+    if ((0, index_1.IsDate)(value))
+        return DateType(value);
+    if ((0, index_1.IsNull)(value))
+        return NullType(value);
+    if ((0, index_1.IsNumber)(value))
+        return NumberType(value);
+    if ((0, index_1.IsPlainObject)(value))
+        return ObjectType(value);
+    if ((0, index_1.IsString)(value))
+        return StringType(value);
+    if ((0, index_1.IsSymbol)(value))
+        return SymbolType(value);
+    if ((0, index_1.IsUint8Array)(value))
+        return Uint8ArrayType(value);
+    if ((0, index_1.IsUndefined)(value))
+        return UndefinedType(value);
+    throw new ValueHashError(value);
+}
+function FNV1A64(byte) {
+    Accumulator = Accumulator ^ Bytes[byte];
+    Accumulator = (Accumulator * Prime) % Size;
+}
+function Hash(value) {
+    Accumulator = BigInt('14695981039346656037');
+    Visit(value);
+    return Accumulator;
+}
+exports.Hash = Hash;

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

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

package/build/default/value/index.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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;
+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 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; } });
+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; } });
+const index_16 = require("./value/index");
+Object.defineProperty(exports, "Value", { enumerable: true, get: function () { return index_16.Value; } });
+exports.default = index_16.Value;

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

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