@sanity/diff-patch 6.0.0 → 7.0.0

package/dist/index.js

@@ -1,271 +1,412 @@
-import { 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" && !!obj && "_key" in obj && 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;
+	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);
-  const result = /* @__PURE__ */ new Set();
-  for (const item of source)
-    target.has(item) || result.add(item);
-  return result;
+	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);
-  const result = /* @__PURE__ */ new Set();
-  for (const item of source)
-    target.has(item) && result.add(item);
-  return result;
+	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;
 }
-const SYSTEM_KEYS = ["_id", "_type", "_createdAt", "_updatedAt", "_rev"], DMP_MAX_STRING_SIZE = 1e6, DMP_MAX_STRING_LENGTH_CHANGE_RATIO = 0.4, DMP_MIN_SIZE_FOR_RATIO_CHECK = 1e4;
+/**
+* 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 = {}) {
-  const 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 new Error(
-      "_id on source and target 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 && source._type !== target._type)
-    throw new Error(`_type is immutable and cannot be changed (${source._type} => ${target._type})`);
-  const operations = diffItem(source, target, basePath, []);
-  return serializePatches(operations).map((patchOperations, i) => ({
-    patch: {
-      id,
-      // only add `ifRevisionID` to the first patch
-      ...i === 0 && ifRevisionID && { ifRevisionID },
-      ...patchOperations
-    }
-  }));
+	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));
+	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);
+	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) {
-  const 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++) {
-    const key = aKeys[i];
-    key in target || patches.push({ op: "unset", path: path.concat(key) });
-  }
-  for (let i = 0; i < bKeysLength; i++) {
-    const key = bKeys[i];
-    diffItem(source[key], target[key], path.concat([key]), patches);
-  }
-  return 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);
+	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) {
-    const 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]);
-  const 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;
+	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) {
-  const 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++) {
-    const 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 (const key of keysInBothArrays)
-    diffItem(sourceItemsByKey.get(key), targetItemsByKey.get(key), [...path, { _key: key }], patches);
-  for (const keyToRemove of keysRemovedFromSource)
-    patches.push({ op: "unset", path: [...path, { _key: keyToRemove }] });
-  if (keysAddedToTarget.size) {
-    let insertionAnchorKey, itemsPendingInsertion = [];
-    const flushPendingInsertions = () => {
-      itemsPendingInsertion.length && patches.push({
-        op: "insert",
-        // Insert after the anchor key if we have one, otherwise insert at the beginning
-        ...insertionAnchorKey ? { position: "after", path: [...path, { _key: insertionAnchorKey }] } : { position: "before", path: [...path, 0] },
-        items: itemsPendingInsertion
-      });
-    };
-    for (const key of targetKeys)
-      keysAddedToTarget.has(key) ? itemsPendingInsertion.push(targetItemsByKey.get(key)) : keysInBothArrays.has(key) && (flushPendingInsertions(), insertionAnchorKey = key, itemsPendingInsertion = []);
-    flushPendingInsertions();
-  }
-  return 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) {
-  const maxLength = Math.max(source.length, target.length);
-  return maxLength > DMP_MAX_STRING_SIZE ? !1 : maxLength < DMP_MIN_SIZE_FOR_RATIO_CHECK ? !0 : !(Math.abs(target.length - source.length) / maxLength > DMP_MAX_STRING_LENGTH_CHANGE_RATIO);
+	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) {
-  const last = path.at(-1);
-  if (!(typeof last == "string" && last.startsWith("_")) && shouldUseDiffMatchPatch(source, target))
-    try {
-      const strPatch = stringifyPatches(makePatches(source, target));
-      return { op: "diffMatchPatch", path, value: strPatch };
-    } catch {
-      return;
-    }
+	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) {
-  const dmp = getDiffMatchPatch(source, target, path);
-  return patches.push(dmp ?? { op: "set", path, value: target }), patches;
+	let dmp = getDiffMatchPatch(source, target, path);
+	return patches.push(dmp ?? {
+		op: "set",
+		path,
+		value: target
+	}), patches;
 }
 function isNotIgnoredKey(key) {
-  return SYSTEM_KEYS.indexOf(key) === -1;
+	return SYSTEM_KEYS.indexOf(key) === -1;
 }
 function serializePatches(patches, curr) {
-  const [patch, ...rest] = patches;
-  if (!patch) return curr ? [curr] : [];
-  switch (patch.op) {
-    case "set":
-    case "diffMatchPatch": {
-      const 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": {
-      const 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)];
-      const tempKeyOperations = {};
-      tempKeyOperations.set = {};
-      for (const { sourceKey, targetKey } of patch.reorders) {
-        const temporaryKey = `__temp_reorder_${sourceKey}__`, finalContentForThisPosition = patch.snapshot[getIndexForKey(patch.snapshot, targetKey)];
-        Object.assign(tempKeyOperations.set, {
-          [pathToString([...patch.path, { _key: sourceKey }])]: {
-            ...finalContentForThisPosition,
-            _key: temporaryKey
-          }
-        });
-      }
-      const finalKeyOperations = {};
-      finalKeyOperations.set = {};
-      for (const { sourceKey, targetKey } of patch.reorders) {
-        const temporaryKey = `__temp_reorder_${sourceKey}__`;
-        Object.assign(finalKeyOperations.set, {
-          [pathToString([...patch.path, { _key: temporaryKey }, "_key"])]: targetKey
-        });
-      }
-      return [tempKeyOperations, finalKeyOperations, ...serializePatches(rest)];
-    }
-    default:
-      return [];
-  }
+	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 seenKeys = /* @__PURE__ */ new Set();
-  for (const item of arr) {
-    if (!isKeyedObject(item) || seenKeys.has(item._key)) return !1;
-    seenKeys.add(item._key);
-  }
-  return !0;
+	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) {
-  const cachedMapping = keyToIndexCache.get(keyedArray);
-  if (cachedMapping) return cachedMapping[targetKey];
-  const keyToIndexMapping = keyedArray.reduce(
-    (mapping, { _key }, arrayIndex) => (mapping[_key] = arrayIndex, mapping),
-    {}
-  );
-  return keyToIndexCache.set(keyedArray, keyToIndexMapping), keyToIndexMapping[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);
+	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;
+	return item === void 0 ? null : item;
 }
-function yes(_) {
-  return !0;
+function yes() {
+	return !0;
 }
-export {
-  DiffError,
-  diffPatch,
-  diffValue
-};
-//# sourceMappingURL=index.js.map
+export { DiffError, diffPatch, diffValue };
+
+//# sourceMappingURL=index.js.map