@stll/folio-core 0.61.0 → 0.63.0

package/dist/utils/replaceText.js

@@ -1,10 +1,6 @@
 import { cloneDocumentWithParagraphPropertySources } from "../docx/paragraphPropertySource.js";
-import { textFormattingToMarks } from "../prosemirror/commands/formatting.js";
-import { fromProseDoc } from "../prosemirror/conversion/fromProseDoc.js";
-import { toProseDoc } from "../prosemirror/conversion/toProseDoc.js";
-import { resolveFindMatchRange } from "../prosemirror/findReplaceSelection.js";
-import { schema } from "../prosemirror/schema/index.js";
-import { EditorState } from "prosemirror-state";
+import { getFindParagraphText } from "./findReplace.js";
+import { panic } from "better-result";
 //#region src/utils/replaceText.ts
 /**
 * Lightweight text replacement on the document model.
@@ -16,23 +12,26 @@ function replaceTextInDocument(doc, range, text, formatting) {
 	const body = newDoc.package.document;
 	const { start, end } = range;
 	if (start.paragraphIndex === end.paragraphIndex) {
-		const proseDoc = toProseDoc(newDoc);
-		const proseRange = resolveFindMatchRange(proseDoc, {
-			paragraphIndex: start.paragraphIndex,
+		const paragraph = getParagraphByIndex(body, start.paragraphIndex);
+		if (!paragraph) return newDoc;
+		replaceTextInParagraph({
+			paragraph,
 			startOffset: start.offset,
-			endOffset: end.offset
+			endOffset: end.offset,
+			text,
+			...formatting && { formatting }
 		});
-		if (proseRange === null) return newDoc;
-		const transaction = EditorState.create({ doc: proseDoc }).tr;
-		if (text.length > 0 && formatting !== void 0) transaction.replaceWith(proseRange.from, proseRange.to, schema.text(text, textFormattingToMarks(formatting)));
-		else transaction.insertText(text, proseRange.from, proseRange.to);
-		return fromProseDoc(transaction.doc, newDoc, { stylesheetSource: { type: "package" } });
 	} else {
 		const startParagraph = getParagraphByIndex(body, start.paragraphIndex);
 		if (!startParagraph) return newDoc;
-		const startText = getParagraphText(startParagraph);
-		startParagraph.content = deleteTextInParagraph(startParagraph, start.offset, startText.length);
-		startParagraph.content = insertTextAtOffset(startParagraph, start.offset, text, formatting);
+		const startText = getFindParagraphText(startParagraph);
+		replaceTextInParagraph({
+			paragraph: startParagraph,
+			startOffset: start.offset,
+			endOffset: startText.length,
+			text,
+			...formatting && { formatting }
+		});
 		const paragraphsToRemove = [];
 		for (let i = start.paragraphIndex + 1; i <= end.paragraphIndex; i++) paragraphsToRemove.push(getTopLevelParagraphBlockIndex(body, i));
 		for (let i = paragraphsToRemove.length - 1; i >= 0; i--) {
@@ -74,107 +73,139 @@ function getParagraphByIndex(body, paragraphIndex) {
 	};
 	return walkBlocks(body.content);
 }
-function getParagraphText(paragraph) {
-	let text = "";
-	for (const item of paragraph.content) if (item.type === "run") {
-		for (const c of item.content) if (c.type === "text") text += c.text;
-	} else if (item.type === "hyperlink") for (const child of item.children) {
-		if (child.type !== "run") continue;
-		for (const c of child.content) if (c.type === "text") text += c.text;
-	}
-	return text;
-}
-function deleteTextInParagraph(paragraph, startOffset, endOffset) {
-	const result = [];
-	let currentOffset = 0;
-	for (const item of paragraph.content) if (item.type === "run") {
-		const newContent = [];
-		for (const content of item.content) if (content.type === "text") {
-			const textStart = currentOffset;
-			const textEnd = currentOffset + content.text.length;
-			if (textEnd <= startOffset || textStart >= endOffset) newContent.push(content);
-			else {
-				let newText = "";
-				if (textStart < startOffset) newText += content.text.slice(0, startOffset - textStart);
-				if (textEnd > endOffset) newText += content.text.slice(endOffset - textStart);
-				if (newText) newContent.push({
-					...content,
-					text: newText
-				});
-			}
-			currentOffset = textEnd;
-		} else newContent.push(content);
-		if (newContent.length > 0) result.push({
-			...item,
-			content: newContent
-		});
-	} else result.push(item);
-	return result;
-}
-function insertTextAtOffset(paragraph, offset, text, formatting) {
-	if (!text) return paragraph.content;
+const itemTextLength = (item) => getFindParagraphText({
+	type: "paragraph",
+	content: [item]
+}).length;
+/** Walk authored offsets once, preserving wrappers and opaque source units. */
+const replaceTextInParagraph = ({ paragraph, startOffset, endOffset, text, formatting }) => {
 	let currentOffset = 0;
-	for (const item of paragraph.content) if (item.type === "run") for (let ci = 0; ci < item.content.length; ci++) {
-		const content = item.content[ci];
-		if (content.type === "text") {
-			const textStart = currentOffset;
-			const textEnd = currentOffset + content.text.length;
-			if (offset >= textStart && offset <= textEnd) {
-				const relOffset = offset - textStart;
-				if (formatting) {
-					const before = content.text.slice(0, relOffset);
-					const after = content.text.slice(relOffset);
-					const newContent = [];
-					if (before) newContent.push({
-						type: "text",
-						text: before
+	let inserted = false;
+	const visit = (items) => {
+		for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+			const item = items.at(itemIndex);
+			if (!item) continue;
+			switch (item.type) {
+				case "run": {
+					const before = [];
+					const after = [];
+					let splitAtInsertion = false;
+					for (const unit of item.content) {
+						const unitStart = currentOffset;
+						const unitText = getFindParagraphText({
+							type: "paragraph",
+							content: [{
+								type: "run",
+								content: [unit]
+							}]
+						});
+						const unitLength = unitText.length;
+						const unitEnd = unitStart + unitLength;
+						currentOffset = unitEnd;
+						const output = splitAtInsertion ? after : before;
+						if (unit.type === "preservedXml" || unitLength === 0) {
+							output.push(unit);
+							continue;
+						}
+						const overlaps = unitEnd > startOffset && unitStart < endOffset;
+						if (!overlaps && !(!inserted && startOffset === endOffset && startOffset >= unitStart && startOffset <= unitEnd)) {
+							output.push(unit);
+							continue;
+						}
+						if (unit.type !== "text" && !overlaps) {
+							if (startOffset === unitEnd) output.push(unit);
+							inserted = true;
+							if (formatting) splitAtInsertion = true;
+							else if (text) output.push({
+								type: "text",
+								text
+							});
+							if (startOffset === unitStart) (splitAtInsertion ? after : before).push(unit);
+							continue;
+						}
+						const prefix = unitText.slice(0, Math.max(0, startOffset - unitStart));
+						const suffix = unitText.slice(Math.max(0, endOffset - unitStart));
+						if (prefix) output.push({
+							type: "text",
+							text: prefix
+						});
+						if (!inserted) {
+							inserted = true;
+							if (formatting) splitAtInsertion = true;
+							else if (text) output.push({
+								type: "text",
+								text
+							});
+						}
+						if (suffix) (splitAtInsertion ? after : before).push({
+							type: "text",
+							text: suffix
+						});
+					}
+					if (!splitAtInsertion) {
+						item.content = before;
+						break;
+					}
+					const replacement = [];
+					if (before.length > 0) replacement.push({
+						...item,
+						content: before
 					});
-					const newRun = {
-						type: "text",
-						text
-					};
-					item.content.splice(ci, 1, ...newContent);
-					const insertRun = {
+					if (text) replacement.push({
 						type: "run",
-						content: [newRun],
-						formatting
-					};
-					const afterItems = [];
-					if (after) afterItems.push({
-						type: "text",
-						text: after
+						content: [{
+							type: "text",
+							text
+						}],
+						...formatting && { formatting }
 					});
-					const remaining = item.content.splice(ci + newContent.length);
-					const afterRun = {
-						type: "run",
-						content: [...remaining, ...afterItems],
-						...item.formatting !== void 0 ? { formatting: item.formatting } : {}
-					};
-					const idx = paragraph.content.indexOf(item);
-					paragraph.content.splice(idx + 1, 0, insertRun);
-					if (afterItems.length > 0 || remaining.length > 0) paragraph.content.splice(idx + 2, 0, afterRun);
-					return paragraph.content;
+					if (after.length > 0) replacement.push({
+						...item,
+						content: after
+					});
+					items.splice(itemIndex, 1, ...replacement);
+					itemIndex += replacement.length - 1;
+					break;
 				}
-				content.text = content.text.slice(0, relOffset) + text + content.text.slice(relOffset);
-				return paragraph.content;
+				case "hyperlink":
+					visit(item.children);
+					break;
+				case "inlineWrapper":
+				case "inlineSdt":
+				case "insertion":
+				case "deletion":
+				case "moveFrom":
+				case "moveTo":
+					visit(item.content);
+					break;
+				case "simpleField":
+				case "complexField":
+				case "preservedInline":
+				case "mathEquation":
+				case "bookmarkStart":
+				case "bookmarkEnd":
+				case "commentRangeStart":
+				case "commentRangeEnd":
+				case "commentReference":
+				case "moveFromRangeStart":
+				case "moveFromRangeEnd":
+				case "moveToRangeStart":
+				case "moveToRangeEnd":
+					currentOffset += itemTextLength(item);
+					break;
+				default: panic("Unsupported replacement paragraph content", { content: item });
 			}
-			currentOffset = textEnd;
 		}
-	}
-	const lastRun = paragraph.content.findLast((item) => item.type === "run");
-	if (lastRun) lastRun.content.push({
-		type: "text",
-		text
-	});
-	else paragraph.content.push({
+	};
+	visit(paragraph.content);
+	if (!inserted && startOffset === endOffset && startOffset === currentOffset && text) paragraph.content.push({
 		type: "run",
 		content: [{
 			type: "text",
 			text
 		}],
-		formatting: formatting ?? {}
+		...formatting ? { formatting } : {}
 	});
-	return paragraph.content;
-}
+};
 //#endregion
 export { replaceTextInDocument };

package/dist/utils/rotationBoundingBox.d.ts

@@ -1,15 +1,14 @@
 import { ImageRun } from "../layout-engine/types.js";
 //#region src/utils/rotationBoundingBox.d.ts
-type BoundingBox = {
+export type BoundingBox = {
   width: number;
   height: number;
 };
-declare function parseRotationDegrees(transform: string | undefined): number;
+export declare function parseRotationDegrees(transform: string | undefined): number;
 /** Whether a DrawingML/CSS transform reflects around the vertical centre line. */
-declare function hasHorizontalFlip(transform: string | undefined): boolean;
+export declare function hasHorizontalFlip(transform: string | undefined): boolean;
 /** Whether a DrawingML/CSS transform reflects around the horizontal centre line. */
-declare function hasVerticalFlip(transform: string | undefined): boolean;
-declare function rotatedBoundingBox(w: number, h: number, deg: number): BoundingBox;
-declare function inlineImageBoundingBox(run: ImageRun): BoundingBox;
-//#endregion
-export { BoundingBox, hasHorizontalFlip, hasVerticalFlip, inlineImageBoundingBox, parseRotationDegrees, rotatedBoundingBox };
+export declare function hasVerticalFlip(transform: string | undefined): boolean;
+export declare function rotatedBoundingBox(w: number, h: number, deg: number): BoundingBox;
+export declare function inlineImageBoundingBox(run: ImageRun): BoundingBox;
+//#endregion

package/dist/utils/sanitizeImageSrc.d.ts

@@ -7,7 +7,7 @@
  * pasting an untrusted document cannot trigger an external request or run a
  * script scheme through `<img src>`.
  */
-declare function sanitizeImageSrc(src: string | null | undefined): string | undefined;
+export declare function sanitizeImageSrc(src: string | null | undefined): string | undefined;
 /**
  * Assign a sanitized source to an `<img>` element. When the source is rejected
  * the `src` attribute is left unset: assigning `""` makes some browsers resolve
@@ -16,6 +16,5 @@ declare function sanitizeImageSrc(src: string | null | undefined): string | unde
  * Structural parameter type so painter unit tests (which fake the DOM) can
  * exercise it without an `HTMLImageElement`.
  */
-declare function applySanitizedImageSrc(imgEl: Pick<HTMLImageElement, "src">, src: string | null | undefined): void;
-//#endregion
-export { applySanitizedImageSrc, sanitizeImageSrc };
+export declare function applySanitizedImageSrc(imgEl: Pick<HTMLImageElement, "src">, src: string | null | undefined): void;
+//#endregion

package/dist/utils/scriptSegments.d.ts

@@ -17,30 +17,43 @@
  * glyph once silently corrupted an RTL character class here).
  */
 /** Which of Word's font slots a code point selects. */
-declare const SCRIPT_CLASS: {
+export declare const SCRIPT_CLASS: {
   /** `w:eastAsia` — CJK ideographs, kana, Hangul. */
   readonly eastAsia: "eastAsia";
   /** `w:cs` — Arabic, Hebrew, Indic, South-East Asian. */
   readonly complex: "complex";
+  /** `w:hAnsi` — non-ASCII western text when that slot has its own face. */
+  readonly hAnsi: "hAnsi";
   /** `w:ascii` / `w:hAnsi` — everything else. */
   readonly western: "western";
 };
-type ScriptClass = (typeof SCRIPT_CLASS)[keyof typeof SCRIPT_CLASS];
-type ScriptSegment = {
+export type ScriptClass = (typeof SCRIPT_CLASS)[keyof typeof SCRIPT_CLASS];
+export type ScriptSegment = {
   text: string;
   script: ScriptClass;
 };
+export type ScriptSegmentationOptions = {
+  eastAsiaHint?: boolean | undefined;
+  hasHAnsiFont?: boolean | undefined;
+};
+export type HAnsiFontSlot = {
+  fontFamily?: string;
+  alternateFontFamily?: string;
+  hAnsiFontFamily?: string;
+  hAnsiAlternateFontFamily?: string;
+};
+export declare function hasDistinctHAnsiFont({ fontFamily, alternateFontFamily, hAnsiFontFamily, hAnsiAlternateFontFamily }: HAnsiFontSlot): boolean;
 /**
  * True when a code point belongs to an East-Asian script that Word renders with
  * the `w:eastAsia` font slot: CJK ideographs, kana, Hangul, CJK symbols and
  * punctuation, and fullwidth/halfwidth forms.
  */
-declare function isCjkCodePoint(cp: number): boolean;
+export declare function isCjkCodePoint(cp: number): boolean;
 /**
  * True when the text contains at least one East-Asian code point. Callers use
  * this to skip segmentation entirely on the common all-Latin path.
  */
-declare function hasCjk(text: string): boolean;
+export declare function hasCjk(text: string): boolean;
 /**
  * True when a code point belongs to a script Word renders with the `w:cs`
  * (complex script) font slot: the bidirectional scripts plus the Indic and
@@ -49,7 +62,7 @@ declare function hasCjk(text: string): boolean;
  * Checked after CJK, which owns the ranges above U+2E80 that would otherwise
  * overlap the presentation forms below.
  */
-declare function isComplexScriptCodePoint(cp: number): boolean;
+export declare function isComplexScriptCodePoint(cp: number): boolean;
 /**
  * True when `w:rFonts/@w:hint="eastAsia"` moves a code point from the
  * `w:hAnsi` slot to the `w:eastAsia` slot (ECMA-376 §17.3.2.26): the ranges
@@ -58,13 +71,15 @@ declare function isComplexScriptCodePoint(cp: number): boolean;
  * Latin-1 Supplement and the Latin Extended blocks, whose move the table also
  * conditions on the run's East Asian language.
  */
-declare function isEastAsiaHintCodePoint(cp: number): boolean;
+export declare function isEastAsiaHintCodePoint(cp: number): boolean;
+/** Characters assigned to `w:hAnsi` when no East Asian hint moves them. */
+export declare function isHAnsiCodePoint(cp: number): boolean;
 /**
  * Whether a run's `w:hint="eastAsia"` takes effect. A run under `w:cs` or
  * `w:rtl` formats every character with the complex-script slot, which the
  * hint does not override.
  */
-declare function eastAsiaHintApplies(run: {
+export declare function eastAsiaHintApplies(run: {
   readonly eastAsiaHint?: boolean | undefined;
   readonly forceComplexScript?: boolean | undefined;
   readonly rtl?: boolean | undefined;
@@ -74,7 +89,7 @@ declare function eastAsiaHintApplies(run: {
  * `eastAsiaHint` is the run's effective `w:hint="eastAsia"`
  * (see {@link eastAsiaHintApplies}).
  */
-declare function scriptClassOf(cp: number, eastAsiaHint?: boolean): ScriptClass;
+export declare function scriptClassOf(cp: number, options?: ScriptSegmentationOptions): ScriptClass;
 /**
  * True when the text contains at least one complex-script code point. Callers
  * use this to skip segmentation entirely on the common all-Latin path.
@@ -87,21 +102,24 @@ declare function scriptClassOf(cp: number, eastAsiaHint?: boolean): ScriptClass;
  * because the direction decides the order glyphs come back in, and a run shaped
  * the wrong way round reads backwards.
  */
-declare function isRightToLeftCodePoint(cp: number): boolean;
+export declare function isRightToLeftCodePoint(cp: number): boolean;
 /** True when the text contains at least one right-to-left code point. */
-declare function hasRightToLeft(text: string): boolean;
-declare function hasComplexScript(text: string): boolean;
+export declare function hasRightToLeft(text: string): boolean;
+export declare function hasComplexScript(text: string): boolean;
 /**
  * True when some code point of the text selects the `w:eastAsia` slot: a CJK
  * code point, or under an effective `w:hint="eastAsia"` one the hint moves.
  */
-declare function hasEastAsiaSlotText(text: string, eastAsiaHint?: boolean): boolean;
+export declare function hasEastAsiaSlotText(text: string, eastAsiaHint?: boolean): boolean;
+/** True when text selects `w:hAnsi` and the run has an independent hAnsi face. */
+export declare function hasHAnsiSlotText(text: string, options?: {
+  eastAsiaHint?: boolean | undefined;
+}): boolean;
 /**
  * Split text into maximal runs of one script class (CJK vs. non-CJK). Iterates
  * by code point so astral ideographs (surrogate pairs) are never split between
  * fonts. Empty input yields no segments; single-class input yields one.
  * `eastAsiaHint` is the run's effective `w:hint="eastAsia"`.
  */
-declare function segmentByScript(text: string, eastAsiaHint?: boolean): ScriptSegment[];
-//#endregion
-export { SCRIPT_CLASS, ScriptClass, ScriptSegment, eastAsiaHintApplies, hasCjk, hasComplexScript, hasEastAsiaSlotText, hasRightToLeft, isCjkCodePoint, isComplexScriptCodePoint, isEastAsiaHintCodePoint, isRightToLeftCodePoint, scriptClassOf, segmentByScript };
+export declare function segmentByScript(text: string, options?: ScriptSegmentationOptions): ScriptSegment[];
+//#endregion

package/dist/utils/scriptSegments.js

@@ -22,9 +22,14 @@ const SCRIPT_CLASS = {
 	eastAsia: "eastAsia",
 	/** `w:cs` — Arabic, Hebrew, Indic, South-East Asian. */
 	complex: "complex",
+	/** `w:hAnsi` — non-ASCII western text when that slot has its own face. */
+	hAnsi: "hAnsi",
 	/** `w:ascii` / `w:hAnsi` — everything else. */
 	western: "western"
 };
+function hasDistinctHAnsiFont({ fontFamily, alternateFontFamily, hAnsiFontFamily, hAnsiAlternateFontFamily }) {
+	return hAnsiFontFamily !== void 0 && (hAnsiFontFamily !== fontFamily || hAnsiAlternateFontFamily !== alternateFontFamily);
+}
 /**
 * True when a code point belongs to an East-Asian script that Word renders with
 * the `w:eastAsia` font slot: CJK ideographs, kana, Hangul, CJK symbols and
@@ -61,7 +66,11 @@ function isComplexScriptCodePoint(cp) {
 * conditions on the run's East Asian language.
 */
 function isEastAsiaHintCodePoint(cp) {
-	return cp === 161 || cp === 164 || cp === 167 || cp === 168 || cp === 170 || cp === 173 || cp === 175 || cp >= 176 && cp <= 180 || cp >= 182 && cp <= 186 || cp >= 188 && cp <= 191 || cp === 215 || cp === 247 || cp >= 688 && cp <= 879 || cp >= 880 && cp <= 1023 || cp >= 1024 && cp <= 1279 || cp >= 8192 && cp <= 10175 || cp >= 57344 && cp <= 63743 || cp >= 64256 && cp <= 64284;
+	return cp === 161 || cp === 164 || cp === 167 || cp === 168 || cp === 170 || cp === 173 || cp === 175 || cp >= 176 && cp <= 180 || cp >= 182 && cp <= 186 || cp >= 188 && cp <= 191 || cp === 215 || cp === 247 || cp >= 688 && cp <= 879 || cp >= 880 && cp <= 1023 || cp >= 1024 && cp <= 1279 || cp >= 8192 && cp <= 8238 || cp >= 8240 && cp <= 10175 || cp >= 57344 && cp <= 63743 || cp >= 64256 && cp <= 64284;
+}
+/** Characters assigned to `w:hAnsi` when no East Asian hint moves them. */
+function isHAnsiCodePoint(cp) {
+	return cp >= 160 && cp <= 65535 && !isComplexScriptCodePoint(cp) && !isCjkCodePoint(cp);
 }
 /**
 * Whether a run's `w:hint="eastAsia"` takes effect. A run under `w:cs` or
@@ -76,9 +85,11 @@ function eastAsiaHintApplies(run) {
 * `eastAsiaHint` is the run's effective `w:hint="eastAsia"`
 * (see {@link eastAsiaHintApplies}).
 */
-function scriptClassOf(cp, eastAsiaHint = false) {
+function scriptClassOf(cp, options = {}) {
+	const { eastAsiaHint = false, hasHAnsiFont = false } = options;
 	if (isCjkCodePoint(cp) || eastAsiaHint && isEastAsiaHintCodePoint(cp)) return SCRIPT_CLASS.eastAsia;
 	if (isComplexScriptCodePoint(cp)) return SCRIPT_CLASS.complex;
+	if (hasHAnsiFont && isHAnsiCodePoint(cp) && !(eastAsiaHint && isEastAsiaHintCodePoint(cp))) return SCRIPT_CLASS.hAnsi;
 	return SCRIPT_CLASS.western;
 }
 /**
@@ -111,7 +122,16 @@ function hasComplexScript(text) {
 */
 function hasEastAsiaSlotText(text, eastAsiaHint = false) {
 	if (!eastAsiaHint) return hasCjk(text);
-	for (const ch of text) if (scriptClassOf(ch.codePointAt(0), true) === SCRIPT_CLASS.eastAsia) return true;
+	for (const ch of text) if (scriptClassOf(ch.codePointAt(0), { eastAsiaHint: true }) === SCRIPT_CLASS.eastAsia) return true;
+	return false;
+}
+/** True when text selects `w:hAnsi` and the run has an independent hAnsi face. */
+function hasHAnsiSlotText(text, options = {}) {
+	const { eastAsiaHint = false } = options;
+	for (const ch of text) if (scriptClassOf(ch.codePointAt(0), {
+		eastAsiaHint,
+		hasHAnsiFont: true
+	}) === SCRIPT_CLASS.hAnsi) return true;
 	return false;
 }
 /**
@@ -120,12 +140,12 @@ function hasEastAsiaSlotText(text, eastAsiaHint = false) {
 * fonts. Empty input yields no segments; single-class input yields one.
 * `eastAsiaHint` is the run's effective `w:hint="eastAsia"`.
 */
-function segmentByScript(text, eastAsiaHint = false) {
+function segmentByScript(text, options = {}) {
 	const segments = [];
 	let current = "";
 	let currentScript = SCRIPT_CLASS.western;
 	for (const ch of text) {
-		const script = scriptClassOf(ch.codePointAt(0), eastAsiaHint);
+		const script = scriptClassOf(ch.codePointAt(0), options);
 		if (current.length === 0) {
 			current = ch;
 			currentScript = script;
@@ -149,4 +169,4 @@ function segmentByScript(text, eastAsiaHint = false) {
 	return segments;
 }
 //#endregion
-export { SCRIPT_CLASS, eastAsiaHintApplies, hasCjk, hasComplexScript, hasEastAsiaSlotText, hasRightToLeft, isCjkCodePoint, isComplexScriptCodePoint, isEastAsiaHintCodePoint, isRightToLeftCodePoint, scriptClassOf, segmentByScript };
+export { SCRIPT_CLASS, eastAsiaHintApplies, hasCjk, hasComplexScript, hasDistinctHAnsiFont, hasEastAsiaSlotText, hasHAnsiSlotText, hasRightToLeft, isCjkCodePoint, isComplexScriptCodePoint, isEastAsiaHintCodePoint, isHAnsiCodePoint, isRightToLeftCodePoint, scriptClassOf, segmentByScript };

package/dist/utils/sliceText.js

@@ -1,2 +1 @@
-import { sliceText } from "@stll/utf8-boundaries";
-export { sliceText };
+export { sliceText } from "@stll/utf8-boundaries";

package/dist/utils/stripXmlDeclarations.d.ts

@@ -6,6 +6,5 @@
  * when many `<?xml` openers appear with no closing `>`. An unterminated opener
  * is preserved verbatim (same as the regex, which never matched it).
  */
-declare function stripXmlDeclarations(html: string): string;
-//#endregion
-export { stripXmlDeclarations };
+export declare function stripXmlDeclarations(html: string): string;
+//#endregion

package/dist/utils/tableOfContentsStyle.d.ts

@@ -4,6 +4,6 @@ type TableOfContentsStyleIdentity = {
   styleName?: string;
 };
 /** Resolve a built-in TOC entry style without relying on its localized style id. */
-declare const tableOfContentsStyleLevel: ({ styleId, styleName }: TableOfContentsStyleIdentity) => number | undefined;
+export declare const tableOfContentsStyleLevel: ({ styleId, styleName }: TableOfContentsStyleIdentity) => number | undefined;
 //#endregion
-export { tableOfContentsStyleLevel };
+export {};

package/dist/utils/tableOperations.d.ts

@@ -1,13 +1,13 @@
 import { document_d_exports } from "../types/document.js";
 //#region src/utils/tableOperations.d.ts
-type TablePropertiesCommand = {
+export type TablePropertiesCommand = {
   width?: number | null;
   widthType?: document_d_exports.TableWidthType | null;
   justification?: document_d_exports.TableAlignment | null;
 };
-declare const TABLE_PROPERTY_JUSTIFICATIONS: readonly document_d_exports.TableAlignment[];
-declare const toTablePropertyJustification: (value: string | null | undefined) => NonNullable<TablePropertiesCommand["justification"]>;
-type TableAction = "addRowAbove" | "addRowBelow" | "addColumnLeft" | "addColumnRight" | "deleteRow" | "deleteColumn" | "mergeCells" | "splitCell" | "deleteTable" | "selectTable" | "selectRow" | "selectColumn" | "borderAll" | "borderOutside" | "borderInside" | "borderNone" | "borderTop" | "borderBottom" | "borderLeft" | "borderRight" | {
+export declare const TABLE_PROPERTY_JUSTIFICATIONS: readonly document_d_exports.TableAlignment[];
+export declare const toTablePropertyJustification: (value: string | null | undefined) => NonNullable<TablePropertiesCommand["justification"]>;
+export type TableAction = "addRowAbove" | "addRowBelow" | "addColumnLeft" | "addColumnRight" | "deleteRow" | "deleteColumn" | "mergeCells" | "splitCell" | "deleteTable" | "selectTable" | "selectRow" | "selectColumn" | "borderAll" | "borderOutside" | "borderInside" | "borderNone" | "borderTop" | "borderBottom" | "borderLeft" | "borderRight" | {
   type: "cellFillColor";
   color: string | null;
 } | {
@@ -57,7 +57,7 @@ type TableAction = "addRowAbove" | "addRowBelow" | "addColumnLeft" | "addColumnR
   type: "applyTableStyle";
   styleId: string;
 };
-type TableSelection = {
+export type TableSelection = {
   tableIndex: number;
   rowIndex: number;
   columnIndex: number;
@@ -68,7 +68,7 @@ type TableSelection = {
     endCol: number;
   };
 };
-type TableContext = {
+export type TableContext = {
   table: document_d_exports.Table;
   selection: TableSelection;
   hasMultiCellSelection: boolean;
@@ -76,14 +76,13 @@ type TableContext = {
   rowCount: number;
   columnCount: number;
 };
-declare const getColumnCount: (table: document_d_exports.Table) => number;
-declare const getCellAt: (table: document_d_exports.Table, rowIndex: number, columnIndex: number) => document_d_exports.TableCell | null;
-declare const createTableContext: (table: document_d_exports.Table, selection: TableSelection) => TableContext;
-declare const addRow: (table: document_d_exports.Table, atIndex: number, position?: "before" | "after") => document_d_exports.Table;
-declare const deleteRow: (table: document_d_exports.Table, rowIndex: number) => document_d_exports.Table;
-declare const addColumn: (table: document_d_exports.Table, atIndex: number, position?: "before" | "after") => document_d_exports.Table;
-declare const deleteColumn: (table: document_d_exports.Table, columnIndex: number) => document_d_exports.Table;
-declare const mergeCells: (table: document_d_exports.Table, selection: TableSelection) => document_d_exports.Table;
-declare const splitCell: (table: document_d_exports.Table, rowIndex: number, columnIndex: number) => document_d_exports.Table;
-//#endregion
-export { TABLE_PROPERTY_JUSTIFICATIONS, TableAction, TableContext, TablePropertiesCommand, TableSelection, addColumn, addRow, createTableContext, deleteColumn, deleteRow, getCellAt, getColumnCount, mergeCells, splitCell, toTablePropertyJustification };
+export declare const getColumnCount: (table: document_d_exports.Table) => number;
+export declare const getCellAt: (table: document_d_exports.Table, rowIndex: number, columnIndex: number) => document_d_exports.TableCell | null;
+export declare const createTableContext: (table: document_d_exports.Table, selection: TableSelection) => TableContext;
+export declare const addRow: (table: document_d_exports.Table, atIndex: number, position?: "before" | "after") => document_d_exports.Table;
+export declare const deleteRow: (table: document_d_exports.Table, rowIndex: number) => document_d_exports.Table;
+export declare const addColumn: (table: document_d_exports.Table, atIndex: number, position?: "before" | "after") => document_d_exports.Table;
+export declare const deleteColumn: (table: document_d_exports.Table, columnIndex: number) => document_d_exports.Table;
+export declare const mergeCells: (table: document_d_exports.Table, selection: TableSelection) => document_d_exports.Table;
+export declare const splitCell: (table: document_d_exports.Table, rowIndex: number, columnIndex: number) => document_d_exports.Table;
+//#endregion