@stll/folio-core 0.62.0 → 0.63.0

package/dist/utils/paragraphInlineLayout.d.ts

@@ -1,7 +1,104 @@
-import { ParagraphAttrs, ParagraphBlock } from "../layout-engine/types.js";
+import { ImageRun, MeasuredLine, Page, ParagraphAttrs, ParagraphBlock, ParagraphFragment } from "../layout-engine/types.js";
 //#region src/utils/paragraphInlineLayout.d.ts
 type ParagraphAlignment = NonNullable<ParagraphAttrs["alignment"]>;
-type PhysicalParagraphInlineLayout = {
+export type HorizontalClipViewport = {
+  left: number;
+  right: number;
+};
+export declare const intersectHorizontalClipViewports: (first: HorizontalClipViewport | undefined, second: HorizontalClipViewport) => HorizontalClipViewport;
+export type InlinePictureClipInsets = {
+  left: number;
+  right: number;
+};
+type HorizontalColumn = {
+  left: number;
+  width: number;
+};
+type ColumnPictureClipViewportOptions = {
+  paper: HorizontalClipViewport;
+  columns: readonly HorizontalColumn[];
+  columnIndex: number;
+};
+export type PageColumnLayout = NonNullable<Page["columns"]>;
+export type InlinePictureVisibleBounds = {
+  left: number;
+  right: number;
+};
+type InlinePictureVisibleBoundsOptions = {
+  pictureLeft: number;
+  pictureWidth: number;
+  viewport: HorizontalClipViewport;
+};
+export declare const inlinePictureVisibleBounds: ({ pictureLeft, pictureWidth, viewport }: InlinePictureVisibleBoundsOptions) => InlinePictureVisibleBounds;
+type PageHorizontalColumnsOptions = {
+  layout: PageColumnLayout | undefined;
+  contentLeft: number;
+  contentWidth: number;
+};
+export declare const pageHorizontalColumns: ({ layout, contentLeft, contentWidth }: PageHorizontalColumnsOptions) => HorizontalColumn[];
+type ColumnPictureClipViewportForFragmentOptions = {
+  paper: HorizontalClipViewport;
+  columns: readonly HorizontalColumn[];
+  fragmentX: number;
+  fragmentWidth: number;
+  inlinePictureViewport?: HorizontalClipViewport;
+};
+export declare const columnPictureClipViewportForFragment: ({ paper, columns, fragmentX, fragmentWidth, inlinePictureViewport }: ColumnPictureClipViewportForFragmentOptions) => HorizontalClipViewport;
+type InlinePictureClipInsetsOptions = {
+  pictureLeft: number;
+  pictureWidth: number;
+  viewport: HorizontalClipViewport;
+};
+export declare const inlinePictureClipInsets: ({ pictureLeft, pictureWidth, viewport }: InlinePictureClipInsetsOptions) => InlinePictureClipInsets;
+export declare const columnPictureClipViewportForColumn: ({ paper, columns, columnIndex }: ColumnPictureClipViewportOptions) => HorizontalClipViewport;
+export declare const resolveImageLineAlign: (imageRun: ImageRun, paragraphAlignment: ParagraphAlignment | undefined) => ParagraphAlignment | undefined;
+type ResolveParagraphLineAlignmentOptions = {
+  imageOnlyRun?: ImageRun;
+  paragraphAlignment: ParagraphAlignment;
+  availableWidth: number;
+};
+export declare const resolveParagraphLineAlignment: ({ imageOnlyRun, paragraphAlignment, availableWidth }: ResolveParagraphLineAlignmentOptions) => ParagraphAlignment;
+export declare const paragraphImageOnlyRun: (block: ParagraphBlock, line: MeasuredLine) => ImageRun | undefined;
+export declare const paragraphHasInlinePicture: (block: ParagraphBlock) => boolean;
+type ParagraphInlinePictureViewportOptions = {
+  block: ParagraphBlock;
+  fragment: Pick<ParagraphFragment, "x" | "width" | "inlinePictureViewport">;
+  paper: HorizontalClipViewport;
+  columns: readonly HorizontalColumn[];
+};
+export declare const paragraphInlinePictureViewport: ({ block, fragment, paper, columns }: ParagraphInlinePictureViewportOptions) => HorizontalClipViewport | undefined;
+export declare const isInlinePictureRun: (run: ImageRun) => boolean;
+export type ParagraphLineGeometry = {
+  alignment: ParagraphAlignment;
+  paintStartXPx: number;
+  layoutStartXPx: number;
+  layoutRightEdgeXPx: number;
+  baselineYPx: number;
+  lineTopYPx: number;
+};
+type ResolveParagraphLineGeometryOptions = {
+  fragment: Pick<ParagraphFragment, "x" | "width">;
+  line: MeasuredLine;
+  lineTopYPx: number;
+  alignment: ParagraphAlignment;
+  isRtl: boolean;
+  indentLeft: number;
+  indentRight: number;
+  firstLineOffsetPx: number;
+  markerInlineWidthPx: number;
+  isFirstLine: boolean;
+  imageOnlyRun?: ImageRun;
+};
+export declare const resolveParagraphLineGeometry: ({ fragment, line, lineTopYPx, alignment, isRtl, indentLeft, indentRight, firstLineOffsetPx, markerInlineWidthPx, isFirstLine, imageOnlyRun }: ResolveParagraphLineGeometryOptions) => ParagraphLineGeometry;
+type ResolveParagraphLineGeometryForBlockOptions = {
+  fragment: Pick<ParagraphFragment, "x" | "width">;
+  block: ParagraphBlock;
+  line: MeasuredLine;
+  lineTopYPx: number;
+  isFirstLine: boolean;
+};
+export declare const resolveParagraphLineGeometryForBlock: ({ fragment, block, line, lineTopYPx, isFirstLine }: ResolveParagraphLineGeometryForBlockOptions) => ParagraphLineGeometry;
+export type PhysicalParagraphInlineLayout = {
   alignment: ParagraphAlignment;
   explicitAlignment?: ParagraphAlignment;
   indentLeft: number;
@@ -9,6 +106,6 @@ type PhysicalParagraphInlineLayout = {
   isRtl: boolean;
 };
 /** Resolve logical OOXML paragraph sides into physical inline geometry. */
-declare const resolvePhysicalParagraphInlineLayout: (block: ParagraphBlock) => PhysicalParagraphInlineLayout;
+export declare const resolvePhysicalParagraphInlineLayout: (block: ParagraphBlock) => PhysicalParagraphInlineLayout;
 //#endregion
-export { PhysicalParagraphInlineLayout, resolvePhysicalParagraphInlineLayout };
+export {};

package/dist/utils/paragraphInlineLayout.js

@@ -1,5 +1,168 @@
+import { getListMarkerInlineWidth } from "../layout-engine/measure/listMarkerWidth.js";
+import { isFloatingImageRun } from "../layout-engine/types.js";
 import { isRtlParagraph } from "./paragraphBaseDirection.js";
+import { getParagraphFrame } from "./paragraphFrame.js";
+import { inlineImageBoundingBox } from "./rotationBoundingBox.js";
+import { panic } from "better-result";
 //#region src/utils/paragraphInlineLayout.ts
+const intersectHorizontalClipViewports = (first, second) => {
+	if (first === void 0) return second;
+	const left = Math.max(first.left, second.left);
+	return {
+		left,
+		right: Math.max(left, Math.min(first.right, second.right))
+	};
+};
+const inlinePictureVisibleBounds = ({ pictureLeft, pictureWidth, viewport }) => {
+	const left = Math.max(pictureLeft, viewport.left);
+	return {
+		left,
+		right: Math.max(left, Math.min(pictureLeft + pictureWidth, viewport.right))
+	};
+};
+const pageHorizontalColumns = ({ layout, contentLeft, contentWidth }) => {
+	if (layout === void 0 || layout.count < 2) return [];
+	const equalWidth = (contentWidth - layout.gap * (layout.count - 1)) / layout.count;
+	const columns = [];
+	let left = contentLeft;
+	for (let index = 0; index < layout.count; index += 1) {
+		const width = layout.widths?.at(index) ?? equalWidth;
+		columns.push({
+			left,
+			width
+		});
+		left += width + (layout.gaps?.[index] ?? layout.gap);
+	}
+	return columns;
+};
+const columnPictureClipViewportForFragment = ({ paper, columns, fragmentX, fragmentWidth, inlinePictureViewport }) => {
+	if (inlinePictureViewport !== void 0) return inlinePictureViewport;
+	if (columns.length === 0) return paper;
+	const columnIndex = columns.findIndex((column) => column.left === fragmentX && column.width === fragmentWidth);
+	if (columnIndex === -1) return panic("Paragraph fragment has no matching page column clip bounds");
+	return columnPictureClipViewportForColumn({
+		paper,
+		columns,
+		columnIndex
+	});
+};
+const inlinePictureClipInsets = ({ pictureLeft, pictureWidth, viewport }) => ({
+	left: Math.max(0, viewport.left - pictureLeft),
+	right: Math.max(0, pictureLeft + pictureWidth - viewport.right)
+});
+const columnPictureClipViewportForColumn = ({ paper, columns, columnIndex }) => {
+	const column = columns[columnIndex];
+	if (column === void 0 || columns.length < 2) return paper;
+	const columnRight = column.left + column.width;
+	let left = paper.left;
+	let right = paper.right;
+	for (const [index, other] of columns.entries()) {
+		if (index === columnIndex) continue;
+		const otherRight = other.left + other.width;
+		if (otherRight <= column.left) left = Math.max(left, (otherRight + column.left) / 2);
+		if (other.left >= columnRight) right = Math.min(right, (columnRight + other.left) / 2);
+	}
+	return {
+		left,
+		right
+	};
+};
+const resolveImageLineAlign = (imageRun, paragraphAlignment) => {
+	const horizontal = imageRun.position?.horizontal;
+	if (!horizontal) return paragraphAlignment;
+	switch (horizontal.align) {
+		case "center": return "center";
+		case "right":
+		case "outside": return "right";
+		default: return "left";
+	}
+};
+const resolveInlineImageLineAlign = ({ imageRun, paragraphAlignment, availableWidth }) => {
+	if (!imageRun.position?.horizontal && availableWidth !== void 0 && inlineImageBoundingBox(imageRun).width > availableWidth) return "left";
+	return resolveImageLineAlign(imageRun, paragraphAlignment);
+};
+const resolveParagraphLineAlignment = ({ imageOnlyRun, paragraphAlignment, availableWidth }) => imageOnlyRun === void 0 ? paragraphAlignment : resolveInlineImageLineAlign({
+	imageRun: imageOnlyRun,
+	paragraphAlignment,
+	availableWidth
+}) ?? paragraphAlignment;
+const paragraphImageOnlyRun = (block, line) => {
+	if (line.fromRun !== line.toRun) return void 0;
+	const run = block.runs.at(line.fromRun);
+	if (run?.kind !== "image" || !isInlinePictureRun(run)) return void 0;
+	return run;
+};
+const paragraphHasInlinePicture = (block) => block.runs.some((run) => run.kind === "image" && isInlinePictureRun(run));
+const paragraphInlinePictureViewport = ({ block, fragment, paper, columns }) => {
+	if (!paragraphHasInlinePicture(block)) return void 0;
+	if (getParagraphFrame(block) !== void 0) return {
+		left: fragment.x,
+		right: fragment.x + fragment.width
+	};
+	return columnPictureClipViewportForFragment({
+		paper,
+		columns,
+		fragmentX: fragment.x,
+		fragmentWidth: fragment.width,
+		...fragment.inlinePictureViewport === void 0 ? {} : { inlinePictureViewport: fragment.inlinePictureViewport }
+	});
+};
+const isInlinePictureRun = (run) => !isFloatingImageRun(run) && run.displayMode !== "block" && run.wrapType !== "topAndBottom";
+const resolveParagraphLineGeometry = ({ fragment, line, lineTopYPx, alignment, isRtl, indentLeft, indentRight, firstLineOffsetPx, markerInlineWidthPx, isFirstLine, imageOnlyRun }) => {
+	const leftOffset = line.leftOffset ?? 0;
+	const rightOffset = line.rightOffset ?? 0;
+	const firstLineExtra = isFirstLine ? firstLineOffsetPx + markerInlineWidthPx : 0;
+	const layoutStartXPx = indentLeft + leftOffset + (isRtl ? 0 : firstLineExtra);
+	const layoutRightEdgeXPx = fragment.width - indentRight - rightOffset;
+	const leftEdge = fragment.x + layoutStartXPx;
+	const rightEdge = fragment.x + layoutRightEdgeXPx - (isRtl ? firstLineExtra : 0);
+	const resolvedAlignment = resolveParagraphLineAlignment({
+		...imageOnlyRun === void 0 ? {} : { imageOnlyRun },
+		paragraphAlignment: alignment,
+		availableWidth: rightEdge - leftEdge
+	});
+	let paintStartXPx;
+	switch (resolvedAlignment) {
+		case "right":
+			paintStartXPx = rightEdge - line.width;
+			break;
+		case "center":
+			paintStartXPx = leftEdge + (rightEdge - leftEdge - line.width) / 2;
+			break;
+		case "left":
+			paintStartXPx = leftEdge;
+			break;
+		case "justify": paintStartXPx = isRtl ? rightEdge - line.width : leftEdge;
+	}
+	const baselineYPx = lineTopYPx + (line.lineHeight - (line.ascent + line.descent)) / 2 + line.ascent;
+	return {
+		alignment: resolvedAlignment,
+		paintStartXPx,
+		layoutStartXPx,
+		layoutRightEdgeXPx,
+		baselineYPx,
+		lineTopYPx
+	};
+};
+const resolveParagraphLineGeometryForBlock = ({ fragment, block, line, lineTopYPx, isFirstLine }) => {
+	const inlineLayout = resolvePhysicalParagraphInlineLayout(block);
+	const indent = block.attrs?.indent;
+	const firstLineOffsetPx = indent?.hanging !== void 0 && indent.hanging > 0 ? -indent.hanging : indent?.firstLine ?? 0;
+	const imageOnlyRun = paragraphImageOnlyRun(block, line);
+	return resolveParagraphLineGeometry({
+		fragment,
+		line,
+		lineTopYPx,
+		alignment: inlineLayout.alignment,
+		isRtl: inlineLayout.isRtl,
+		indentLeft: inlineLayout.indentLeft,
+		indentRight: inlineLayout.indentRight,
+		firstLineOffsetPx,
+		markerInlineWidthPx: getListMarkerInlineWidth(block),
+		isFirstLine,
+		...imageOnlyRun === void 0 ? {} : { imageOnlyRun }
+	});
+};
 const mirrorHorizontalAlignment = (alignment) => {
 	if (alignment === "left") return "right";
 	if (alignment === "right") return "left";
@@ -22,4 +185,4 @@ const resolvePhysicalParagraphInlineLayout = (block) => {
 	};
 };
 //#endregion
-export { resolvePhysicalParagraphInlineLayout };
+export { columnPictureClipViewportForColumn, columnPictureClipViewportForFragment, inlinePictureClipInsets, inlinePictureVisibleBounds, intersectHorizontalClipViewports, isInlinePictureRun, pageHorizontalColumns, paragraphHasInlinePicture, paragraphImageOnlyRun, paragraphInlinePictureViewport, resolveImageLineAlign, resolveParagraphLineAlignment, resolveParagraphLineGeometry, resolveParagraphLineGeometryForBlock, resolvePhysicalParagraphInlineLayout };

package/dist/utils/replaceText.d.ts

@@ -11,6 +11,6 @@ type ReplaceRange = {
   };
 };
 /** Replace text within a range in the document. Returns a new document. */
-declare function replaceTextInDocument(doc: document_d_exports.Document, range: ReplaceRange, text: string, formatting?: document_d_exports.TextFormatting): document_d_exports.Document;
+export declare function replaceTextInDocument(doc: document_d_exports.Document, range: ReplaceRange, text: string, formatting?: document_d_exports.TextFormatting): document_d_exports.Document;
 //#endregion
-export { replaceTextInDocument };
+export {};

package/dist/utils/replaceText.js

@@ -2,6 +2,10 @@ import { cloneDocumentWithParagraphPropertySources } from "../docx/paragraphProp
 import { getFindParagraphText } from "./findReplace.js";
 import { panic } from "better-result";
 //#region src/utils/replaceText.ts
+/**
+* Lightweight text replacement on the document model.
+* Used by find & replace. Operates immutably.
+*/
 /** Replace text within a range in the document. Returns a new document. */
 function replaceTextInDocument(doc, range, text, formatting) {
 	const newDoc = cloneDocumentWithParagraphPropertySources(doc);

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