@stll/folio-core 0.44.0 → 0.45.0

package/dist/ai-edits/__fixtures__/paragraphs.js

@@ -1,3 +1,4 @@
+import { escapeXmlText } from "@stll/docx-core";
 import JSZip from "jszip";
 //#region src/ai-edits/__fixtures__/paragraphs.ts
 /**
@@ -13,8 +14,7 @@ const ZIP_ENTRY_OPTIONS = {
 	date: new Date(Date.UTC(2e3, 0, 1)),
 	createFolders: false
 };
-const escapeXml = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
-const paragraphXml = (text) => `<w:p><w:r><w:t xml:space="preserve">${escapeXml(text)}</w:t></w:r></w:p>`;
+const paragraphXml = (text) => `<w:p><w:r><w:t xml:space="preserve">${escapeXmlText(text)}</w:t></w:r></w:p>`;
 const buildParagraphsDocx = async (paragraphs, { inTableCell } = {}) => {
 	const paragraphsXml = paragraphs.map(paragraphXml).join("");
 	const body = inTableCell ? `<w:tbl><w:tblPr><w:tblW w:w="0" w:type="auto"/></w:tblPr><w:tblGrid><w:gridCol w:w="9360"/></w:tblGrid><w:tr><w:tc><w:tcPr><w:tcW w:w="9360" w:type="dxa"/></w:tcPr>${paragraphsXml}</w:tc></w:tr></w:tbl>` + paragraphXml("After the table.") : paragraphsXml;

package/dist/ai-edits/headless.js

@@ -212,6 +212,7 @@ const sameReferencedNumberingLevels = ({ current, target, numId, levelsByNumId }
 	for (const level of levelsByNumId.get(numId) ?? []) {
 		const currentLevel = currentNumbering.getLevel(numId, level);
 		const targetLevel = targetNumbering.getLevel(numId, level);
+		if (currentLevel === null && targetLevel === null) continue;
 		if (!currentLevel || !targetLevel || canonicalJson(currentLevel) !== canonicalJson(targetLevel)) return false;
 	}
 	return true;

package/dist/compare/content-alignment.js

@@ -455,6 +455,27 @@ const MAX_CONTENT_STRUCTURE_PROFILE_TEXT_CODE_UNITS = 16384;
 const MAX_CONTENT_STRUCTURE_PROFILE_TOKENS = 64;
 const MAX_CONTENT_STRUCTURE_PROFILE_KIND_CODE_UNITS = 256;
 const CONTENT_STRUCTURE_ANCHOR_MINIMUM_WORD_COUNT = 3;
+/** Four independent 32-bit lanes, so a digest collision needs four at once. */
+const CONTENT_DIGEST_SEEDS = [
+	2166136261,
+	2654435769,
+	2246822507,
+	3266489909
+];
+const CONTENT_DIGEST_PRIMES = [
+	16777619,
+	1540483477,
+	668265263,
+	374761393
+];
+const foldContentDigest = (lanes, text) => {
+	for (let index = 0; index < text.length; index++) {
+		const unit = text.charCodeAt(index);
+		for (let lane = 0; lane < lanes.length; lane++) lanes[lane] = Math.imul((lanes[lane] ?? 0) ^ unit, CONTENT_DIGEST_PRIMES[lane] ?? 1);
+	}
+	for (let lane = 0; lane < lanes.length; lane++) lanes[lane] = Math.imul((lanes[lane] ?? 0) ^ text.length, CONTENT_DIGEST_PRIMES[lane] ?? 1);
+};
+const renderContentDigest = (lanes, blockCount) => `${String(blockCount)}:${[...lanes].map((lane) => (lane >>> 0).toString(36)).join(":")}`;
 const createContentStructureProfile = ({ blocks, blockStructure, idStability, physicalCellCount, retainContainerIdentity = false }) => {
 	let containerIdentity = null;
 	if (retainContainerIdentity) if (blocks.length > MAX_CONTENT_STRUCTURE_PROFILE_BLOCKS) containerIdentity = { status: "unavailable" };
@@ -481,39 +502,34 @@ const createContentStructureProfile = ({ blocks, blockStructure, idStability, ph
 			if (idStability(block) === "stable") stableIds.push(block.id);
 		}
 	}
-	if (blocks.length > MAX_CONTENT_STRUCTURE_PROFILE_BLOCKS) return {
-		anchorTexts: [],
+	const lanes = Int32Array.from(CONTENT_DIGEST_SEEDS);
+	for (const block of blocks) foldContentDigest(lanes, JSON.stringify([
+		...blockStructure(block),
+		block.kind,
+		block.text
+	]));
+	const identity = {
 		blockIds,
 		containerIdentity,
-		exactSignature: null,
+		contentDigest: renderContentDigest(lanes, blocks.length),
 		physicalCellCount: physicalCellCount ?? null,
-		stableIds,
-		tokenCounts: null,
-		tokenCount: 0
+		stableIds
+	};
+	const overCap = {
+		...identity,
+		anchors: { status: "skipped-over-cap" },
+		tokens: { status: "skipped-over-cap" }
 	};
+	if (blocks.length > MAX_CONTENT_STRUCTURE_PROFILE_BLOCKS) return overCap;
 	let textCodeUnits = 0;
 	for (const block of blocks) {
-		if (block.kind.length > MAX_CONTENT_STRUCTURE_PROFILE_KIND_CODE_UNITS || block.text.length > MAX_CONTENT_STRUCTURE_PROFILE_TEXT_CODE_UNITS - textCodeUnits) return {
-			anchorTexts: [],
-			blockIds,
-			containerIdentity,
-			exactSignature: null,
-			physicalCellCount: physicalCellCount ?? null,
-			stableIds,
-			tokenCounts: null,
-			tokenCount: 0
-		};
+		if (block.kind.length > MAX_CONTENT_STRUCTURE_PROFILE_KIND_CODE_UNITS || block.text.length > MAX_CONTENT_STRUCTURE_PROFILE_TEXT_CODE_UNITS - textCodeUnits) return overCap;
 		textCodeUnits += block.text.length;
 	}
 	const tokenCounts = /* @__PURE__ */ new Map();
 	const anchorTexts = /* @__PURE__ */ new Set();
 	let tokenCount = 0;
 	let tokensComplete = true;
-	const signature = blocks.map((block) => [
-		...blockStructure(block),
-		block.kind,
-		block.text
-	]);
 	for (const block of blocks) {
 		let blockWordCount = 0;
 		for (const match of block.text.matchAll(/\S+/gu)) {
@@ -530,24 +546,31 @@ const createContentStructureProfile = ({ blocks, blockStructure, idStability, ph
 		if (!tokensComplete) break;
 	}
 	return {
-		anchorTexts: [...anchorTexts],
-		blockIds,
-		containerIdentity,
-		exactSignature: JSON.stringify(signature),
-		physicalCellCount: physicalCellCount ?? null,
-		stableIds,
-		tokenCounts: tokensComplete ? tokenCounts : null,
-		tokenCount: tokensComplete ? tokenCount : 0
+		...identity,
+		anchors: {
+			status: "computed",
+			texts: [...anchorTexts]
+		},
+		tokens: tokensComplete ? {
+			status: "computed",
+			counts: tokenCounts,
+			total: tokenCount
+		} : { status: "skipped-over-cap" }
 	};
 };
+const UNKNOWN_CONTENT_STRUCTURE_SIMILARITY = { status: "unknown" };
 const contentStructureProfileSimilarity = (base, revised, workSession) => {
-	if (!base.tokenCounts || !revised.tokenCounts || base.tokenCount === 0 || revised.tokenCount === 0) return 0;
-	const [tokens, counterparts] = base.tokenCounts.size <= revised.tokenCounts.size ? [base.tokenCounts, revised.tokenCounts] : [revised.tokenCounts, base.tokenCounts];
-	if (tokens.size > workSession.remainingStructuralTokenLookups) return 0;
+	if (base.tokens.status === "skipped-over-cap" || revised.tokens.status === "skipped-over-cap") return UNKNOWN_CONTENT_STRUCTURE_SIMILARITY;
+	if (base.tokens.total === 0 || revised.tokens.total === 0) return UNKNOWN_CONTENT_STRUCTURE_SIMILARITY;
+	const [tokens, counterparts] = base.tokens.counts.size <= revised.tokens.counts.size ? [base.tokens.counts, revised.tokens.counts] : [revised.tokens.counts, base.tokens.counts];
+	if (tokens.size > workSession.remainingStructuralTokenLookups) return UNKNOWN_CONTENT_STRUCTURE_SIMILARITY;
 	workSession.remainingStructuralTokenLookups -= tokens.size;
 	let shared = 0;
 	for (const [token, count] of tokens) shared += Math.min(count, counterparts.get(token) ?? 0);
-	return 2 * shared / (base.tokenCount + revised.tokenCount);
+	return {
+		status: "measured",
+		value: 2 * shared / (base.tokens.total + revised.tokens.total)
+	};
 };
 const tableStructureProfile = (blocks, idStability) => {
 	const tableOrdinalByIndex = /* @__PURE__ */ new Map();
@@ -634,7 +657,6 @@ const uniqueExactContentSequencePairs = ({ baseKeys, revisedKeys }) => {
 	const uniqueIndexes = (keys) => {
 		const indexes = /* @__PURE__ */ new Map();
 		keys.forEach((key, index) => {
-			if (key === -1) return;
 			indexes.set(key, indexes.has(key) ? null : index);
 		});
 		return indexes;
@@ -731,16 +753,15 @@ const alignProfiledContentSequence = ({ base, revised, workSession, canPair = ()
 	}
 	const exactSignatureKeys = /* @__PURE__ */ new Map();
 	let nextExactSignatureKey = 0;
-	const internExactSignature = (signature) => {
-		if (signature === null) return -1;
-		const existing = exactSignatureKeys.get(signature);
+	const internContentDigest = (digest) => {
+		const existing = exactSignatureKeys.get(digest);
 		if (existing !== void 0) return existing;
 		const key = nextExactSignatureKey++;
-		exactSignatureKeys.set(signature, key);
+		exactSignatureKeys.set(digest, key);
 		return key;
 	};
-	const baseExactSignatureKeys = base.map(({ profile }) => internExactSignature(profile.exactSignature));
-	const revisedExactSignatureKeys = revised.map(({ profile }) => internExactSignature(profile.exactSignature));
+	const baseExactSignatureKeys = base.map(({ profile }) => internContentDigest(profile.contentDigest));
+	const revisedExactSignatureKeys = revised.map(({ profile }) => internContentDigest(profile.contentDigest));
 	let persistedPairs = /* @__PURE__ */ new Set();
 	if (base.some(({ profile }) => profile.containerIdentity !== null) || revised.some(({ profile }) => profile.containerIdentity !== null)) {
 		const exactPairs = uniqueExactContentSequencePairs({
@@ -781,16 +802,20 @@ const alignProfiledContentSequence = ({ base, revised, workSession, canPair = ()
 			if (!revisedItem) continue;
 			if (!canPair(baseItem, revisedItem)) continue;
 			const pairIndex = baseIndex * revised.length + revisedIndex;
-			const exact = baseExactSignatureKeys[baseIndex] !== -1 && baseExactSignatureKeys[baseIndex] === revisedExactSignatureKeys[revisedIndex];
+			const exact = baseExactSignatureKeys[baseIndex] === revisedExactSignatureKeys[revisedIndex];
 			const stable = stablePairs.has(pairIndex);
-			const profileSimilarity = exact ? 1 : contentStructureProfileSimilarity(baseItem.profile, revisedItem.profile, workSession);
-			const similar = Math.max(0, Math.min(1, profileSimilarity * similarityFactor(baseItem, revisedItem)));
+			const profileSimilarity = exact ? {
+				status: "measured",
+				value: 1
+			} : contentStructureProfileSimilarity(baseItem.profile, revisedItem.profile, workSession);
+			const similar = profileSimilarity.status === "measured" ? Math.max(0, Math.min(1, profileSimilarity.value * similarityFactor(baseItem, revisedItem))) : 0;
+			const similarEnough = profileSimilarity.status === "measured" && similar >= CONTENT_STRUCTURE_PAIR_SIMILARITY;
 			const stableAtSamePosition = stable && baseIndex === revisedIndex;
 			const persistedAtSamePosition = baseIndex === revisedIndex && provenanceTransitionAtSamePosition[baseIndex] === 1;
 			const shiftedPersisted = baseIndex !== revisedIndex && persistedPairs.has(pairIndex);
 			const persisted = persistedAtSamePosition || shiftedPersisted;
 			const soleStructuralSlot = pairSoleStructuralSlot && base.length === 1 && revised.length === 1;
-			if (!exact && !stableAtSamePosition && !persisted && !soleStructuralSlot && similar < CONTENT_STRUCTURE_PAIR_SIMILARITY) continue;
+			if (!exact && !stableAtSamePosition && !persisted && !soleStructuralSlot && !similarEnough) continue;
 			pairScores[pairIndex] = (stable ? stableWeight : 0) + (exact ? exactWeight : 0) + (shiftedPersisted && !stable && !exact ? secondaryWeight : 0) + (persistedAtSamePosition ? continuityBonus : 0) + Math.round(similar * CONTENT_STRUCTURE_SIMILARITY_SCALE) + (soleStructuralSlot ? 1 : 0);
 		}
 	}
@@ -1124,11 +1149,10 @@ const contentStructureEvidenceIndexes = (base, revised) => {
 	let nextExactKey = 0;
 	const internExactSignatures = (items) => {
 		for (const { profile } of items) {
-			if (profile.exactSignature === null) continue;
-			let key = exactKeys.get(profile.exactSignature);
+			let key = exactKeys.get(profile.contentDigest);
 			if (key === void 0) {
 				key = nextExactKey++;
-				exactKeys.set(profile.exactSignature, key);
+				exactKeys.set(profile.contentDigest, key);
 			}
 			exactKeyByProfile.set(profile, key);
 		}
@@ -1152,7 +1176,7 @@ const contentStructureEvidenceIndexes = (base, revised) => {
 					if (indexes.at(-1) !== itemIndex) indexes.push(itemIndex);
 				} else stableIndexes.set(id, [itemIndex]);
 			}
-			for (const text of profile.anchorTexts) {
+			for (const text of profile.anchors.status === "computed" ? profile.anchors.texts : []) {
 				const indexes = anchorTextIndexes.get(text);
 				if (indexes) {
 					if (indexes.at(-1) !== itemIndex) indexes.push(itemIndex);
@@ -1190,12 +1214,13 @@ const sortedIndexesLeaveRange = (indexes, start, end) => {
 const profileHasEvidenceOutsideRange = (profile, opposite, start, end) => {
 	const exactKey = opposite.exactKeyByProfile.get(profile);
 	if (exactKey !== void 0 && sortedIndexesLeaveRange(opposite.exactIndexes.get(exactKey), start, end)) return true;
-	if (profile.anchorTexts.some((text) => sortedIndexesLeaveRange(opposite.anchorTextIndexes.get(text), start, end))) return true;
+	if (profile.anchors.status === "computed" && profile.anchors.texts.some((text) => sortedIndexesLeaveRange(opposite.anchorTextIndexes.get(text), start, end))) return true;
 	return profile.stableIds.some((id) => sortedIndexesLeaveRange(opposite.stableIndexes.get(id), start, end));
 };
 const profilesShareContentAnchor = (base, revised) => {
-	const baseTexts = new Set(base.anchorTexts);
-	return revised.anchorTexts.some((text) => baseTexts.has(text));
+	if (base.anchors.status === "skipped-over-cap" || revised.anchors.status === "skipped-over-cap") return "unknown";
+	const baseTexts = new Set(base.anchors.texts);
+	return revised.anchors.texts.some((text) => baseTexts.has(text)) ? "shares" : "disjoint";
 };
 const isBodyDocumentSegment = (segment) => segment.kind === "body";
 const profileBodySegments = (segments, idStability) => segments.flatMap((segment) => isBodyDocumentSegment(segment) ? [{
@@ -1288,13 +1313,13 @@ const pairTableSegmentsInGaps = ({ base, revised, baseGaps, revisedGaps, trusted
 		const revisedEnd = revisedStart + revisedItems.length;
 		const baseHasExternalEvidence = new Set(baseItems.filter(({ profile }) => profileHasEvidenceOutsideRange(profile, evidence.revised, revisedStart, revisedEnd)).map(({ item }) => item));
 		const revisedHasExternalEvidence = new Set(revisedItems.filter(({ profile }) => profileHasEvidenceOutsideRange(profile, evidence.base, baseStart, baseEnd)).map(({ item }) => item));
-		const solePairHasContentAnchor = baseItems.length === 1 && revisedItems.length === 1 && profilesShareContentAnchor(baseItems.at(0)?.profile ?? panic("A sole base table has no profile"), revisedItems.at(0)?.profile ?? panic("A sole revised table has no profile"));
+		const solePairAnchorOverlap = baseItems.length === 1 && revisedItems.length === 1 ? profilesShareContentAnchor(baseItems.at(0)?.profile ?? panic("A sole base table has no profile"), revisedItems.at(0)?.profile ?? panic("A sole revised table has no profile")) : "disjoint";
 		const alignments = alignProfiledContentSequence({
 			base: baseItems,
 			revised: revisedItems,
 			workSession,
 			canPair: (baseItem, revisedItem) => !baseHasExternalEvidence.has(baseItem.item) && !revisedHasExternalEvidence.has(revisedItem.item),
-			pairSoleStructuralSlot: trustedBodyPairCount > 0 || solePairHasContentAnchor
+			pairSoleStructuralSlot: trustedBodyPairCount > 0 || solePairAnchorOverlap === "shares"
 		});
 		for (const alignment of alignments) {
 			if (alignment.type !== "pair") continue;

package/dist/compare/inline-atoms.js

@@ -29,6 +29,15 @@ const textBlocksOf = (doc) => {
 	});
 	return blocks;
 };
+/**
+* Clean-text offset nearest a document position.
+*
+* `buildCleanBlockText` returns one offset per character plus one for
+* end-of-block, so there is always an offset to land on. The result was typed
+* `number | null` and never was: the caller's refusal branch could not run,
+* while an empty `offsets` would have produced `-1` rather than the `null` the
+* type promised.
+*/
 const offsetAt = ({ offsets, position }) => {
 	let low = 0;
 	let high = offsets.length;
@@ -40,16 +49,33 @@ const offsetAt = ({ offsets, position }) => {
 	}
 	return Math.min(low, offsets.length - 1);
 };
+/**
+* Attributes a conversion mints for itself rather than reads from the package.
+*
+* `toProseDoc` salts text-box anchor ids with a per-load nonce so a pasted span
+* cannot hijack a real anchor. A comparison reads two independent conversions,
+* so a minted handle differs on every run, and a key holding one makes a
+* document differ from itself. Only document facts belong in a key.
+*
+* The guard against a node type gaining a minted attribute without being added
+* here is not this list but `compareIdentity.property.test.ts`, which compares
+* generated packages carrying each atom with themselves.
+*/
+const CONVERSION_LOCAL_ATTRS = { textBoxAnchor: ["anchorId"] };
+const documentFactAttrs = (node) => {
+	const local = CONVERSION_LOCAL_ATTRS[node.type.name];
+	if (!local) return node.attrs;
+	return Object.fromEntries(Object.entries(node.attrs).filter(([name]) => !local.includes(name)));
+};
 const atomKey = (node) => canonicalJson({
 	type: node.type.name,
-	attrs: node.attrs,
+	attrs: documentFactAttrs(node),
 	content: node.content.toJSON()
 });
 const atomBlockOf = ({ node, from }) => {
 	const clean = buildCleanBlockText(node, from, { fieldResults: "omitted" });
 	const supported = [];
 	const unsupportedTopology = [];
-	let unalignable = false;
 	node.descendants((child, relativePosition) => {
 		if (child.isText) return false;
 		if (!child.isInline || !child.isAtom) return true;
@@ -58,18 +84,14 @@ const atomBlockOf = ({ node, from }) => {
 			offsets: clean.offsets,
 			position
 		});
-		if (offset === null) {
-			unalignable = true;
-			return false;
-		}
 		if (!isSupportedAtom(child)) {
 			if (child.type.name === "renderedPageBreak") return false;
-			unsupportedTopology.push(`${offset}:${child.type.name}:${canonicalJson(child.attrs)}`);
+			unsupportedTopology.push(`${offset}:${child.type.name}:${canonicalJson(documentFactAttrs(child))}`);
 			return false;
 		}
 		const prepared = prepareTargetInlineAtom(child);
 		if (!prepared) {
-			unsupportedTopology.push(`${offset}:${child.type.name}:${canonicalJson(child.attrs)}`);
+			unsupportedTopology.push(`${offset}:${child.type.name}:${canonicalJson(documentFactAttrs(child))}`);
 			return false;
 		}
 		supported.push({
@@ -80,7 +102,7 @@ const atomBlockOf = ({ node, from }) => {
 		});
 		return false;
 	});
-	return unalignable ? null : {
+	return {
 		node,
 		from,
 		cleanText: clean.text,
@@ -108,15 +130,7 @@ const targetBlockIdLookup = (snapshot) => {
 		return owner?.id;
 	};
 };
-const atomBlocksOf = (doc) => {
-	const blocks = [];
-	for (const block of textBlocksOf(doc)) {
-		const atoms = atomBlockOf(block);
-		if (!atoms) return null;
-		blocks.push(atoms);
-	}
-	return blocks;
-};
+const atomBlocksOf = (doc) => textBlocksOf(doc).map(atomBlockOf);
 const sameBlockTopology = (left, right) => left.node.type === right.node.type && left.cleanText === right.cleanText && canonicalJson(left.unsupportedTopology) === canonicalJson(right.unsupportedTopology);
 const matchingAtomGroup = ({ live, target, liveStart, targetStart }) => {
 	if (live.length === target.length && live.every((atom, index) => atom.key === target[index]?.key)) return live.map((_, index) => [liveStart + index, targetStart + index]);
@@ -260,7 +274,7 @@ const matchInlineAtoms = ({ state, targetSnapshot, revisionStamp, originalRevisi
 	let sourceBlocks;
 	const liveBlocks = atomBlocksOf(reviewed.state.doc);
 	const targetBlocks = atomBlocksOf(targetDocument);
-	if (!liveBlocks || !targetBlocks || liveBlocks.length !== targetBlocks.length) return { status: "unalignable" };
+	if (liveBlocks.length !== targetBlocks.length) return { status: "unalignable" };
 	const actions = [];
 	for (const [index, live] of liveBlocks.entries()) {
 		const target = targetBlocks[index];
@@ -366,7 +380,7 @@ const sameInlineAtoms = (leftDocument, rightDocument) => {
 	if (!hasSupportedAtom(leftDocument) && !hasSupportedAtom(rightDocument)) return true;
 	const leftBlocks = atomBlocksOf(leftDocument);
 	const rightBlocks = atomBlocksOf(rightDocument);
-	if (!leftBlocks || !rightBlocks || leftBlocks.length !== rightBlocks.length) return false;
+	if (leftBlocks.length !== rightBlocks.length) return false;
 	return leftBlocks.every((left, index) => {
 		const right = rightBlocks[index];
 		if (left.supported.length === 0 && right?.supported.length === 0) return true;

package/dist/content-controls/mutateContentControls.js

@@ -1,5 +1,6 @@
 import { formatDate } from "../docx/fieldParser.js";
 import { ContentControlBoundError, ContentControlLockedError, ContentControlTypeError } from "./errors.js";
+import { sanitizeXmlCharacters } from "@stll/docx-core";
 //#region src/content-controls/mutateContentControls.ts
 /**
 * Pure (immutable) write helpers for block-level content controls.
@@ -220,7 +221,8 @@ function controlMatchesFilter(control, filter) {
 	if (filter.sdtType !== void 0 && control.properties.sdtType !== filter.sdtType) return false;
 	return true;
 }
-function makeParagraphFromText(text) {
+function makeParagraphFromText(rawText) {
+	const text = sanitizeXmlCharacters(rawText);
 	return {
 		type: "paragraph",
 		content: text.length === 0 ? [] : [{
@@ -300,7 +302,7 @@ function setContentControlValue(doc, filter, input, options = {}) {
 				...control,
 				properties: {
 					...control.properties,
-					dropdownLastValue: input.value,
+					dropdownLastValue: sanitizeXmlCharacters(input.value),
 					showingPlaceholder: false,
 					...strippedRawPropertiesXml !== void 0 ? { rawPropertiesXml: strippedRawPropertiesXml } : {}
 				},

package/dist/display-list/dom/renderDisplayListToDom.js

@@ -1,3 +1,5 @@
+import { bytesToDataUrl } from "../../utils/base64.js";
+import { anchorTargetAttrs } from "../../utils/urlSecurity.js";
 import { STROKE_DASH_FACTORS, walkRegions } from "../primitives.js";
 import { panic } from "better-result";
 //#region src/display-list/dom/renderDisplayListToDom.ts
@@ -42,7 +44,6 @@ const PAGE_CLASS_NAME = "layout-page";
 */
 const PAGE_ELEMENT_ID_PREFIX = "page-";
 const DEGREES_PER_RADIAN = 180 / Math.PI;
-const BASE64_CHUNK_SIZE = 32768;
 const IMAGE_MIME_TYPES = {
 	png: "image/png",
 	jpeg: "image/jpeg"
@@ -98,17 +99,11 @@ const resolveImage = (ref, images) => {
 	if (source === void 0) panic(`renderDisplayListToDom: image ref ${ref} is out of range (${images.length} images)`);
 	return source;
 };
-const toBase64 = (bytes) => {
-	let binary = "";
-	for (let offset = 0; offset < bytes.length; offset += BASE64_CHUNK_SIZE) binary += String.fromCharCode(...bytes.subarray(offset, offset + BASE64_CHUNK_SIZE));
-	return btoa(binary);
-};
 /** A `Blob` part cannot be backed by shared memory, so prove it is not. */
 const isBlobPart = (bytes) => bytes.buffer instanceof ArrayBuffer;
 const binarySrc = (bytes, mimeType) => {
 	if (isBlobPart(bytes) && typeof Blob === "function" && typeof URL !== "undefined" && typeof URL.createObjectURL === "function") return URL.createObjectURL(new Blob([bytes], { type: mimeType }));
-	if (typeof btoa === "function") return `data:${mimeType};base64,${toBase64(bytes)}`;
-	panic("renderDisplayListToDom: no Blob or btoa to build a binary source from");
+	return bytesToDataUrl(bytes, mimeType);
 };
 const fontFaceRule = (face, embedded, src) => `@font-face { font-family: ${quoteFontFamily(embedded.id)}; src: url("${src}"); font-weight: ${face.weight}; font-style: ${face.italic ? "italic" : "normal"}; }`;
 /**
@@ -489,6 +484,11 @@ const paintLink = ({ rect, target, tooltip }, context) => {
 	element.style.width = px(rect.widthPx);
 	element.style.height = px(rect.heightPx);
 	element.href = linkHref(target);
+	if (target.kind !== "page") {
+		const anchor = anchorTargetAttrs(void 0);
+		element.target = anchor.target;
+		element.rel = anchor.rel;
+	}
 	if (tooltip !== void 0) element.title = tooltip;
 	context.parent.append(element);
 };

package/dist/document-operations.js

@@ -1,6 +1,7 @@
 import { applyFolioAIEditOperations, previewFolioAIEditOperations } from "./ai-edits/apply.js";
 import { LINE_SPACING_RULE_VALUES, PARAGRAPH_ALIGNMENT_VALUES } from "./types/documentEnumValues.js";
 import { TaggedError } from "better-result";
+import { sanitizeXmlCharacters } from "@stll/docx-core";
 //#region src/document-operations.ts
 const FOLIO_DOCUMENT_OPERATION_CONTRACT_VERSION = 1;
 /** Direct paragraph-alignment values accepted by the operation contract. */
@@ -138,15 +139,25 @@ const assertAllowedKeys = (value, path, allowedKeys) => {
 	const unexpected = Object.keys(value).find((key) => !allowedKeys.includes(key));
 	if (unexpected !== void 0) invalidBatch(`${path}.${unexpected}`, "unexpected property");
 };
+/**
+* Every string in a batch passes through here, so this is where a value an
+* agent sent stops being able to corrupt the package it lands in: XML 1.0
+* admits none of the C0 controls but tab, LF and CR, and no escape can carry
+* one into a document. The batch is otherwise held to exactly what it says, so
+* the rule is the narrowest one that keeps the request usable — drop what
+* cannot be written, map an unpaired surrogate to U+FFFD — rather than
+* rejecting a whole edit over a stray control character. The parsed batch is
+* both what folio applies and what the receipt reports, so the two agree.
+*/
 const readString = (value, key, path) => {
 	const candidate = value[key];
-	if (typeof candidate === "string") return candidate;
+	if (typeof candidate === "string") return sanitizeXmlCharacters(candidate);
 	return invalidBatch(`${path}.${key}`, "expected a string");
 };
 const readOptionalString = (value, key, path) => {
 	const candidate = value[key];
 	if (candidate === void 0) return;
-	if (typeof candidate === "string") return candidate;
+	if (typeof candidate === "string") return sanitizeXmlCharacters(candidate);
 	return invalidBatch(`${path}.${key}`, "expected a string when provided");
 };
 const readOptionalBoolean = (value, key, path) => {
@@ -184,7 +195,7 @@ const readOptionalStringArray = (value, key, path) => {
 	if (candidate === void 0) return;
 	if (!Array.isArray(candidate)) return invalidBatch(`${path}.${key}`, "expected an array when provided");
 	return candidate.map((item, index) => {
-		if (typeof item === "string") return item;
+		if (typeof item === "string") return sanitizeXmlCharacters(item);
 		return invalidBatch(`${path}.${key}[${index}]`, "expected a string");
 	});
 };

package/dist/docx/borderParser.js

@@ -55,15 +55,15 @@ function parseBorderSpec(border, context) {
 	if (shadow !== void 0) spec.shadow = shadow;
 	const frame = parseOnOffAttribute(border, "w", "frame");
 	if (frame !== void 0) spec.frame = frame;
-	const artRelationshipId = getAttribute(border, "w", "id")?.trim();
+	const artRelationshipId = getAttribute(border, "r", "id")?.trim();
 	if (artRelationshipId) spec.artRelationshipId = artRelationshipId;
-	const topLeftArtRelationshipId = getAttribute(border, "w", "topLeft")?.trim();
+	const topLeftArtRelationshipId = getAttribute(border, "r", "topLeft")?.trim();
 	if (topLeftArtRelationshipId) spec.topLeftArtRelationshipId = topLeftArtRelationshipId;
-	const topRightArtRelationshipId = getAttribute(border, "w", "topRight")?.trim();
+	const topRightArtRelationshipId = getAttribute(border, "r", "topRight")?.trim();
 	if (topRightArtRelationshipId) spec.topRightArtRelationshipId = topRightArtRelationshipId;
-	const bottomLeftArtRelationshipId = getAttribute(border, "w", "bottomLeft")?.trim();
+	const bottomLeftArtRelationshipId = getAttribute(border, "r", "bottomLeft")?.trim();
 	if (bottomLeftArtRelationshipId) spec.bottomLeftArtRelationshipId = bottomLeftArtRelationshipId;
-	const bottomRightArtRelationshipId = getAttribute(border, "w", "bottomRight")?.trim();
+	const bottomRightArtRelationshipId = getAttribute(border, "r", "bottomRight")?.trim();
 	if (bottomRightArtRelationshipId) spec.bottomRightArtRelationshipId = bottomRightArtRelationshipId;
 	return spec;
 }