@createiq/htmldiff 1.2.0-beta.1 → 1.2.0-beta.10

package/dist/HtmlDiff.mjs

@@ -1333,13 +1333,33 @@ function collectInsertionsKeyedByEnd(d) {
 	return out;
 }
 /**
-* Emit any insertions at boundary `b`. When both authors inserted at
-* the same boundary AND the inserted token sequences are textually
-* identical, the insertion is treated as agreed and emitted unmarked.
-* Otherwise each side's insertion is emitted with author attribution.
+* Emit any insertions at boundary `b`.
 *
-* The CP-then-Me ordering for disagreement is arbitrary but consistent;
-* callers don't depend on it.
+* Reading model: a legal reviewer wants to see CP's INTENT relative
+* to Me's current content. Me's content is the base; CP's deltas are
+* what they need to act on. Under that framing:
+*   - tokens both authors inserted at the same boundary → settled
+*   - tokens CP inserted that Me doesn't have → ins-cp (CP wants
+*     this added)
+*   - tokens Me inserted that CP doesn't have → del-cp (CP wants
+*     this removed from Me's content)
+*
+* The third case is the load-bearing attribution flip. The
+* genesis-spine view technically labels me-only-at-boundary tokens
+* as "ins-me" (Me added them; CP didn't), but that's confusing to
+* a reviewer: they see "Me added X" alongside "CP added Y" and have
+* to mentally derive "CP wants X gone, replaced with Y". Surfacing
+* me-only tokens as `del-cp` shows CP's intent directly:
+*   - "CP accepted Me's text minus `things`": settled bulk + del-cp
+*     `things` (no parallel redundant insertions)
+*   - "CP wants `cruel` where Me wrote `brave`": ins-cp `cruel` +
+*     del-cp `brave` (the substitution intent reads directly)
+*   - "CP added extra words": cp-extras stay as ins-cp (same as
+*     before; the cp-only direction was always intent-correct)
+*
+* Pure single-side insertions (Me added text CP doesn't engage
+* with at all, or vice versa) keep their genesis-spine attribution
+* — these aren't refinement cases, just Me's own content additions.
 */
 function emitBoundary(b, cpInsAt, meInsAt, _cpDiffWords, _meDiffWords, segments) {
 	const cpIns = cpInsAt.get(b);
@@ -1347,18 +1367,34 @@ function emitBoundary(b, cpInsAt, meInsAt, _cpDiffWords, _meDiffWords, segments)
 	const hasCp = !!cpIns && cpIns.length > 0;
 	const hasMe = !!meIns && meIns.length > 0;
 	if (!hasCp && !hasMe) return;
-	if (hasCp && hasMe && tokenArraysEqual(cpIns, meIns)) {
+	if (!hasCp) {
+		appendSegment(segments, {
+			kind: "ins",
+			author: "me"
+		}, meIns);
+		return;
+	}
+	if (!hasMe) {
+		appendSegment(segments, {
+			kind: "ins",
+			author: "cp"
+		}, cpIns);
+		return;
+	}
+	if (tokenArraysEqual(cpIns, meIns)) {
 		appendSegment(segments, { kind: "equal" }, cpIns);
 		return;
 	}
-	if (hasCp) appendSegment(segments, {
+	const alignment = lcsAlign(cpIns, meIns);
+	for (const a of alignment) if (a.oldIdx !== null && a.newIdx !== null) appendSegment(segments, { kind: "equal" }, [cpIns[a.oldIdx]]);
+	else if (a.oldIdx !== null) appendSegment(segments, {
 		kind: "ins",
 		author: "cp"
-	}, cpIns);
-	if (hasMe) appendSegment(segments, {
-		kind: "ins",
-		author: "me"
-	}, meIns);
+	}, [cpIns[a.oldIdx]]);
+	else if (a.newIdx !== null) appendSegment(segments, {
+		kind: "del",
+		author: "cp"
+	}, [meIns[a.newIdx]]);
 }
 function tokenArraysEqual(a, b) {
 	if (a.length !== b.length) return false;
@@ -1468,8 +1504,8 @@ function preprocessByContent(genesis, cpLatest, meCurrent, gTables, cTables, mTa
 	const gKeys = gTables.map((t) => tableKey(genesis, t));
 	const cKeys = cTables.map((t) => tableKey(cpLatest, t));
 	const mKeys = mTables.map((t) => tableKey(meCurrent, t));
-	const alignCp = lcsAlign(gKeys, cKeys);
-	const alignMe = lcsAlign(gKeys, mKeys);
+	const alignCp = pairSimilarTablesThreeWay(lcsAlign(gKeys, cKeys), genesis, cpLatest, gTables, cTables);
+	const alignMe = pairSimilarTablesThreeWay(lcsAlign(gKeys, mKeys), genesis, meCurrent, gTables, mTables);
 	const gToCp = new Array(gTables.length).fill(-1);
 	const cpToG = new Array(cTables.length).fill(-1);
 	for (const a of alignCp) if (a.oldIdx !== null && a.newIdx !== null) {
@@ -1580,7 +1616,7 @@ function preprocessByContent(genesis, cpLatest, meCurrent, gTables, cTables, mTa
 		placeholderToDiff
 	};
 }
-const POSITIONAL_PAIR_SIMILARITY_THRESHOLD = .5;
+const POSITIONAL_PAIR_SIMILARITY_THRESHOLD = .15;
 function positionallyAligned(genesis, cpLatest, meCurrent, gTables, cTables, mTables) {
 	if (gTables.length !== cTables.length || cTables.length !== mTables.length) return false;
 	for (let i = 0; i < gTables.length; i++) {
@@ -1595,6 +1631,59 @@ function positionallyAligned(genesis, cpLatest, meCurrent, gTables, cTables, mTa
 function tableKey(html, table) {
 	return html.slice(table.tableStart, table.tableEnd).replace(/\s+/g, " ").trim();
 }
+/**
+* Character-level similarity above which the three-way aligner treats
+* two rows / tables as "the same logical entry, edited" rather than
+* an unrelated delete + insert. Matched to TableDiff's
+* `ROW_FUZZY_THRESHOLD` / `CELL_FUZZY_THRESHOLD` so 2-way and 3-way
+* agree on which pairings are reachable; if a row's content overlap
+* is enough to fool the 2-way diff into pairing, it should also be
+* enough for 3-way.
+*/
+const THREE_WAY_FUZZY_THRESHOLD = .5;
+/**
+* Run the same fuzzy-pairing pass `TableDiff.pairSimilarUnmatchedRows`
+* applies after its exact-LCS, but against one side of the genesis
+* spine (either cp or me). The genesis tables/rows are always the
+* "old" side; `newTable` is the cp or me table being aligned. Returns
+* the enriched alignment with additional paired entries.
+*
+* Cell-count guard: only fuzzy-pair when both rows have the same cell
+* count. Without this guard an asymmetric restructure — e.g. CP and
+* Me both added a different column — leads to ONE side fuzzy-pairing
+* its row with genesis (content overlap above threshold) while the
+* other side falls below threshold. That mismatch routes through
+* `diffTableStructural`'s "Me dropped, CP kept" (or the mirror)
+* branch, which emits CP's row as a Me-attributed deletion. In
+* cp-only mode `stripMeAttributedMarkers` then removes the row
+* entirely and CP's edit vanishes from the view — exactly the
+* content-loss case we're meant to prevent. Restricting fuzzy
+* pairing to same-shape rows preserves the common case (single cell
+* edit, identical row shape) while pushing structural mismatches
+* back to the boundary-insertion path that emits both sides
+* explicitly.
+*/
+function pairSimilarRowsThreeWay(alignment, genesis, newHtml, oldTable, newTable) {
+	const oldTexts = oldTable.rows.map((r) => rowText(genesis, r));
+	const newTexts = newTable.rows.map((r) => rowText(newHtml, r));
+	return pairSimilarUnmatched(alignment, THREE_WAY_FUZZY_THRESHOLD, (oldIdx, newIdx) => {
+		if (oldTable.rows[oldIdx].cells.length !== newTable.rows[newIdx].cells.length) return 0;
+		return textSimilarity(oldTexts[oldIdx], newTexts[newIdx]);
+	});
+}
+/**
+* Table-level counterpart: after `lcsAlign(gKeys, otherKeys)` over
+* full table HTML keys, fuzzy-pair unmatched table runs by their
+* row-text-concatenated content. Without this, a table whose body
+* was edited (but not its outer shape) fails the exact-key match
+* and the preprocessing emits whole-table del + whole-table ins
+* instead of recursing into per-cell three-way diffs.
+*/
+function pairSimilarTablesThreeWay(alignment, oldHtml, newHtml, oldTables, newTables) {
+	const oldTexts = oldTables.map((t) => t.rows.map((r) => rowText(oldHtml, r)).join(" "));
+	const newTexts = newTables.map((t) => t.rows.map((r) => rowText(newHtml, r)).join(" "));
+	return pairSimilarUnmatched(alignment, THREE_WAY_FUZZY_THRESHOLD, (oldIdx, newIdx) => textSimilarity(oldTexts[oldIdx], newTexts[newIdx]));
+}
 function diffTableThreeWay(genesis, cpLatest, meCurrent, tG, tC, tM, cellDiff) {
 	if (sameDimensions(tG, tC) && sameDimensions(tC, tM)) return diffTablePositional(genesis, cpLatest, meCurrent, tG, tC, tM, cellDiff);
 	return diffTableStructural(genesis, cpLatest, meCurrent, tG, tC, tM, cellDiff);
@@ -1637,8 +1726,8 @@ function diffTableStructural(genesis, cpLatest, meCurrent, tG, tC, tM, cellDiff)
 	const gKeys = tG.rows.map((r) => rowKey(genesis, r));
 	const cKeys = tC.rows.map((r) => rowKey(cpLatest, r));
 	const mKeys = tM.rows.map((r) => rowKey(meCurrent, r));
-	const alignCp = lcsAlign(gKeys, cKeys);
-	const alignMe = lcsAlign(gKeys, mKeys);
+	const alignCp = pairSimilarRowsThreeWay(lcsAlign(gKeys, cKeys), genesis, cpLatest, tG, tC);
+	const alignMe = pairSimilarRowsThreeWay(lcsAlign(gKeys, mKeys), genesis, meCurrent, tG, tM);
 	const gToCp = new Array(tG.rows.length).fill(-1);
 	for (const a of alignCp) if (a.oldIdx !== null && a.newIdx !== null) gToCp[a.oldIdx] = a.newIdx;
 	const gToMe = new Array(tG.rows.length).fill(-1);
@@ -1695,7 +1784,20 @@ function emitPreservedRow(genesis, cpLatest, meCurrent, rG, rC, rM, cellDiff) {
 		out.push(genesis.slice(cursor, rG.rowEnd));
 		return out.join("");
 	}
-	return emitFullRowAttributed(genesis, rG, "del", "me") + emitFullRowAttributed(meCurrent, rM, "ins", "me");
+	const cpRestructured = rC.cells.length !== rG.cells.length;
+	const meRestructured = rM.cells.length !== rG.cells.length;
+	const blocks = [];
+	if (cpRestructured && meRestructured) {
+		blocks.push(emitFullRowAttributed(cpLatest, rC, "ins", "cp"));
+		blocks.push(emitFullRowAttributed(meCurrent, rM, "ins", "me"));
+	} else if (cpRestructured) {
+		blocks.push(emitFullRowAttributed(genesis, rG, "del", "cp"));
+		blocks.push(emitFullRowAttributed(cpLatest, rC, "ins", "cp"));
+	} else {
+		blocks.push(emitFullRowAttributed(genesis, rG, "del", "me"));
+		blocks.push(emitFullRowAttributed(meCurrent, rM, "ins", "me"));
+	}
+	return blocks.join("");
 }
 /**
 * Returns map "genesis-row-boundary → list of new-side row indices
@@ -1969,6 +2071,37 @@ var BlockFinder = class {
 };
 //#endregion
 //#region src/HtmlDiff.ts
+/**
+* Opinionated options that align htmldiff's output with Microsoft Word's
+* track-changes rendering for legal-document rewrites.
+*
+* The library's bare default (`orphanMatchThreshold = 0`) keeps every
+* LCS match, however small — which fragments long sentence rewrites
+* into many tiny ins/del pairs around stray word matches ("of", "the",
+* "shall"). Word collapses those into a single coarse del+ins, which is
+* dramatically more readable for legal text.
+*
+* 0.25 was tuned empirically against a customer Word reference (US
+* Commercial One CP, May 2026):
+*   - short edits (typo / one-word insert): output identical to
+*     threshold=0 — inter-match distances are tiny so every match
+*     trivially clears the bar;
+*   - long rewrites (the "Specified Indebtedness" rewrite in the
+*     reference): previously produced 6 dels + 5 ins fragmented around
+*     stray matches; at 0.25 it condenses to 3 dels + 2 ins — close to
+*     Word's 1+1 and a major readability win;
+*   - higher values (0.3+) collapsed short edits containing inline
+*     formatting changes into a single block — too aggressive.
+*
+* Consumers rendering legal documents should spread this into their
+* options:
+*   `HtmlDiff.execute(old, new, { ...WORD_ALIGNED_OPTIONS })`
+*   `HtmlDiff.executeThreeWay(g, c, m, { ...WORD_ALIGNED_OPTIONS })`
+*
+* Other consumers (machine-readable diff, exact-token alignment) can
+* keep the bare default.
+*/
+const WORD_ALIGNED_OPTIONS = { orphanMatchThreshold: .25 };
 var HtmlDiff = class HtmlDiff {
 	/**
 	* This value defines balance between speed and memory utilization. The higher it is the faster it works and more memory consumes.
@@ -2044,6 +2177,16 @@ var HtmlDiff = class HtmlDiff {
 	newText;
 	oldText;
 	tablePreprocessDepth = 0;
+	/**
+	* Tracks currently-open formatting-tag wraps. Each entry pairs the
+	* opening tag (so a later closing tag can find its match) with the
+	* styling info needed to RE-OPEN the wrap if an overlapping
+	* formatting-tag close forces it to split. Without the styling info,
+	* an overlap like `<strong>X</strong>` ↔ `<u>X</u>` produces an
+	* unclosable wrap (the closing tag for the outer wrap arrives while
+	* an inner wrap is still on the stack); see `insertTag`'s closing
+	* handler for the split logic.
+	*/
 	specialTagDiffStack = [];
 	newWords = [];
 	oldWords = [];
@@ -2111,8 +2254,23 @@ var HtmlDiff = class HtmlDiff {
 		this.oldText = oldText;
 		this.newText = newText;
 	}
-	static execute(oldText, newText) {
-		return new HtmlDiff(oldText, newText).build();
+	/**
+	* Two-way diff entry point. Accepts the same `AnalyzeOptions` bag as
+	* `executeThreeWay`, with two intentional exceptions documented
+	* inline below. Consumers wanting Word-aligned output should spread
+	* `WORD_ALIGNED_OPTIONS` into the third argument.
+	*
+	* Note: unlike `analyze`, `execute` runs `build()` which performs
+	* full table preprocessing — `tablePreprocessDepth` stays at 0 so
+	* the recursive cell diff can happen. Callers can't override that.
+	*/
+	static execute(oldText, newText, options = {}) {
+		const inner = new HtmlDiff(oldText, newText);
+		if (options.blockExpressions) for (const expr of options.blockExpressions) inner.addBlockExpression(expr);
+		if (options.repeatingWordsAccuracy !== void 0) inner.repeatingWordsAccuracy = options.repeatingWordsAccuracy;
+		if (options.orphanMatchThreshold !== void 0) inner.orphanMatchThreshold = options.orphanMatchThreshold;
+		if (options.ignoreWhitespaceDifferences !== void 0) inner.ignoreWhitespaceDifferences = options.ignoreWhitespaceDifferences;
+		return inner.build();
 	}
 	/**
 	* Analyse a two-way diff and return its raw building blocks: the word
@@ -2181,22 +2339,6 @@ var HtmlDiff = class HtmlDiff {
 		return HtmlDiff.shouldUseContentProjections(oldWords, newWords, oldProj, newProj);
 	}
 	/**
-	* Three-way HTML diff. Given V1 (the version Me last sent), V2 (the
-	* version CP sent back), and V3 (Me's current draft), produces a
-	* single attributed HTML output where CP's and Me's changes are
-	* distinguished by `data-author` ('cp' or 'me') and matching
-	* `class='diffins cp'` / `class='diffdel me'` etc. The "Me rejected
-	* CP's proposal" case (Me deleted text CP had inserted) gets a
-	* dedicated marker: `data-rejects='cp'` plus `class='... rejects-cp'`.
-	*
-	* Coordinates the symmetric-projection decision (D1) across both
-	* internal `analyze` calls so V2 tokenises identically on each side
-	* of the spine. When `useProjections` is left undefined, the decision
-	* is the conjunction of both pair-wise heuristics — project iff both
-	* pairs would project on their own. Pass an explicit boolean to
-	* override.
-	*/
-	/**
 	* Three-way HTML diff against a shared genesis. Produces attributed
 	* HTML that distinguishes CP's accumulated changes (genesis → cpLatest)
 	* from Me's accumulated changes (genesis → meCurrent). Use this for
@@ -2243,6 +2385,25 @@ var HtmlDiff = class HtmlDiff {
 	* buffer. Reusing the instance keeps the formatting-tag stack
 	* (`specialTagDiffStack`) coherent across segments — a `<strong>`
 	* opened in one segment and closed in another stays balanced.
+	*
+	* Edge case: an ins/del segment can open a formatting wrap whose
+	* matching closer ends up in an equal segment (`<strong>` deleted
+	* by CP but `</strong>` kept by both — buildSegments emits the open
+	* as del-cp and the close as equal). Equal segments bypass
+	* `insertTag` and push raw, so the stack entry for the open is
+	* never popped. Rather than throw — which forces the caller's UI
+	* into an error boundary — close every leftover wrap with `</ins>`
+	* at the end of emission.
+	*
+	* Caveat: the `</ins>` close is honest for the mod-wrap that the
+	* opener pushed (every formatting opener emits an inner `<ins…>`
+	* postInject regardless of whether the outer segment is ins or
+	* del). For del-segment formatting openers the outer `<del>` may
+	* itself be left open by the same emission imbalance; this fixup
+	* doesn't address that. Downstream browsers/DOMParser normalise
+	* mildly-malformed HTML by closing dangling tags, so the rendered
+	* output is usually acceptable — but the warning IS the signal
+	* that the input had a real imbalance worth investigating.
 	*/
 	static emitSegments(segments) {
 		const emitter = new HtmlDiff("", "");
@@ -2254,7 +2415,13 @@ var HtmlDiff = class HtmlDiff {
 			const { tag, baseClass, metadata } = segmentEmissionShape(seg.attr);
 			emitter.insertTag(tag, baseClass, [...seg.words], metadata);
 		}
-		if (emitter.specialTagDiffStack.length > 0) throw new Error(`HtmlDiff.executeThreeWay: emission left ${emitter.specialTagDiffStack.length} unclosed formatting tag(s) on the stack — input may have unbalanced <strong>/<em>/etc. or there is a bug in segment emission.`);
+		if (emitter.specialTagDiffStack.length > 0) {
+			console.warn(`HtmlDiff.executeThreeWay: emission left ${emitter.specialTagDiffStack.length} unclosed formatting wrap(s) on the stack. Closing defensively. This usually means a formatting tag opens in a del/ins segment and its matching closer is in an equal segment.`);
+			while (emitter.specialTagDiffStack.length > 0) {
+				emitter.content.push("</ins>");
+				emitter.specialTagDiffStack.pop();
+			}
+		}
 		return emitter.content.join("");
 	}
 	/**
@@ -2510,38 +2677,52 @@ var HtmlDiff = class HtmlDiff {
 			if (words.length === 0) break;
 			const indexOfFirstNonTag = words.findIndex((x) => !Utils_default.isTag(x));
 			const indexLastTagInFirstTagBlock = indexOfFirstNonTag === -1 ? words.length - 1 : indexOfFirstNonTag - 1;
-			let specialCaseTagInjection = "";
-			let specialCaseTagInjectionIsBefore = false;
+			let preInject = "";
+			let postInject = "";
 			if (HtmlDiff.SpecialCaseOpeningTagRegex.test(words[0])) {
 				const tagNames = /* @__PURE__ */ new Set();
 				for (const word of words) if (Utils_default.isTag(word)) tagNames.add(Utils_default.getTagName(word));
 				const styledTagNames = Array.from(tagNames).join(" ");
-				this.specialTagDiffStack.push(words[0]);
-				specialCaseTagInjection = `<ins${Utils_default.composeTagAttributes(`mod ${styledTagNames}`, metadata ?? {})}>`;
+				const styledCssClass = `mod ${styledTagNames}`;
+				this.specialTagDiffStack.push({
+					tag: words[0],
+					styledTagNames,
+					cssClass: styledCssClass,
+					metadata
+				});
+				postInject = `<ins${Utils_default.composeTagAttributes(styledCssClass, metadata ?? {})}>`;
 				if (tag === HtmlDiff.DelTag) {
 					words.shift();
 					while (words.length > 0 && HtmlDiff.SpecialCaseOpeningTagRegex.test(words[0])) words.shift();
 				}
 			} else if (HtmlDiff.SpecialCaseClosingTagsSet.has(words[0].toLowerCase())) {
-				const openingTag = this.specialTagDiffStack.length === 0 ? null : this.specialTagDiffStack.pop();
 				let tagIndexToCompare = indexLastTagInFirstTagBlock;
 				if (tag === HtmlDiff.DelTag && indexOfFirstNonTag === -1) {
 					if (words.slice(0, indexLastTagInFirstTagBlock + 1).some((w) => !HtmlDiff.SpecialCaseClosingTagsSet.has(w.toLowerCase()))) tagIndexToCompare = 0;
 				}
-				const openingAndClosingTagsMatch = !!openingTag && Utils_default.getTagName(openingTag) === Utils_default.getTagName(words[tagIndexToCompare]);
-				if (openingTag && openingAndClosingTagsMatch) {
-					specialCaseTagInjection = "</ins>";
-					specialCaseTagInjectionIsBefore = true;
-				} else if (openingTag) this.specialTagDiffStack.push(openingTag);
+				const closingTagName = Utils_default.getTagName(words[tagIndexToCompare]);
+				let matchIdx = -1;
+				for (let i = this.specialTagDiffStack.length - 1; i >= 0; i--) if (Utils_default.getTagName(this.specialTagDiffStack[i].tag) === closingTagName) {
+					matchIdx = i;
+					break;
+				}
+				if (matchIdx >= 0) {
+					const aboveEntries = this.specialTagDiffStack.splice(matchIdx + 1);
+					this.specialTagDiffStack.pop();
+					preInject = "</ins>".repeat(aboveEntries.length + 1);
+					for (const entry of aboveEntries) {
+						postInject += `<ins${Utils_default.composeTagAttributes(entry.cssClass, entry.metadata ?? {})}>`;
+						this.specialTagDiffStack.push(entry);
+					}
+				}
 				if (tag === HtmlDiff.DelTag) {
 					words.shift();
 					while (words.length > 0 && HtmlDiff.SpecialCaseClosingTagsSet.has(words[0].toLowerCase())) words.shift();
 				}
 			}
-			if (words.length === 0 && specialCaseTagInjection.length === 0) break;
+			if (words.length === 0 && preInject.length === 0 && postInject.length === 0) break;
 			const isTagForExtraction = tag === HtmlDiff.DelTag ? (x) => Utils_default.isTag(x) && !HtmlDiff.SpecialCaseOpeningTagRegex.test(x) && !HtmlDiff.SpecialCaseClosingTagsSet.has(x.toLowerCase()) : Utils_default.isTag;
-			if (specialCaseTagInjectionIsBefore) this.content.push(specialCaseTagInjection + this.extractConsecutiveWords(words, isTagForExtraction).join(""));
-			else this.content.push(this.extractConsecutiveWords(words, isTagForExtraction).join("") + specialCaseTagInjection);
+			this.content.push(preInject + this.extractConsecutiveWords(words, isTagForExtraction).join("") + postInject);
 			if (words.length === 0) continue;
 			this.insertTag(tag, cssClass, words, metadata);
 			break;
@@ -2606,6 +2787,17 @@ var HtmlDiff = class HtmlDiff {
 				curr = next;
 				continue;
 			}
+			let allTags = true;
+			for (let i = curr.startInNew; i < curr.endInNew; i++) if (!Utils_default.isTag(wordsForDiffNew[i])) {
+				allTags = false;
+				break;
+			}
+			if (allTags) {
+				yield curr;
+				prev = curr;
+				curr = next;
+				continue;
+			}
 			let oldDistanceInChars = 0;
 			for (let i = prev.endInOld; i < next.startInOld; i++) oldDistanceInChars += wordsForDiffOld[i].length;
 			let newDistanceInChars = 0;
@@ -2648,6 +2840,6 @@ var HtmlDiff = class HtmlDiff {
 	}
 };
 //#endregion
-export { HtmlDiff as default };
+export { WORD_ALIGNED_OPTIONS, HtmlDiff as default };
 
 //# sourceMappingURL=HtmlDiff.mjs.map