@stll/folio-core 0.47.5 → 0.47.7

package/dist/ai-edits/word-diff.d.ts

@@ -2,8 +2,9 @@
 /**
  * Diff between two strings, as the segments a redline is drawn from.
  *
- * Tokenises (by default on whitespace boundaries, preserving the whitespace as
- * part of each token), runs an LCS, and returns a left-to-right ordered list of
+ * Tokenises (by default into words and the punctuation marks at their edges,
+ * preserving the whitespace as part of each token; see {@link pushRunTokens}),
+ * runs an LCS, and returns a left-to-right ordered list of
  * segments where shared runs render as `equal`, removed runs as `del`, and
  * added runs as `ins`. Used by the panel (to render minimal-change redlines),
  * the version comparison, and the apply engine (so tracked changes mark only
@@ -18,10 +19,25 @@
  * same thing and can actually be read. Three rules pull the output back:
  *
  * 1. A match made only of separators is not a match ({@link isSeparatorOnly}).
- * 2. A match too short to carry meaning is dropped unless it opens the string,
- *    where it is the reader's anchor rather than an island.
+ * 2. A match too short to carry meaning is dropped when changes sit on both
+ *    sides of it and at least one of them changes words. At either end of the
+ *    string it is the reader's anchor, and
+ *    between two punctuation or whitespace edits it is what they were made
+ *    around; neither is an island.
  * 3. When what survives is still too fragmented for its length, the whole
- *    paragraph is one replacement ({@link isTooFragmented}).
+ *    paragraph is one replacement ({@link isTooFragmented}). Punctuation and
+ *    whitespace edits alone never are.
+ *
+ * At word granularity the LCS itself prefers words: one matched word outweighs
+ * any number of matched marks, and a unique mark is never an anchor.
+ *
+ * A word token carries the whitespace before it, so a string's first word has
+ * none while the same word inside the other string does. Word tokens are
+ * therefore matched on their text alone; the rules above judge that
+ * alignment, and a whitespace difference around a matched word is marked
+ * afterwards as a change of the whitespace only
+ * ({@link separateWhitespaceChanges}). Otherwise prefixing "(1) " would strike
+ * through the unchanged first word.
  *
  * Common affixes and unique-token anchors split the input into independent
  * gaps before any quadratic work. The residual gaps share one
@@ -61,6 +77,9 @@ type WordDiffOptions = {
   /** Default: nothing normalized, so both strings reconstruct exactly. */
   normalization?: WordDiffNormalization;
 };
+/** Keep token storage bounded when a run has an unusually long punctuation edge. */
+declare const MAX_EDGE_PUNCTUATION_TOKENS = 64;
+declare const tokenizeWords: (value: string) => string[];
 /**
  * One internal comparison/apply scope. Every diff shares the same quadratic
  * allowance; public standalone calls below still receive a fresh allowance.
@@ -75,4 +94,4 @@ declare const createScopedWordDiffOptions: <Options extends WordDiffOptions>(opt
 declare const wordDiffSessionFromOptions: (options: WordDiffOptions | undefined) => ReturnType<typeof createWordDiffSession>;
 declare const diffWordSegments: (before: string, after: string, options?: WordDiffOptions) => WordDiffSegment[];
 //#endregion
-export { WORD_DIFF_GRANULARITIES, WordDiffGranularity, WordDiffNormalization, WordDiffOptions, WordDiffSegment, createScopedWordDiffOptions, createWordDiffSession, diffWordSegments, wordDiffSessionFromOptions };
+export { MAX_EDGE_PUNCTUATION_TOKENS, WORD_DIFF_GRANULARITIES, WordDiffGranularity, WordDiffNormalization, WordDiffOptions, WordDiffSegment, createScopedWordDiffOptions, createWordDiffSession, diffWordSegments, tokenizeWords, wordDiffSessionFromOptions };

package/dist/ai-edits/word-diff.js

@@ -7,10 +7,11 @@
 */
 const WORD_DIFF_GRANULARITIES = Object.freeze(["word", "character"]);
 const WHITESPACE = /\s/u;
-/** Punctuation, symbols and whitespace: everything that is not content. */
-const SEPARATOR_ONLY = /^[\s\p{P}\p{S}]*$/u;
+/** Punctuation and whitespace carry no content except legal section/paragraph signs. */
+const SEPARATOR_ONLY = /^[\s\p{P}]*$/u;
+const CONTENT_PUNCTUATION = /[§¶]/u;
 /**
-* A match of at most this many tokens that carries no letters or digits is
+* A match of at most this many tokens that carries only punctuation or space is
 * noise: a lone space, a comma, a stray closing bracket. Matching it splits
 * two rewrites into four.
 */
@@ -33,6 +34,59 @@ const MINIMUM_ISOLATED_MATCH_UNITS = 2;
 const FRAGMENTATION_SCALE = 32;
 /** Below this length every match is a large fraction of the string, so the floor says nothing. */
 const FRAGMENTATION_MINIMUM_AVERAGE_LENGTH = 8;
