typebox 0.0.1 → 1.0.0

package/build/value/create/from-type.mjs

@@ -0,0 +1,69 @@
+// deno-fmt-ignore-file
+import * as T from '../../type/index.mjs';
+import * as S from '../../schema/types/index.mjs';
+import { FromDefault } from './from-default.mjs';
+import { FromArray } from './from-array.mjs';
+import { FromAsyncIterator } from './from-async-iterator.mjs';
+import { FromBase } from './from-base.mjs';
+import { FromBigInt } from './from-bigint.mjs';
+import { FromBoolean } from './from-boolean.mjs';
+import { FromConstructor } from './from-constructor.mjs';
+import { FromCyclic } from './from-cyclic.mjs';
+import { FromEnum } from './from-enum.mjs';
+import { FromFunction } from './from-function.mjs';
+import { FromInteger } from './from-integer.mjs';
+import { FromIntersect } from './from-intersect.mjs';
+import { FromIterator } from './from-iterator.mjs';
+import { FromLiteral } from "./from-literal.mjs";
+import { FromNever } from './from-never.mjs';
+import { FromNull } from './from-null.mjs';
+import { FromNumber } from './from-number.mjs';
+import { FromObject } from './from-object.mjs';
+import { FromPromise } from './from-promise.mjs';
+import { FromRecord } from './from-record.mjs';
+import { FromRef } from './from-ref.mjs';
+import { FromString } from './from-string.mjs';
+import { FromSymbol } from './from-symbol.mjs';
+import { FromTemplateLiteral } from './from-template-literal.mjs';
+import { FromTuple } from './from-tuple.mjs';
+import { FromUndefined } from './from-undefined.mjs';
+import { FromUnion } from './from-union.mjs';
+import { FromVoid } from './from-void.mjs';
+export function FromType(context, type) {
+    return (
+    // -----------------------------------------------------
+    // Default
+    // -----------------------------------------------------
+    S.IsDefault(type) ? FromDefault(context, type) :
+        // -----------------------------------------------------
+        // Types
+        // -----------------------------------------------------
+        T.IsArray(type) ? FromArray(context, type) :
+            T.IsAsyncIterator(type) ? FromAsyncIterator(context, type) :
+                T.IsBase(type) ? FromBase(context, type) :
+                    T.IsBigInt(type) ? FromBigInt(context, type) :
+                        T.IsBoolean(type) ? FromBoolean(context, type) :
+                            T.IsConstructor(type) ? FromConstructor(context, type) :
+                                T.IsCyclic(type) ? FromCyclic(context, type) :
+                                    T.IsEnum(type) ? FromEnum(context, type) :
+                                        T.IsFunction(type) ? FromFunction(context, type) :
+                                            T.IsInteger(type) ? FromInteger(context, type) :
+                                                T.IsIntersect(type) ? FromIntersect(context, type) :
+                                                    T.IsIterator(type) ? FromIterator(context, type) :
+                                                        T.IsLiteral(type) ? FromLiteral(context, type) :
+                                                            T.IsNever(type) ? FromNever(context, type) :
+                                                                T.IsNull(type) ? FromNull(context, type) :
+                                                                    T.IsNumber(type) ? FromNumber(context, type) :
+                                                                        T.IsObject(type) ? FromObject(context, type) :
+                                                                            T.IsPromise(type) ? FromPromise(context, type) :
+                                                                                T.IsRecord(type) ? FromRecord(context, type) :
+                                                                                    T.IsRef(type) ? FromRef(context, type) :
+                                                                                        T.IsString(type) ? FromString(context, type) :
+                                                                                            T.IsSymbol(type) ? FromSymbol(context, type) :
+                                                                                                T.IsTemplateLiteral(type) ? FromTemplateLiteral(context, type) :
+                                                                                                    T.IsTuple(type) ? FromTuple(context, type) :
+                                                                                                        T.IsUndefined(type) ? FromUndefined(context, type) :
+                                                                                                            T.IsUnion(type) ? FromUnion(context, type) :
+                                                                                                                T.IsVoid(type) ? FromVoid(context, type) :
+                                                                                                                    undefined);
+}

package/build/value/create/from-undefined.d.mts

@@ -0,0 +1,2 @@
+import type { TProperties, TUndefined } from '../../type/index.mjs';
+export declare function FromUndefined(context: TProperties, type: TUndefined): unknown;

