@dabble/patches 0.1.1

package/dist/json-patch/JSONPatch.js

@@ -0,0 +1,221 @@
+/*!
+ * Based on work from
+ * https://github.com/mohayonao/json-touch-patch
+ * (c) 2018 mohayonao
+ *
+ * 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 { Delta } from '@dabble/delta';
+import { applyPatch } from './applyPatch.js';
+import { composePatch } from './composePatch.js';
+import { invertPatch } from './invertPatch.js';
+import { bitmask } from './ops/bitmask.js';
+import { transformPatch } from './transformPatch.js';
+/**
+ * A JSONPatch helps with creating and applying one or more "JSON patches". It can track one or more changes
+ * together which may form a single operation or transaction.
+ */
+export class JSONPatch {
+    /**
+     * Create a new JSONPatch, optionally with an existing array of operations.
+     */
+    constructor(ops = [], custom = {}) {
+        this.ops = ops;
+        this.custom = custom;
+    }
+    op(op, path, value, from, soft) {
+        path = checkPath(path);
+        if (from !== undefined) {
+            from = checkPath(from);
+        }
+        const patchOp = (from ? { op, from, path } : { op, path });
+        if (value !== undefined)
+            patchOp.value = value;
+        if (soft)
+            patchOp.soft = soft;
+        this.ops.push(patchOp);
+        return this;
+    }
+    /**
+     * Tests a value exists. If it doesn't, the patch is not applied.
+     */
+    test(path, value) {
+        return this.op('test', path, value);
+    }
+    /**
+     * Adds the value to an object or array, inserted before the given index.
+     */
+    add(path, value, options) {
+        if (value && value.toJSON)
+            value = value.toJSON();
+        return this.op('add', path, value, undefined, options?.soft);
+    }
+    /**
+     * Deletes the value at the given path or removes it from an array.
+     */
+    remove(path) {
+        return this.op('remove', path);
+    }
+    /**
+     * Replaces a value (same as remove+add).
+     */
+    replace(path, value, options) {
+        if (value && value.toJSON)
+            value = value.toJSON();
+        return this.op('replace', path, value, undefined, options?.soft);
+    }
+    /**
+     * Copies the value at `from` to `path`.
+     */
+    copy(from, to, options) {
+        return this.op('copy', to, undefined, from, options?.soft);
+    }
+    /**
+     * Moves the value at `from` to `path`.
+     */
+    move(from, to) {
+        if (from === to)
+            return this;
+        return this.op('move', to, undefined, from);
+    }
+    /**
+     * Increments a numeric value by 1 or the given amount.
+     */
+    increment(path, value = 1) {
+        return this.op('@inc', path, value);
+    }
+    /**
+     * Decrements a numeric value by 1 or the given amount.
+     */
+    decrement(path, value = 1) {
+        return this.op('@inc', path, -value);
+    }
+    /**
+     * Flips a bit at the given index in a bitmask to the given value.
+     */
+    bit(path, index, on) {
+        return this.op('@bit', path, bitmask(index, on));
+    }
+    /**
+     * Applies a delta to a text document.
+     */
+    text(path, value) {
+        if (Array.isArray(value)) {
+            value = new Delta(value);
+        }
+        else if (!(value instanceof Delta) && Array.isArray(value?.ops)) {
+            value = new Delta(value.ops);
+        }
+        else if (!(value instanceof Delta)) {
+            throw new Error('Invalid Delta');
+        }
+        return this.op('@txt', path, value);
+    }
+    /**
+     * Creates a patch from an object partial, updating each field. Set a field to undefined to delete it.
+     */
+    addUpdates(updates, path = '/') {
+        if (path[path.length - 1] !== '/')
+            path += '/';
+        Object.keys(updates).forEach(key => {
+            const value = updates[key];
+            if (value == undefined) {
+                this.remove(path + key);
+            }
+            else {
+                this.replace(path + key, value);
+            }
+        });
+        return this;
+    }
+    /**
+     * This will ensure an "add empty object" operation is created for each property along the path that does not exist.
+     */
+    addObjectsInPath(obj, path) {
+        path = checkPath(path);
+        const parts = path.split('/');
+        for (var i = 1; i < parts.length - 1; i++) {
+            const prop = parts[i];
+            if (!obj || !obj[prop]) {
+                this.add(parts.slice(0, i + 1).join('/'), {});
+            }
+            obj = obj && obj[prop];
+        }
+        return this;
+    }
+    /**
+     * Apply this patch to an object, returning a new object with the applied changes (or the same object if nothing
+     * changed in the patch). Optionally apply the page at the given path prefix.
+     */
+    apply(obj, options) {
+        return applyPatch(obj, this.ops, options, this.custom);
+    }
+    /**
+     * Transform the given patch against this one. This patch is considered to have happened first. Optionally provide
+     * the object these operations are being applied to if available to know for sure if a numerical path is an array
+     * index or object key. Otherwise, all numerical paths are treated as array indexes.
+     */
+    transform(patch, obj) {
+        const JSONPatch = this.constructor;
+        return new JSONPatch(transformPatch(obj, this.ops, Array.isArray(patch) ? patch : patch.ops, this.custom), this.custom);
+    }
+    /**
+     * Create a patch which can reverse what this patch does. Because JSON Patches do not store previous values, you
+     * must provide the previous object to create a reverse patch.
+     */
+    invert(obj) {
+        const JSONPatch = this.constructor;
+        return new JSONPatch(invertPatch(obj, this.ops, this.custom), this.custom);
+    }
+    /**
+     * Compose/collapse patches into fewer operations.
+     */
+    compose(patch) {
+        const JSONPatch = this.constructor;
+        let ops = this.ops;
+        if (patch)
+            ops = ops.concat(Array.isArray(patch) ? patch : patch.ops);
+        return new JSONPatch(composePatch(ops), this.custom);
+    }
+    /**
+     * Add two patches together.
+     */
+    concat(patch) {
+        const JSONPatch = this.constructor;
+        return new JSONPatch(this.ops.concat(Array.isArray(patch) ? patch : patch.ops), this.custom);
+    }
+    /**
+     * Returns an array of patch operations.
+     */
+    toJSON() {
+        return this.ops.slice();
+    }
+    /**
+     * Create a new JSONPatch with the provided JSON patch operations.
+     */
+    static fromJSON(ops, types) {
+        return new this(ops, types);
+    }
+}
+function checkPath(path) {
+    path = path.toString();
+    if (path.length && path[0] !== '/')
+        path = `/${path}`;
+    return path;
+}
+export function createJSONPath() {
+    const handler = {
+        get(target, prop) {
+            if (prop === 'toString') {
+                return () => target.path ?? '';
+            }
+            return new Proxy({ path: `${target.path}/${prop}` }, handler);
+        },
+    };
+    return new Proxy({ path: '' }, handler);
+}

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

