@portabletext/editor 8.1.6 → 8.1.7

package/lib/index.js

@@ -1,9 +1,9 @@
-import { a as getChildren, d as nodeSegment, f as serializePath, i as resolveNode, n as parentPath, o as getNodeChildren, p as isKeyedSegment, r as getNode, t as getParent, u as hasUsableKey } from "./get-parent-BLzi7eLr.js";
-import { C as getAncestors, S as hasNode, _ as comparePoints, a as isInline, b as isEditableContainer, c as isSpanNode, d as resolveChildEntryIndex, f as isAncestorPath, g as isAfterPoint, h as isBackwardRange, i as getEnclosingBlock, l as getSibling, m as rangeEdges, n as getEnclosingContainer, o as getBlock, p as isTextBlockNode, s as isBlock, t as getPathSubSchema, u as getNodes, v as comparePaths, x as resolveContainerAt, y as isObject } from "./get-path-sub-schema-DsN1qF_l.js";
-import { _ as getAncestor, a as getTextBlock, c as pathContains, d as isRange, f as isPoint, g as isLeafObject, h as getLeaf, i as getFirstChild, l as getSpan, m as isPath, n as getUnionSchema, o as rangeIntersects, p as isObject$1, r as getLastChild, s as isBeforePoint, t as getContainer, u as getText } from "./get-container-CXdmRdiX.js";
-import { a as parseMarkDefs, c as getSelectionStartPoint, d as getBlockStartPoint, f as getBlockEndPoint, g as blockOffsetToSpanSelectionPoint, i as parseInlineObject, l as getSelectionEndPoint, m as isEqualSelectionPoints, n as parseAnnotation, o as parseSpan, p as getBlockKeyFromSelectionPoint, r as parseBlock, s as defaultKeyGenerator, u as isSelectionCollapsed, v as childAtTextOffset, y as textOffsetOfChild } from "./util.slice-blocks-B-iKFEG7.js";
-import { A as getSelectionEndPoint$1, B as getFocusTextBlock, C as getSelectedTextBlocks, D as getPreviousSpan, F as getSelectionStartBlock, H as getFocusSpan, I as getSelectionEndBlock, K as rangesOverlap, L as getFragment, M as isSelectionExpanded, N as isSelectionCollapsed$1, O as getSelectionStartPoint$1, P as isOverlappingSelection, R as getSelectedValue, S as getActiveDecorators, T as getMarkState, U as getFocusInlineObject, V as getFocusBlock, W as getFocusChild, a as isActiveListItem, b as getActiveAnnotations, c as getSelectionEndChild, d as getLastBlock, f as getFocusListBlock, i as isActiveStyle, j as isListBlock, k as getNextSpan, l as getPreviousBlock, m as getCaretWordSelection, n as isAtTheStartOfBlock, o as isActiveDecorator, p as getFocusBlockObject, r as isAtTheEndOfBlock, s as getSelectionStartChild, t as isSelectingEntireBlocks, u as getNextBlock, w as getActiveAnnotationsMarks, x as isActiveAnnotation, z as getRootAcceptedTypes } from "./selector.is-selecting-entire-blocks-BHVYIXbI.js";
-import { n as isEmptyTextBlock, r as getTextBlockText, t as isEqualSelections } from "./util.is-equal-selections-sCQib0IC.js";
+import { a as getChildren, d as nodeSegment, f as serializePath, i as resolveNode, n as parentPath, o as getNodeChildren, p as isKeyedSegment, r as getNode, t as getParent, u as hasUsableKey } from "./get-parent-1LYvKkzm.js";
+import { C as getAncestors, S as hasNode, _ as comparePoints, a as isInline, b as isEditableContainer, c as isSpanNode, d as resolveChildEntryIndex, f as isAncestorPath, g as isAfterPoint, h as isBackwardRange, i as getEnclosingBlock, l as getSibling, m as rangeEdges, n as getEnclosingContainer, o as getBlock, p as isTextBlockNode, s as isBlock, t as getPathSubSchema, u as getNodes, v as comparePaths, x as resolveContainerAt, y as isObject } from "./get-path-sub-schema-BQTgjrJ0.js";
+import { _ as getAncestor, a as getTextBlock, c as pathContains, d as isRange, f as isPoint, g as isLeafObject, h as getLeaf, i as getFirstChild, l as getSpan, m as isPath, n as getUnionSchema, o as rangeIntersects, p as isObject$1, r as getLastChild, s as isBeforePoint, t as getContainer, u as getText } from "./get-container-BNT2gY-T.js";
+import { a as parseMarkDefs, c as getSelectionStartPoint, d as getBlockStartPoint, f as getBlockEndPoint, g as blockOffsetToSpanSelectionPoint, i as parseInlineObject, l as getSelectionEndPoint, m as isEqualSelectionPoints, n as parseAnnotation, o as parseSpan, p as getBlockKeyFromSelectionPoint, r as parseBlock, s as defaultKeyGenerator, u as isSelectionCollapsed, v as childAtTextOffset, y as textOffsetOfChild } from "./util.slice-blocks-By7qN-i2.js";
+import { A as getSelectionEndPoint$1, B as getFocusTextBlock, C as getSelectedTextBlocks, D as getPreviousSpan, F as getSelectionStartBlock, H as getFocusSpan, I as getSelectionEndBlock, K as rangesOverlap, L as getFragment, M as isSelectionExpanded, N as isSelectionCollapsed$1, O as getSelectionStartPoint$1, P as isOverlappingSelection, R as getSelectedValue, S as getActiveDecorators, T as getMarkState, U as getFocusInlineObject, V as getFocusBlock, W as getFocusChild, a as isActiveListItem, b as getActiveAnnotations, c as getSelectionEndChild, d as getLastBlock, f as getFocusListBlock, i as isActiveStyle, j as isListBlock, k as getNextSpan, l as getPreviousBlock, m as getCaretWordSelection, n as isAtTheStartOfBlock, o as isActiveDecorator, p as getFocusBlockObject, r as isAtTheEndOfBlock, s as getSelectionStartChild, t as isSelectingEntireBlocks, u as getNextBlock, w as getActiveAnnotationsMarks, x as isActiveAnnotation, z as getRootAcceptedTypes } from "./selector.is-selecting-entire-blocks-CAUZpsBb.js";
+import { n as isEmptyTextBlock, r as getTextBlockText, t as isEqualSelections } from "./util.is-equal-selections-Ae0HO_72.js";
 import { a as raise$1, i as forward, n as effect, t as defineBehavior } from "./behavior.types.behavior-BxSLb73I.js";
 import { n as EditorContext$1, t as useEditor } from "./use-editor-CwNeVwVC.js";
 import { c } from "react/compiler-runtime";
