@dabble/patches 0.2.10 → 0.2.11

package/dist/json-patch/patchProxy.d.ts

@@ -0,0 +1,41 @@
+import { JSONPatch } from './JSONPatch';
+/**
+ * Creates a proxy object that can be used in two ways:
+ *
+ * 1.  **Path Generation:** When used without a `JSONPatch` instance, accessing properties
+ *     on the proxy generates a JSON Pointer path string via `toString()`. This allows
+ *     for type-safe path creation when using `JSONPatch` methods directly.
+ *     ```ts
+ *     const patch = new JSONPatch();
+ *     const proxy = createPatchProxy<MyType>();
+ *     patch.text(proxy.content, new Delta().insert('text')); // Path is '/content'
+ *     patch.increment(proxy.counter, 5);                     // Path is '/counter'
+ *     ```
+ *
+ * 2.  **Automatic Patch Generation:** When created with a target object and a `JSONPatch`
+ *     instance, modifying the proxy (setting properties, calling array methods like
+ *     `push`, `splice`, etc.) automatically generates the corresponding JSON Patch
+ *     operations and adds them to the provided `patch` instance.
+ *     ```ts
+ *     const patch = new JSONPatch();
+ *     const myObj = { name: { first: 'Alice' }, tags: ['a'] };
+ *     const proxy = createPatchProxy(myObj, patch);
+ *     proxy.name.first = 'Bob';  // Generates replace op
+ *     proxy.tags.push('b');      // Generates add op
+ *     ```
+ *
+ * The proxy behaves like the original value in most contexts due to the `valueOf` trap.
+ * For optional properties, use the non-null assertion operator (!) when setting values:
+ * ```ts
+ * interface User { middleName?: string }
+ * const proxy = createPatchProxy<User>(user, patch);
+ * proxy.middleName! = 'John';  // Assert middleName exists before setting
+ * ```
+ *
+ * @template T The type of the object to proxy.
+ * @param target The target object (required for automatic patch generation mode).
+ * @param patch The `JSONPatch` instance to add generated operations to (required for automatic patch generation mode).
+ * @returns A proxy object of type T.
+ */
+export declare function createPatchProxy<T>(): T;
+export declare function createPatchProxy<T>(target: T, patch: JSONPatch): T;

package/dist/json-patch/patchProxy.js