@@ -0,0 +1,11 @@
+import type { ApplyJSONPatchOptions, JSONPatchOp, JSONPatchOpHandlerMap } from './types.js';
+/**
+ * Applies a sequence of JSON patch operations to an object.
+ *
+ * @param object - The object to apply the patches to
+ * @param patches - The JSON patch operations to apply
+ * @param opts - Options for applying the patch
+ * @param custom - Custom patch operation handlers
+ * @returns The object after applying the patches
+ */
+export declare function applyPatch(object: any, patches: JSONPatchOp[], opts?: ApplyJSONPatchOptions, custom?: JSONPatchOpHandlerMap): any;

package/dist/json-patch/applyPatch.js

@@ -0,0 +1,37 @@
+import { getTypes } from './ops/index.js';
+import { runWithObject } from './state.js';
+import { exit } from './utils/exit.js';
+import { getType } from './utils/getType.js';
+/**
+ * Applies a sequence of JSON patch operations to an object.
+ *
+ * @param object - The object to apply the patches to
+ * @param patches - The JSON patch operations to apply
+ * @param opts - Options for applying the patch
+ * @param custom - Custom patch operation handlers
+ * @returns The object after applying the patches
+ */
+export function applyPatch(object, patches, opts = {}, custom) {
+    if (patches.length === 0) {
+        return object;
+    }
+    if (opts.atPath) {
+        patches = patches.map(op => ({ ...op, path: opts.atPath + op.path }));
+    }
+    const types = getTypes(custom);
+    return runWithObject(object, types, patches.length > 1, state => {
+        for (let i = 0, imax = patches.length; i < imax; i++) {
+            const patch = patches[i];
+            const handler = getType(state, patch)?.apply;
+            const error = handler ? handler(state, '' + patch.path, patch.from || patch.value) : `[op:${patch.op}] unknown`;
+            if (error) {
+                if ((!opts.silent && !opts.strict) || opts.silent === false)
+                    console.error(error, patch);
+                if (opts.strict)
+                    throw new TypeError(error);
+                if (opts.rigid)
+                    return exit(state, object, patch, opts);
+            }
+        }
+    });
+}

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