package/build/value/create/from-undefined.mjs

@@ -0,0 +1,4 @@
+// deno-fmt-ignore-file
+export function FromUndefined(context, type) {
+    return undefined;
+}

package/build/value/create/from-union.d.mts

@@ -0,0 +1,2 @@
+import { type TProperties, type TUnion } from '../../type/index.mjs';
+export declare function FromUnion(context: TProperties, type: TUnion): unknown;

package/build/value/create/from-union.mjs

@@ -0,0 +1,9 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { FromType } from './from-type.mjs';
+export function FromUnion(context, type) {
+    if (Guard.IsEqual(type.anyOf.length, 0)) {
+        throw Error('Unable to create Union with no variants');
+    }
+    return FromType(context, type.anyOf[0]);
+}

package/build/value/create/from-void.d.mts

@@ -0,0 +1,2 @@
+import type { TProperties, TVoid } from '../../type/index.mjs';
+export declare function FromVoid(context: TProperties, type: TVoid): unknown;

package/build/value/create/from-void.mjs

@@ -0,0 +1,4 @@
+// deno-fmt-ignore-file
+export function FromVoid(context, type) {
+    return void 0;
+}

package/build/value/create/index.d.mts

@@ -0,0 +1,2 @@
+export * from './error.mjs';
+export * from './create.mjs';

package/build/value/create/index.mjs

@@ -0,0 +1,2 @@
+export * from './error.mjs';
+export * from './create.mjs';

package/build/value/default/default.d.mts

@@ -0,0 +1,13 @@
+import type { TProperties, TSchema } from '../../type/index.mjs';
+/**
+ * Patches missing properties on the value using default annotations specified on the provided type. This
+ * function returns unknown so callers should Check the return value before use. This function mutates the
+ * provided value. If mutation is not wanted, you should Clone the value before passing to this function.
+ */
+export declare function Default(type: TSchema, value: unknown): unknown;
+/**
+ * Patches missing properties on the value using default annotations specified on the provided type. This
+ * function returns unknown so callers should Check the return value before use. This function mutates the
+ * provided value. If mutation is not wanted, you should Clone the value before passing to this function.
+ */
+export declare function Default(context: TProperties, type: TSchema, value: unknown): unknown;

package/build/value/default/default.mjs

@@ -0,0 +1,15 @@
+// deno-fmt-ignore-file
+import { Arguments } from '../../system/arguments/index.mjs';
+import { FromType } from './from-type.mjs';
+/**
+ * Patches missing properties on the value using default annotations specified on the provided type. This
+ * function returns unknown so callers should Check the return value before use. This function mutates the
+ * provided value. If mutation is not wanted, you should Clone the value before passing to this function.
+ */
+export function Default(...args) {
+    const [context, type, value] = Arguments.Match(args, {
+        3: (context, type, value) => [context, type, value],
+        2: (type, value) => [{}, type, value],
+    });
+    return FromType(context, type, value);
+}

package/build/value/default/from-array.d.mts

@@ -0,0 +1,2 @@
+import type { TProperties, TArray } from '../../type/index.mjs';
+export declare function FromArray(context: TProperties, type: TArray, value: unknown): unknown;

package/build/value/default/from-array.mjs

@@ -0,0 +1,12 @@
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { FromType } from './from-type.mjs';
+export function FromArray(context, type, value) {
+    if (!Guard.IsArray(value))
+        return value;
+    for (let i = 0; i < value.length; i++) {
+        value[i] = FromType(context, type.items, value[i]);
+    }
+    return value;
+}

package/build/value/default/from-base.d.mts

@@ -0,0 +1,2 @@
+import type { TProperties, Base } from '../../type/index.mjs';
+export declare function FromBase(context: TProperties, type: Base, value: unknown): unknown;

package/build/value/default/from-base.mjs

@@ -0,0 +1,5 @@
+// deno-fmt-ignore-file
+// deno-lint-ignore-file 
+export function FromBase(context, type, value) {
+    return type.Default(value);
+}

package/build/value/default/from-cyclic.d.mts

@@ -0,0 +1,2 @@
+import { type TProperties, type TCyclic } from '../../type/index.mjs';
+export declare function FromCyclic(context: TProperties, type: TCyclic, value: unknown): unknown;

package/build/value/default/from-cyclic.mjs