@@ -18,6 +18,7 @@ import { and, assertEvent, assign, createActor, emit, enqueueActions, fromCallba
 import { htmlToPortableText } from "@portabletext/html";
 import { toHTML } from "@portabletext/to-html";
 import { applyAll, diffMatchPatch, insert, set, setIfMissing, unset } from "@portabletext/patches";
+import { DIFF_DELETE, DIFF_EQUAL, DIFF_INSERT, applyPatches, cleanupEfficiency, makeDiff, parsePatch } from "@sanity/diff-match-patch";
 /**
 * Resolve the DOM node corresponding to a keyed path.
 */
@@ -564,16 +565,16 @@ const getCharacterDistance = (str, isRTL = !1) => {
 	let end = str.length - 1;
 	for (let i = 0; i < str.length; i++) {
 		let char1 = str.charAt(end - i);
-		if (isLowSurrogate$1(char1.charCodeAt(0))) {
+		if (isLowSurrogate(char1.charCodeAt(0))) {
 			let char2 = str.charAt(end - i - 1);
-			if (isHighSurrogate$1(char2.charCodeAt(0))) {
+			if (isHighSurrogate(char2.charCodeAt(0))) {
 				yield char2 + char1, i++;
 				continue;
 			}
 		}
 		yield char1;
 	}
-}, isHighSurrogate$1 = (charCode) => charCode >= 55296 && charCode <= 56319, isLowSurrogate$1 = (charCode) => charCode >= 56320 && charCode <= 57343, CodepointType = {
+}, isHighSurrogate = (charCode) => charCode >= 55296 && charCode <= 56319, isLowSurrogate = (charCode) => charCode >= 56320 && charCode <= 57343, CodepointType = {
 	None: 0,
 	Extend: 1,
 	ZWJ: 2,
@@ -4651,7 +4652,7 @@ function getSelectionState(snapshot, selection) {
 function subscribeCoalesced(actor, observer) {
 	let scheduled = !1, active = !0, subscription = actor.subscribe({
 		next: observer.next ? () => {
-			scheduled || !active || (scheduled = !0, queueMicrotask(() => {
+			!scheduled && active && (scheduled = !0, queueMicrotask(() => {
 				scheduled = !1, active && observer.next?.();
 			}));
 		} : void 0,
@@ -5306,7 +5307,7 @@ function validateSelection(editorEngine, editorElement) {
 	} catch {}
 	if (!root || editorElement !== root.activeElement) return;
 	let domSelection = DOMEditor.getWindow(editorEngine).getSelection();
-	if (!(!domSelection || domSelection.rangeCount === 0)) try {
+	if (domSelection && domSelection.rangeCount !== 0) try {
 		let domEditorSelection = DOMEditor.toEditorSelection(editorEngine, domSelection, {
 			exactMatch: !1,
 			suppressThrow: !0
@@ -5666,7 +5667,7 @@ const PortableTextEditable = forwardRef(function PortableTextEditable(props, for
 	}, $[105] = editorActor, $[106] = editorEngine, $[107] = onDragStart, $[108] = readOnly, $[109] = t28) : t28 = $[109];
 	let handleDragStart = t28, t29;
 	$[110] !== editorActor || $[111] !== editorEngine || $[112] !== onDrag ? (t29 = (event_9) => {
-		if (onDrag?.(event_9), !(event_9.isDefaultPrevented() || event_9.isPropagationStopped()) && !(editorActor.getSnapshot().matches({ setup: "setting up" }) || !DOMEditor.hasTarget(editorEngine, event_9.target))) return editorActor.send({
+		if (onDrag?.(event_9), !(event_9.isDefaultPrevented() || event_9.isPropagationStopped()) && !editorActor.getSnapshot().matches({ setup: "setting up" }) && DOMEditor.hasTarget(editorEngine, event_9.target)) return editorActor.send({
 			type: "behavior event",
 			behaviorEvent: {
 				type: "drag.drag",
@@ -5750,7 +5751,7 @@ const PortableTextEditable = forwardRef(function PortableTextEditable(props, for
 	}, $[126] = editorActor, $[127] = editorEngine, $[128] = onDrop, $[129] = t33) : t33 = $[129];
 	let handleDrop = t33, t34;
 	$[130] !== editorActor || $[131] !== editorEngine || $[132] !== onDragLeave ? (t34 = (event_14) => {
-		if (onDragLeave?.(event_14), !(event_14.isDefaultPrevented() || event_14.isPropagationStopped()) && !(editorActor.getSnapshot().matches({ setup: "setting up" }) || !DOMEditor.hasTarget(editorEngine, event_14.target))) return editorActor.send({
+		if (onDragLeave?.(event_14), !(event_14.isDefaultPrevented() || event_14.isPropagationStopped()) && !editorActor.getSnapshot().matches({ setup: "setting up" }) && DOMEditor.hasTarget(editorEngine, event_14.target)) return editorActor.send({
 			type: "behavior event",
 			behaviorEvent: {
 				type: "drag.dragleave",
@@ -6161,7 +6162,7 @@ function createEditableAPI(editor, editorActor) {
 		focusChild: () => {
 			if (!editor.snapshot.context.selection) return;
 			let leaf = getLeaf(editor.snapshot, editor.snapshot.context.selection.focus.path, { edge: "start" });
-			if (!(!leaf || isBlock(editor.snapshot, leaf.path))) return leaf.node;
+			if (leaf && !isBlock(editor.snapshot, leaf.path)) return leaf.node;
 		},
 		insertChild: (type, value) => (editorActor.send({
 			type: "behavior event",
@@ -7242,7 +7243,7 @@ function updateDirtyPaths(editor, newDirtyPaths) {
 	for (let path of newDirtyPaths) add(path);
 	editor.dirtyPaths = dirtyPaths, editor.dirtyPathKeys = dirtyPathKeys;
 }
-const apply$1 = (editor, op) => {
+const apply = (editor, op) => {
 	let beforeListeners = editor.operationListeners.before, operationEvent = beforeListeners.length > 0 || editor.operationListeners.after.length > 0 ? createOperationEvent(editor, op) : void 0;
 	operationEvent && emitOperationEvent(beforeListeners, operationEvent);
 	for (let ref of editor.pathRefs) PathRef.transform(ref, op);
@@ -8256,7 +8257,7 @@ const shouldNormalize = (_editor, { iteration, initialDirtyPathsLength }) => {
 		pointRefs: /* @__PURE__ */ new Set(),
 		rangeRefs: /* @__PURE__ */ new Set(),
 		onChange: () => {},
-		apply: (...args) => apply$1(e, ...args),
+		apply: (...args) => apply(e, ...args),
 		normalizeNode: (...args) => normalizeNode(e, ...args),
 		shouldNormalize: (...args) => shouldNormalize(e, ...args),
 		select: (...args) => select(e, ...args),
@@ -8355,624 +8356,6 @@ function pluginWithoutHistory(editor, fn) {
 		editor.withHistory = prev;
 	}
 }
-function cloneDiff(diff2) {
-	let [type, patch] = diff2;
-	return [type, patch];
-}
-function getCommonOverlap(textA, textB) {
-	let text1 = textA, text2 = textB, text1Length = text1.length, text2Length = text2.length;
-	if (text1Length === 0 || text2Length === 0) return 0;
-	text1Length > text2Length ? text1 = text1.substring(text1Length - text2Length) : text1Length < text2Length && (text2 = text2.substring(0, text1Length));
-	let textLength = Math.min(text1Length, text2Length);
-	if (text1 === text2) return textLength;
-	let best = 0, length = 1;
-	for (let found = 0; found !== -1;) {
-		let pattern = text1.substring(textLength - length);
-		if (found = text2.indexOf(pattern), found === -1) return best;
-		length += found, (found === 0 || text1.substring(textLength - length) === text2.substring(0, length)) && (best = length, length++);
-	}
-	return best;
-}
-function getCommonPrefix(text1, text2) {
-	if (!text1 || !text2 || text1[0] !== text2[0]) return 0;
-	let pointerMin = 0, pointerMax = Math.min(text1.length, text2.length), pointerMid = pointerMax, pointerStart = 0;
-	for (; pointerMin < pointerMid;) text1.substring(pointerStart, pointerMid) === text2.substring(pointerStart, pointerMid) ? (pointerMin = pointerMid, pointerStart = pointerMin) : pointerMax = pointerMid, pointerMid = Math.floor((pointerMax - pointerMin) / 2 + pointerMin);
-	return pointerMid;
-}
-function getCommonSuffix(text1, text2) {
-	if (!text1 || !text2 || text1[text1.length - 1] !== text2[text2.length - 1]) return 0;
-	let pointerMin = 0, pointerMax = Math.min(text1.length, text2.length), pointerMid = pointerMax, pointerEnd = 0;
-	for (; pointerMin < pointerMid;) text1.substring(text1.length - pointerMid, text1.length - pointerEnd) === text2.substring(text2.length - pointerMid, text2.length - pointerEnd) ? (pointerMin = pointerMid, pointerEnd = pointerMin) : pointerMax = pointerMid, pointerMid = Math.floor((pointerMax - pointerMin) / 2 + pointerMin);
-	return pointerMid;
-}
-function isHighSurrogate(char) {
-	let charCode = char.charCodeAt(0);
-	return charCode >= 55296 && charCode <= 56319;
-}
-function isLowSurrogate(char) {
-	let charCode = char.charCodeAt(0);
-	return charCode >= 56320 && charCode <= 57343;
-}
-function bisect(text1, text2, deadline) {
-	let text1Length = text1.length, text2Length = text2.length, maxD = Math.ceil((text1Length + text2Length) / 2), vOffset = maxD, vLength = 2 * maxD, v1 = Array(vLength), v2 = Array(vLength);
-	for (let x = 0; x < vLength; x++) v1[x] = -1, v2[x] = -1;
-	v1[vOffset + 1] = 0, v2[vOffset + 1] = 0;
-	let delta = text1Length - text2Length, front = delta % 2 != 0, k1start = 0, k1end = 0, k2start = 0, k2end = 0;
-	for (let d = 0; d < maxD && !(Date.now() > deadline); d++) {
-		for (let k1 = -d + k1start; k1 <= d - k1end; k1 += 2) {
-			let k1Offset = vOffset + k1, x1;
-			x1 = k1 === -d || k1 !== d && v1[k1Offset - 1] < v1[k1Offset + 1] ? v1[k1Offset + 1] : v1[k1Offset - 1] + 1;
-			let y1 = x1 - k1;
-			for (; x1 < text1Length && y1 < text2Length && text1.charAt(x1) === text2.charAt(y1);) x1++, y1++;
-			if (v1[k1Offset] = x1, x1 > text1Length) k1end += 2;
-			else if (y1 > text2Length) k1start += 2;
-			else if (front) {
-				let k2Offset = vOffset + delta - k1;
-				if (k2Offset >= 0 && k2Offset < vLength && v2[k2Offset] !== -1) {
-					let x2 = text1Length - v2[k2Offset];
-					if (x1 >= x2) return bisectSplit(text1, text2, x1, y1, deadline);
-				}
-			}
-		}
-		for (let k2 = -d + k2start; k2 <= d - k2end; k2 += 2) {
-			let k2Offset = vOffset + k2, x2;
-			x2 = k2 === -d || k2 !== d && v2[k2Offset - 1] < v2[k2Offset + 1] ? v2[k2Offset + 1] : v2[k2Offset - 1] + 1;
-			let y2 = x2 - k2;
-			for (; x2 < text1Length && y2 < text2Length && text1.charAt(text1Length - x2 - 1) === text2.charAt(text2Length - y2 - 1);) x2++, y2++;
-			if (v2[k2Offset] = x2, x2 > text1Length) k2end += 2;
-			else if (y2 > text2Length) k2start += 2;
-			else if (!front) {
-				let k1Offset = vOffset + delta - k2;
-				if (k1Offset >= 0 && k1Offset < vLength && v1[k1Offset] !== -1) {
-					let x1 = v1[k1Offset], y1 = vOffset + x1 - k1Offset;
-					if (x2 = text1Length - x2, x1 >= x2) return bisectSplit(text1, text2, x1, y1, deadline);
-				}
-			}
-		}
-	}
-	return [[-1, text1], [1, text2]];
-}
-function bisectSplit(text1, text2, x, y, deadline) {
-	let text1a = text1.substring(0, x), text2a = text2.substring(0, y), text1b = text1.substring(x), text2b = text2.substring(y), diffs = doDiff(text1a, text2a, {
-		checkLines: !1,
-		deadline
-	}), diffsb = doDiff(text1b, text2b, {
-		checkLines: !1,
-		deadline
-	});
-	return diffs.concat(diffsb);
-}
-function findHalfMatch(text1, text2, timeout = 1) {
-	if (timeout <= 0) return null;
-	let longText = text1.length > text2.length ? text1 : text2, shortText = text1.length > text2.length ? text2 : text1;
-	if (longText.length < 4 || shortText.length * 2 < longText.length) return null;
-	let halfMatch1 = halfMatchI(longText, shortText, Math.ceil(longText.length / 4)), halfMatch2 = halfMatchI(longText, shortText, Math.ceil(longText.length / 2)), halfMatch;
-	if (halfMatch1 && halfMatch2) halfMatch = halfMatch1[4].length > halfMatch2[4].length ? halfMatch1 : halfMatch2;
-	else {
-		if (!halfMatch1 && !halfMatch2) return null;
-		halfMatch2 ? halfMatch1 || (halfMatch = halfMatch2) : halfMatch = halfMatch1;
-	}
-	if (!halfMatch) throw Error("Unable to find a half match.");
-	let text1A, text1B, text2A, text2B;
-	text1.length > text2.length ? (text1A = halfMatch[0], text1B = halfMatch[1], text2A = halfMatch[2], text2B = halfMatch[3]) : (text2A = halfMatch[0], text2B = halfMatch[1], text1A = halfMatch[2], text1B = halfMatch[3]);
-	let midCommon = halfMatch[4];
-	return [
-		text1A,
-		text1B,
-		text2A,
-		text2B,
-		midCommon
-	];
-}
-function halfMatchI(longText, shortText, i) {
-	let seed = longText.slice(i, i + Math.floor(longText.length / 4)), j = -1, bestCommon = "", bestLongTextA, bestLongTextB, bestShortTextA, bestShortTextB;
-	for (; (j = shortText.indexOf(seed, j + 1)) !== -1;) {
-		let prefixLength = getCommonPrefix(longText.slice(i), shortText.slice(j)), suffixLength = getCommonSuffix(longText.slice(0, i), shortText.slice(0, j));
-		bestCommon.length < suffixLength + prefixLength && (bestCommon = shortText.slice(j - suffixLength, j) + shortText.slice(j, j + prefixLength), bestLongTextA = longText.slice(0, i - suffixLength), bestLongTextB = longText.slice(i + prefixLength), bestShortTextA = shortText.slice(0, j - suffixLength), bestShortTextB = shortText.slice(j + prefixLength));
-	}
-	return bestCommon.length * 2 >= longText.length ? [
-		bestLongTextA || "",
-		bestLongTextB || "",
-		bestShortTextA || "",
-		bestShortTextB || "",
-		bestCommon || ""
-	] : null;
-}
-function charsToLines(diffs, lineArray) {
-	for (let x = 0; x < diffs.length; x++) {
-		let chars = diffs[x][1], text = [];
-		for (let y = 0; y < chars.length; y++) text[y] = lineArray[chars.charCodeAt(y)];
-		diffs[x][1] = text.join("");
-	}
-}
-function linesToChars(textA, textB) {
-	let lineArray = [], lineHash = {};
-	lineArray[0] = "";
-	function diffLinesToMunge(text) {
-		let chars = "", lineStart = 0, lineEnd = -1, lineArrayLength = lineArray.length;
-		for (; lineEnd < text.length - 1;) {
-			lineEnd = text.indexOf("\n", lineStart), lineEnd === -1 && (lineEnd = text.length - 1);
-			let line = text.slice(lineStart, lineEnd + 1);
-			(lineHash.hasOwnProperty ? lineHash.hasOwnProperty(line) : lineHash[line] !== void 0) ? chars += String.fromCharCode(lineHash[line]) : (lineArrayLength === maxLines && (line = text.slice(lineStart), lineEnd = text.length), chars += String.fromCharCode(lineArrayLength), lineHash[line] = lineArrayLength, lineArray[lineArrayLength++] = line), lineStart = lineEnd + 1;
-		}
-		return chars;
-	}
-	let maxLines = 4e4, chars1 = diffLinesToMunge(textA);
-	return maxLines = 65535, {
-		chars1,
-		chars2: diffLinesToMunge(textB),
-		lineArray
-	};
-}
-function doLineModeDiff(textA, textB, opts) {
-	let text1 = textA, text2 = textB, a = linesToChars(text1, text2);
-	text1 = a.chars1, text2 = a.chars2;
-	let linearray = a.lineArray, diffs = doDiff(text1, text2, {
-		checkLines: !1,
-		deadline: opts.deadline
-	});
-	charsToLines(diffs, linearray), diffs = cleanupSemantic(diffs), diffs.push([0, ""]);
-	let pointer = 0, countDelete = 0, countInsert = 0, textDelete = "", textInsert = "";
-	for (; pointer < diffs.length;) {
-		switch (diffs[pointer][0]) {
-			case 1:
-				countInsert++, textInsert += diffs[pointer][1];
-				break;
-			case -1:
-				countDelete++, textDelete += diffs[pointer][1];
-				break;
-			case 0:
-				if (countDelete >= 1 && countInsert >= 1) {
-					diffs.splice(pointer - countDelete - countInsert, countDelete + countInsert), pointer = pointer - countDelete - countInsert;
-					let aa = doDiff(textDelete, textInsert, {
-						checkLines: !1,
-						deadline: opts.deadline
-					});
-					for (let j = aa.length - 1; j >= 0; j--) diffs.splice(pointer, 0, aa[j]);
-					pointer += aa.length;
-				}
-				countInsert = 0, countDelete = 0, textDelete = "", textInsert = "";
-				break;
-			default: throw Error("Unknown diff operation.");
-		}
-		pointer++;
-	}
-	return diffs.pop(), diffs;
-}
-function computeDiff(text1, text2, opts) {
-	let diffs;
-	if (!text1) return [[1, text2]];
-	if (!text2) return [[-1, text1]];
-	let longtext = text1.length > text2.length ? text1 : text2, shorttext = text1.length > text2.length ? text2 : text1, i = longtext.indexOf(shorttext);
-	if (i !== -1) return diffs = [
-		[1, longtext.substring(0, i)],
-		[0, shorttext],
-		[1, longtext.substring(i + shorttext.length)]
-	], text1.length > text2.length && (diffs[0][0] = -1, diffs[2][0] = -1), diffs;
-	if (shorttext.length === 1) return [[-1, text1], [1, text2]];
-	let halfMatch = findHalfMatch(text1, text2);
-	if (halfMatch) {
-		let text1A = halfMatch[0], text1B = halfMatch[1], text2A = halfMatch[2], text2B = halfMatch[3], midCommon = halfMatch[4], diffsA = doDiff(text1A, text2A, opts), diffsB = doDiff(text1B, text2B, opts);
-		return diffsA.concat([[0, midCommon]], diffsB);
-	}
-	return opts.checkLines && text1.length > 100 && text2.length > 100 ? doLineModeDiff(text1, text2, opts) : bisect(text1, text2, opts.deadline);
-}
-var __defProp$2 = Object.defineProperty, __getOwnPropSymbols$2 = Object.getOwnPropertySymbols, __hasOwnProp$2 = Object.prototype.hasOwnProperty, __propIsEnum$2 = Object.prototype.propertyIsEnumerable, __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, {
-	enumerable: !0,
-	configurable: !0,
-	writable: !0,
-	value
-}) : obj[key] = value, __spreadValues$2 = (a, b) => {
-	for (var prop in b ||= {}) __hasOwnProp$2.call(b, prop) && __defNormalProp$2(a, prop, b[prop]);
-	if (__getOwnPropSymbols$2) for (var prop of __getOwnPropSymbols$2(b)) __propIsEnum$2.call(b, prop) && __defNormalProp$2(a, prop, b[prop]);
-	return a;
-};
-function diff(textA, textB, opts) {
-	if (textA === null || textB === null) throw Error("Null input. (diff)");
-	let diffs = doDiff(textA, textB, createInternalOpts(opts || {}));
-	return adjustDiffForSurrogatePairs(diffs), diffs;
-}
-function doDiff(textA, textB, options) {
-	let text1 = textA, text2 = textB;
-	if (text1 === text2) return text1 ? [[0, text1]] : [];
-	let commonlength = getCommonPrefix(text1, text2), commonprefix = text1.substring(0, commonlength);
-	text1 = text1.substring(commonlength), text2 = text2.substring(commonlength), commonlength = getCommonSuffix(text1, text2);
-	let commonsuffix = text1.substring(text1.length - commonlength);
-	text1 = text1.substring(0, text1.length - commonlength), text2 = text2.substring(0, text2.length - commonlength);
-	let diffs = computeDiff(text1, text2, options);
-	return commonprefix && diffs.unshift([0, commonprefix]), commonsuffix && diffs.push([0, commonsuffix]), diffs = cleanupMerge(diffs), diffs;
-}
-function createDeadLine(timeout) {
-	let t = 1;
-	return typeof timeout < "u" && (t = timeout <= 0 ? Number.MAX_VALUE : timeout), Date.now() + t * 1e3;
-}
-function createInternalOpts(opts) {
-	return __spreadValues$2({
-		checkLines: !0,
-		deadline: createDeadLine(opts.timeout || 1)
-	}, opts);
-}
-function combineChar(data, char, dir) {
-	return dir === 1 ? data + char : char + data;
-}
-function splitChar(data, dir) {
-	return dir === 1 ? [data.substring(0, data.length - 1), data[data.length - 1]] : [data.substring(1), data[0]];
-}
-function hasSharedChar(diffs, i, j, dir) {
-	return dir === 1 ? diffs[i][1][diffs[i][1].length - 1] === diffs[j][1][diffs[j][1].length - 1] : diffs[i][1][0] === diffs[j][1][0];
-}
-function deisolateChar(diffs, i, dir) {
-	let inv = dir === 1 ? -1 : 1, insertIdx = null, deleteIdx = null, j = i + dir;
-	for (; j >= 0 && j < diffs.length && (insertIdx === null || deleteIdx === null); j += dir) {
-		let [op, text2] = diffs[j];
-		if (text2.length !== 0) {
-			if (op === 1) {
-				insertIdx === null && (insertIdx = j);
-				continue;
-			}
-			if (op === -1) {
-				deleteIdx === null && (deleteIdx = j);
-				continue;
-			}
-			if (op === 0) {
-				if (insertIdx === null && deleteIdx === null) {
-					let [rest, char2] = splitChar(diffs[i][1], dir);
-					diffs[i][1] = rest, diffs[j][1] = combineChar(diffs[j][1], char2, inv);
-					return;
-				}
-				break;
-			}
-		}
-	}
-	if (insertIdx !== null && deleteIdx !== null && hasSharedChar(diffs, insertIdx, deleteIdx, dir)) {
-		let [insertText, insertChar] = splitChar(diffs[insertIdx][1], inv), [deleteText] = splitChar(diffs[deleteIdx][1], inv);
-		diffs[insertIdx][1] = insertText, diffs[deleteIdx][1] = deleteText, diffs[i][1] = combineChar(diffs[i][1], insertChar, dir);
-		return;
-	}
-	let [text, char] = splitChar(diffs[i][1], dir);
-	diffs[i][1] = text, insertIdx === null ? (diffs.splice(j, 0, [1, char]), deleteIdx !== null && deleteIdx >= j && deleteIdx++) : diffs[insertIdx][1] = combineChar(diffs[insertIdx][1], char, inv), deleteIdx === null ? diffs.splice(j, 0, [-1, char]) : diffs[deleteIdx][1] = combineChar(diffs[deleteIdx][1], char, inv);
-}
-function adjustDiffForSurrogatePairs(diffs) {
-	for (let i = 0; i < diffs.length; i++) {
-		let [diffType, diffText] = diffs[i];
-		if (diffText.length === 0) continue;
-		let firstChar = diffText[0], lastChar = diffText[diffText.length - 1];
-		isHighSurrogate(lastChar) && diffType === 0 && deisolateChar(diffs, i, 1), isLowSurrogate(firstChar) && diffType === 0 && deisolateChar(diffs, i, -1);
-	}
-	for (let i = 0; i < diffs.length; i++) diffs[i][1].length === 0 && diffs.splice(i, 1);
-}
-function cleanupSemantic(rawDiffs) {
-	let diffs = rawDiffs.map((diff2) => cloneDiff(diff2)), hasChanges = !1, equalities = [], equalitiesLength = 0, lastEquality = null, pointer = 0, lengthInsertions1 = 0, lengthDeletions1 = 0, lengthInsertions2 = 0, lengthDeletions2 = 0;
-	for (; pointer < diffs.length;) diffs[pointer][0] === 0 ? (equalities[equalitiesLength++] = pointer, lengthInsertions1 = lengthInsertions2, lengthDeletions1 = lengthDeletions2, lengthInsertions2 = 0, lengthDeletions2 = 0, lastEquality = diffs[pointer][1]) : (diffs[pointer][0] === 1 ? lengthInsertions2 += diffs[pointer][1].length : lengthDeletions2 += diffs[pointer][1].length, lastEquality && lastEquality.length <= Math.max(lengthInsertions1, lengthDeletions1) && lastEquality.length <= Math.max(lengthInsertions2, lengthDeletions2) && (diffs.splice(equalities[equalitiesLength - 1], 0, [-1, lastEquality]), diffs[equalities[equalitiesLength - 1] + 1][0] = 1, equalitiesLength--, equalitiesLength--, pointer = equalitiesLength > 0 ? equalities[equalitiesLength - 1] : -1, lengthInsertions1 = 0, lengthDeletions1 = 0, lengthInsertions2 = 0, lengthDeletions2 = 0, lastEquality = null, hasChanges = !0)), pointer++;
-	for (hasChanges && (diffs = cleanupMerge(diffs)), diffs = cleanupSemanticLossless(diffs), pointer = 1; pointer < diffs.length;) {
-		if (diffs[pointer - 1][0] === -1 && diffs[pointer][0] === 1) {
-			let deletion = diffs[pointer - 1][1], insertion = diffs[pointer][1], overlapLength1 = getCommonOverlap(deletion, insertion), overlapLength2 = getCommonOverlap(insertion, deletion);
-			overlapLength1 >= overlapLength2 ? (overlapLength1 >= deletion.length / 2 || overlapLength1 >= insertion.length / 2) && (diffs.splice(pointer, 0, [0, insertion.substring(0, overlapLength1)]), diffs[pointer - 1][1] = deletion.substring(0, deletion.length - overlapLength1), diffs[pointer + 1][1] = insertion.substring(overlapLength1), pointer++) : (overlapLength2 >= deletion.length / 2 || overlapLength2 >= insertion.length / 2) && (diffs.splice(pointer, 0, [0, deletion.substring(0, overlapLength2)]), diffs[pointer - 1][0] = 1, diffs[pointer - 1][1] = insertion.substring(0, insertion.length - overlapLength2), diffs[pointer + 1][0] = -1, diffs[pointer + 1][1] = deletion.substring(overlapLength2), pointer++), pointer++;
-		}
-		pointer++;
-	}
-	return diffs;
-}
-const nonAlphaNumericRegex = /[^a-zA-Z0-9]/, whitespaceRegex = /\s/, linebreakRegex = /[\r\n]/, blanklineEndRegex = /\n\r?\n$/, blanklineStartRegex = /^\r?\n\r?\n/;
-function cleanupSemanticLossless(rawDiffs) {
-	let diffs = rawDiffs.map((diff2) => cloneDiff(diff2));
-	function diffCleanupSemanticScore(one, two) {
-		if (!one || !two) return 6;
-		let char1 = one.charAt(one.length - 1), char2 = two.charAt(0), nonAlphaNumeric1 = char1.match(nonAlphaNumericRegex), nonAlphaNumeric2 = char2.match(nonAlphaNumericRegex), whitespace1 = nonAlphaNumeric1 && char1.match(whitespaceRegex), whitespace2 = nonAlphaNumeric2 && char2.match(whitespaceRegex), lineBreak1 = whitespace1 && char1.match(linebreakRegex), lineBreak2 = whitespace2 && char2.match(linebreakRegex), blankLine1 = lineBreak1 && one.match(blanklineEndRegex), blankLine2 = lineBreak2 && two.match(blanklineStartRegex);
-		return blankLine1 || blankLine2 ? 5 : lineBreak1 || lineBreak2 ? 4 : nonAlphaNumeric1 && !whitespace1 && whitespace2 ? 3 : whitespace1 || whitespace2 ? 2 : nonAlphaNumeric1 || nonAlphaNumeric2 ? 1 : 0;
-	}
-	let pointer = 1;
-	for (; pointer < diffs.length - 1;) {
-		if (diffs[pointer - 1][0] === 0 && diffs[pointer + 1][0] === 0) {
-			let equality1 = diffs[pointer - 1][1], edit = diffs[pointer][1], equality2 = diffs[pointer + 1][1], commonOffset = getCommonSuffix(equality1, edit);
-			if (commonOffset) {
-				let commonString = edit.substring(edit.length - commonOffset);
-				equality1 = equality1.substring(0, equality1.length - commonOffset), edit = commonString + edit.substring(0, edit.length - commonOffset), equality2 = commonString + equality2;
-			}
-			let bestEquality1 = equality1, bestEdit = edit, bestEquality2 = equality2, bestScore = diffCleanupSemanticScore(equality1, edit) + diffCleanupSemanticScore(edit, equality2);
-			for (; edit.charAt(0) === equality2.charAt(0);) {
-				equality1 += edit.charAt(0), edit = edit.substring(1) + equality2.charAt(0), equality2 = equality2.substring(1);
-				let score = diffCleanupSemanticScore(equality1, edit) + diffCleanupSemanticScore(edit, equality2);
-				score >= bestScore && (bestScore = score, bestEquality1 = equality1, bestEdit = edit, bestEquality2 = equality2);
-			}
-			diffs[pointer - 1][1] !== bestEquality1 && (bestEquality1 ? diffs[pointer - 1][1] = bestEquality1 : (diffs.splice(pointer - 1, 1), pointer--), diffs[pointer][1] = bestEdit, bestEquality2 ? diffs[pointer + 1][1] = bestEquality2 : (diffs.splice(pointer + 1, 1), pointer--));
-		}
-		pointer++;
-	}
-	return diffs;
-}
-function cleanupMerge(rawDiffs) {
-	let diffs = rawDiffs.map((diff2) => cloneDiff(diff2));
-	diffs.push([0, ""]);
-	let pointer = 0, countDelete = 0, countInsert = 0, textDelete = "", textInsert = "", commonlength;
-	for (; pointer < diffs.length;) switch (diffs[pointer][0]) {
-		case 1:
-			countInsert++, textInsert += diffs[pointer][1], pointer++;
-			break;
-		case -1:
-			countDelete++, textDelete += diffs[pointer][1], pointer++;
-			break;
-		case 0:
-			countDelete + countInsert > 1 ? (countDelete !== 0 && countInsert !== 0 && (commonlength = getCommonPrefix(textInsert, textDelete), commonlength !== 0 && (pointer - countDelete - countInsert > 0 && diffs[pointer - countDelete - countInsert - 1][0] === 0 ? diffs[pointer - countDelete - countInsert - 1][1] += textInsert.substring(0, commonlength) : (diffs.splice(0, 0, [0, textInsert.substring(0, commonlength)]), pointer++), textInsert = textInsert.substring(commonlength), textDelete = textDelete.substring(commonlength)), commonlength = getCommonSuffix(textInsert, textDelete), commonlength !== 0 && (diffs[pointer][1] = textInsert.substring(textInsert.length - commonlength) + diffs[pointer][1], textInsert = textInsert.substring(0, textInsert.length - commonlength), textDelete = textDelete.substring(0, textDelete.length - commonlength))), pointer -= countDelete + countInsert, diffs.splice(pointer, countDelete + countInsert), textDelete.length && (diffs.splice(pointer, 0, [-1, textDelete]), pointer++), textInsert.length && (diffs.splice(pointer, 0, [1, textInsert]), pointer++), pointer++) : pointer !== 0 && diffs[pointer - 1][0] === 0 ? (diffs[pointer - 1][1] += diffs[pointer][1], diffs.splice(pointer, 1)) : pointer++, countInsert = 0, countDelete = 0, textDelete = "", textInsert = "";
-			break;
-		default: throw Error("Unknown diff operation");
-	}
-	diffs[diffs.length - 1][1] === "" && diffs.pop();
-	let hasChanges = !1;
-	for (pointer = 1; pointer < diffs.length - 1;) diffs[pointer - 1][0] === 0 && diffs[pointer + 1][0] === 0 && (diffs[pointer][1].substring(diffs[pointer][1].length - diffs[pointer - 1][1].length) === diffs[pointer - 1][1] ? (diffs[pointer][1] = diffs[pointer - 1][1] + diffs[pointer][1].substring(0, diffs[pointer][1].length - diffs[pointer - 1][1].length), diffs[pointer + 1][1] = diffs[pointer - 1][1] + diffs[pointer + 1][1], diffs.splice(pointer - 1, 1), hasChanges = !0) : diffs[pointer][1].substring(0, diffs[pointer + 1][1].length) === diffs[pointer + 1][1] && (diffs[pointer - 1][1] += diffs[pointer + 1][1], diffs[pointer][1] = diffs[pointer][1].substring(diffs[pointer + 1][1].length) + diffs[pointer + 1][1], diffs.splice(pointer + 1, 1), hasChanges = !0)), pointer++;
-	return hasChanges && (diffs = cleanupMerge(diffs)), diffs;
-}
-function trueCount(...args) {
-	return args.reduce((n, bool) => n + +!!bool, 0);
-}
-function cleanupEfficiency(rawDiffs, editCost = 4) {
-	let diffs = rawDiffs.map((diff2) => cloneDiff(diff2)), hasChanges = !1, equalities = [], equalitiesLength = 0, lastEquality = null, pointer = 0, preIns = !1, preDel = !1, postIns = !1, postDel = !1;
-	for (; pointer < diffs.length;) diffs[pointer][0] === 0 ? (diffs[pointer][1].length < editCost && (postIns || postDel) ? (equalities[equalitiesLength++] = pointer, preIns = postIns, preDel = postDel, lastEquality = diffs[pointer][1]) : (equalitiesLength = 0, lastEquality = null), postIns = !1, postDel = !1) : (diffs[pointer][0] === -1 ? postDel = !0 : postIns = !0, lastEquality && (preIns && preDel && postIns && postDel || lastEquality.length < editCost / 2 && trueCount(preIns, preDel, postIns, postDel) === 3) && (diffs.splice(equalities[equalitiesLength - 1], 0, [-1, lastEquality]), diffs[equalities[equalitiesLength - 1] + 1][0] = 1, equalitiesLength--, lastEquality = null, preIns && preDel ? (postIns = !0, postDel = !0, equalitiesLength = 0) : (equalitiesLength--, pointer = equalitiesLength > 0 ? equalities[equalitiesLength - 1] : -1, postIns = !1, postDel = !1), hasChanges = !0)), pointer++;
-	return hasChanges && (diffs = cleanupMerge(diffs)), diffs;
-}
-var __defProp$1 = Object.defineProperty, __getOwnPropSymbols$1 = Object.getOwnPropertySymbols, __hasOwnProp$1 = Object.prototype.hasOwnProperty, __propIsEnum$1 = Object.prototype.propertyIsEnumerable, __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, {
-	enumerable: !0,
-	configurable: !0,
-	writable: !0,
-	value
-}) : obj[key] = value, __spreadValues$1 = (a, b) => {
-	for (var prop in b ||= {}) __hasOwnProp$1.call(b, prop) && __defNormalProp$1(a, prop, b[prop]);
-	if (__getOwnPropSymbols$1) for (var prop of __getOwnPropSymbols$1(b)) __propIsEnum$1.call(b, prop) && __defNormalProp$1(a, prop, b[prop]);
-	return a;
-};
-const DEFAULT_OPTIONS = {
-	/**
-	* At what point is no match declared (0.0 = perfection, 1.0 = very loose).
-	*/
-	threshold: .5,
-	/**
-	* How far to search for a match (0 = exact location, 1000+ = broad match).
-	* A match this many characters away from the expected location will add
-	* 1.0 to the score (0.0 is a perfect match).
-	*/
-	distance: 1e3
-};
-function applyDefaults(options) {
-	return __spreadValues$1(__spreadValues$1({}, DEFAULT_OPTIONS), options);
-}
-function bitap(text, pattern, loc, opts = {}) {
-	if (pattern.length > 32) throw Error("Pattern too long for this browser.");
-	let options = applyDefaults(opts), s = getAlphabetFromPattern(pattern);
-	function getBitapScore(e, x) {
-		let accuracy = e / pattern.length, proximity = Math.abs(loc - x);
-		return options.distance ? accuracy + proximity / options.distance : proximity ? 1 : accuracy;
-	}
-	let scoreThreshold = options.threshold, bestLoc = text.indexOf(pattern, loc);
-	bestLoc !== -1 && (scoreThreshold = Math.min(getBitapScore(0, bestLoc), scoreThreshold), bestLoc = text.lastIndexOf(pattern, loc + pattern.length), bestLoc !== -1 && (scoreThreshold = Math.min(getBitapScore(0, bestLoc), scoreThreshold)));
-	let matchmask = 1 << pattern.length - 1;
-	bestLoc = -1;
-	let binMin, binMid, binMax = pattern.length + text.length, lastRd = [];
-	for (let d = 0; d < pattern.length; d++) {
-		for (binMin = 0, binMid = binMax; binMin < binMid;) getBitapScore(d, loc + binMid) <= scoreThreshold ? binMin = binMid : binMax = binMid, binMid = Math.floor((binMax - binMin) / 2 + binMin);
-		binMax = binMid;
-		let start = Math.max(1, loc - binMid + 1), finish = Math.min(loc + binMid, text.length) + pattern.length, rd = Array(finish + 2);
-		rd[finish + 1] = (1 << d) - 1;
-		for (let j = finish; j >= start; j--) {
-			let charMatch = s[text.charAt(j - 1)];
-			if (d === 0 ? rd[j] = (rd[j + 1] << 1 | 1) & charMatch : rd[j] = (rd[j + 1] << 1 | 1) & charMatch | (lastRd[j + 1] | lastRd[j]) << 1 | 1 | lastRd[j + 1], rd[j] & matchmask) {
-				let score = getBitapScore(d, j - 1);
-				if (score <= scoreThreshold) {
-					if (scoreThreshold = score, bestLoc = j - 1, bestLoc > loc) start = Math.max(1, 2 * loc - bestLoc);
-					else break;
-				}
-			}
-		}
-		if (getBitapScore(d + 1, loc) > scoreThreshold) break;
-		lastRd = rd;
-	}
-	return bestLoc;
-}
-function getAlphabetFromPattern(pattern) {
-	let s = {};
-	for (let i = 0; i < pattern.length; i++) s[pattern.charAt(i)] = 0;
-	for (let i = 0; i < pattern.length; i++) s[pattern.charAt(i)] |= 1 << pattern.length - i - 1;
-	return s;
-}
-function match(text, pattern, searchLocation, options = {}) {
-	if (text === null || pattern === null || searchLocation === null) throw Error("Null input. (match())");
-	let loc = Math.max(0, Math.min(searchLocation, text.length));
-	if (text === pattern) return 0;
-	if (text.length) {
-		if (text.substring(loc, loc + pattern.length) === pattern) return loc;
-	} else return -1;
-	return bitap(text, pattern, loc, options);
-}
-function diffText1(diffs) {
-	let text = [];
-	for (let x = 0; x < diffs.length; x++) diffs[x][0] !== 1 && (text[x] = diffs[x][1]);
-	return text.join("");
-}
-function diffText2(diffs) {
-	let text = [];
-	for (let x = 0; x < diffs.length; x++) diffs[x][0] !== -1 && (text[x] = diffs[x][1]);
-	return text.join("");
-}
-function levenshtein(diffs) {
-	let leven = 0, insertions = 0, deletions = 0;
-	for (let x = 0; x < diffs.length; x++) {
-		let op = diffs[x][0], data = diffs[x][1];
-		switch (op) {
-			case 1:
-				insertions += data.length;
-				break;
-			case -1:
-				deletions += data.length;
-				break;
-			case 0:
-				leven += Math.max(insertions, deletions), insertions = 0, deletions = 0;
-				break;
-			default: throw Error("Unknown diff operation.");
-		}
-	}
-	return leven += Math.max(insertions, deletions), leven;
-}
-function xIndex(diffs, location) {
-	let chars1 = 0, chars2 = 0, lastChars1 = 0, lastChars2 = 0, x;
-	for (x = 0; x < diffs.length && (diffs[x][0] !== 1 && (chars1 += diffs[x][1].length), diffs[x][0] !== -1 && (chars2 += diffs[x][1].length), !(chars1 > location)); x++) lastChars1 = chars1, lastChars2 = chars2;
-	return diffs.length !== x && diffs[x][0] === -1 ? lastChars2 : lastChars2 + (location - lastChars1);
-}
-function countUtf8Bytes(str) {
-	let bytes = 0;
-	for (let i = 0; i < str.length; i++) {
-		let codePoint = str.codePointAt(i);
-		if (typeof codePoint > "u") throw Error("Failed to get codepoint");
-		codePoint > 65535 && i++, bytes += utf8len(codePoint);
-	}
-	return bytes;
-}
-function adjustIndiciesToUcs2(patches, base, options = {}) {
-	let byteOffset = 0, idx = 0;
-	function advanceTo(target) {
-		for (; byteOffset < target;) {
-			let codePoint = base.codePointAt(idx);
-			if (typeof codePoint > "u") return idx;
-			byteOffset += utf8len(codePoint), idx += codePoint > 65535 ? 2 : 1;
-		}
-		if (!options.allowExceedingIndices && byteOffset !== target) throw Error("Failed to determine byte offset");
-		return idx;
-	}
-	let adjusted = [];
-	for (let patch of patches) adjusted.push({
-		diffs: patch.diffs.map((diff2) => cloneDiff(diff2)),
-		start1: advanceTo(patch.start1),
-		start2: advanceTo(patch.start2),
-		utf8Start1: patch.utf8Start1,
-		utf8Start2: patch.utf8Start2,
-		length1: patch.length1,
-		length2: patch.length2,
-		utf8Length1: patch.utf8Length1,
-		utf8Length2: patch.utf8Length2
-	});
-	return adjusted;
-}
-function utf8len(codePoint) {
-	return codePoint <= 127 ? 1 : codePoint <= 2047 ? 2 : codePoint <= 65535 ? 3 : 4;
-}
-function addPadding(patches, margin = 4) {
-	let paddingLength = margin, nullPadding = "";
-	for (let x = 1; x <= paddingLength; x++) nullPadding += String.fromCharCode(x);
-	for (let p of patches) p.start1 += paddingLength, p.start2 += paddingLength, p.utf8Start1 += paddingLength, p.utf8Start2 += paddingLength;
-	let patch = patches[0], diffs = patch.diffs;
-	if (diffs.length === 0 || diffs[0][0] !== 0) diffs.unshift([0, nullPadding]), patch.start1 -= paddingLength, patch.start2 -= paddingLength, patch.utf8Start1 -= paddingLength, patch.utf8Start2 -= paddingLength, patch.length1 += paddingLength, patch.length2 += paddingLength, patch.utf8Length1 += paddingLength, patch.utf8Length2 += paddingLength;
-	else if (paddingLength > diffs[0][1].length) {
-		let firstDiffLength = diffs[0][1].length, extraLength = paddingLength - firstDiffLength;
-		diffs[0][1] = nullPadding.substring(firstDiffLength) + diffs[0][1], patch.start1 -= extraLength, patch.start2 -= extraLength, patch.utf8Start1 -= extraLength, patch.utf8Start2 -= extraLength, patch.length1 += extraLength, patch.length2 += extraLength, patch.utf8Length1 += extraLength, patch.utf8Length2 += extraLength;
-	}
-	if (patch = patches[patches.length - 1], diffs = patch.diffs, diffs.length === 0 || diffs[diffs.length - 1][0] !== 0) diffs.push([0, nullPadding]), patch.length1 += paddingLength, patch.length2 += paddingLength, patch.utf8Length1 += paddingLength, patch.utf8Length2 += paddingLength;
-	else if (paddingLength > diffs[diffs.length - 1][1].length) {
-		let extraLength = paddingLength - diffs[diffs.length - 1][1].length;
-		diffs[diffs.length - 1][1] += nullPadding.substring(0, extraLength), patch.length1 += extraLength, patch.length2 += extraLength, patch.utf8Length1 += extraLength, patch.utf8Length2 += extraLength;
-	}
-	return nullPadding;
-}
-function createPatchObject(start1, start2) {
-	return {
-		diffs: [],
-		start1,
-		start2,
-		utf8Start1: start1,
-		utf8Start2: start2,
-		length1: 0,
-		length2: 0,
-		utf8Length1: 0,
-		utf8Length2: 0
-	};
-}
-function splitMax(patches, margin = 4) {
-	for (let x = 0; x < patches.length; x++) {
-		if (patches[x].length1 <= 32) continue;
-		let bigpatch = patches[x];
-		patches.splice(x--, 1);
-		let start1 = bigpatch.start1, start2 = bigpatch.start2, preContext = "";
-		for (; bigpatch.diffs.length !== 0;) {
-			let patch = createPatchObject(start1 - preContext.length, start2 - preContext.length), empty = !0;
-			if (preContext !== "") {
-				let precontextByteCount = countUtf8Bytes(preContext);
-				patch.length1 = preContext.length, patch.utf8Length1 = precontextByteCount, patch.length2 = preContext.length, patch.utf8Length2 = precontextByteCount, patch.diffs.push([0, preContext]);
-			}
-			for (; bigpatch.diffs.length !== 0 && patch.length1 < 32 - margin;) {
-				let diffType = bigpatch.diffs[0][0], diffText = bigpatch.diffs[0][1], diffTextByteCount = countUtf8Bytes(diffText);
-				if (diffType === 1) {
-					patch.length2 += diffText.length, patch.utf8Length2 += diffTextByteCount, start2 += diffText.length;
-					let diff2 = bigpatch.diffs.shift();
-					diff2 && patch.diffs.push(diff2), empty = !1;
-				} else diffType === -1 && patch.diffs.length === 1 && patch.diffs[0][0] === 0 && diffText.length > 64 ? (patch.length1 += diffText.length, patch.utf8Length1 += diffTextByteCount, start1 += diffText.length, empty = !1, patch.diffs.push([diffType, diffText]), bigpatch.diffs.shift()) : (diffText = diffText.substring(0, 32 - patch.length1 - margin), diffTextByteCount = countUtf8Bytes(diffText), patch.length1 += diffText.length, patch.utf8Length1 += diffTextByteCount, start1 += diffText.length, diffType === 0 ? (patch.length2 += diffText.length, patch.utf8Length2 += diffTextByteCount, start2 += diffText.length) : empty = !1, patch.diffs.push([diffType, diffText]), diffText === bigpatch.diffs[0][1] ? bigpatch.diffs.shift() : bigpatch.diffs[0][1] = bigpatch.diffs[0][1].substring(diffText.length));
-			}
-			preContext = diffText2(patch.diffs), preContext = preContext.substring(preContext.length - margin);
-			let postContext = diffText1(bigpatch.diffs).substring(0, margin), postContextByteCount = countUtf8Bytes(postContext);
-			postContext !== "" && (patch.length1 += postContext.length, patch.length2 += postContext.length, patch.utf8Length1 += postContextByteCount, patch.utf8Length2 += postContextByteCount, patch.diffs.length !== 0 && patch.diffs[patch.diffs.length - 1][0] === 0 ? patch.diffs[patch.diffs.length - 1][1] += postContext : patch.diffs.push([0, postContext])), empty || patches.splice(++x, 0, patch);
-		}
-	}
-}
-function apply(patches, originalText, opts = {}) {
-	if (typeof patches == "string") throw Error("Patches must be an array - pass the patch to `parsePatch()` first");
-	let text = originalText;
-	if (patches.length === 0) return [text, []];
-	let parsed = adjustIndiciesToUcs2(patches, text, { allowExceedingIndices: opts.allowExceedingIndices }), margin = opts.margin || 4, deleteThreshold = opts.deleteThreshold || .4, nullPadding = addPadding(parsed, margin);
-	text = nullPadding + text + nullPadding, splitMax(parsed, margin);
-	let delta = 0, results = [];
-	for (let x = 0; x < parsed.length; x++) {
-		let expectedLoc = parsed[x].start2 + delta, text1 = diffText1(parsed[x].diffs), startLoc, endLoc = -1;
-		if (text1.length > 32 ? (startLoc = match(text, text1.substring(0, 32), expectedLoc), startLoc !== -1 && (endLoc = match(text, text1.substring(text1.length - 32), expectedLoc + text1.length - 32), (endLoc === -1 || startLoc >= endLoc) && (startLoc = -1))) : startLoc = match(text, text1, expectedLoc), startLoc === -1) results[x] = !1, delta -= parsed[x].length2 - parsed[x].length1;
-		else {
-			results[x] = !0, delta = startLoc - expectedLoc;
-			let text2;
-			if (text2 = endLoc === -1 ? text.substring(startLoc, startLoc + text1.length) : text.substring(startLoc, endLoc + 32), text1 === text2) text = text.substring(0, startLoc) + diffText2(parsed[x].diffs) + text.substring(startLoc + text1.length);
-			else {
-				let diffs = diff(text1, text2, { checkLines: !1 });
-				if (text1.length > 32 && levenshtein(diffs) / text1.length > deleteThreshold) results[x] = !1;
-				else {
-					diffs = cleanupSemanticLossless(diffs);
-					let index1 = 0, index2 = 0;
-					for (let y = 0; y < parsed[x].diffs.length; y++) {
-						let mod = parsed[x].diffs[y];
-						mod[0] !== 0 && (index2 = xIndex(diffs, index1)), mod[0] === 1 ? text = text.substring(0, startLoc + index2) + mod[1] + text.substring(startLoc + index2) : mod[0] === -1 && (text = text.substring(0, startLoc + index2) + text.substring(startLoc + xIndex(diffs, index1 + mod[1].length))), mod[0] !== -1 && (index1 += mod[1].length);
-					}
-				}
-			}
-		}
-	}
-	return text = text.substring(nullPadding.length, text.length - nullPadding.length), [text, results];
-}
-const patchHeader = /^@@ -(\d+),?(\d*) \+(\d+),?(\d*) @@$/;
-function parse(textline) {
-	if (!textline) return [];
-	let patches = [], lines = textline.split("\n"), textPointer = 0;
-	for (; textPointer < lines.length;) {
-		let m = lines[textPointer].match(patchHeader);
-		if (!m) throw Error(`Invalid patch string: ${lines[textPointer]}`);
-		let patch = createPatchObject(toInt(m[1]), toInt(m[3]));
-		for (patches.push(patch), m[2] === "" ? (patch.start1--, patch.utf8Start1--, patch.length1 = 1, patch.utf8Length1 = 1) : m[2] === "0" ? (patch.length1 = 0, patch.utf8Length1 = 0) : (patch.start1--, patch.utf8Start1--, patch.utf8Length1 = toInt(m[2]), patch.length1 = patch.utf8Length1), m[4] === "" ? (patch.start2--, patch.utf8Start2--, patch.length2 = 1, patch.utf8Length2 = 1) : m[4] === "0" ? (patch.length2 = 0, patch.utf8Length2 = 0) : (patch.start2--, patch.utf8Start2--, patch.utf8Length2 = toInt(m[4]), patch.length2 = patch.utf8Length2), textPointer++; textPointer < lines.length;) {
-			let currentLine = lines[textPointer], sign = currentLine.charAt(0);
-			if (sign === "@") break;
-			if (sign === "") {
-				textPointer++;
-				continue;
-			}
-			let line;
-			try {
-				line = decodeURI(currentLine.slice(1));
-			} catch {
-				throw Error(`Illegal escape in parse: ${currentLine}`);
-			}
-			let utf8Diff = countUtf8Bytes(line) - line.length;
-			if (sign === "-") patch.diffs.push([-1, line]), patch.length1 -= utf8Diff;
-			else if (sign === "+") patch.diffs.push([1, line]), patch.length2 -= utf8Diff;
-			else if (sign === " ") patch.diffs.push([0, line]), patch.length1 -= utf8Diff, patch.length2 -= utf8Diff;
-			else throw Error(`Invalid patch mode "${sign}" in: ${line}`);
-			textPointer++;
-		}
-	}
-	return patches;
-}
-function toInt(num) {
-	return parseInt(num, 10);
-}
 function toEngineBlock(block, { schemaTypes }) {
 	let { _type, _key, ...rest } = block;
 	if (block && block._type === schemaTypes.block.name) {
@@ -9042,7 +8425,7 @@ function diffMatchPatch$1(editor, patch) {
 	if (patch.path.at(-1) !== "text") {
 		let currentValue = getValue(editor.snapshot.context.value, patch.path);
 		if (typeof currentValue != "string") return !1;
-		let [newValue] = apply(parse(patch.value), currentValue, { allowExceedingIndices: !0 });
+		let [newValue] = applyPatches(parsePatch(patch.value), currentValue, { allowExceedingIndices: !0 });
 		return editor.apply({
 			type: "set",
 			path: patch.path,
@@ -9051,18 +8434,18 @@ function diffMatchPatch$1(editor, patch) {
 	}
 	let spanPath = patch.path.slice(0, -1), spanEntry = getNode(editor.snapshot, spanPath);
 	if (!spanEntry || !isSpan({ schema: editor.snapshot.context.schema }, spanEntry.node)) return !1;
-	let [newValue] = apply(parse(patch.value), spanEntry.node.text, { allowExceedingIndices: !0 }), diff$1 = cleanupEfficiency(diff(spanEntry.node.text, newValue), 5), offset = 0;
-	for (let [op, text] of diff$1) op === 1 ? (editor.apply({
+	let patches = parsePatch(patch.value), [newValue] = applyPatches(patches, spanEntry.node.text, { allowExceedingIndices: !0 }), diff = cleanupEfficiency(makeDiff(spanEntry.node.text, newValue), 5), offset = 0;
+	for (let [op, text] of diff) op === DIFF_INSERT ? (editor.apply({
 		type: "insert.text",
 		path: spanEntry.path,
 		offset,
 		text
-	}), offset += text.length) : op === -1 ? editor.apply({
+	}), offset += text.length) : op === DIFF_DELETE ? editor.apply({
 		type: "remove.text",
 		path: spanEntry.path,
 		offset,
 		text
-	}) : op === 0 && (offset += text.length);
+	}) : op === DIFF_EQUAL && (offset += text.length);
 	return !0;
 }
 function insertPatch(context, editor, patch) {
@@ -9429,7 +8812,7 @@ function resolveSiblingContext(context, value, opPath) {
 	let resolvedParent = resolveIndexableNode(context, value, keyedParentPath);
 	if (!resolvedParent) return;
 	let childrenResult = getNodeChildren(context, resolvedParent.node, resolvedParent.containerOfParent);
-	if (!(!childrenResult || childrenResult.fieldName !== fieldSegment)) return {
+	if (childrenResult && childrenResult.fieldName === fieldSegment) return {
 		children: childrenResult.children,
 		serializedPrefix: serializePath([...keyedParentPath, fieldSegment])
 	};
@@ -9445,7 +8828,7 @@ function resolveSiblingContext(context, value, opPath) {
 function reindexSiblings(map, siblingContext, startIndex) {
 	for (let childIndex = Math.max(0, startIndex); childIndex < siblingContext.children.length; childIndex++) {
 		let child = siblingContext.children[childIndex];
-		!child || child._key === void 0 || map.set(`${siblingContext.serializedPrefix}[_key=="${child._key}"]`, childIndex);
+		child && child._key !== void 0 && map.set(`${siblingContext.serializedPrefix}[_key=="${child._key}"]`, childIndex);
 	}
 }
 /**
@@ -11691,7 +11074,7 @@ function planMergeKeyRenames(args) {
 		});
 	}
 	let childRenames = [], renamedChildren = mergingBlock.children.map((child) => {
-		let currentMarks = isSpan(context, child) ? child.marks : void 0, remappedMarks = currentMarks?.map((mark) => markDefKeyMap.get(mark) ?? mark), marksChanged = !!(remappedMarks && !isEqualMarks(remappedMarks, currentMarks)), newKey = destinationChildKeys.has(child._key) ? context.keyGenerator() : child._key, props = {};
+		let currentMarks = isSpan(context, child) ? child.marks : void 0, remappedMarks = currentMarks?.map((mark) => markDefKeyMap.get(mark) ?? mark), marksChanged = !(!remappedMarks || isEqualMarks(remappedMarks, currentMarks)), newKey = destinationChildKeys.has(child._key) ? context.keyGenerator() : child._key, props = {};
 		return newKey !== child._key && (props._key = newKey), marksChanged && (props.marks = remappedMarks), Object.keys(props).length > 0 && childRenames.push({
 			childKey: child._key,
 			props
@@ -12386,11 +11769,11 @@ function transformOperation(editor, patch, operation) {
 	if (patch.type === "unset" && patch.path.length === 0) return debug.history(`Adjusting selection for unset everything patch and ${operation.type} operation`), [];
 	if (patch.type === "diffMatchPatch") {
 		let operationTargetBlock = findOperationTargetBlock(snapshot, editor, transformedOperation), patchTargetBlock = getEnclosingBlock(snapshot, patch.path);
-		return !operationTargetBlock || !patchTargetBlock || operationTargetBlock._key !== patchTargetBlock.node._key || parse(patch.value).forEach((diffPatch) => {
+		return !operationTargetBlock || !patchTargetBlock || operationTargetBlock._key !== patchTargetBlock.node._key || parsePatch(patch.value).forEach((diffPatch) => {
 			let adjustOffsetBy = 0, changedOffset = diffPatch.utf8Start1, { diffs } = diffPatch;
 			if (diffs.forEach((diff, index) => {
 				let [diffType, text] = diff;
-				diffType === 1 ? (adjustOffsetBy += text.length, changedOffset += text.length) : diffType === -1 ? (adjustOffsetBy -= text.length, changedOffset -= text.length) : diffType === 0 && (diffs.slice(index).every(([dType]) => dType === 0) || (changedOffset += text.length));
+				diffType === DIFF_INSERT ? (adjustOffsetBy += text.length, changedOffset += text.length) : diffType === DIFF_DELETE ? (adjustOffsetBy -= text.length, changedOffset -= text.length) : diffType === DIFF_EQUAL && (diffs.slice(index).every(([dType]) => dType === DIFF_EQUAL) || (changedOffset += text.length));
 			}), transformedOperation.type === "insert.text" && changedOffset < transformedOperation.offset && (transformedOperation.offset += adjustOffsetBy), transformedOperation.type === "remove.text" && changedOffset <= transformedOperation.offset - transformedOperation.text.length && (transformedOperation.offset += adjustOffsetBy), transformedOperation.type === "set.selection") {
 				let currentFocus = transformedOperation.properties?.focus ? { ...transformedOperation.properties.focus } : void 0, currentAnchor = transformedOperation?.properties?.anchor ? { ...transformedOperation.properties.anchor } : void 0, newFocus = transformedOperation?.newProperties?.focus ? { ...transformedOperation.newProperties.focus } : void 0, newAnchor = transformedOperation?.newProperties?.anchor ? { ...transformedOperation.newProperties.anchor } : void 0;
 				(currentFocus && currentAnchor || newFocus && newAnchor) && ([
@@ -14438,7 +13821,7 @@ const abstractInsertBehaviors = [
 				context: snapshot.context,
 				block: endBlock
 			});
-			return !!(isTextBlockNode(snapshot.context, startBlock.node) && isTextBlockNode(snapshot.context, endBlock.node) && !isEqualSelectionPoints(startPoint, startBlockStartPoint) && !isEqualSelectionPoints(endPoint, endBlockEndPoint));
+			return !(!isTextBlockNode(snapshot.context, startBlock.node) || !isTextBlockNode(snapshot.context, endBlock.node) || isEqualSelectionPoints(startPoint, startBlockStartPoint) || isEqualSelectionPoints(endPoint, endBlockEndPoint));
 		},
 		actions: [() => [raise$1({ type: "delete" }), raise$1({ type: "split" })]]
 	}),
@@ -14784,7 +14167,7 @@ function sortByPriority(items) {
 		ensureNode(id);
 	}
 	function addEdge(fromId, toId) {
-		!graph.has(fromId) || !graph.has(toId) || (graph.get(fromId)?.add(toId), inDegree.set(toId, (inDegree.get(toId) ?? 0) + 1));
+		graph.has(fromId) && graph.has(toId) && (graph.get(fromId)?.add(toId), inDegree.set(toId, (inDegree.get(toId) ?? 0) + 1));
 	}
 	for (let item of itemsWithPriority) {
 		let id = item.priority.id, visited = /* @__PURE__ */ new Set(), ref = item.priority.reference;
@@ -15021,7 +14404,7 @@ function isTypeAlreadyRegistered(maps, attempting, type) {
 	]) {
 		if (otherKind === attempting || attempting === "blockObject" && otherKind === "inlineObject" || attempting === "inlineObject" && otherKind === "blockObject") continue;
 		let attemptingIsExclusive = exclusiveKinds.includes(attempting), otherIsExclusive = exclusiveKinds.includes(otherKind);
-		if (!(!attemptingIsExclusive && !otherIsExclusive) && claimedAs(otherKind)) return console.warn(`registerNode: type "${type}" is already registered as a ${otherKind}. A type must be exactly one of: container, textBlock, span, or co-registered as blockObject+inlineObject.`), !0;
+		if ((attemptingIsExclusive || otherIsExclusive) && claimedAs(otherKind)) return console.warn(`registerNode: type "${type}" is already registered as a ${otherKind}. A type must be exactly one of: container, textBlock, span, or co-registered as blockObject+inlineObject.`), !0;
 	}
 	return !1;
 }