@@ -0,0 +1,125 @@
+// We use a function as the target so that `push` and other array methods can be called without error.
+const proxyFodder = {};
+export function createPatchProxy(target, patch) {
+    // Call the internal implementation
+    return createPatchProxyInternal(target, patch);
+}
+// Internal implementation with the path parameter
+function createPatchProxyInternal(target, patch, path = '') {
+    // Always use an empty function as the proxy target
+    // This allows us to proxy any type of value, including primitives and undefined,
+    // and enables calling array methods like push/splice directly on array proxies.
+    return new Proxy(proxyFodder, {
+        get(_, prop) {
+            // Return the value directly for symbol properties (not relevant for JSON paths)
+            if (typeof prop === 'symbol') {
+                return target?.[prop];
+            }
+            // Handle toString specially to make properties work as PathLike
+            if (prop === 'toString') {
+                return function () {
+                    return path;
+                };
+            }
+            // Handle valueOf to make the proxy behave like the original value in most contexts
+            if (prop === 'valueOf') {
+                return function () {
+                    return target;
+                };
+            }
+            // --- Array Method Interception ---
+            if (Array.isArray(target)) {
+                switch (prop) {
+                    case 'push':
+                        return (...items) => {
+                            const index = target.length;
+                            for (let i = 0; i < items.length; i++) {
+                                patch?.add(`${path}/${index + i}`, items[i]);
+                            }
+                        };
+                    case 'pop':
+                        return () => {
+                            const index = target.length - 1;
+                            if (index >= 0) {
+                                patch?.remove(`${path}/${index}`);
+                            }
+                        };
+                    case 'shift':
+                        return () => {
+                            if (target.length > 0) {
+                                patch?.remove(`${path}/0`);
+                            }
+                        };
+                    case 'unshift':
+                        return (...items) => {
+                            for (let i = 0; i < items.length; i++) {
+                                patch?.add(`${path}/${i}`, items[i]);
+                            }
+                        };
+                    case 'splice':
+                        return (start, deleteCount, ...items) => {
+                            const actualStart = start < 0 ? Math.max(target.length + start, 0) : Math.min(start, target.length);
+                            const actualDeleteCount = Math.min(Math.max(deleteCount === undefined ? target.length - actualStart : deleteCount, 0), target.length - actualStart);
+                            // Remove deleted elements
+                            for (let i = 0; i < actualDeleteCount; i++) {
+                                patch?.remove(`${path}/${actualStart}`); // Path automatically adjusts for subsequent removes
+                            }
+                            // Add new elements
+                            for (let i = 0; i < items.length; i++) {
+                                patch?.add(`${path}/${actualStart + i}`, items[i]);
+                            }
+                        };
+                }
+            }
+            // --- End Array Method Interception ---
+            // Create a proxy for the property value if it's not an intercepted array method
+            // This handles objects, primitives, and undefined values uniformly
+            // Call the internal implementation recursively
+            return createPatchProxyInternal(target?.[prop], patch, `${path}/${String(prop)}`);
+        },
+        set(_, prop, value) {
+            // Ignore setting the 'length' property on arrays directly
+            if (Array.isArray(target) && prop === 'length') {
+                return true;
+            }
+            if (target?.[prop] === value)
+                return true;
+            const patchPath = `${path}/${String(prop)}`;
+            if (value === undefined) {
+                patch?.remove(patchPath);
+            }
+            else {
+                patch?.replace(patchPath, value);
+            }
+            return true;
+        },
+        deleteProperty(_, prop) {
+            if (target == null || prop in target) {
+                patch?.remove(`${path}/${String(prop)}`);
+            }
+            return true;
+        },
+        // Make the proxy appear to be the same type as the target
+        getPrototypeOf() {
+            return Object.getPrototypeOf(target);
+        },
+        // Support instanceof checks
+        isExtensible() {
+            return target != null && Object.isExtensible(target);
+        },
+        // Support Object.keys and other enumeration methods
+        ownKeys() {
+            return target != null && typeof target === 'object' ? Reflect.ownKeys(target) : [];
+        },
+        // Support property descriptor access
+        getOwnPropertyDescriptor(_, prop) {
+            if (target == null || typeof target !== 'object')
+                return undefined;
+            return Object.getOwnPropertyDescriptor(target, prop);
+        },
+        // Support Object.hasOwnProperty
+        has(_, prop) {
+            return target != null && typeof target === 'object' && prop in target;
+        },
+    });
+}

package/dist/json-patch/state.d.ts

@@ -0,0 +1,2 @@
+import type { JSONPatchOpHandlerMap, Runner } from './types.js';
+export declare function runWithObject(object: any, allTypes: JSONPatchOpHandlerMap, shouldCache: boolean, callback: Runner): any;

package/dist/json-patch/state.js

@@ -0,0 +1,8 @@
+export function runWithObject(object, allTypes, shouldCache, callback) {
+    const state = {
+        root: { '': object },
+        types: allTypes,
+        cache: shouldCache ? new Set() : null,
+    };
+    return callback(state) || state.root[''];
+}

package/dist/json-patch/transformPatch.d.ts

@@ -0,0 +1,19 @@
+/*!
+ * Based on work from
+ * https://github.com/Palindrom/JSONPatchOT
+ * (c) 2017 Tomek Wytrebowicz
+ *
+ * MIT license
+ * (c) 2022 Jacob Wright
+ *
+ *
+ * WARNING: using /array/- syntax to indicate the end of the array makes it impossible to transform arrays correctly in
+ * all situaions. Please avoid using this syntax when using Operational Transformations.
+ */
+import type { JSONPatchOp, JSONPatchOpHandlerMap } from './types.js';
+/**
+ * Transform an array of JSON Patch operations against another array of JSON Patch operations. Returns a new array with
+ * transformed operations. Operations that change are cloned, making the results of this function immutable.
+ * `otherOps` are transformed over `thisOps` with thisOps considered to have happened first.
+ */
+export declare function transformPatch(obj: any, thisOps: JSONPatchOp[], otherOps: JSONPatchOp[], custom?: JSONPatchOpHandlerMap): JSONPatchOp[];

package/dist/json-patch/transformPatch.js

