@sanity/diff-patch 5.0.0 → 7.0.0

package/dist/index.js

@@ -1,251 +1,412 @@
-import { makeDiff, cleanupEfficiency, stringifyPatches, makePatches } from "@sanity/diff-match-patch";
+import { makePatches, stringifyPatches } from "@sanity/diff-match-patch";
 const IS_DOTTABLE_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+/**
+* Converts an array path to a string path
+*
+* @param path - The array path to convert
+* @returns A stringified path
+* @internal
+*/
 function pathToString(path) {
-  return path.reduce((target, segment, i) => {
-    if (Array.isArray(segment))
-      return `${target}[${segment.join(":")}]`;
-    if (isKeyedObject(segment))
-      return `${target}[_key=="${segment._key}"]`;
-    if (typeof segment == "number")
-      return `${target}[${segment}]`;
-    if (typeof segment == "string" && !IS_DOTTABLE_RE.test(segment))
-      return `${target}['${segment}']`;
-    if (typeof segment == "string")
-      return `${target}${i === 0 ? "" : "."}${segment}`;
-    throw new Error(`Unsupported path segment "${segment}"`);
-  }, "");
+	return path.reduce((target, segment, i) => {
+		if (Array.isArray(segment)) return `${target}[${segment.join(":")}]`;
+		if (isKeyedObject(segment)) return `${target}[_key=="${segment._key}"]`;
+		if (typeof segment == "number") return `${target}[${segment}]`;
+		if (typeof segment == "string" && !IS_DOTTABLE_RE.test(segment)) return `${target}['${segment}']`;
+		if (typeof segment == "string") return `${target}${i === 0 ? "" : "."}${segment}`;
+		throw Error(`Unsupported path segment "${segment}"`);
+	}, "");
 }
 function isKeyedObject(obj) {
-  return typeof obj == "object" && typeof obj._key == "string";
+	return typeof obj == "object" && !!obj && "_key" in obj && typeof obj._key == "string";
 }
-class DiffError extends Error {
-  path;
-  value;
-  serializedPath;
-  constructor(message, path, value) {
-    const serializedPath = pathToString(path);
-    super(`${message} (at '${serializedPath}')`), this.path = path, this.serializedPath = serializedPath, this.value = value;
-  }
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && typeof Symbol == "function" && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof(o);
 }