@@ -0,0 +1,7 @@
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+import { Ref } from '../../type/index.mjs';
+import { FromType } from './from-type.mjs';
+export function FromCyclic(context, type, value) {
+    return FromType({ ...context, ...type.$defs }, Ref(type.$ref), value);
+}

package/build/value/default/from-default.d.mts

@@ -0,0 +1,3 @@
+import { type XDefault } from '../../schema/index.mjs';
+import type { TSchema } from '../../type/index.mjs';
+export declare function FromDefault(type: TSchema & XDefault, value: unknown): unknown;

package/build/value/default/from-default.mjs

@@ -0,0 +1,13 @@
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { Clone } from '../clone/index.mjs';
+// ------------------------------------------------------------------
+// FromDefault
+// ------------------------------------------------------------------
+export function FromDefault(type, value) {
+    // we only use defaults when values are undefined, exit early
+    if (!Guard.IsUndefined(value))
+        return value;
+    return Guard.IsFunction(type.default) ? type.default() : Clone(type.default);
+}

package/build/value/default/from-intersect.d.mts

@@ -0,0 +1,2 @@
+import { TProperties, TIntersect } from '../../type/index.mjs';
+export declare function FromIntersect(context: TProperties, type: TIntersect, value: unknown): unknown;

package/build/value/default/from-intersect.mjs

@@ -0,0 +1,8 @@
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+import { Evaluate } from '../../type/index.mjs';
+import { FromType } from './from-type.mjs';
+export function FromIntersect(context, type, value) {
+    const evaluted = Evaluate(type);
+    return FromType(context, evaluted, value);
+}

package/build/value/default/from-object.d.mts

@@ -0,0 +1,2 @@
+import type { TProperties, TObject } from '../../type/index.mjs';
+export declare function FromObject(context: TProperties, type: TObject, value: unknown): unknown;

package/build/value/default/from-object.mjs

@@ -0,0 +1,30 @@
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { FromType } from './from-type.mjs';
+import { IsAdditionalProperties } from '../../schema/types/index.mjs';
+export function FromObject(context, type, value) {
+    if (!Guard.IsObject(value))
+        return value;
+    const knownPropertyKeys = Guard.Keys(type.properties);
+    // Properties
+    for (const key of knownPropertyKeys) {
+        // note: we need to traverse into the object and test if the return value
+        // yielded a non undefined result. Here we interpret an undefined result as
+        // a non assignable property and continue.
+        const propertyValue = FromType(context, type.properties[key], value[key]);
+        if (Guard.IsUndefined(propertyValue))
+            continue;
+        value[key] = FromType(context, type.properties[key], value[key]);
+    }
+    // return if not additional properties
+    if (!IsAdditionalProperties(type))
+        return value;
+    // AdditionalProperties
+    for (const key of Guard.Keys(value)) {
+        if (knownPropertyKeys.includes(key))
+            continue;
+        value[key] = FromType(context, type.additionalProperties, value[key]);
+    }
+    return value;
+}

package/build/value/default/from-record.d.mts

@@ -0,0 +1,2 @@
+import { type TProperties, type TRecord } from '../../type/index.mjs';
+export declare function FromRecord(context: TProperties, type: TRecord, value: unknown): unknown;

package/build/value/default/from-record.mjs

@@ -0,0 +1,26 @@
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+import { RecordPattern, RecordValue } from '../../type/index.mjs';
+import { IsAdditionalProperties, IsDefault } from '../../schema/types/index.mjs';
+import { Guard } from '../../guard/index.mjs';
+import { FromType } from './from-type.mjs';
+export function FromRecord(context, type, value) {
+    if (!Guard.IsObject(value))
+        return value;
+    // PatternProperties
+    const [recordKey, recordValue] = [new RegExp(RecordPattern(type)), RecordValue(type)];
+    for (const key of Guard.Keys(value)) {
+        if (!(recordKey.test(key) && IsDefault(recordValue)))
+            continue;
+        value[key] = FromType(context, recordValue, value[key]);
+    }
+    // AdditionalProperties
+    if (!IsAdditionalProperties(type))
+        return value;
+    for (const key of Guard.Keys(value)) {
+        if (recordKey.test(key))
+            continue;
+        value[key] = FromType(context, type.additionalProperties, value[key]);
+    }
+    return value;
+}

package/build/value/default/from-ref.d.mts

