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

package/build/import/value/default/default.mjs

@@ -0,0 +1,125 @@
+import { IsString, IsObject, IsArray, IsUndefined } from '../guard/index.mjs';
+import { TSchema as IsSchemaType } from '../../type/guard/type.mjs';
+import { Check } from '../check/index.mjs';
+import { Deref } from '../deref/index.mjs';
+import { Kind } from '../../type/symbols/index.mjs';
+function ValueOrDefault(schema, value) {
+    return !(value === undefined) || !('default' in schema) ? value : schema.default;
+}
+function IsCheckable(schema) {
+    return IsSchemaType(schema) && schema[Kind] !== 'Unsafe';
+}
+function IsDefaultSchema(value) {
+    return IsSchemaType(value) && 'default' in value;
+}
+function TArray(schema, references, value) {
+    const defaulted = ValueOrDefault(schema, value);
+    if (!IsArray(defaulted))
+        return defaulted;
+    for (let i = 0; i < defaulted.length; i++) {
+        defaulted[i] = Visit(schema.items, references, defaulted[i]);
+    }
+    return defaulted;
+}
+function TIntersect(schema, references, value) {
+    const defaulted = ValueOrDefault(schema, value);
+    return schema.allOf.reduce((acc, schema) => {
+        const next = Visit(schema, references, defaulted);
+        return IsObject(next) ? { ...acc, ...next } : next;
+    }, {});
+}
+function TObject(schema, references, value) {
+    const defaulted = ValueOrDefault(schema, value);
+    if (!IsObject(defaulted))
+        return defaulted;
+    const additionalPropertiesSchema = schema.additionalProperties;
+    const knownPropertyKeys = Object.getOwnPropertyNames(schema.properties);
+    for (const key of knownPropertyKeys) {
+        if (!IsDefaultSchema(schema.properties[key]))
+            continue;
+        defaulted[key] = Visit(schema.properties[key], references, defaulted[key]);
+    }
+    if (!IsDefaultSchema(additionalPropertiesSchema))
+        return defaulted;
+    for (const key of Object.getOwnPropertyNames(defaulted)) {
+        if (knownPropertyKeys.includes(key))
+            continue;
+        defaulted[key] = Visit(additionalPropertiesSchema, references, defaulted[key]);
+    }
+    return defaulted;
+}
+function TRecord(schema, references, value) {
+    const defaulted = ValueOrDefault(schema, value);
+    if (!IsObject(defaulted))
+        return defaulted;
+    const additionalPropertiesSchema = schema.additionalProperties;
+    const [propertyKeyPattern, propertySchema] = Object.entries(schema.patternProperties)[0];
+    const knownPropertyKey = new RegExp(propertyKeyPattern);
+    for (const key of Object.getOwnPropertyNames(defaulted)) {
+        if (!(knownPropertyKey.test(key) && IsDefaultSchema(propertySchema)))
+            continue;
+        defaulted[key] = Visit(propertySchema, references, defaulted[key]);
+    }
+    if (!IsDefaultSchema(additionalPropertiesSchema))
+        return defaulted;
+    for (const key of Object.getOwnPropertyNames(defaulted)) {
+        if (knownPropertyKey.test(key))
+            continue;
+        defaulted[key] = Visit(additionalPropertiesSchema, references, defaulted[key]);
+    }
+    return defaulted;
+}
+function TRef(schema, references, value) {
+    return Visit(Deref(schema, references), references, ValueOrDefault(schema, value));
+}
+function TThis(schema, references, value) {
+    return Visit(Deref(schema, references), references, value);
+}
+function TTuple(schema, references, value) {
+    const defaulted = ValueOrDefault(schema, value);
+    if (!IsArray(defaulted) || IsUndefined(schema.items))
+        return defaulted;
+    const [items, max] = [schema.items, Math.max(schema.items.length, defaulted.length)];
+    for (let i = 0; i < max; i++) {
+        if (i < items.length)
+            defaulted[i] = Visit(items[i], references, defaulted[i]);
+    }
+    return defaulted;
+}
+function TUnion(schema, references, value) {
+    const defaulted = ValueOrDefault(schema, value);
+    for (const inner of schema.anyOf) {
+        const result = Visit(inner, references, defaulted);
+        if (IsCheckable(inner) && Check(inner, result)) {
+            return result;
+        }
+    }
+    return defaulted;
+}
+function Visit(schema, references, value) {
+    const references_ = IsString(schema.$id) ? [...references, schema] : references;
+    const schema_ = schema;
+    switch (schema_[Kind]) {
+        case 'Array':
+            return TArray(schema_, references_, value);
+        case 'Intersect':
+            return TIntersect(schema_, references_, value);
+        case 'Object':
+            return TObject(schema_, references_, value);
+        case 'Record':
+            return TRecord(schema_, references_, value);
+        case 'Ref':
+            return TRef(schema_, references_, value);
+        case 'This':
+            return TThis(schema_, references_, value);
+        case 'Tuple':
+            return TTuple(schema_, references_, value);
+        case 'Union':
+            return TUnion(schema_, references_, value);
+        default:
+            return ValueOrDefault(schema_, value);
+    }
+}
+export function Default(...args) {
+    return args.length === 3 ? Visit(args[0], args[1], args[2]) : Visit(args[0], [], args[1]);
+}