@@ -0,0 +1,37 @@
+/*!
+ * Based on work from
+ * https://github.com/Palindrom/JSONPatchOT
+ * (c) 2017 Tomek Wytrebowicz
+ *
+ * MIT license
+ * (c) 2022 Jacob Wright
+ *
+ *
+ * WARNING: using /array/- syntax to indicate the end of the array makes it impossible to transform arrays correctly in
+ * all situaions. Please avoid using this syntax when using Operational Transformations.
+ */
+import { getTypes } from './ops/index.js';
+import { runWithObject } from './state.js';
+import { getType } from './utils/getType.js';
+import { log } from './utils/log.js';
+/**
+ * Transform an array of JSON Patch operations against another array of JSON Patch operations. Returns a new array with
+ * transformed operations. Operations that change are cloned, making the results of this function immutable.
+ * `otherOps` are transformed over `thisOps` with thisOps considered to have happened first.
+ */
+export function transformPatch(obj, thisOps, otherOps, custom) {
+    const types = getTypes(custom);
+    return runWithObject(obj, types, false, state => {
+        return thisOps.reduce((otherOps, thisOp) => {
+            // transform ops with patch operation
+            const handler = getType(state, thisOp)?.transform;
+            if (typeof handler === 'function') {
+                otherOps = handler(state, thisOp, otherOps);
+            }
+            else {
+                log('No function to transform against for', thisOp.op);
+            }
+            return otherOps;
+        }, otherOps);
+    });
+}

package/dist/json-patch/types.d.ts

@@ -0,0 +1,52 @@
+export interface JSONPatchOpHandler {
+    like: 'add' | 'remove' | 'replace' | 'move' | 'copy' | 'test';
+    apply(state: State, path: string, valueOrFrom: any): string | void;
+    transform(state: State, other: JSONPatchOp, ops: JSONPatchOp[]): JSONPatchOp[];
+    invert(state: State, op: JSONPatchOp, value: any, changedObj: any, isIndex: boolean): JSONPatchOp;
+    compose?(state: State, value1: any, value2: any): any;
+}
+export interface JSONPatchOpHandlerMap {
+    [key: string]: JSONPatchOpHandler;
+}
+export interface ApplyJSONPatchOptions {
+    /**
+     * Do not reject patches if error occurs (partial patching)
+     */
+    partial?: boolean;
+    /**
+     * Throw an exception if an error occurs when patching
+     */
+    strict?: boolean;
+    /**
+     * Stop on error and return the original object (without throwing an exception)
+     */
+    rigid?: boolean;
+    /**
+     * Don't log errors when they occurs during patching, if strict is not true, errors will be logged if this is false
+     */
+    silent?: boolean;
+    /**
+     * Saves the patch that caused the error to this property of the options object
+     */
+    error?: JSONPatchOp;
+    /**
+     * Apply changes at a given path prefix
+     */
+    atPath?: string;
+}
+export interface JSONPatchOp {
+    op: string;
+    path: string;
+    from?: string;
+    value?: any;
+    soft?: boolean;
+}
+export interface Root {
+    '': any;
+}
+export type State = {
+    root: Root;
+    types: JSONPatchOpHandlerMap;
+    cache: Set<any> | null;
+};
+export type Runner = (state: State) => any;

package/dist/json-patch/types.js

@@ -0,0 +1 @@
+export {};

package/dist/json-patch/utils/deepEqual.d.ts

@@ -0,0 +1 @@
+export declare function deepEqual(a: any, b: any): boolean;

package/dist/json-patch/utils/deepEqual.js