@@ -0,0 +1,2 @@
+import type { TProperties, TRef } from '../../type/index.mjs';
+export declare function FromRef(context: TProperties, type: TRef, value: unknown): unknown;

package/build/value/default/from-ref.mjs

@@ -0,0 +1,9 @@
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { FromType } from './from-type.mjs';
+export function FromRef(context, type, value) {
+    return Guard.HasPropertyKey(context, type.$ref)
+        ? FromType(context, context[type.$ref], value)
+        : value;
+}

package/build/value/default/from-tuple.d.mts

@@ -0,0 +1,2 @@
+import type { TProperties, TTuple } from '../../type/index.mjs';
+export declare function FromTuple(context: TProperties, schema: TTuple, value: unknown): unknown;

package/build/value/default/from-tuple.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { FromType } from './from-type.mjs';
+export function FromTuple(context, schema, value) {
+    if (!Guard.IsArray(value))
+        return value;
+    const [items, max] = [schema.items, Math.max(schema.items.length, value.length)];
+    for (let i = 0; i < max; i++) {
+        if (i < items.length)
+            value[i] = FromType(context, items[i], value[i]);
+    }
+    return value;
+}

package/build/value/default/from-type.d.mts

@@ -0,0 +1,2 @@
+import * as T from '../../type/index.mjs';
+export declare function FromType(context: T.TProperties, type: T.TSchema, value: unknown): unknown;

package/build/value/default/from-type.mjs

@@ -0,0 +1,27 @@
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+import { IsDefault } from '../../schema/index.mjs';
+import * as T from '../../type/index.mjs';
+import { FromArray } from './from-array.mjs';
+import { FromBase } from './from-base.mjs';
+import { FromCyclic } from './from-cyclic.mjs';
+import { FromDefault } from './from-default.mjs';
+import { FromIntersect } from './from-intersect.mjs';
+import { FromObject } from './from-object.mjs';
+import { FromRecord } from './from-record.mjs';
+import { FromRef } from './from-ref.mjs';
+import { FromTuple } from './from-tuple.mjs';
+import { FromUnion } from './from-union.mjs';
+export function FromType(context, type, value) {
+    const defaulted = IsDefault(type) ? FromDefault(type, value) : value;
+    return (T.IsArray(type) ? FromArray(context, type, defaulted) :
+        T.IsBase(type) ? FromBase(context, type, defaulted) :
+            T.IsCyclic(type) ? FromCyclic(context, type, defaulted) :
+                T.IsIntersect(type) ? FromIntersect(context, type, defaulted) :
+                    T.IsObject(type) ? FromObject(context, type, defaulted) :
+                        T.IsRecord(type) ? FromRecord(context, type, defaulted) :
+                            T.IsRef(type) ? FromRef(context, type, defaulted) :
+                                T.IsTuple(type) ? FromTuple(context, type, defaulted) :
+                                    T.IsUnion(type) ? FromUnion(context, type, defaulted) :
+                                        defaulted);
+}

package/build/value/default/from-union.d.mts

@@ -0,0 +1,2 @@
+import type { TProperties, TUnion } from '../../type/index.mjs';
+export declare function FromUnion(context: TProperties, schema: TUnion, value: unknown): unknown;

package/build/value/default/from-union.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+import { Check } from '../check/index.mjs';
+import { Clone } from '../clone/index.mjs';
+import { FromType } from './from-type.mjs';
+export function FromUnion(context, schema, value) {
+    for (const inner of schema.anyOf) {
+        const result = FromType(context, inner, Clone(value));
+        if (Check(context, inner, result)) {
+            return result;
+        }
+    }
+    return value;
+}

package/build/value/default/index.d.mts

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

package/build/value/default/index.mjs

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

package/build/value/delta/diff.d.mts

@@ -0,0 +1,10 @@
+import { type TEdit } from './edit.mjs';
+/**
+ * Generates a sequence of Edit commands to transform the current value into the next value.
+ * These commands can be serialized and sent over a network to synchronize a remote
+ * value, applied with Patch, or tested with Hash. Edit commands should be treated as
+ * opaque data structures; TypeBox may enhance this functionality in the future to
+ * support full operational transformation and may change the commands. Do not apply
+ * any logic directly to the command structures.
+ */
+export declare function Diff(current: unknown, next: unknown): TEdit[];

package/build/value/delta/diff.mjs