@@ -0,0 +1,2 @@
+import type { JSONPatchOp, JSONPatchOpHandlerMap } from './types.js';
+export declare function composePatch(patches: JSONPatchOp[], custom?: JSONPatchOpHandlerMap): JSONPatchOp[];

package/dist/json-patch/composePatch.js

@@ -0,0 +1,38 @@
+import { getTypes } from './ops/index.js';
+import { runWithObject } from './state.js';
+import { getType } from './utils/getType.js';
+import { mapAndFilterOps } from './utils/ops.js';
+import { getValue } from './utils/pluck.js';
+export function composePatch(patches, custom = {}) {
+    const types = getTypes(custom);
+    const opsByPath = new Map();
+    // Only composing ops next to each other on the same path. It becomes too complex to do more because of moves and arrays
+    return runWithObject(null, types, patches.length > 1, state => {
+        return mapAndFilterOps(patches, op => {
+            const type = getType(state, op);
+            const handler = type?.compose;
+            if (handler) {
+                const lastOp = opsByPath.get(op.path);
+                if (lastOp && match(lastOp, op)) {
+                    lastOp.value = handler(state, lastOp.value, op.value);
+                    return null;
+                }
+                else {
+                    const prefix = `${op.path}/`;
+                    for (const path of opsByPath.keys()) {
+                        if (path.startsWith(prefix))
+                            opsByPath.delete(path);
+                    }
+                    opsByPath.set(op.path, (op = getValue(state, op)));
+                }
+            }
+            else {
+                opsByPath.clear();
+            }
+            return op;
+        });
+    });
+}
+function match(op1, op2) {
+    return op1 && op2 && op1.op === op2.op && op1.path === op2.path;
+}

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

@@ -0,0 +1,35 @@
+import { JSONPatch } from './JSONPatch';
+/**
+ * Creates a `JSONPatch` instance by tracking changes made to a proxy object within an updater function.
+ *
+ * This provides a convenient way to generate patches based on direct object manipulation.
+ * The `updater` function receives a proxy of the `target` object and the `JSONPatch` instance.
+ * Modifications made to the proxy object (setting properties, calling array methods)
+ * are automatically converted into JSON Patch operations and added to the patch instance.
+ * You can also directly call methods on the `patch` instance within the updater.
+ *
+ * @template T The type of the target object.
+ * @param target The initial state of the object.
+ * @param updater A function that receives a proxy of the target and a `JSONPatch` instance.
+ *                Modify the proxy or call patch methods within this function to generate operations.
+ * @returns A `JSONPatch` instance containing the operations generated within the updater.
+ *
+ * @example
+ * ```ts
+ * const myObj = { name: { first: 'Alice' }, age: 30, tags: ['a'] };
+ *
+ * const patch = createJSONPatch(myObj, (proxy, p) => {
+ *   proxy.name.first = 'Bob'; // Generates a 'replace' op via the proxy
+ *   proxy.tags.push('b');     // Generates an 'add' op via the proxy
+ *   p.increment(proxy.age, 1); // Directly adds an 'increment' op
+ * });
+ *
+ * console.log(patch.ops);
+ * // [
+ * //   { op: 'replace', path: '/name/first', value: 'Bob' },
+ * //   { op: 'add', path: '/tags/1', value: 'b' },
+ * //   { op: 'increment', path: '/age', value: 1 }
+ * // ]
+ * ```
+ */
+export declare function createJSONPatch<T>(target: T, updater: (proxy: T, patch: JSONPatch) => void): JSONPatch;

package/dist/json-patch/createJSONPatch.js