+function toPrimitive(t, r) {
+	if (_typeof(t) != "object" || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (e !== void 0) {
+		var i = e.call(t, r || "default");
+		if (_typeof(i) != "object") return i;
+		throw TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return (r === "string" ? String : Number)(t);
+}
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return _typeof(i) == "symbol" ? i : i + "";
+}
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+/**
+* Represents an error that occurred during a diff process.
+* Contains `path`, `value` and `serializedPath` properties,
+* which is helpful for debugging and showing friendly messages.
+*
+* @public
+*/
+var DiffError = class extends Error {
+	constructor(message, path, value) {
+		let serializedPath = pathToString(path);
+		super(`${message} (at '${serializedPath}')`), _defineProperty(this, "path", void 0), _defineProperty(this, "value", void 0), _defineProperty(this, "serializedPath", void 0), this.path = path, this.serializedPath = serializedPath, this.value = value;
+	}
+};
 const idPattern = /^[a-z0-9][a-z0-9_.-]+$/i, propPattern = /^[a-zA-Z_][a-zA-Z0-9_-]*$/, propStartPattern = /^[a-z_]/i;
+/**
+* Validate a property for Sanity compatibility
+*
+* @param property - The property to valide
+* @param value - The value of the property
+* @param path - The path of the property, for error reporting
+* @returns The property name, if valid
+* @internal
+*/
 function validateProperty(property, value, path) {
-  if (!propStartPattern.test(property))
-    throw new DiffError("Keys must start with a letter (a-z)", path.concat(property), value);
-  if (!propPattern.test(property))
-    throw new DiffError(
-      "Keys can only contain letters, numbers and underscores",
-      path.concat(property),
-      value
-    );
-  if (property === "_key" || property === "_ref" || property === "_type") {
-    if (typeof value != "string")
-      throw new DiffError("Keys must be strings", path.concat(property), value);
-    if (!idPattern.test(value))
-      throw new DiffError("Invalid key - use less exotic characters", path.concat(property), value);
-  }
-  return property;
-}
-const ignoredKeys = ["_id", "_type", "_createdAt", "_updatedAt", "_rev"], defaultOptions = {
-  hideWarnings: !1,
-  diffMatchPatch: {
-    enabled: !0,
-    // Only use diff-match-patch if target string is longer than this threshold
-    lengthThresholdAbsolute: 30,
-    // Only use generated diff-match-patch if the patch length is less than or equal to
-    // (targetString * relative). Example: A 100 character target with a relative factor
-    // of 1.2 will allow a 120 character diff-match-patch. If larger than this number,
-    // it will fall back to a regular `set` patch.
-    lengthThresholdRelative: 1.2
-  }
-};
-function mergeOptions(options) {
-  return {
-    ...defaultOptions,
-    ...options,
-    diffMatchPatch: { ...defaultOptions.diffMatchPatch, ...options.diffMatchPatch || {} }
-  };
-}
-function diffPatch(itemA, itemB, opts) {
-  const options = mergeOptions(opts || {}), id = options.id || itemA._id === itemB._id && itemA._id, revisionLocked = options.ifRevisionID, ifRevisionID = typeof revisionLocked == "boolean" ? itemA._rev : revisionLocked, basePath = options.basePath || [];
-  if (!id)
-    throw new Error(
-      "_id on itemA and itemB not present or differs, specify document id the mutations should be applied to"
-    );
-  if (revisionLocked === !0 && !ifRevisionID)
-    throw new Error(
-      "`ifRevisionID` is set to `true`, but no `_rev` was passed in item A. Either explicitly set `ifRevisionID` to a revision, or pass `_rev` as part of item A."
-    );
-  if (basePath.length === 0 && itemA._type !== itemB._type)
-    throw new Error(`_type is immutable and cannot be changed (${itemA._type} => ${itemB._type})`);
-  const operations = diffItem(itemA, itemB, options, basePath, []);
-  return serializePatches(operations, { id, ifRevisionID: revisionLocked ? ifRevisionID : void 0 });
-}
-function diffItem(itemA, itemB, opts = defaultOptions, path = [], patches = []) {
-  if (itemA === itemB)
-    return patches;
-  const aType = Array.isArray(itemA) ? "array" : typeof itemA, bType = Array.isArray(itemB) ? "array" : typeof itemB, aIsUndefined = aType === "undefined", bIsUndefined = bType === "undefined";
-  if (aIsUndefined && !bIsUndefined)
-    return patches.push({ op: "set", path, value: itemB }), patches;
-  if (!aIsUndefined && bIsUndefined)
-    return patches.push({ op: "unset", path }), patches;
-  const options = mergeOptions(opts), dataType = aIsUndefined ? bType : aType;
-  return dataType === "object" || dataType === "array" ? aType !== bType ? (patches.push({ op: "set", path, value: itemB }), patches) : dataType === "array" ? diffArray(itemA, itemB, options, path, patches) : diffObject(itemA, itemB, options, path, patches) : diffPrimitive(itemA, itemB, options, path, patches);
-}
-function diffObject(itemA, itemB, options, path, patches) {
-  const atRoot = path.length === 0, aKeys = Object.keys(itemA).filter(atRoot ? isNotIgnoredKey : yes).map((key) => validateProperty(key, itemA[key], path)), aKeysLength = aKeys.length, bKeys = Object.keys(itemB).filter(atRoot ? isNotIgnoredKey : yes).map((key) => validateProperty(key, itemB[key], path)), bKeysLength = bKeys.length;
-  for (let i = 0; i < aKeysLength; i++) {
-    const key = aKeys[i];
-    key in itemB || patches.push({ op: "unset", path: path.concat(key) });
-  }
-  for (let i = 0; i < bKeysLength; i++) {
-    const key = bKeys[i];
-    diffItem(itemA[key], itemB[key], options, path.concat([key]), patches);
-  }
-  return patches;
-}
-function diffArray(itemA, itemB, options, path, patches) {
-  if (itemB.length > itemA.length && patches.push({
-    op: "insert",
-    after: path.concat([-1]),
-    items: itemB.slice(itemA.length).map((item, i) => nullifyUndefined(item, path, i, options))
-  }), itemB.length < itemA.length) {
-    const isSingle = itemA.length - itemB.length === 1, unsetItems = itemA.slice(itemB.length);
-    isRevisionLocked(options) || !isUniquelyKeyed(unsetItems) ? patches.push({
-      op: "unset",
-      path: path.concat([isSingle ? itemB.length : [itemB.length, ""]])
-    }) : patches.push(
-      ...unsetItems.map(
-        (item) => ({ op: "unset", path: path.concat({ _key: item._key }) })
-      )
-    );
-  }
-  for (let i = 0; i < itemB.length; i++)
-    if (Array.isArray(itemB[i]))
-      throw new DiffError("Multi-dimensional arrays not supported", path.concat(i), itemB[i]);
-  const overlapping = Math.min(itemA.length, itemB.length), segmentA = itemA.slice(0, overlapping), segmentB = itemB.slice(0, overlapping);
-  return isUniquelyKeyed(segmentA) && isUniquelyKeyed(segmentB) ? diffArrayByKey(segmentA, segmentB, options, path, patches) : diffArrayByIndex(segmentA, segmentB, options, path, patches);
-}
-function diffArrayByIndex(itemA, itemB, options, path, patches) {
-  for (let i = 0; i < itemA.length; i++)
-    diffItem(
-      itemA[i],
-      nullifyUndefined(itemB[i], path, i, options),
-      options,
-      path.concat(i),
-      patches
-    );
-  return patches;
-}
-function diffArrayByKey(itemA, itemB, options, path, patches) {
-  const keyedA = indexByKey(itemA), keyedB = indexByKey(itemB);
-  if (!arrayIsEqual(keyedA.keys, keyedB.keys))
-    return diffArrayByIndex(itemA, itemB, options, path, patches);
-  for (let i = 0; i < keyedB.keys.length; i++) {
-    const key = keyedB.keys[i], valueA = keyedA.index[key], valueB = nullifyUndefined(keyedB.index[key], path, i, options);
-    diffItem(valueA, valueB, options, path.concat({ _key: key }), patches);
-  }
-  return patches;
-}
-function getDiffMatchPatch(itemA, itemB, options, path) {
-  const { enabled, lengthThresholdRelative, lengthThresholdAbsolute } = options.diffMatchPatch, segment = path[path.length - 1];
-  if (!enabled || // Don't use for anything but strings
-  typeof itemA != "string" || typeof itemB != "string" || // Don't use for `_key`, `_ref` etc
-  typeof segment == "string" && segment[0] === "_" || // Don't use on short strings
-  itemB.length < lengthThresholdAbsolute)
-    return;
-  let strPatch = "";
-  try {
-    const patch = makeDiff(itemA, itemB), diff = cleanupEfficiency(patch);
-    strPatch = stringifyPatches(makePatches(diff));
-  } catch {
-    return;
-  }
-  return strPatch.length > itemB.length * lengthThresholdRelative ? void 0 : { op: "diffMatchPatch", path, value: strPatch };
-}
-function diffPrimitive(itemA, itemB, options, path, patches) {
-  const dmp = getDiffMatchPatch(itemA, itemB, options, path);
-  return patches.push(
-    dmp || {
-      op: "set",
-      path,
-      value: itemB
-    }
-  ), patches;
+	if (!propStartPattern.test(property)) throw new DiffError("Keys must start with a letter (a-z)", path.concat(property), value);
+	if (!propPattern.test(property)) throw new DiffError("Keys can only contain letters, numbers and underscores", path.concat(property), value);
+	if (property === "_key" || property === "_ref" || property === "_type") {
+		if (typeof value != "string") throw new DiffError("Keys must be strings", path.concat(property), value);
+		if (!idPattern.test(value)) throw new DiffError("Invalid key - use less exotic characters", path.concat(property), value);
+	}
+	return property;
+}
+function difference(source, target) {
+	if ("difference" in Set.prototype) return source.difference(target);
+	let result = /* @__PURE__ */ new Set();
+	for (let item of source) target.has(item) || result.add(item);
+	return result;
+}
+function intersection(source, target) {
+	if ("intersection" in Set.prototype) return source.intersection(target);
+	let result = /* @__PURE__ */ new Set();
+	for (let item of source) target.has(item) && result.add(item);
+	return result;
+}
+/**
+* Document keys that are ignored during diff operations.
+* These are system-managed fields that should not be included in patches on
+* top-level documents and should not be diffed with diff-match-patch.
+*/
+const SYSTEM_KEYS = [
+	"_id",
+	"_type",
+	"_createdAt",
+	"_updatedAt",
+	"_rev"
+];
+/**
+* Generates an array of mutations for Sanity, based on the differences between
+* the two passed documents/trees.
+*
+* @param source - The first document/tree to compare
+* @param target - The second document/tree to compare
+* @param opts - Options for the diff generation
+* @returns Array of mutations
+* @public
+*/
+function diffPatch(source, target, options = {}) {
+	let id = options.id || source._id === target._id && source._id, revisionLocked = options.ifRevisionID, ifRevisionID = typeof revisionLocked == "boolean" ? source._rev : revisionLocked, basePath = options.basePath || [];
+	if (!id) throw Error("_id on source and target not present or differs, specify document id the mutations should be applied to");
+	if (revisionLocked === !0 && !ifRevisionID) throw Error("`ifRevisionID` is set to `true`, but no `_rev` was passed in item A. Either explicitly set `ifRevisionID` to a revision, or pass `_rev` as part of item A.");
+	if (basePath.length === 0 && source._type !== target._type) throw Error(`_type is immutable and cannot be changed (${source._type} => ${target._type})`);
+	return serializePatches(diffItem(source, target, basePath, [])).map((patchOperations, i) => ({ patch: {
+		id,
+		...i === 0 && ifRevisionID && { ifRevisionID },
+		...patchOperations
+	} }));
+}
+/**
+* Generates an array of patch operation objects for Sanity, based on the
+* differences between the two passed values
+*
+* @param source - The source value to start off with
+* @param target - The target value that the patch operations will aim to create
+* @param basePath - An optional path that will be prefixed to all subsequent patch operations
+* @returns Array of mutations
+* @public
+*/
+function diffValue(source, target, basePath = []) {
+	return serializePatches(diffItem(source, target, basePath));
+}
+function diffItem(source, target, path = [], patches = []) {
+	return source === target ? patches : typeof source == "string" && typeof target == "string" ? (diffString(source, target, path, patches), patches) : Array.isArray(source) && Array.isArray(target) ? (diffArray(source, target, path, patches), patches) : isRecord(source) && isRecord(target) ? (diffObject(source, target, path, patches), patches) : target === void 0 ? (patches.push({
+		op: "unset",
+		path
+	}), patches) : (patches.push({
+		op: "set",
+		path,
+		value: target
+	}), patches);
+}
+function diffObject(source, target, path, patches) {
+	let atRoot = path.length === 0, aKeys = Object.keys(source).filter(atRoot ? isNotIgnoredKey : yes).map((key) => validateProperty(key, source[key], path)), aKeysLength = aKeys.length, bKeys = Object.keys(target).filter(atRoot ? isNotIgnoredKey : yes).map((key) => validateProperty(key, target[key], path)), bKeysLength = bKeys.length;
+	for (let i = 0; i < aKeysLength; i++) {
+		let key = aKeys[i];
+		key in target || patches.push({
+			op: "unset",
+			path: path.concat(key)
+		});
+	}
+	for (let i = 0; i < bKeysLength; i++) {
+		let key = bKeys[i];
+		diffItem(source[key], target[key], path.concat([key]), patches);
+	}
+	return patches;
+}
+function diffArray(source, target, path, patches) {
+	return isUniquelyKeyed(source) && isUniquelyKeyed(target) ? diffArrayByKey(source, target, path, patches) : diffArrayByIndex(source, target, path, patches);
+}
+function diffArrayByIndex(source, target, path, patches) {
+	if (target.length > source.length && patches.push({
+		op: "insert",
+		position: "after",
+		path: path.concat([-1]),
+		items: target.slice(source.length).map(nullifyUndefined)
+	}), target.length < source.length) {
+		let isSingle = source.length - target.length === 1, unsetItems = source.slice(target.length);
+		isUniquelyKeyed(unsetItems) ? patches.push(...unsetItems.map((item) => ({
+			op: "unset",
+			path: path.concat({ _key: item._key })
+		}))) : patches.push({
+			op: "unset",
+			path: path.concat([isSingle ? target.length : [target.length, ""]])
+		});
+	}
+	for (let i = 0; i < target.length; i++) if (Array.isArray(target[i])) throw new DiffError("Multi-dimensional arrays not supported", path.concat(i), target[i]);
+	let overlapping = Math.min(source.length, target.length), segmentA = source.slice(0, overlapping), segmentB = target.slice(0, overlapping);
+	for (let i = 0; i < segmentA.length; i++) diffItem(segmentA[i], nullifyUndefined(segmentB[i]), path.concat(i), patches);
+	return patches;
+}
+/**
+* Diffs two arrays of keyed objects by their `_key` properties.
+*
+* This approach is preferred over index-based diffing for collaborative editing scenarios
+* because it generates patches that are more resilient to concurrent modifications.
+* When multiple users edit the same array simultaneously, key-based patches have better
+* conflict resolution characteristics than index-based patches.
+*
+* The function handles three main operations:
+* 1. **Reordering**: When existing items change positions within the array
+* 2. **Content changes**: When the content of existing items is modified
+* 3. **Insertions/Deletions**: When items are added or removed from the array
+*
+* @param source - The original array with keyed objects
+* @param target - The target array with keyed objects
+* @param path - The path to this array within the document
+* @param patches - Array to accumulate generated patches
+* @returns The patches array with new patches appended
+*/
+function diffArrayByKey(source, target, path, patches) {
+	let sourceItemsByKey = new Map(source.map((item) => [item._key, item])), targetItemsByKey = new Map(target.map((item) => [item._key, item])), sourceKeys = new Set(sourceItemsByKey.keys()), targetKeys = new Set(targetItemsByKey.keys()), keysRemovedFromSource = difference(sourceKeys, targetKeys), keysAddedToTarget = difference(targetKeys, sourceKeys), keysInBothArrays = intersection(sourceKeys, targetKeys), sourceKeysStillPresent = Array.from(difference(sourceKeys, keysRemovedFromSource)), targetKeysAlreadyPresent = Array.from(difference(targetKeys, keysAddedToTarget)), keyReorderOperations = [];
+	for (let i = 0; i < keysInBothArrays.size; i++) {
+		let keyAtPositionInSource = sourceKeysStillPresent[i], keyAtPositionInTarget = targetKeysAlreadyPresent[i];
+		keyAtPositionInSource !== keyAtPositionInTarget && keyReorderOperations.push({
+			sourceKey: keyAtPositionInSource,
+			targetKey: keyAtPositionInTarget
+		});
+	}
+	keyReorderOperations.length && patches.push({
+		op: "reorder",
+		path,
+		snapshot: source,
+		reorders: keyReorderOperations
+	});
+	for (let key of keysInBothArrays) diffItem(sourceItemsByKey.get(key), targetItemsByKey.get(key), [...path, { _key: key }], patches);
+	for (let keyToRemove of keysRemovedFromSource) patches.push({
+		op: "unset",
+		path: [...path, { _key: keyToRemove }]
+	});
+	if (keysAddedToTarget.size) {
+		let insertionAnchorKey, itemsPendingInsertion = [], flushPendingInsertions = () => {
+			itemsPendingInsertion.length && patches.push({
+				op: "insert",
+				...insertionAnchorKey ? {
+					position: "after",
+					path: [...path, { _key: insertionAnchorKey }]
+				} : {
+					position: "before",
+					path: [...path, 0]
+				},
+				items: itemsPendingInsertion
+			});
+		};
+		for (let key of targetKeys) keysAddedToTarget.has(key) ? itemsPendingInsertion.push(targetItemsByKey.get(key)) : keysInBothArrays.has(key) && (flushPendingInsertions(), insertionAnchorKey = key, itemsPendingInsertion = []);
+		flushPendingInsertions();
+	}
+	return patches;
+}
+/**
+* Determines whether to use diff-match-patch or fallback to a `set` operation
+* when creating a patch to transform a `source` string to `target` string.
+*
+* `diffMatchPatch` patches are typically preferred to `set` operations because
+* they handle conflicts better (when multiple editors work simultaneously) by
+* preserving the user's intended and allowing for 3-way merges.
+*
+* **Heuristic rationale:**
+*
+* Perf analysis revealed that string length has minimal impact on small,
+* keystroke-level changes, but large text replacements (high change ratio) can
+* trigger worst-case algorithm behavior. The 40% change ratio threshold is a
+* simple heuristic that catches problematic replacement scenarios while
+* allowing the algorithm to excel at insertions and deletions.
+*
+* **Performance characteristics (tested on M2 MacBook Pro):**
+*
+* *Keystroke-level editing (most common use case):*
+* - Small strings (1KB-10KB): 0ms for 1-5 keystrokes, consistently sub-millisecond
+* - Medium strings (50KB-200KB): 0ms for 1-5 keystrokes, consistently sub-millisecond
+* - 10 simultaneous keystrokes: ~12ms on 100KB strings
+*
+* *Copy-paste operations (less frequent):*
+* - Small copy-paste operations (<50KB): 0-10ms regardless of string length
+* - Large insertions/deletions (50KB+): 0-50ms (excellent performance)
+* - Large text replacements (50KB+): 70ms-2s+ (can be slow due to algorithm complexity)
+*
+* **Algorithm details:**
+* Uses Myers' diff algorithm with O(ND) time complexity where N=text length and D=edit distance.
+* Includes optimizations: common prefix/suffix removal, line-mode processing, and timeout protection.
+*
+*
+* **Test methodology:**
+* - Generated realistic word-based text patterns
+* - Simulated actual editing behaviors (keystrokes vs copy-paste)
+* - Measured performance across string sizes from 1KB to 10MB
+* - Validated against edge cases including repetitive text and scattered changes
+*
+* @param source - The previous version of the text
+* @param target - The new version of the text
+* @returns true if diff-match-patch should be used, false if fallback to set operation
+*
+* @example
+* ```typescript
+* // Keystroke editing - always fast
+* shouldUseDiffMatchPatch(largeDoc, largeDocWithTypo) // true, ~0ms
+*
+* // Small paste - always fast
+* shouldUseDiffMatchPatch(doc, docWithSmallInsertion) // true, ~0ms
+*
+* // Large replacement - potentially slow
+* shouldUseDiffMatchPatch(article, completelyDifferentArticle) // false, use set
+* ```
+*
+* Compatible with @sanity/diff-match-patch@3.2.0
+*/
+function shouldUseDiffMatchPatch(source, target) {
+	let maxLength = Math.max(source.length, target.length);
+	return maxLength > 1e6 ? !1 : maxLength < 1e4 || !(Math.abs(target.length - source.length) / maxLength > .4);
+}
+function getDiffMatchPatch(source, target, path) {
+	let last = path.at(-1);
+	if (!(typeof last == "string" && last.startsWith("_")) && shouldUseDiffMatchPatch(source, target)) try {
+		return {
+			op: "diffMatchPatch",
+			path,
+			value: stringifyPatches(makePatches(source, target))
+		};
+	} catch {
+		return;
+	}
+}
+function diffString(source, target, path, patches) {
+	let dmp = getDiffMatchPatch(source, target, path);
+	return patches.push(dmp ?? {
+		op: "set",
+		path,
+		value: target
+	}), patches;
 }
 function isNotIgnoredKey(key) {
-  return ignoredKeys.indexOf(key) === -1;
-}
-function serializePatches(patches, options) {
-  if (patches.length === 0)
-    return [];
-  const { id, ifRevisionID } = options, set = patches.filter((patch) => patch.op === "set"), unset = patches.filter((patch) => patch.op === "unset"), insert = patches.filter((patch) => patch.op === "insert"), dmp = patches.filter((patch) => patch.op === "diffMatchPatch"), withSet = set.length > 0 && set.reduce(
-    (patch, item) => {
-      const path = pathToString(item.path);
-      return patch.set[path] = item.value, patch;
-    },
-    { id, set: {} }
-  ), withUnset = unset.length > 0 && unset.reduce(
-    (patch, item) => {
-      const path = pathToString(item.path);
-      return patch.unset.push(path), patch;
-    },
-    { id, unset: [] }
-  ), withInsert = insert.reduce((acc, item) => {
-    const after = pathToString(item.after);
-    return acc.concat({ id, insert: { after, items: item.items } });
-  }, []), withDmp = dmp.length > 0 && dmp.reduce(
-    (patch, item) => {
-      const path = pathToString(item.path);
-      return patch.diffMatchPatch[path] = item.value, patch;
-    },
-    { id, diffMatchPatch: {} }
-  );
-  return [withUnset, withSet, withDmp, ...withInsert].filter(
-    (item) => item !== !1
-  ).map((patch, i) => ({
-    patch: ifRevisionID && i === 0 ? { ...patch, ifRevisionID } : patch
-  }));
+	return SYSTEM_KEYS.indexOf(key) === -1;
+}
+function serializePatches(patches, curr) {
+	let [patch, ...rest] = patches;
+	if (!patch) return curr ? [curr] : [];
+	switch (patch.op) {
+		case "set":
+		case "diffMatchPatch": {
+			let emptyOp = { [patch.op]: {} };
+			return curr ? patch.op in curr ? (Object.assign(curr[patch.op], { [pathToString(patch.path)]: patch.value }), serializePatches(rest, curr)) : [curr, ...serializePatches(patches, emptyOp)] : serializePatches(patches, emptyOp);
+		}
+		case "unset": {
+			let emptyOp = { unset: [] };
+			return curr ? "unset" in curr ? (curr.unset.push(pathToString(patch.path)), serializePatches(rest, curr)) : [curr, ...serializePatches(patches, emptyOp)] : serializePatches(patches, emptyOp);
+		}
+		case "insert": return curr ? [curr, ...serializePatches(patches)] : [{ insert: {
+			[patch.position]: pathToString(patch.path),
+			items: patch.items
+		} }, ...serializePatches(rest)];
+		case "reorder": {
+			if (curr) return [curr, ...serializePatches(patches)];
+			let tempKeyOperations = {};
+			tempKeyOperations.set = {};
+			for (let { sourceKey, targetKey } of patch.reorders) {
+				let temporaryKey = `__temp_reorder_${sourceKey}__`, finalContentForThisPosition = patch.snapshot[getIndexForKey(patch.snapshot, targetKey)];
+				Object.assign(tempKeyOperations.set, { [pathToString([...patch.path, { _key: sourceKey }])]: {
+					...finalContentForThisPosition,
+					_key: temporaryKey
+				} });
+			}
+			let finalKeyOperations = {};
+			finalKeyOperations.set = {};
+			for (let { sourceKey, targetKey } of patch.reorders) {
+				let temporaryKey = `__temp_reorder_${sourceKey}__`;
+				Object.assign(finalKeyOperations.set, { [pathToString([
+					...patch.path,
+					{ _key: temporaryKey },
+					"_key"
+				])]: targetKey });
+			}
+			return [
+				tempKeyOperations,
+				finalKeyOperations,
+				...serializePatches(rest)
+			];
+		}
+		default: return [];
+	}
 }
 function isUniquelyKeyed(arr) {
-  const keys = [];
-  for (let i = 0; i < arr.length; i++) {
-    const key = getKey(arr[i]);
-    if (!key || keys.indexOf(key) !== -1)
-      return !1;
-    keys.push(key);
-  }
-  return !0;
-}
-function getKey(obj) {
-  return typeof obj == "object" && obj !== null && obj._key;
-}
-function indexByKey(arr) {
-  return arr.reduce(
-    (acc, item) => (acc.keys.push(item._key), acc.index[item._key] = item, acc),
-    { keys: [], index: {} }
-  );
-}
-function arrayIsEqual(itemA, itemB) {
-  return itemA.length === itemB.length && itemA.every((item, i) => itemB[i] === item);
-}
-function nullifyUndefined(item, path, index, options) {
-  if (typeof item < "u")
-    return item;
-  if (!options.hideWarnings) {
-    const serializedPath = pathToString(path.concat(index));
-    console.warn(`undefined value in array converted to null (at '${serializedPath}')`);
-  }
-  return null;
-}
-function isRevisionLocked(options) {
-  return !!options.ifRevisionID;
-}
-function yes(_) {
-  return !0;
-}
-export {
-  DiffError,
-  diffItem,
-  diffPatch
-};
-//# sourceMappingURL=index.js.map
+	let seenKeys = /* @__PURE__ */ new Set();
+	for (let item of arr) {
+		if (!isKeyedObject(item) || seenKeys.has(item._key)) return !1;
+		seenKeys.add(item._key);
+	}
+	return !0;
+}
+const keyToIndexCache = /* @__PURE__ */ new WeakMap();
+function getIndexForKey(keyedArray, targetKey) {
+	let cachedMapping = keyToIndexCache.get(keyedArray);
+	if (cachedMapping) return cachedMapping[targetKey];
+	let keyToIndexMapping = keyedArray.reduce((mapping, { _key }, arrayIndex) => (mapping[_key] = arrayIndex, mapping), {});
+	return keyToIndexCache.set(keyedArray, keyToIndexMapping), keyToIndexMapping[targetKey];
+}
+function isRecord(value) {
+	return typeof value == "object" && !!value && !Array.isArray(value);
+}
+/**
+* Simplify returns `null` if the value given was `undefined`. This behavior
+* is the same as how `JSON.stringify` works so this is relatively expected
+* behavior.
+*/
+function nullifyUndefined(item) {
+	return item === void 0 ? null : item;
+}
+function yes() {
+	return !0;
+}
+export { DiffError, diffPatch, diffValue };
+
+//# sourceMappingURL=index.js.map