+/** Unicode general category P: punctuation marks, dashes, brackets and quotes. */
+const PUNCTUATION = /^\p{P}$/u;
+/** Keep token storage bounded when a run has an unusually long punctuation edge. */
+const MAX_EDGE_PUNCTUATION_TOKENS = 64;
+/** The code point starting at `index`, as a string of one or two UTF-16 units. */
+const codePointAt = (value, index) => String.fromCodePoint(value.codePointAt(index) ?? 0);
+/** The code point ending just before `end`. */
+const codePointBefore = (value, end) => {
+	const low = value.charCodeAt(end - 1);
+	const high = value.charCodeAt(end - 2);
+	return low >= 56320 && low <= 57343 && high >= 55296 && high <= 56319 ? value.slice(end - 2, end) : value.slice(end - 1, end);
+};
+/**
+* Split one whitespace-free run into its words and punctuation marks.
+*
+* Punctuation marks (general category P) at either edge of the run are
+* tokens of their own, as Word's compare treats them: `jmění.` becoming `jmění,`
+* changes the mark, not the word. Punctuation inside the run stays in the
+* word, so `d.o.o`, `1.1.2026`, `3.5`, `well-known` and `don't` are single
+* tokens; only their edge marks split off (`d.o.o.` is `d.o.o` + `.`, `b)` is
+* `b` + `)`). A run made only of punctuation is split up to the edge cap.
+* `§` and `¶` are content markers despite their Unicode punctuation category;
+* symbols (general category S, such as `€` or `+`) are not punctuation.
+*/
+const pushRunTokens = (tokens, value, run, prefixStart) => {
+	let wordStart = run.start;
+	let pending = value.slice(prefixStart, run.start);
+	let leadingMarks = 0;
+	while (wordStart < run.end && leadingMarks < 64) {
+		const mark = codePointAt(value, wordStart);
+		if (!PUNCTUATION.test(mark) || CONTENT_PUNCTUATION.test(mark)) break;
+		tokens.push(pending + mark);
+		pending = "";
+		wordStart += mark.length;
+		leadingMarks++;
+	}
+	let wordEnd = run.end;
+	const trailing = [];
+	while (wordEnd > wordStart && trailing.length < 64) {
+		const mark = codePointBefore(value, wordEnd);
+		if (!PUNCTUATION.test(mark) || CONTENT_PUNCTUATION.test(mark)) break;
+		trailing.push(mark);
+		wordEnd -= mark.length;
+	}
+	if (wordStart < wordEnd) {
+		tokens.push(pending + value.slice(wordStart, wordEnd));
+		pending = "";
+	}
+	for (let index = trailing.length - 1; index >= 0; index--) {
+		tokens.push(pending + (trailing[index] ?? ""));
+		pending = "";
+	}
+};
 const tokenizeWords = (value) => {
 	const tokens = [];
 	let tokenStart = 0;
@@ -40,8 +94,12 @@ const tokenizeWords = (value) => {
 	while (cursor < value.length) {
 		while (cursor < value.length && WHITESPACE.test(value.charAt(cursor))) cursor++;
 		if (cursor === value.length) break;
+		const runStart = cursor;
 		while (cursor < value.length && !WHITESPACE.test(value.charAt(cursor))) cursor++;
-		tokens.push(value.slice(tokenStart, cursor));
+		pushRunTokens(tokens, value, {
+			start: runStart,
+			end: cursor
+		}, tokenStart);
 		tokenStart = cursor;
 	}
 	const last = tokens.at(-1);
@@ -61,7 +119,7 @@ const comparisonKey = (token, normalization) => {
 	const collapsed = normalization.whitespace === true ? token.replaceAll(/\s+/gu, " ").trim() : token;
 	return normalization.case === true ? collapsed.toLowerCase() : collapsed;
 };
-const isSeparatorOnly = (text) => SEPARATOR_ONLY.test(text);
+const isSeparatorOnly = (text) => SEPARATOR_ONLY.test(text) && !CONTENT_PUNCTUATION.test(text);
 /**
 * Cell budget shared by the residual LCS gaps inside one comparison or apply
 * scope. `before`/`after` come from attacker-controlled document text (a
@@ -85,11 +143,21 @@ const MAX_WORD_DIFF_ANCHOR_TOKENS = 16384;
 * and case or whitespace normalization creates another string for it.
 */
 const MAX_WORD_DIFF_COMPARISON_KEY_CODE_UNITS = 1048576;
+/**
+* How the LCS scores a match. `uniform` counts every matched token once;
+* `content-first` (word granularity) never trades a matched word for matched
+* punctuation, so moving a mark across a word cannot strike the word through.
+*/
+const MATCH_WEIGHTING = {
+	Uniform: "uniform",
+	ContentFirst: "content-first"
+};
 const ALIGNMENT_OPERATION = {
 	Equal: 1,
 	Delete: 2,
 	Insert: 3
 };
+const hasOppositeChange = (runs, direction) => runs.some(({ type }) => type === (direction === "insertion" ? "del" : "ins"));
 const fitsCellBudget = (beforeLength, afterLength, budget) => beforeLength === 0 || afterLength === 0 || beforeLength <= Math.floor(budget.remainingCells / afterLength);
 const pushRun = (runs, run) => {
 	const last = runs.at(-1);
@@ -128,13 +196,7 @@ const pushChangedRange = (runs, before, after, beforeRange, afterRange) => {
 		text: joinTokenRange(after, afterRange)
 	});
 };
-/**
-* Unique tokens common to both ranges, reduced to a monotone subsequence of
-* target positions. Repeated boilerplate is deliberately ineligible: a unique
-* clause number or name is stronger lineage evidence than another occurrence
-* of "the" chosen by an arbitrary LCS tie.
-*/
-const findPatienceAnchors = (beforeKeys, afterKeys, beforeRange, afterRange) => {
+const findPatienceAnchors = ({ beforeKeys, afterKeys, beforeRange, afterRange, weighting }) => {
 	const beforeOccurrences = /* @__PURE__ */ new Map();
 	for (let index = beforeRange.start; index < beforeRange.end; index++) {
 		const key = beforeKeys[index] ?? "";
@@ -155,7 +217,7 @@ const findPatienceAnchors = (beforeKeys, afterKeys, beforeRange, afterRange) =>
 		const key = beforeKeys[beforeIndex] ?? "";
 		const beforeCount = beforeOccurrences.get(key);
 		const afterOccurrence = afterOccurrences.get(key);
-		if (beforeCount === 1 && afterOccurrence?.count === 1) candidates.push({
+		if ((weighting === MATCH_WEIGHTING.Uniform || !isSeparatorOnly(key)) && beforeCount === 1 && afterOccurrence?.count === 1) candidates.push({
 			beforeIndex,
 			afterIndex: afterOccurrence.index
 		});
@@ -275,7 +337,7 @@ const alignMonotoneChange = (beforeText, afterText, before, after, normalization
 	return runs;
 };
 /** Longest-common-subsequence alignment for one residual, bounded gap. */
-const alignDenseGap = ({ before, after, beforeKeys, afterKeys, beforeRange, afterRange, runs, budget }) => {
+const alignDenseGap = ({ before, after, beforeKeys, afterKeys, beforeRange, afterRange, runs, budget, weighting }) => {
 	const beforeLength = beforeRange.end - beforeRange.start;
 	const afterLength = afterRange.end - afterRange.start;
 	if (beforeLength === 0 || afterLength === 0) {
@@ -289,15 +351,24 @@ const alignDenseGap = ({ before, after, beforeKeys, afterKeys, beforeRange, afte
 	const cellCount = beforeLength * afterLength;
 	budget.remainingCells -= cellCount;
 	const lengths = new Uint32Array(cellCount);
-	for (let beforeOffset = 0; beforeOffset < beforeLength; beforeOffset++) for (let afterOffset = 0; afterOffset < afterLength; afterOffset++) {
-		const index = beforeOffset * afterLength + afterOffset;
-		if (beforeKeys[beforeRange.start + beforeOffset] === afterKeys[afterRange.start + afterOffset]) {
-			lengths[index] = (beforeOffset > 0 && afterOffset > 0 ? lengths[(beforeOffset - 1) * afterLength + afterOffset - 1] ?? 0 : 0) + 1;
-			continue;
+	const contentWeight = weighting === MATCH_WEIGHTING.ContentFirst ? Math.min(beforeLength, afterLength) + 1 : 1;
+	const matchWeights = new Uint32Array(beforeLength);
+	for (let beforeOffset = 0; beforeOffset < beforeLength; beforeOffset++) {
+		const key = beforeKeys[beforeRange.start + beforeOffset] ?? "";
+		matchWeights[beforeOffset] = isSeparatorOnly(key) ? 1 : contentWeight;
+	}
+	for (let beforeOffset = 0; beforeOffset < beforeLength; beforeOffset++) {
+		const matchWeight = matchWeights[beforeOffset] ?? 1;
+		for (let afterOffset = 0; afterOffset < afterLength; afterOffset++) {
+			const index = beforeOffset * afterLength + afterOffset;
+			if (beforeKeys[beforeRange.start + beforeOffset] === afterKeys[afterRange.start + afterOffset]) {
+				lengths[index] = (beforeOffset > 0 && afterOffset > 0 ? lengths[(beforeOffset - 1) * afterLength + afterOffset - 1] ?? 0 : 0) + matchWeight;
+				continue;
+			}
+			const above = beforeOffset > 0 ? lengths[(beforeOffset - 1) * afterLength + afterOffset] ?? 0 : 0;
+			const left = afterOffset > 0 ? lengths[index - 1] ?? 0 : 0;
+			lengths[index] = Math.max(above, left);
 		}
-		const above = beforeOffset > 0 ? lengths[(beforeOffset - 1) * afterLength + afterOffset] ?? 0 : 0;
-		const left = afterOffset > 0 ? lengths[index - 1] ?? 0 : 0;
-		lengths[index] = Math.max(above, left);
 	}
 	const reversedOperations = new Uint8Array(beforeLength + afterLength);
 	let operationCount = 0;
@@ -404,7 +475,7 @@ const alignGap = (options) => {
 * repeated boilerplate from winning a tie over a unique legal term, and makes
 * a small edit inside a long paragraph pay for only its changed gap.
 */
-const alignTokens = ({ beforeText, afterText, before, after, normalization, budget }) => {
+const alignTokens = ({ beforeText, afterText, before, after, normalization, budget, weighting }) => {
 	let commonPrefixLength = 0;
 	let beforePrefixLength = 0;
 	let afterPrefixLength = 0;
@@ -491,7 +562,13 @@ const alignTokens = ({ beforeText, afterText, before, after, normalization, budg
 		start: 0,
 		end: afterMiddle.length
 	};
-	const anchors = findPatienceAnchors(beforeKeys, afterKeys, middleRangeBefore, middleRangeAfter);
+	const anchors = findPatienceAnchors({
+		beforeKeys,
+		afterKeys,
+		beforeRange: middleRangeBefore,
+		afterRange: middleRangeAfter,
+		weighting
+	});
 	if (anchors.length === 0 && fullInputFits && fullInputFitsStorage) {
 		alignDenseGap({
 			before,
@@ -507,7 +584,8 @@ const alignTokens = ({ beforeText, afterText, before, after, normalization, budg
 				end: after.length
 			},
 			runs,
-			budget
+			budget,
+			weighting
 		});
 		return {
 			runs,
@@ -538,7 +616,8 @@ const alignTokens = ({ beforeText, afterText, before, after, normalization, budg
 				end: anchor.afterIndex
 			},
 			runs,
-			budget
+			budget,
+			weighting
 		});
 		pushRun(runs, {
 			type: "equal",
@@ -563,7 +642,8 @@ const alignTokens = ({ beforeText, afterText, before, after, normalization, budg
 			end: afterMiddle.length
 		},
 		runs,
-		budget
+		budget,
+		weighting
 	});
 	pushEqualRange(runs, before, after, {
 		start: beforeMiddleEnd,
@@ -587,6 +667,16 @@ const isTooFragmented = (runs, averageLength) => {
 	for (const run of runs) if (run.type === "equal") sumOfSquares += run.before.length * run.before.length;
 	return sumOfSquares * FRAGMENTATION_SCALE < averageLength * averageLength;
 };
+/** True when a run changes words, not only punctuation or whitespace. */
+const isContentChange = (run) => run.type !== "equal" && !isSeparatorOnly(run.text);
+/** True when the change region starting at `from`, walking by `step`, changes words. */
+const changeCarriesContent = (runs, { from, step }) => {
+	for (let index = from;; index += step) {
+		const run = runs[index];
+		if (run === void 0 || run.type === "equal") return false;
+		if (isContentChange(run)) return true;
+	}
+};
 /**
 * Turn a match the quality rules rejected back into the change it interrupts.
 *
@@ -602,7 +692,13 @@ const demoteRejectedMatches = (runs) => {
 			continue;
 		}
 		const interruptsAChange = runs[index - 1] !== void 0 || runs[index + 1] !== void 0;
-		const isIsland = runs[index - 1] !== void 0 && runs[index + 1] !== void 0;
+		const isIsland = runs[index - 1] !== void 0 && runs[index + 1] !== void 0 && (changeCarriesContent(runs, {
+			from: index - 1,
+			step: -1
+		}) || changeCarriesContent(runs, {
+			from: index + 1,
+			step: 1
+		}));
 		if (!(interruptsAChange && run.units <= MAX_SEPARATOR_ONLY_MATCH_UNITS && isSeparatorOnly(run.before) || isIsland && run.units < MINIMUM_ISOLATED_MATCH_UNITS)) {
 			kept.push(run);
 			continue;
@@ -617,6 +713,70 @@ const demoteRejectedMatches = (runs) => {
 	}
 	return kept;
 };
+const TOKEN_WHITESPACE = /^(\s*)(.*?)(\s*)$/su;
+const splitTokenWhitespace = (token) => {
+	const [, leading = "", text = "", trailing = ""] = TOKEN_WHITESPACE.exec(token) ?? [];
+	return {
+		leading,
+		text,
+		trailing
+	};
+};
+const pushChangedText = (runs, before, after) => {
+	if (before.length > 0) pushRun(runs, {
+		type: "del",
+		text: before
+	});
+	if (after.length > 0) pushRun(runs, {
+		type: "ins",
+		text: after
+	});
+};
+const pushWhitespace = (runs, before, after) => {
+	if (before !== after) {
+		pushChangedText(runs, before, after);
+		return;
+	}
+	if (before.length > 0) pushRun(runs, {
+		type: "equal",
+		before,
+		after,
+		units: 0
+	});
+};
+/**
+* Mark the whitespace a matched word gained, lost or changed, leaving the word
+* itself equal. Word tokens are aligned on their text alone, so an `equal` run
+* may pair `"Závislá"` with `" Závislá"`; both sides of such a run tokenize
+* to the same number of words. Every piece of both texts is emitted exactly
+* once and in order, so both strings reconstruct whatever the pairing.
+*/
+const separateWhitespaceChanges = (runs) => {
+	const separated = [];
+	for (const run of runs) {
+		if (run.type !== "equal" || run.before === run.after) {
+			pushRun(separated, run);
+			continue;
+		}
+		const beforeTokens = tokenizeWords(run.before);
+		const afterTokens = tokenizeWords(run.after);
+		const tokenCount = Math.max(beforeTokens.length, afterTokens.length);
+		for (let index = 0; index < tokenCount; index++) {
+			const before = splitTokenWhitespace(beforeTokens[index] ?? "");
+			const after = splitTokenWhitespace(afterTokens[index] ?? "");
+			pushWhitespace(separated, before.leading, after.leading);
+			if (before.text.length > 0 && after.text.length > 0) pushRun(separated, {
+				type: "equal",
+				before: before.text,
+				after: after.text,
+				units: 1
+			});
+			else pushChangedText(separated, before.text, after.text);
+			pushWhitespace(separated, before.trailing, after.trailing);
+		}
+	}
+	return separated;
+};
 const toSegments = (runs) => {
 	const segments = [];
 	const push = (type, text) => {
@@ -694,7 +854,13 @@ const diffWordSegmentsWithBudget = (before, after, options, budget) => {
 		text: before
 	}];
 	const granularity = options.granularity ?? "word";
-	const normalization = options.normalization ?? {};
+	const requestedNormalization = options.normalization ?? {};
+	const normalization = granularity === "word" ? {
+		...requestedNormalization,
+		whitespace: true
+	} : requestedNormalization;
+	const whitespaceIsSignificant = granularity === "word" && requestedNormalization.whitespace !== true;
+	const weighting = granularity === "word" ? MATCH_WEIGHTING.ContentFirst : MATCH_WEIGHTING.Uniform;
 	const beforeTokens = tokenize(before, granularity);
 	const afterTokens = tokenize(after, granularity);
 	if (beforeTokens.length === 0 && afterTokens.length === 0) return [];
@@ -705,12 +871,12 @@ const diffWordSegmentsWithBudget = (before, after, options, budget) => {
 		before: beforeTokens,
 		after: afterTokens,
 		normalization,
-		budget
+		budget,
+		weighting
 	});
 	let surviving = demoteRejectedMatches(aligned.runs);
-	const inventedOppositeChange = aligned.monotoneDirection === "insertion" && surviving.some(({ type }) => type === "del") || aligned.monotoneDirection === "deletion" && surviving.some(({ type }) => type === "ins");
 	const monotoneDirection = aligned.monotoneDirection;
-	if (inventedOppositeChange && monotoneDirection !== null) if (beforeTokens.length + afterTokens.length <= MAX_WORD_DIFF_ANCHOR_TOKENS && before.length + after.length <= MAX_WORD_DIFF_COMPARISON_KEY_CODE_UNITS && fitsCellBudget(beforeTokens.length, afterTokens.length, budget)) {
+	if (monotoneDirection !== null && hasOppositeChange(surviving, monotoneDirection)) if (beforeTokens.length + afterTokens.length <= MAX_WORD_DIFF_ANCHOR_TOKENS && before.length + after.length <= MAX_WORD_DIFF_COMPARISON_KEY_CODE_UNITS && fitsCellBudget(beforeTokens.length, afterTokens.length, budget)) {
 		const unanchored = [];
 		alignDenseGap({
 			before: beforeTokens,
@@ -726,12 +892,18 @@ const diffWordSegmentsWithBudget = (before, after, options, budget) => {
 				end: afterTokens.length
 			},
 			runs: unanchored,
-			budget
+			budget,
+			weighting
 		});
-		surviving = unanchored;
-	} else surviving = monotoneDirection === "insertion" && aligned.runs.some(({ type }) => type === "del") || monotoneDirection === "deletion" && aligned.runs.some(({ type }) => type === "ins") ? alignMonotoneChange(before, after, beforeTokens, afterTokens, normalization, monotoneDirection) : aligned.runs;
-	if (aligned.monotoneDirection === null && isTooFragmented(surviving, (before.length + after.length) / 2)) return wholeStringReplacement(before, after);
-	return toSegments(orderDeletionsFirst(surviving));
+		surviving = hasOppositeChange(unanchored, monotoneDirection) ? alignMonotoneChange(before, after, beforeTokens, afterTokens, normalization, monotoneDirection) : unanchored;
+	} else surviving = hasOppositeChange(aligned.runs, monotoneDirection) ? alignMonotoneChange(before, after, beforeTokens, afterTokens, normalization, monotoneDirection) : aligned.runs;
+	if (aligned.monotoneDirection === null && surviving.some(isContentChange) && isTooFragmented(surviving, (before.length + after.length) / 2)) return wholeStringReplacement(before, after);
+	let marked = whitespaceIsSignificant ? separateWhitespaceChanges(surviving) : surviving;
+	if (monotoneDirection !== null && hasOppositeChange(marked, monotoneDirection)) {
+		const monotoneRuns = alignMonotoneChange(before, after, beforeTokens, afterTokens, normalization, monotoneDirection);
+		marked = whitespaceIsSignificant ? separateWhitespaceChanges(monotoneRuns) : monotoneRuns;
+	}
+	return toSegments(orderDeletionsFirst(marked));
 };
 /**
 * One internal comparison/apply scope. Every diff shares the same quadratic
@@ -760,4 +932,4 @@ const wordDiffSessionFromOptions = (options) => {
 };
 const diffWordSegments = (before, after, options = {}) => diffWordSegmentsWithBudget(before, after, options, { remainingCells: MAX_WORD_DIFF_CELLS });
 //#endregion
-export { WORD_DIFF_GRANULARITIES, createScopedWordDiffOptions, createWordDiffSession, diffWordSegments, wordDiffSessionFromOptions };
+export { MAX_EDGE_PUNCTUATION_TOKENS, WORD_DIFF_GRANULARITIES, createScopedWordDiffOptions, createWordDiffSession, diffWordSegments, tokenizeWords, wordDiffSessionFromOptions };

package/dist/controller/headerFooterEditorManager.d.ts

@@ -1,5 +1,5 @@
 import { document_d_exports } from "../types/document.js";
-import { EditorView } from "prosemirror-view";
+import { DirectEditorProps, EditorView } from "prosemirror-view";
 //#region src/controller/headerFooterEditorManager.d.ts
 type HeaderFooterPartKind = "header" | "footer";
 type HeaderFooterPartKey = {
@@ -14,6 +14,7 @@ type HeaderFooterEditorTransaction = {
   view: EditorView;
 };
 type HeaderFooterEditorManagerDeps = {
+  createView?: ((mountNode: HTMLElement, props: DirectEditorProps) => EditorView) | undefined;
   getDocument: () => document_d_exports.Document | null;
   getHost: () => HTMLElement | null;
   getStyles: () => document_d_exports.StyleDefinitions | null | undefined;

package/dist/controller/headerFooterEditorManager.js

@@ -12,6 +12,7 @@ import { schema } from "../prosemirror/schema/index.js";
 import { EditorState } from "prosemirror-state";
 import { EditorView } from "prosemirror-view";
 //#region src/controller/headerFooterEditorManager.ts
+const createEditorView = (mountNode, props) => new EditorView(mountNode, props);
 const DETACHED_WATERMARK_HOST = Symbol.for("stll.detachedWatermarkHost");
 const headerFooterToProseDocWithDetachedWatermarkHost = (headerFooter, options) => {
 	return headerFooterToProseDoc(headerFooter.content.map((block, blockIndex) => {
@@ -109,7 +110,7 @@ const createHeaderFooterEditorManager = (deps) => {
 			mountNode.dataset["hfRId"] = part.rId;
 			mountNode.dataset["hfKind"] = part.kind;
 			host.append(mountNode);
-			const view = new EditorView(mountNode, {
+			const view = (deps.createView ?? createEditorView)(mountNode, {
 				state: buildInitialState(headerFooter, styles, theme, numbering, manager),
 				dispatchTransaction(transaction) {
 					const nextState = view.state.apply(transaction);

package/dist/controller/noteEditorManager.d.ts

@@ -1,7 +1,7 @@
 import { document_d_exports } from "../types/document.js";
 import { NoteStoryKey } from "../types/editor-story.js";
 import { Plugin } from "prosemirror-state";
-import { EditorView } from "prosemirror-view";
+import { DirectEditorProps, EditorView } from "prosemirror-view";
 //#region src/controller/noteEditorManager.d.ts
 type NoteStoryKind = NoteStoryKey["kind"];
 type NoteEditorTransaction = NoteStoryKey & {
@@ -10,6 +10,7 @@ type NoteEditorTransaction = NoteStoryKey & {
   view: EditorView;
 };
 type NoteEditorManagerDeps = {
+  createView?: ((mountNode: HTMLElement, props: DirectEditorProps) => EditorView) | undefined;
   getDocument: () => document_d_exports.Document | null;
   getHost: () => HTMLElement | null;
   getPlugins?: (() => Plugin[]) | undefined;

package/dist/controller/noteEditorManager.js

@@ -12,6 +12,7 @@ import { EditorState } from "prosemirror-state";
 import { EditorView } from "prosemirror-view";
 //#region src/controller/noteEditorManager.ts
 /** Framework-neutral lifecycle owner for editable footnote and endnote stories. */
+const createEditorView = (mountNode, props) => new EditorView(mountNode, props);
 const EMPTY_PLUGINS = [];
 const storyMapKey = ({ kind, noteId }) => `${kind}:${String(noteId)}`;
 const isNormalFootnote = (note) => !isSeparatorFootnote(note);
@@ -110,7 +111,7 @@ const createNoteEditorManager = (deps) => {
 			mountNode.dataset["noteId"] = String(storyKey.noteId);
 			host.append(mountNode);
 			const proseDocument = noteToProseDocument(note, styles, theme);
-			const view = new EditorView(mountNode, {
+			const view = (deps.createView ?? createEditorView)(mountNode, {
 				state: buildInitialState(proseDocument, styles, numbering, manager, externalPlugins),
 				dispatchTransaction(transaction) {
 					view.updateState(view.state.apply(transaction));

package/dist/docx/relsParser.js

@@ -27,6 +27,14 @@ const RELATIONSHIP_TYPES = {
 	comments: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments",
 	commentsExtended: "http://schemas.microsoft.com/office/2011/relationships/commentsExtended"
 };
+const STRICT_OFFICE_RELATIONSHIP_PREFIX = "http://purl.oclc.org/ooxml/officeDocument/relationships/";
+const TRANSITIONAL_OFFICE_RELATIONSHIP_PREFIX = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/";
+const KNOWN_RELATIONSHIP_TYPES = new Set(Object.values(RELATIONSHIP_TYPES));
+const normalizeRelationshipType = (type) => {
+	if (!type.startsWith(STRICT_OFFICE_RELATIONSHIP_PREFIX)) return type;
+	const normalized = TRANSITIONAL_OFFICE_RELATIONSHIP_PREFIX + type.slice(56);
+	return KNOWN_RELATIONSHIP_TYPES.has(normalized) ? normalized : type;
+};
 /**
 * Parse a .rels XML file into a RelationshipMap
 *
@@ -49,7 +57,7 @@ function parseRelationships(relsXml) {
 		if (!id || !type || !target) continue;
 		const relationship = {
 			id,
-			type,
+			type: normalizeRelationshipType(type),
 			target
 		};
 		if (targetMode === "External") relationship.targetMode = "External";

package/dist/docx/selectiveSave.js

@@ -1,6 +1,7 @@
 import { parseCommentsExtended } from "./commentParser.js";
 import { withoutOrphanCommentRanges } from "./commentRangeIntegrity.js";
 import { hasUnsynthesizedReplyRanges } from "./commentReplyMarkers.js";
+import { detectDocxConformanceClass } from "./conformance.js";
 import { validateFolioDocumentModel } from "./modelValidation.js";
 import { parseNumbering } from "./numberingParser.js";
 import { isUnsafePackagePath } from "./packageParts.js";
@@ -13,6 +14,7 @@ import { serializeDocument } from "./serializer/documentSerializer.js";
 import { serializeEndnotes, serializeFootnotes } from "./serializer/noteSerializer.js";
 import { serializeNumberingXml } from "./serializer/numberingSerializer.js";
 import { readRootNamespaceBindings } from "./serializer/partNamespaces.js";
+import { DOCX_CONFORMANCE_CLASSES } from "@stll/docx-core/model";
 //#region src/docx/selectiveSave.ts
 /**
 * Splice edited footnote/endnote paragraphs into their parts and return the
@@ -217,8 +219,9 @@ async function attemptSelectiveSave(doc, originalBuffer, options) {
 		}
 		const sourceCommentsFile = zip.file("word/comments.xml");
 		if (hasComments || sourceCommentsFile) {
-			const sourceBindings = sourceCommentsFile ? readRootNamespaceBindings(await sourceCommentsFile.async("text")) : void 0;
-			updates.set("word/comments.xml", serializeComments(commentPlan, sourceBindings));
+			const sourceCommentsXml = sourceCommentsFile ? await sourceCommentsFile.async("text") : void 0;
+			const commentsXml = serializeComments(commentPlan, sourceCommentsXml === void 0 ? void 0 : readRootNamespaceBindings(sourceCommentsXml));
+			if (commentsXml !== sourceCommentsXml) updates.set("word/comments.xml", commentsXml);
 		}
 		if (hasComments) {
 			const ctFile = zip.file("[Content_Types].xml");
@@ -245,6 +248,12 @@ async function attemptSelectiveSave(doc, originalBuffer, options) {
 			const corePropsXml = await corePropsFile.async("text");
 			updates.set("docProps/core.xml", updateCoreProperties(corePropsXml, { updateModifiedDate: true }));
 		}
+		if ([...updates.keys()].some((path) => {
+			const lowerPath = path.toLowerCase();
+			return lowerPath.startsWith("word/") && (lowerPath.endsWith(".xml") || lowerPath.endsWith(".rels"));
+		})) {
+			if (detectDocxConformanceClass(await findZipEntryCaseInsensitive(zip, "word/document.xml")?.async("text") ?? null) === DOCX_CONFORMANCE_CLASSES.STRICT) return null;
+		}
 		return await applyUpdatesToZip(zip, updates);
 	} catch {
 		return null;

package/dist/prosemirror/attrs/index.d.ts

@@ -1,4 +1,4 @@
-import { CharacterSpacingAttrs, CharacterStyleAttrs, CommentAttrs, EmphasisMarkAttrs, FontFamilyAttrs, FontSizeAttrs, FootnoteRefAttrs, HighlightAttrs, HyperlinkAttrs, InlineWrapperAttrs, InlineWrapperLayer, LanguageAttrs, RunFormattingOverrideAttrs, RunIdentityMarkAttrs, RunPropertyChangeMarkAttrs, RunShadingAttrs, StrikeAttrs, TextColorAttrs, TextEffectAttrs, TrackedChangeMarkAttrs, UnderlineAttrs } from "../schema/marks.js";
+import { CharacterSpacingAttrs, CharacterStyleAttrs, CommentAttrs, EmphasisMarkAttrs, FontFamilyAttrs, FontSizeAttrs, FootnoteRefAttrs, HighlightAttrs, HyperlinkAttrs, InlineWrapperAttrs, InlineWrapperLayer, LanguageAttrs, RunFormattingOverrideAttrs, RunIdentityMarkAttrs, RunPropertyChangeMarkAttrs, RunShadingAttrs, StrikeAttrs, TextColorAttrs, TextEffectAttrs, TrackedChangeMarkAttrs, TrackedRevisionAncestor, UnderlineAttrs } from "../schema/marks.js";
 import { BlockSdtAttrs, FieldAttrs, HardBreakAttrs, ImageAttrs, MathAttrs, PageBreakRunAttrs, ParagraphAttrs, PreservedBlockAttrs, PreservedXmlAttrs, SdtAttrs, ShapeAttrs, SymbolAttrs, TabAttrs, TableAttrs, TableCellAttrs, TableRowAttrs, TextBoxAttrs } from "../schema/nodes.js";
 import "../schema/index.js";
 import { Mark, Node } from "prosemirror-model";
@@ -76,6 +76,7 @@ declare const readFootnoteRefMarkAttrs: (mark: Mark) => ReadProseMirrorAttrsResu
 declare const expectFootnoteRefMarkAttrs: (mark: Mark) => FootnoteRefAttrs;
 declare const readCommentMarkAttrs: (mark: Mark) => ReadProseMirrorAttrsResult<CommentAttrs>;
 declare const expectCommentMarkAttrs: (mark: Mark) => CommentAttrs;
+declare const isTrackedRevisionAncestorArray: (value: unknown) => value is readonly TrackedRevisionAncestor[];
 declare const readTrackedChangeMarkAttrs: (mark: Mark) => ReadProseMirrorAttrsResult<TrackedChangeMarkAttrs>;
 declare const expectTrackedChangeMarkAttrs: (mark: Mark) => TrackedChangeMarkAttrs;
 declare const readRunPropertyChangeMarkAttrs: (mark: Mark) => ReadProseMirrorAttrsResult<RunPropertyChangeMarkAttrs>;
@@ -118,4 +119,4 @@ declare const mergeTableRowAttrs: (node: Node, patch: NodeAttrPatch<TableRowAttr
  */
 declare const mergeTableCellAttrs: (node: Node, patch: NodeAttrPatch<TableCellAttrs>) => TableCellAttrs;
 //#endregion
-export { ProseMirrorAttrIssue, ReadProseMirrorAttrsResult, expectBlockSdtAttrs, expectCharacterSpacingMarkAttrs, expectCharacterStyleMarkAttrs, expectCommentMarkAttrs, expectEmphasisMarkAttrs, expectFieldAttrs, expectFontFamilyMarkAttrs, expectFontSizeMarkAttrs, expectFootnoteRefMarkAttrs, expectHardBreakAttrs, expectHighlightMarkAttrs, expectHyperlinkMarkAttrs, expectImageAttrs, expectInlineWrapperMarkAttrs, expectLanguageMarkAttrs, expectMathAttrs, expectPageBreakRunAttrs, expectParagraphAttrs, expectPreservedBlockAttrs, expectPreservedXmlAttrs, expectRunFormattingOverrideMarkAttrs, expectRunIdentityMarkAttrs, expectRunPropertyChangeMarkAttrs, expectRunShadingMarkAttrs, expectSdtAttrs, expectShapeAttrs, expectStrikeMarkAttrs, expectSymbolAttrs, expectTabAttrs, expectTableAttrs, expectTableCellAttrs, expectTableRowAttrs, expectTextBoxAttrs, expectTextColorMarkAttrs, expectTextEffectMarkAttrs, expectTrackedChangeMarkAttrs, expectUnderlineMarkAttrs, mergeImageAttrs, mergeParagraphAttrs, mergeTableAttrs, mergeTableCellAttrs, mergeTableRowAttrs, readBlockSdtAttrs, readCharacterSpacingMarkAttrs, readCharacterStyleMarkAttrs, readCommentMarkAttrs, readEmphasisMarkAttrs, readFieldAttrs, readFontFamilyMarkAttrs, readFontSizeMarkAttrs, readFootnoteRefMarkAttrs, readHardBreakAttrs, readHighlightMarkAttrs, readHyperlinkMarkAttrs, readImageAttrs, readInlineWrapperMarkAttrs, readInlineWrapperStack, readLanguageMarkAttrs, readMathAttrs, readPageBreakRunAttrs, readParagraphAttrs, readPreservedBlockAttrs, readPreservedXmlAttrs, readRunFormattingOverrideMarkAttrs, readRunIdentityMarkAttrs, readRunPropertyChangeMarkAttrs, readRunShadingMarkAttrs, readSdtAttrs, readShapeAttrs, readStrikeMarkAttrs, readSymbolAttrs, readTabAttrs, readTableAttrs, readTableCellAttrs, readTableRowAttrs, readTextBoxAttrs, readTextColorMarkAttrs, readTextEffectMarkAttrs, readTrackedChangeMarkAttrs, readUnderlineMarkAttrs };
+export { ProseMirrorAttrIssue, ReadProseMirrorAttrsResult, expectBlockSdtAttrs, expectCharacterSpacingMarkAttrs, expectCharacterStyleMarkAttrs, expectCommentMarkAttrs, expectEmphasisMarkAttrs, expectFieldAttrs, expectFontFamilyMarkAttrs, expectFontSizeMarkAttrs, expectFootnoteRefMarkAttrs, expectHardBreakAttrs, expectHighlightMarkAttrs, expectHyperlinkMarkAttrs, expectImageAttrs, expectInlineWrapperMarkAttrs, expectLanguageMarkAttrs, expectMathAttrs, expectPageBreakRunAttrs, expectParagraphAttrs, expectPreservedBlockAttrs, expectPreservedXmlAttrs, expectRunFormattingOverrideMarkAttrs, expectRunIdentityMarkAttrs, expectRunPropertyChangeMarkAttrs, expectRunShadingMarkAttrs, expectSdtAttrs, expectShapeAttrs, expectStrikeMarkAttrs, expectSymbolAttrs, expectTabAttrs, expectTableAttrs, expectTableCellAttrs, expectTableRowAttrs, expectTextBoxAttrs, expectTextColorMarkAttrs, expectTextEffectMarkAttrs, expectTrackedChangeMarkAttrs, expectUnderlineMarkAttrs, isTrackedRevisionAncestorArray, mergeImageAttrs, mergeParagraphAttrs, mergeTableAttrs, mergeTableCellAttrs, mergeTableRowAttrs, readBlockSdtAttrs, readCharacterSpacingMarkAttrs, readCharacterStyleMarkAttrs, readCommentMarkAttrs, readEmphasisMarkAttrs, readFieldAttrs, readFontFamilyMarkAttrs, readFontSizeMarkAttrs, readFootnoteRefMarkAttrs, readHardBreakAttrs, readHighlightMarkAttrs, readHyperlinkMarkAttrs, readImageAttrs, readInlineWrapperMarkAttrs, readInlineWrapperStack, readLanguageMarkAttrs, readMathAttrs, readPageBreakRunAttrs, readParagraphAttrs, readPreservedBlockAttrs, readPreservedXmlAttrs, readRunFormattingOverrideMarkAttrs, readRunIdentityMarkAttrs, readRunPropertyChangeMarkAttrs, readRunShadingMarkAttrs, readSdtAttrs, readShapeAttrs, readStrikeMarkAttrs, readSymbolAttrs, readTabAttrs, readTableAttrs, readTableCellAttrs, readTableRowAttrs, readTextBoxAttrs, readTextColorMarkAttrs, readTextEffectMarkAttrs, readTrackedChangeMarkAttrs, readUnderlineMarkAttrs };