@@ -0,0 +1,41 @@
+import { JSONPatch } from './JSONPatch';
+import { createPatchProxy } from './patchProxy';
+/**
+ * Creates a `JSONPatch` instance by tracking changes made to a proxy object within an updater function.
+ *
+ * This provides a convenient way to generate patches based on direct object manipulation.
+ * The `updater` function receives a proxy of the `target` object and the `JSONPatch` instance.
+ * Modifications made to the proxy object (setting properties, calling array methods)
+ * are automatically converted into JSON Patch operations and added to the patch instance.
+ * You can also directly call methods on the `patch` instance within the updater.
+ *
+ * @template T The type of the target object.
+ * @param target The initial state of the object.
+ * @param updater A function that receives a proxy of the target and a `JSONPatch` instance.
+ *                Modify the proxy or call patch methods within this function to generate operations.
+ * @returns A `JSONPatch` instance containing the operations generated within the updater.
+ *
+ * @example
+ * ```ts
+ * const myObj = { name: { first: 'Alice' }, age: 30, tags: ['a'] };
+ *
+ * const patch = createJSONPatch(myObj, (proxy, p) => {
+ *   proxy.name.first = 'Bob'; // Generates a 'replace' op via the proxy
+ *   proxy.tags.push('b');     // Generates an 'add' op via the proxy
+ *   p.increment(proxy.age, 1); // Directly adds an 'increment' op
+ * });
+ *
+ * console.log(patch.ops);
+ * // [
+ * //   { op: 'replace', path: '/name/first', value: 'Bob' },
+ * //   { op: 'add', path: '/tags/1', value: 'b' },
+ * //   { op: 'increment', path: '/age', value: 1 }
+ * // ]
+ * ```
+ */
+export function createJSONPatch(target, updater) {
+    const patch = new JSONPatch();
+    // Use the specific overload of createPatchProxy that takes target and patch
+    updater(createPatchProxy(target, patch), patch);
+    return patch;
+}

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

@@ -0,0 +1,9 @@
+export { applyPatch } from './applyPatch.js';
+export { composePatch } from './composePatch.js';
+export { invertPatch } from './invertPatch.js';
+export { applyBitmask, bitmask, combineBitmasks } from './ops/bitmask.js';
+export * as defaultOps from './ops/index.js';
+export { transformPatch } from './transformPatch.js';
+export * from './ops/index.js';
+export * from './ops/index.js';
+export type { ApplyJSONPatchOptions, JSONPatchOpHandlerMap as JSONPatchCustomTypes, JSONPatchOp } from './types.js';

package/dist/json-patch/index.js

@@ -0,0 +1,8 @@
+export { applyPatch } from './applyPatch.js';
+export { composePatch } from './composePatch.js';
+export { invertPatch } from './invertPatch.js';
+export { applyBitmask, bitmask, combineBitmasks } from './ops/bitmask.js';
+export * as defaultOps from './ops/index.js';
+export { transformPatch } from './transformPatch.js';
+export * from './ops/index.js'; // Exports all ops: add, remove, etc.
+export * from './ops/index.js';

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

@@ -0,0 +1,2 @@
+import type { JSONPatchOp, JSONPatchOpHandlerMap } from './types.js';
+export declare function invertPatch(object: any, ops: JSONPatchOp[], custom?: JSONPatchOpHandlerMap): JSONPatchOp[];

package/dist/json-patch/invertPatch.js

@@ -0,0 +1,31 @@
+import { getTypes } from './ops/index.js';
+import { runWithObject } from './state.js';
+import { getType } from './utils/getType.js';
+export function invertPatch(object, ops, custom = {}) {
+    const types = getTypes(custom);
+    return runWithObject({}, types, false, state => {
+        return ops
+            .map((op) => {
+            const pathParts = op.path.split('/').slice(1);
+            let changedObj = object;
+            const prop = pathParts.pop();
+            let value, isIndex;
+            try {
+                for (let i = 0; i < pathParts.length; i++) {
+                    changedObj = changedObj[pathParts[i]];
+                }
+                value = changedObj[prop];
+                isIndex = prop >= 0;
+            }
+            catch (err) {
+                throw new Error(`Patch mismatch. This patch was not applied to the provided object and cannot be inverted. ${err.message || err}`);
+            }
+            const handler = getType(state, op)?.invert;
+            if (!handler)
+                throw new Error('Unknown patch operation, cannot invert');
+            return handler(state, op, value, changedObj, isIndex);
+        })
+            .filter(op => !!op)
+            .reverse();
+    });
+}

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

@@ -0,0 +1,2 @@
+import type { JSONPatchOpHandler } from '../types.js';
+export declare const add: JSONPatchOpHandler;

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