package/build/import/value/default/index.mjs

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

package/build/import/value/delta/delta.mjs

@@ -0,0 +1,152 @@
+import { IsPlainObject, IsArray, IsTypedArray, IsValueType, IsSymbol, IsUndefined } from '../guard/index.mjs';
+import { ValuePointer } from '../pointer/index.mjs';
+import { Clone } from '../clone/index.mjs';
+import { Literal as CreateLiteral } from '../../type/literal/index.mjs';
+import { Object as CreateObject } from '../../type/object/index.mjs';
+import { String as CreateString } from '../../type/string/index.mjs';
+import { Unknown as CreateUnknown } from '../../type/unknown/index.mjs';
+import { Union as CreateUnion } from '../../type/union/index.mjs';
+export const Insert = CreateObject({
+    type: CreateLiteral('insert'),
+    path: CreateString(),
+    value: CreateUnknown(),
+});
+export const Update = CreateObject({
+    type: CreateLiteral('update'),
+    path: CreateString(),
+    value: CreateUnknown(),
+});
+export const Delete = CreateObject({
+    type: CreateLiteral('delete'),
+    path: CreateString(),
+});
+export const Edit = CreateUnion([Insert, Update, Delete]);
+export class ValueDeltaObjectWithSymbolKeyError extends Error {
+    key;
+    constructor(key) {
+        super('Cannot diff objects with symbol keys');
+        this.key = key;
+    }
+}
+export class ValueDeltaUnableToDiffUnknownValue extends Error {
+    value;
+    constructor(value) {
+        super('Unable to create diff edits for unknown value');
+        this.value = value;
+    }
+}
+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 (!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 (IsSymbol(key))
+            throw new ValueDeltaObjectWithSymbolKeyError(key);
+        if (IsUndefined(next[key]) && nextKeys.includes(key))
+            yield CreateUpdate(`${path}/${globalThis.String(key)}`, undefined);
+    }
+    for (const key of nextKeys) {
+        if (IsUndefined(current[key]) || IsUndefined(next[key]))
+            continue;
+        if (IsSymbol(key))
+            throw new ValueDeltaObjectWithSymbolKeyError(key);
+        yield* Visit(`${path}/${globalThis.String(key)}`, current[key], next[key]);
+    }
+    for (const key of nextKeys) {
+        if (IsSymbol(key))
+            throw new ValueDeltaObjectWithSymbolKeyError(key);
+        if (IsUndefined(current[key]))
+            yield CreateInsert(`${path}/${globalThis.String(key)}`, next[key]);
+    }
+    for (const key of currentKeys.reverse()) {
+        if (IsSymbol(key))
+            throw new ValueDeltaObjectWithSymbolKeyError(key);
+        if (IsUndefined(next[key]) && !nextKeys.includes(key))
+            yield CreateDelete(`${path}/${globalThis.String(key)}`);
+    }
+}
+function* ArrayType(path, current, next) {
+    if (!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 (!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 (IsPlainObject(current))
+        return yield* ObjectType(path, current, next);
+    if (IsArray(current))
+        return yield* ArrayType(path, current, next);
+    if (IsTypedArray(current))
+        return yield* TypedArrayType(path, current, next);
+    if (IsValueType(current))
+        return yield* ValueType(path, current, next);
+    throw new ValueDeltaUnableToDiffUnknownValue(current);
+}
+export function Diff(current, next) {
+    return [...Visit('', current, next)];
+}
+function IsRootUpdate(edits) {
+    return edits.length > 0 && edits[0].path === '' && edits[0].type === 'update';
+}
+function IsIdentity(edits) {
+    return edits.length === 0;
+}
+export function Patch(current, edits) {
+    if (IsRootUpdate(edits)) {
+        return Clone(edits[0].value);
+    }
+    if (IsIdentity(edits)) {
+        return Clone(current);
+    }
+    const clone = Clone(current);
+    for (const edit of edits) {
+        switch (edit.type) {
+            case 'insert': {
+                ValuePointer.Set(clone, edit.path, edit.value);
+                break;
+            }
+            case 'update': {
+                ValuePointer.Set(clone, edit.path, edit.value);
+                break;
+            }
+            case 'delete': {
+                ValuePointer.Delete(clone, edit.path);
+                break;
+            }
+        }
+    }
+    return clone;
+}

package/build/import/value/delta/index.mjs

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

package/build/import/value/deref/deref.mjs

@@ -0,0 +1,13 @@
+export class TypeDereferenceError extends Error {
+    schema;
+    constructor(schema) {
+        super(`Unable to dereference schema with $id '${schema.$id}'`);
+        this.schema = schema;
+    }
+}
+export function Deref(schema, references) {
+    const index = references.findIndex((target) => target.$id === schema.$ref);
+    if (index === -1)
+        throw new TypeDereferenceError(schema);
+    return references[index];
+}

package/build/import/value/deref/index.mjs

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

package/build/import/value/equal/equal.mjs

@@ -0,0 +1,39 @@
+import { IsPlainObject, IsDate, IsArray, IsTypedArray, IsValueType } from '../guard/index.mjs';
+function ObjectType(left, right) {
+    if (!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 IsDate(right) && left.getTime() === right.getTime();
+}
+function ArrayType(left, right) {
+    if (!IsArray(right) || left.length !== right.length)
+        return false;
+    return left.every((value, index) => Equal(value, right[index]));
+}
+function TypedArrayType(left, right) {
+    if (!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;
+}
+export function Equal(left, right) {
+    if (IsPlainObject(left))
+        return ObjectType(left, right);
+    if (IsDate(left))
+        return DateType(left, right);
+    if (IsTypedArray(left))
+        return TypedArrayType(left, right);
+    if (IsArray(left))
+        return ArrayType(left, right);
+    if (IsValueType(left))
+        return ValueType(left, right);
+    throw new Error('ValueEquals: Unable to compare value');
+}

package/build/import/value/equal/index.mjs

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

package/build/import/value/guard/guard.mjs

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

package/build/import/value/guard/index.mjs

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

package/build/import/value/hash/hash.mjs

@@ -0,0 +1,127 @@
+import { IsArray, IsBoolean, IsBigInt, IsDate, IsNull, IsNumber, IsPlainObject, IsString, IsSymbol, IsUint8Array, IsUndefined } from '../guard/index.mjs';
+export class ValueHashError extends Error {
+    value;
+    constructor(value) {
+        super(`Unable to hash value`);
+        this.value = value;
+    }
+}
+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 (IsArray(value))
+        return ArrayType(value);
+    if (IsBoolean(value))
+        return BooleanType(value);
+    if (IsBigInt(value))
+        return BigIntType(value);
+    if (IsDate(value))
+        return DateType(value);
+    if (IsNull(value))
+        return NullType(value);
+    if (IsNumber(value))
+        return NumberType(value);
+    if (IsPlainObject(value))
+        return ObjectType(value);
+    if (IsString(value))
+        return StringType(value);
+    if (IsSymbol(value))
+        return SymbolType(value);
+    if (IsUint8Array(value))
+        return Uint8ArrayType(value);
+    if (IsUndefined(value))
+        return UndefinedType(value);
+    throw new ValueHashError(value);
+}
+function FNV1A64(byte) {
+    Accumulator = Accumulator ^ Bytes[byte];
+    Accumulator = (Accumulator * Prime) % Size;
+}
+export function Hash(value) {
+    Accumulator = BigInt('14695981039346656037');
+    Visit(value);
+    return Accumulator;
+}

package/build/import/value/hash/index.mjs

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

package/build/import/value/index.mjs

@@ -0,0 +1,18 @@
+export { ValueErrorType, ValueErrorIterator } from '../errors/index.mjs';
+export { Cast, ValueCastArrayUniqueItemsTypeError, ValueCastNeverTypeError, ValueCastRecursiveTypeError, ValueCastUnknownTypeError } from './cast/index.mjs';
+export { Check } from './check/index.mjs';
+export { Clean } from './clean/index.mjs';
+export { Clone } from './clone/index.mjs';
+export { Convert, ValueConvertUnknownTypeError } from './convert/index.mjs';
+export { Create, ValueCreateIntersectTypeError, ValueCreateNeverTypeError, ValueCreateNotTypeError, ValueCreateRecursiveInstantiationError, ValueCreateTempateLiteralTypeError, ValueCreateUnknownTypeError } from './create/index.mjs';
+export { Default } from './default/index.mjs';
+export { Diff, Patch, Edit, Delete, Insert, Update, ValueDeltaObjectWithSymbolKeyError, ValueDeltaUnableToDiffUnknownValue } from './delta/index.mjs';
+export { Equal } from './equal/index.mjs';
+export { Hash, ValueHashError } from './hash/index.mjs';
+export { Mutate, ValueMutateInvalidRootMutationError, ValueMutateTypeMismatchError } from './mutate/index.mjs';
+export { ValuePointer } from './pointer/index.mjs';
+export { Decode, Encode, HasTransform, TransformDecodeCheckError, TransformDecodeError, TransformEncodeCheckError, TransformEncodeError } from './transform/index.mjs';
+export { HasPropertyKey, IsArray, IsAsyncIterator, IsBigInt, IsBoolean, IsDate, IsFunction, IsInteger, IsIterator, IsNull, IsNumber, IsObject, IsPlainObject, IsPromise, IsString, IsSymbol, IsTypedArray, IsUint8Array, IsUndefined, IsValueType, } from './guard/index.mjs';
+import { Value } from './value/index.mjs';
+export { Value };
+export default Value;

package/build/import/value/mutate/index.mjs

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

package/build/import/value/mutate/mutate.mjs

@@ -0,0 +1,85 @@
+import { IsPlainObject, IsArray, IsTypedArray, IsValueType } from '../guard/index.mjs';
+import { ValuePointer } from '../pointer/index.mjs';
+import { Clone } from '../clone/index.mjs';
+export class ValueMutateTypeMismatchError extends Error {
+    constructor() {
+        super('Cannot assign due type mismatch of assignable values');
+    }
+}
+export class ValueMutateInvalidRootMutationError extends Error {
+    constructor() {
+        super('Only object and array types can be mutated at the root level');
+    }
+}
+function ObjectType(root, path, current, next) {
+    if (!IsPlainObject(current)) {
+        ValuePointer.Set(root, path, Clone(next));
+    }
+    else {
+        const currentKeys = Object.keys(current);
+        const nextKeys = Object.keys(next);
+        for (const currentKey of currentKeys) {
+            if (!nextKeys.includes(currentKey)) {
+                delete current[currentKey];
+            }
+        }
+        for (const nextKey of nextKeys) {
+            if (!currentKeys.includes(nextKey)) {
+                current[nextKey] = null;
+            }
+        }
+        for (const nextKey of nextKeys) {
+            Visit(root, `${path}/${nextKey}`, current[nextKey], next[nextKey]);
+        }
+    }
+}
+function ArrayType(root, path, current, next) {
+    if (!IsArray(current)) {
+        ValuePointer.Set(root, path, Clone(next));
+    }
+    else {
+        for (let index = 0; index < next.length; index++) {
+            Visit(root, `${path}/${index}`, current[index], next[index]);
+        }
+        current.splice(next.length);
+    }
+}
+function TypedArrayType(root, path, current, next) {
+    if (IsTypedArray(current) && current.length === next.length) {
+        for (let i = 0; i < current.length; i++) {
+            current[i] = next[i];
+        }
+    }
+    else {
+        ValuePointer.Set(root, path, Clone(next));
+    }
+}
+function ValueType(root, path, current, next) {
+    if (current === next)
+        return;
+    ValuePointer.Set(root, path, next);
+}
+function Visit(root, path, current, next) {
+    if (IsArray(next))
+        return ArrayType(root, path, current, next);
+    if (IsTypedArray(next))
+        return TypedArrayType(root, path, current, next);
+    if (IsPlainObject(next))
+        return ObjectType(root, path, current, next);
+    if (IsValueType(next))
+        return ValueType(root, path, current, next);
+}
+function IsNonMutableValue(value) {
+    return IsTypedArray(value) || IsValueType(value);
+}
+function IsMismatchedValue(current, next) {
+    return ((IsPlainObject(current) && IsArray(next)) ||
+        (IsArray(current) && IsPlainObject(next)));
+}
+export function Mutate(current, next) {
+    if (IsNonMutableValue(current) || IsNonMutableValue(next))
+        throw new ValueMutateInvalidRootMutationError();
+    if (IsMismatchedValue(current, next))
+        throw new ValueMutateTypeMismatchError();
+    Visit(current, '', current, next);
+}

package/build/import/value/pointer/index.mjs

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