@@ -0,0 +1,33 @@
+export function deepEqual(a, b) {
+    if (a === b) {
+        return true;
+    }
+    if (!(a && b) || typeof a !== 'object' || typeof b !== 'object') {
+        return false;
+    }
+    if (a.length !== b.length) {
+        return false;
+    }
+    if (Array.isArray(a)) {
+        if (!Array.isArray(b)) {
+            return false;
+        }
+        for (let i = 0, imax = a.length; i < imax; i++) {
+            if (!deepEqual(a[i], b[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    const aKeys = Object.keys(a);
+    if (aKeys.length !== Object.keys(b).length) {
+        return false;
+    }
+    for (let j = 0, jmax = aKeys.length; j < jmax; j++) {
+        const key = aKeys[j];
+        if (!deepEqual(a[key], b[key])) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/json-patch/utils/exit.d.ts

@@ -0,0 +1,2 @@
+import type { ApplyJSONPatchOptions, JSONPatchOp, State } from '../types.js';
+export declare function exit(state: State, object: any, patch: JSONPatchOp, opts: ApplyJSONPatchOptions): any;

package/dist/json-patch/utils/exit.js

@@ -0,0 +1,4 @@
+export function exit(state, object, patch, opts) {
+    opts.error = patch;
+    return opts.partial && state.root ? state.root[''] : object;
+}

package/dist/json-patch/utils/get.d.ts

@@ -0,0 +1,2 @@
+import type { State } from '../types.js';
+export declare function get(state: State, path: string): any;

package/dist/json-patch/utils/get.js

@@ -0,0 +1,6 @@
+import { getOpData } from './getOpData.js';
+export function get(state, path) {
+    // eslint-disable-next-line no-unused-vars
+    const [keys, lastKey, target] = getOpData(state, path);
+    return target ? target[lastKey] : undefined;
+}

package/dist/json-patch/utils/getOpData.d.ts

@@ -0,0 +1,2 @@
+import type { State } from '../types.js';
+export declare function getOpData(state: State, path: string, createMissingObjects?: boolean): any[];

package/dist/json-patch/utils/getOpData.js

@@ -0,0 +1,10 @@
+import { EMPTY, pluck } from './pluck.js';
+import { toKeys } from './toKeys.js';
+export function getOpData(state, path, createMissingObjects) {
+    const keys = toKeys(path);
+    const lastKey = keys[keys.length - 1];
+    let target = pluck(state, keys);
+    if (createMissingObjects)
+        target = target || EMPTY;
+    return [keys, lastKey, target];
+}

package/dist/json-patch/utils/getType.d.ts

@@ -0,0 +1,3 @@
+import type { JSONPatchOp, State } from '../types.js';
+export declare function getType(state: State, patch: JSONPatchOp): import("../types.js").JSONPatchOpHandler;
+export declare function getTypeLike(state: State, patch: JSONPatchOp): "replace" | "add" | "remove" | "move" | "copy" | "test";

package/dist/json-patch/utils/getType.js

@@ -0,0 +1,6 @@
+export function getType(state, patch) {
+    return state.types?.[patch.op];
+}
+export function getTypeLike(state, patch) {
+    return state.types?.[patch.op]?.like;
+}

package/dist/json-patch/utils/index.d.ts

@@ -0,0 +1,14 @@
+export * from './deepEqual.js';
+export * from './get.js';
+export * from './getOpData.js';
+export * from './getType.js';
+export * from './log.js';
+export * from './ops.js';
+export * from './paths.js';
+export * from './pluck.js';
+export * from './shallowCopy.js';
+export * from './softWrites.js';
+export * from './toArrayIndex.js';
+export * from './toKeys.js';
+export * from './updateArrayIndexes.js';
+export * from './updateArrayPath.js';

package/dist/json-patch/utils/index.js

@@ -0,0 +1,14 @@
+export * from './deepEqual.js';
+export * from './get.js';
+export * from './getOpData.js';
+export * from './getType.js';
+export * from './log.js';
+export * from './ops.js';
+export * from './paths.js';
+export * from './pluck.js';
+export * from './shallowCopy.js';
+export * from './softWrites.js';
+export * from './toArrayIndex.js';
+export * from './toKeys.js';
+export * from './updateArrayIndexes.js';
+export * from './updateArrayPath.js';

package/dist/json-patch/utils/log.d.ts

@@ -0,0 +1,2 @@
+export declare function verbose(value: boolean): void;
+export declare function log(...rest: any[]): void;

package/dist/json-patch/utils/log.js

@@ -0,0 +1,7 @@
+let displayLogs = false;
+export function verbose(value) {
+    displayLogs = value;
+}
+export function log(...rest) {
+    displayLogs && console.log(...rest);
+}

package/dist/json-patch/utils/ops.d.ts

@@ -0,0 +1,14 @@
+import type { JSONPatchOp, State } from '../types.js';
+/**
+ * Check whether this operation is an add operation of some sort (add, copy, move).
+ */
+export declare function isAdd(state: State, op: JSONPatchOp, pathName: 'from' | 'path'): boolean;
+/**
+ * Transforms an array of ops, returning the original if there is no change, filtering out ops that are dropped.
+ */
+export declare function mapAndFilterOps(ops: JSONPatchOp[], iterator: (op: JSONPatchOp, index: number, breakAfter: (keepRest?: boolean) => {}) => JSONPatchOp | JSONPatchOp[] | null): JSONPatchOp[];
+/**
+ * Remove operations that apply to a value which was removed.
+ */
+export declare function updateRemovedOps(state: State, thisPath: string, otherOps: JSONPatchOp[], isRemove?: boolean, updatableObject?: boolean, opOp?: string, customHandler?: (op: JSONPatchOp) => any): JSONPatchOp[];
+export declare function transformRemove(state: State, thisPath: string, otherOps: JSONPatchOp[], isRemove?: boolean): JSONPatchOp[];

package/dist/json-patch/utils/ops.js

@@ -0,0 +1,103 @@
+import { getTypeLike } from './getType.js';
+import { log } from './log.js';
+import { isArrayPath } from './paths.js';
+import { updateArrayIndexes } from './updateArrayIndexes.js';
+/**
+ * Check whether this operation is an add operation of some sort (add, copy, move).
+ */
+export function isAdd(state, op, pathName) {
+    const like = getTypeLike(state, op);
+    return (like === 'add' || like === 'copy' || like === 'move') && pathName === 'path';
+}
+/**
+ * Transforms an array of ops, returning the original if there is no change, filtering out ops that are dropped.
+ */
+export function mapAndFilterOps(ops, iterator) {
+    let changed = false;
+    const mapped = [];
+    let shouldBreak = false;
+    let keepRest;
+    const breakAfter = (keep) => (shouldBreak = true) && (keepRest = keep);
+    for (let i = 0; i < ops.length; i++) {
+        const original = ops[i];
+        // If an op was copied or moved to the same path, it is a no-op and should be removed
+        if (original.from === original.path) {
+            if (!changed)
+                changed = true;
+            continue;
+        }
+        let value = iterator(original, i, breakAfter);
+        if (value && !Array.isArray(value) && value.from === value.path)
+            value = null;
+        if (!changed && value !== original)
+            changed = true;
+        if (Array.isArray(value))
+            mapped.push(...value);
+        else if (value)
+            mapped.push(value);
+        if (shouldBreak) {
+            if (keepRest)
+                mapped.push(...ops.slice(i + 1));
+            break;
+        }
+    }
+    return changed ? mapped : ops;
+}
+/**
+ * Remove operations that apply to a value which was removed.
+ */
+export function updateRemovedOps(state, thisPath, otherOps, isRemove = false, updatableObject = false, opOp, customHandler) {
+    const softPrefixes = new Set();
+    return mapAndFilterOps(otherOps, (op, index, breakAfter) => {
+        const opLike = getTypeLike(state, op);
+        const canMergeCustom = customHandler && opOp === op.op;
+        if (thisPath === op.path && opLike !== 'remove' && !canMergeCustom && !op.soft) {
+            // Once an operation sets this value again, we can assume the following ops were working on that and not the
+            // old value so they can be kept
+            if (op.op !== 'test') {
+                breakAfter(true); // stop and keep the remaining ops as-is
+            }
+            return op;
+        }
+        const { path, from } = op;
+        if (path === thisPath && canMergeCustom) {
+            const customOp = customHandler(op);
+            if (customOp)
+                return customOp;
+        }
+        if (isRemove && !updatableObject && from === thisPath) {
+            // Because of the check above, moves and copies will only hit here when the "from" field matches
+            if (opLike === 'move') {
+                // We need the rest of the otherOps to be adjusted against this "move"
+                breakAfter();
+                return transformRemove(state, op.path, otherOps.slice(index + 1));
+            }
+            else if (opLike === 'copy') {
+                // We need future ops on the copied object to be removed
+                breakAfter();
+                let rest = transformRemove(state, thisPath, otherOps.slice(index + 1));
+                rest = transformRemove(state, op.path, rest);
+                return rest;
+            }
+        }
+        if (op.soft && path === thisPath) {
+            softPrefixes.add(path);
+            return null;
+        }
+        const samePath = (!updatableObject && path === thisPath) || (!softPrefixes.has(thisPath) && path.startsWith(`${thisPath}/`));
+        const sameFrom = (!updatableObject && from === thisPath) || (!softPrefixes.has(thisPath) && from?.startsWith(`${thisPath}/`));
+        if (samePath || sameFrom) {
+            log('Removing', op);
+            return null;
+        }
+        return op;
+    });
+}
+export function transformRemove(state, thisPath, otherOps, isRemove) {
+    if (isArrayPath(thisPath, state)) {
+        return updateArrayIndexes(state, thisPath, otherOps, -1, isRemove);
+    }
+    else {
+        return updateRemovedOps(state, thisPath, otherOps, isRemove);
+    }
+}

package/dist/json-patch/utils/paths.d.ts

@@ -0,0 +1,9 @@
+import type { State } from '../types.js';
+export declare function getPrefix(path: string): string;
+export declare function getProp(path: string): string;
+export declare function getPrefixAndProp(path: string): [string, string];
+export declare function getPropAfter(path: string, index: number): string;
+export declare function isArrayPath(path: string, state?: State): boolean;
+export declare function getArrayPrefixAndIndex(state: State, path: string, pathLength?: number): [string, number];
+export declare function getArrayIndex(state: State, path: string, pathLength?: number): number;
+export declare function getIndexAndEnd(state: State, path: string | undefined, maxLength: number): number[];

package/dist/json-patch/utils/paths.js

@@ -0,0 +1,53 @@
+import { getOpData } from './getOpData.js';
+const arrayPathExp = /\/(0|[1-9]\d*)$/;
+const EMPTY = [];
+export function getPrefix(path) {
+    const lastSlash = path.lastIndexOf('/');
+    return path.slice(0, lastSlash + 1);
+}
+export function getProp(path) {
+    const lastSlash = path.lastIndexOf('/');
+    return path.slice(lastSlash + 1);
+}
+export function getPrefixAndProp(path) {
+    const prefix = getPrefix(path);
+    return [prefix, path.slice(prefix.length)];
+}
+export function getPropAfter(path, index) {
+    const lastSlash = path.indexOf('/', index);
+    return path.slice(index, lastSlash === -1 ? undefined : lastSlash);
+}
+export function isArrayPath(path, state) {
+    if (!arrayPathExp.test(path))
+        return false;
+    if (!state || !state.root || !state.root[''])
+        return true;
+    // Double-check if this is an array or not
+    const [_, __, target] = getOpData(state, path);
+    return Array.isArray(target) || target == null;
+}
+export function getArrayPrefixAndIndex(state, path, pathLength) {
+    if (pathLength)
+        path = path.slice(0, path.indexOf('/', pathLength));
+    if (!arrayPathExp.test(path))
+        return EMPTY;
+    const [_, __, target] = getOpData(state, path);
+    if (!Array.isArray(target))
+        return EMPTY;
+    const [prefix, indexStr] = getPrefixAndProp(path);
+    const index = parseInt(indexStr);
+    return [prefix, index];
+}
+export function getArrayIndex(state, path, pathLength) {
+    return getArrayPrefixAndIndex(state, path, pathLength)[1];
+}
+export function getIndexAndEnd(state, path, maxLength) {
+    if (!path)
+        return [];
+    const prop = getPropAfter(path, maxLength);
+    const end = maxLength + prop.length;
+    if (!isArrayPath(path.slice(0, end), state))
+        return [];
+    const index = parseInt(prop);
+    return [index, end];
+}

package/dist/json-patch/utils/pluck.d.ts

@@ -0,0 +1,5 @@
+import type { State } from '../types.js';
+export declare const EMPTY: {};
+export declare function pluck(state: State, keys: string[]): any;
+export declare function pluckWithShallowCopy(state: State, keys: string[], createMissingObjects?: boolean): any;
+export declare function getValue(state: State, value: any, addKey?: string, addValue?: any): any;

package/dist/json-patch/utils/pluck.js

@@ -0,0 +1,30 @@
+import { shallowCopy } from './shallowCopy.js';
+export const EMPTY = {};
+export function pluck(state, keys) {
+    let object = state.root;
+    for (let i = 0, imax = keys.length - 1; i < imax; i++) {
+        const key = keys[i];
+        if (!object[key]) {
+            return null;
+        }
+        object = object[key];
+    }
+    return object;
+}
+export function pluckWithShallowCopy(state, keys, createMissingObjects) {
+    let object = state.root;
+    for (let i = 0, imax = keys.length - 1; i < imax; i++) {
+        const key = keys[i];
+        object = object[key] = createMissingObjects && !object[key] ? getValue(state, EMPTY) : getValue(state, object[key]);
+    }
+    return object;
+}
+export function getValue(state, value, addKey, addValue) {
+    if (!state.cache?.has(value)) {
+        value = shallowCopy(value);
+        state.cache?.add(value);
+    }
+    if (addKey)
+        value[addKey] = addValue;
+    return value;
+}

package/dist/json-patch/utils/shallowCopy.d.ts

@@ -0,0 +1 @@
+export declare function shallowCopy(obj: any): any;