@@ -0,0 +1,129 @@
+// deno-fmt-ignore-file
+import { Guard, GlobalsGuard } from '../../guard/index.mjs';
+import { Equal } from '../equal/index.mjs';
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+function CreateUpdate(path, value) {
+    return { type: 'update', path, value };
+}
+function CreateInsert(path, value) {
+    return { type: 'insert', path, value };
+}
+function CreateDelete(path) {
+    return { type: 'delete', path };
+}
+// ------------------------------------------------------------------
+// Assert
+// ------------------------------------------------------------------
+function AssertCanDiffObject(value) {
+    if (Guard.IsObject(value) && Guard.IsEqual(Guard.Symbols(value).length, 0))
+        return;
+    throw new Error('Cannot create diffs for objects with symbols keys');
+}
+// ------------------------------------------------------------------
+// Object
+// ------------------------------------------------------------------
+function* FromObject(path, left, right) {
+    if (!Guard.IsObject(right) || Guard.IsArray(right))
+        return yield CreateUpdate(path, right);
+    AssertCanDiffObject(left);
+    AssertCanDiffObject(right);
+    const leftKeys = Guard.Keys(left);
+    const rightKeys = Guard.Keys(right);
+    // ----------------------------------------------------------------
+    // Insert
+    // ----------------------------------------------------------------
+    for (const key of rightKeys) {
+        if (Guard.HasPropertyKey(left, key))
+            continue;
+        yield CreateInsert(`${path}/${key}`, right[key]);
+    }
+    // ----------------------------------------------------------------
+    // Update
+    // ----------------------------------------------------------------
+    for (const key of leftKeys) {
+        if (!Guard.HasPropertyKey(right, key))
+            continue;
+        if (Equal(left, right))
+            continue;
+        yield* FromValue(`${path}/${key}`, left[key], right[key]);
+    }
+    // ----------------------------------------------------------------
+    // Delete
+    // ----------------------------------------------------------------
+    for (const key of leftKeys) {
+        if (Guard.HasPropertyKey(right, key))
+            continue;
+        yield CreateDelete(`${path}/${key}`);
+    }
+}
+// ------------------------------------------------------------------
+// Array
+// ------------------------------------------------------------------
+function* FromArray(path, left, right) {
+    if (!Guard.IsArray(right))
+        return yield CreateUpdate(path, right);
+    for (let i = 0; i < Math.min(left.length, right.length); i++) {
+        yield* FromValue(`${path}/${i}`, left[i], right[i]);
+    }
+    for (let i = 0; i < right.length; i++) {
+        if (i < left.length)
+            continue;
+        yield CreateInsert(`${path}/${i}`, right[i]);
+    }
+    for (let i = left.length - 1; i >= 0; i--) {
+        if (i < right.length)
+            continue;
+        yield CreateDelete(`${path}/${i}`);
+    }
+}
+// ------------------------------------------------------------------
+// TypedArray
+// ------------------------------------------------------------------
+function* FromTypedArray(path, left, right) {
+    const typeLeft = globalThis.Object.getPrototypeOf(left).constructor.name;
+    const typeRight = globalThis.Object.getPrototypeOf(right).constructor.name;
+    const predicate = GlobalsGuard.IsTypeArray(right)
+        && Guard.IsEqual(left.length, right.length)
+        && Guard.IsEqual(typeLeft, typeRight);
+    if (predicate) {
+        for (let index = 0; index < Math.min(left.length, right.length); index++) {
+            yield* FromValue(`${path}/${index}`, left[index], right[index]);
+        }
+    }
+    else {
+        return yield CreateUpdate(path, right);
+    }
+}
+// ------------------------------------------------------------------
+// Unknown
+// ------------------------------------------------------------------
+function* FromUnknown(path, left, right) {
+    if (left === right)
+        return;
+    yield CreateUpdate(path, right);
+}
+// ------------------------------------------------------------------
+// Value
+// ------------------------------------------------------------------
+function* FromValue(path, left, right) {
+    return (GlobalsGuard.IsTypeArray(left) ? yield* FromTypedArray(path, left, right) :
+        Guard.IsArray(left) ? yield* FromArray(path, left, right) :
+            Guard.IsObject(left) ? yield* FromObject(path, left, right) :
+                yield* FromUnknown(path, left, right));
+}
+// ------------------------------------------------------------------
+// Diff
+// ------------------------------------------------------------------
+/**
+ * Generates a sequence of Edit commands to transform the current value into the next value.
+ * These commands can be serialized and sent over a network to synchronize a remote
+ * value, applied with Patch, or tested with Hash. Edit commands should be treated as
+ * opaque data structures; TypeBox may enhance this functionality in the future to
+ * support full operational transformation and may change the commands. Do not apply
+ * any logic directly to the command structures.
+ */
+export function Diff(current, next) {
+    return [...FromValue('', current, next)];
+}