@@ -0,0 +1,52 @@
+import { deepEqual } from '../utils/deepEqual.js';
+import { getOpData } from '../utils/getOpData.js';
+import { isArrayPath, isEmptyObject, log, updateArrayIndexes, updateRemovedOps, updateSoftWrites, } from '../utils/index.js';
+import { pluckWithShallowCopy } from '../utils/pluck.js';
+import { toArrayIndex } from '../utils/toArrayIndex.js';
+export const add = {
+    like: 'add',
+    apply(state, path, value) {
+        if (typeof value === 'undefined') {
+            return '[op:add] require value, but got undefined';
+        }
+        const [keys, lastKey, target] = getOpData(state, path, true);
+        if (target === null) {
+            return `[op:add] path not found: ${path}`;
+        }
+        if (Array.isArray(target)) {
+            const index = toArrayIndex(target, lastKey);
+            if (target.length < index) {
+                return `[op:add] invalid array index: ${path}`;
+            }
+            pluckWithShallowCopy(state, keys, true).splice(index, 0, value);
+        }
+        else {
+            if (!deepEqual(target[lastKey], value)) {
+                pluckWithShallowCopy(state, keys, true)[lastKey] = value;
+            }
+        }
+    },
+    invert(_state, { path }, value, changedObj, isIndex) {
+        if (path.endsWith('/-'))
+            return { op: 'remove', path: path.replace('-', changedObj.length) };
+        else if (isIndex)
+            return { op: 'remove', path };
+        return value === undefined ? { op: 'remove', path } : { op: 'replace', path, value };
+    },
+    transform(state, thisOp, otherOps) {
+        log('Transforming', otherOps, 'against "add"', thisOp);
+        if (isArrayPath(thisOp.path, state)) {
+            // Adjust any operations on the same array by 1 to account for this new entry
+            return updateArrayIndexes(state, thisOp.path, otherOps, 1);
+        }
+        else if (isEmptyObject(thisOp.value)) {
+            // Treat empty objects special. If two empty objects are added to the same location, don't overwrite the existing
+            // one, allowing for the merging of maps together which did not exist before
+            return updateSoftWrites(thisOp.path, otherOps);
+        }
+        else {
+            // Remove anything that was done at this path since it is being overwritten by the add
+            return updateRemovedOps(state, thisOp.path, otherOps);
+        }
+    },
+};

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

@@ -0,0 +1,14 @@
+import type { JSONPatchOpHandler } from '../types.js';
+/**
+ * Create and maintain up to 15 boolean values in a single positive number (a bitmask). This can reduce the size of your
+ * JSON document. Limiting the bits to 15 allows us to keep the number smaller (max of 9 characters), positive, and
+ * allows us to combine multiple operations into a single number.
+ */
+export declare const bit: JSONPatchOpHandler;
+/**
+ * A helper function to create a mask number for bitmask operations. The bottom 15 bits are used to turn bits on, and
+ * the top 15 bits are used to turn bits off.
+ */
+export declare function bitmask(index: number, value: boolean): number;
+export declare function applyBitmask(num: number, mask: number): number;
+export declare function combineBitmasks(a: number, b: number): number;

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

@@ -0,0 +1,48 @@
+import { get } from '../utils/get.js';
+import { updateRemovedOps } from '../utils/ops.js';
+import { replace } from './replace.js';
+/**
+ * Create and maintain up to 15 boolean values in a single positive number (a bitmask). This can reduce the size of your
+ * JSON document. Limiting the bits to 15 allows us to keep the number smaller (max of 9 characters), positive, and
+ * allows us to combine multiple operations into a single number.
+ */
+export const bit = {
+    like: 'replace',
+    apply(state, path, value) {
+        return replace.apply(state, path, applyBitmask(get(state, path) || 0, value || 0));
+    },
+    transform(state, thisOp, otherOps) {
+        return updateRemovedOps(state, thisOp.path, otherOps, false, true);
+    },
+    invert(state, op, value, changedObj, isIndex) {
+        return replace.invert(state, op, value, changedObj, isIndex);
+    },
+    compose(_state, value1, value2) {
+        return combineBitmasks(value1, value2);
+    },
+};
+/**
+ * A helper function to create a mask number for bitmask operations. The bottom 15 bits are used to turn bits on, and
+ * the top 15 bits are used to turn bits off.
+ */
+export function bitmask(index, value) {
+    if (index < 0 || index > 14)
+        throw new Error('Index must be between 0 and 14');
+    return value ? 1 << index : 1 << (index + 15);
+}
+export function applyBitmask(num, mask) {
+    const offMask = (mask >> 15) & 0x7fff;
+    const onMask = mask & 0x7fff;
+    num &= ~offMask;
+    num |= onMask;
+    return num;
+}
+export function combineBitmasks(a, b) {
+    const aOff = (a >> 15) & 0x7fff;
+    const aOn = a & 0x7fff;
+    const bOff = (b >> 15) & 0x7fff;
+    const bOn = b & 0x7fff;
+    const combinedOn = (aOn & ~bOff) | bOn;
+    const combinedOff = (aOff & ~bOn) | bOff;
+    return (combinedOff << 15) | combinedOn;
+}

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

@@ -0,0 +1,2 @@
+import type { JSONPatchOpHandler } from '../types.js';
+export declare const copy: JSONPatchOpHandler;

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

@@ -0,0 +1,34 @@
+import { getOpData } from '../utils/getOpData.js';
+import { log } from '../utils/log.js';
+import { updateRemovedOps } from '../utils/ops.js';
+import { isArrayPath } from '../utils/paths.js';
+import { updateArrayIndexes } from '../utils/updateArrayIndexes.js';
+import { add } from './add.js';
+export const copy = {
+    like: 'copy',
+    apply(state, path, from) {
+        const [, lastKey, target] = getOpData(state, from);
+        if (target === null) {
+            return `[op:copy] path not found: ${from}`;
+        }
+        return add.apply(state, path, target[lastKey]);
+    },
+    invert(_state, { path }, value, changedObj, isIndex) {
+        if (path.endsWith('/-'))
+            return { op: 'remove', path: path.replace('-', changedObj.length) };
+        else if (isIndex)
+            return { op: 'remove', path };
+        return value === undefined ? { op: 'remove', path } : { op: 'replace', path, value };
+    },
+    transform(state, thisOp, otherOps) {
+        log('Transforming', otherOps, 'against "add"', thisOp);
+        if (isArrayPath(thisOp.path, state)) {
+            // Adjust any operations on the same array by 1 to account for this new entry
+            return updateArrayIndexes(state, thisOp.path, otherOps, 1);
+        }
+        else {
+            // Remove anything that was done at this path since it is being overwritten
+            return updateRemovedOps(state, thisOp.path, otherOps);
+        }
+    },
+};

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

@@ -0,0 +1,5 @@
+import type { JSONPatchOpHandler } from '../types.js';
+/**
+ * Increment or decrement a number (using `+` or `-`).
+ */
+export declare const increment: JSONPatchOpHandler;

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

@@ -0,0 +1,21 @@
+import { get } from '../utils/get.js';
+import { updateRemovedOps } from '../utils/ops.js';
+import { replace } from './replace.js';
+/**
+ * Increment or decrement a number (using `+` or `-`).
+ */
+export const increment = {
+    like: 'replace',
+    apply(state, path, value) {
+        return replace.apply(state, path, (get(state, path) || 0) + value);
+    },
+    transform(state, thisOp, otherOps) {
+        return updateRemovedOps(state, thisOp.path, otherOps, false, true);
+    },
+    invert(state, op, value, changedObj, isIndex) {
+        return replace.invert(state, op, value, changedObj, isIndex);
+    },
+    compose(_state, value1, value2) {
+        return value1 + value2;
+    },
+};

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

@@ -0,0 +1,22 @@
+import type { JSONPatchOpHandlerMap } from '../types.js';
+import { add } from './add.js';
+import { bit } from './bitmask.js';
+import { copy } from './copy.js';
+import { increment } from './increment.js';
+import { move } from './move.js';
+import { remove } from './remove.js';
+import { replace } from './replace.js';
+import { test } from './test.js';
+export * from './bitmask.js';
+export { add, bit, copy, increment, move, remove, replace, test };
+export declare function getTypes(custom?: JSONPatchOpHandlerMap): {
+    test: import("../types.js").JSONPatchOpHandler;
+    add: import("../types.js").JSONPatchOpHandler;
+    remove: import("../types.js").JSONPatchOpHandler;
+    replace: import("../types.js").JSONPatchOpHandler;
+    copy: import("../types.js").JSONPatchOpHandler;
+    move: import("../types.js").JSONPatchOpHandler;
+    '@inc': import("../types.js").JSONPatchOpHandler;
+    '@bit': import("../types.js").JSONPatchOpHandler;
+    '@txt': import("../types.js").JSONPatchOpHandler;
+};