package/build/value/delta/edit.d.mts

@@ -0,0 +1,24 @@
+import * as T from '../../type/index.mjs';
+export type TInsert = T.Static<typeof Insert>;
+export declare const Insert: T.TObject<{
+    type: T.TLiteral<'insert'>;
+    path: T.TString;
+    value: T.TUnknown;
+}>;
+export type TUpdate = T.Static<typeof Update>;
+export declare const Update: T.TObject<{
+    type: T.TLiteral<'update'>;
+    path: T.TString;
+    value: T.TUnknown;
+}>;
+export type TDelete = T.Static<typeof Delete>;
+export declare const Delete: T.TObject<{
+    type: T.TLiteral<'delete'>;
+    path: T.TString;
+}>;
+export type TEdit = T.Static<typeof Edit>;
+export declare const Edit: T.TUnion<[
+    typeof Insert,
+    typeof Update,
+    typeof Delete
+]>;

package/build/value/delta/edit.mjs

@@ -0,0 +1,17 @@
+// deno-fmt-ignore-file
+import * as T from '../../type/index.mjs';
+export const Insert = T.Object({
+    type: T.Literal('insert'),
+    path: T.String(),
+    value: T.Unknown(),
+});
+export const Update = Object({
+    type: T.Literal('update'),
+    path: T.String(),
+    value: T.Unknown(),
+});
+export const Delete = T.Object({
+    type: T.Literal('delete'),
+    path: T.String(),
+});
+export const Edit = T.Union([Insert, Update, Delete]);

package/build/value/delta/index.d.mts

@@ -0,0 +1,3 @@
+export * from './diff.mjs';
+export * from './edit.mjs';
+export * from './patch.mjs';

package/build/value/delta/index.mjs

@@ -0,0 +1,3 @@
+export * from './diff.mjs';
+export * from './edit.mjs';
+export * from './patch.mjs';

package/build/value/delta/patch.d.mts

@@ -0,0 +1,8 @@
+import { type TEdit } from './edit.mjs';
+/**
+ * Applies a sequence of Edit commands to a current value, producing a new value that incorporates
+ * all edits. This function returns unknown so callers should Check the return value before use.
+ * This function mutates the provided value. If mutation is not wanted, you should Clone the value
+ * before passing to this function.
+ */
+export declare function Patch(current: unknown, edits: TEdit[]): unknown;

package/build/value/delta/patch.mjs

@@ -0,0 +1,42 @@
+// deno-fmt-ignore-file
+import { Clone } from '../clone/index.mjs';
+import { Pointer } from '../pointer/index.mjs';
+function IsRoot(edits) {
+    return edits.length > 0 && edits[0].path === '' && edits[0].type === 'update';
+}
+function IsEmpty(edits) {
+    return edits.length === 0;
+}
+// ------------------------------------------------------------------
+// Patch
+// ------------------------------------------------------------------
+/**
+ * Applies a sequence of Edit commands to a current value, producing a new value that incorporates
+ * all edits. This function returns unknown so callers should Check the return value before use.
+ * This function mutates the provided value. If mutation is not wanted, you should Clone the value
+ * before passing to this function.
+ */
+export function Patch(current, edits) {
+    if (IsRoot(edits))
+        return Clone(edits[0].value);
+    if (IsEmpty(edits))
+        return Clone(current);
+    const clone = Clone(current);
+    for (const edit of edits) {
+        switch (edit.type) {
+            case 'insert': {
+                Pointer.Set(clone, edit.path, edit.value);
+                break;
+            }
+            case 'update': {
+                Pointer.Set(clone, edit.path, edit.value);
+                break;
+            }
+            case 'delete': {
+                Pointer.Delete(clone, edit.path);
+                break;
+            }
+        }
+    }
+    return clone;
+}

package/build/value/equal/equal.d.mts

@@ -0,0 +1,2 @@
+/** Returns true if left and right values are structurally equal */
+export declare function Equal(left: unknown, right: unknown): boolean;