@stll/folio-core 0.61.0 → 0.63.0

package/dist/utils/joiningTypes.gen.d.ts

@@ -15,12 +15,11 @@
  * which is why it is by far the largest table.
  */
 /** Joining_Type D, L or C: connects to the FOLLOWING character. */
-declare const JOINS_FORWARD_RANGES: readonly number[];
+export declare const JOINS_FORWARD_RANGES: readonly number[];
 /** Joining_Type D, R or C: connects to the PRECEDING character. */
-declare const JOINS_BACKWARD_RANGES: readonly number[];
+export declare const JOINS_BACKWARD_RANGES: readonly number[];
 /** Joining_Type T: transparent, skipped when looking for a joining neighbour. */
-declare const JOINING_TRANSPARENT_RANGES: readonly number[];
+export declare const JOINING_TRANSPARENT_RANGES: readonly number[];
 /** Joining_Type D, L or R: a cursive letter. Gates the whole joining path. */
-declare const JOINING_LETTER_RANGES: readonly number[];
-//#endregion
-export { JOINING_LETTER_RANGES, JOINING_TRANSPARENT_RANGES, JOINS_BACKWARD_RANGES, JOINS_FORWARD_RANGES };
+export declare const JOINING_LETTER_RANGES: readonly number[];
+//#endregion

package/dist/utils/mergeDocumentContent.d.ts

@@ -23,6 +23,5 @@ import { document_d_exports } from "../types/document.js";
  * const bytes = await createDocx(merged);
  * ```
  */
-declare function mergeDocumentContent(target: document_d_exports.Document, source: document_d_exports.Document): document_d_exports.Document;
-//#endregion
-export { mergeDocumentContent };
+export declare function mergeDocumentContent(target: document_d_exports.Document, source: document_d_exports.Document): document_d_exports.Document;
+//#endregion

package/dist/utils/mergeDocumentContent.js

@@ -3,6 +3,13 @@ import { paragraphNumberingReferenceId } from "../docx/numberingReference.js";
 import { cloneParagraphWithoutPropertySource } from "../docx/paragraphPropertySource.js";
 //#region src/utils/mergeDocumentContent.ts
 /**
+* Merge Document Content Utility
+*
+* Composes two documents by appending one document's body content onto
+* another's, renumbering any list numbering the source carries so it can
+* never collide with numbering the target already defines.
+*/
+/**
 * Append `source`'s body content onto `target`'s. Both documents keep their
 * own identity — this returns a new `Document`; neither argument is mutated.
 *

package/dist/utils/noteReferenceLabels.d.ts

@@ -13,17 +13,17 @@
  * endnote's token carries an `e` so the two sequences never collide
  * (`[^1]` is footnote 1, `[^e1]` is endnote 1).
  */
-type NoteReferenceKind = "footnote" | "endnote";
+export type NoteReferenceKind = "footnote" | "endnote";
 /** The bare token: `1` for footnote 1, `e1` for endnote 1. */
-declare const noteReferenceToken: (kind: NoteReferenceKind, displayNumber: number) => string;
+export declare const noteReferenceToken: (kind: NoteReferenceKind, displayNumber: number) => string;
 /** The marker a text reader shows in the line: `[^1]`, `[^e1]`. */
-declare const noteReferenceMarker: (kind: NoteReferenceKind, displayNumber: number) => string;
-type NoteReferenceNumber = {
+export declare const noteReferenceMarker: (kind: NoteReferenceKind, displayNumber: number) => string;
+export type NoteReferenceNumber = {
   displayNumber: number;
   /** Whether this is the note's first reference in reading order. */
   first: boolean;
 };
-type NoteReferenceNumbering = {
+export type NoteReferenceNumbering = {
   /** Number one reference, in reading order. */
   next: (kind: NoteReferenceKind, noteId: string | number) => NoteReferenceNumber;
 };
@@ -31,6 +31,5 @@ type NoteReferenceNumbering = {
  * A reading-order numbering: each note takes the next number of its kind the
  * first time it is referenced, and a repeated reference reuses it.
  */
-declare const createNoteReferenceNumbering: () => NoteReferenceNumbering;
-//#endregion
-export { NoteReferenceKind, NoteReferenceNumber, NoteReferenceNumbering, createNoteReferenceNumbering, noteReferenceMarker, noteReferenceToken };
+export declare const createNoteReferenceNumbering: () => NoteReferenceNumbering;
+//#endregion

package/dist/utils/ooxmlSymbol.d.ts

@@ -1,4 +1,6 @@
 //#region src/utils/ooxmlSymbol.d.ts
-declare const decodeOoxmlSymbolCharacter: (value: string) => string | null;
-//#endregion
-export { decodeOoxmlSymbolCharacter };
+export declare const isOoxmlSymbolFont: (font: string) => boolean;
+export declare const lookupOoxmlSymbolUnicodeTwin: (codePoint: number) => string | undefined;
+export declare const decodeOoxmlSymbolCharacter: (value: string) => string | null;
+export declare const displayOoxmlSymbolCharacter: (font: string, value: string) => string | null;
+//#endregion

package/dist/utils/ooxmlSymbol.js

@@ -1,5 +1,55 @@
 import { isOoxmlSymbolCharacter } from "@stll/docx-core/model";
 //#region src/utils/ooxmlSymbol.ts
+const SYMBOL_BULLET_MAP = /* @__PURE__ */ new Map([
+	[183, "•"],
+	[111, "○"],
+	[167, "■"],
+	[252, "✓"],
+	[110, "■"],
+	[113, "○"],
+	[117, "◆"],
+	[118, "❖"],
+	[168, "✓"],
+	[251, "✓"],
+	[254, "✓"],
+	[61623, "•"],
+	[61550, "■"],
+	[61551, "○"],
+	[61607, "■"],
+	[61692, "✓"],
+	[8226, "•"],
+	[9679, "●"],
+	[9675, "○"],
+	[9632, "■"],
+	[9633, "□"],
+	[9670, "◆"],
+	[9671, "◇"],
+	[8211, "–"],
+	[8212, "—"],
+	[62, ">"],
+	[45, "-"]
+]);
+const SYMBOL_FONT_NAMES = /* @__PURE__ */ new Set([
+	"symbol",
+	"wingdings",
+	"wingdings 2",
+	"wingdings 3",
+	"webdings"
+]);
+const SYMBOL_DISPLAY_TWIN_CODES = /* @__PURE__ */ new Map([["symbol", /* @__PURE__ */ new Set([61623])], ["wingdings", /* @__PURE__ */ new Set([
+	61550,
+	61551,
+	61607,
+	61692
+])]]);
+const isOoxmlSymbolFont = (font) => SYMBOL_FONT_NAMES.has(font.trim().toLowerCase());
+const lookupOoxmlSymbolUnicodeTwin = (codePoint) => SYMBOL_BULLET_MAP.get(codePoint);
 const decodeOoxmlSymbolCharacter = (value) => isOoxmlSymbolCharacter(value) ? String.fromCodePoint(Number.parseInt(value, 16)) : null;
+const displayOoxmlSymbolCharacter = (font, value) => {
+	if (!isOoxmlSymbolCharacter(value)) return null;
+	const codePoint = Number.parseInt(value, 16);
+	if (!SYMBOL_DISPLAY_TWIN_CODES.get(font.trim().toLowerCase())?.has(codePoint)) return decodeOoxmlSymbolCharacter(value);
+	return lookupOoxmlSymbolUnicodeTwin(codePoint) ?? decodeOoxmlSymbolCharacter(value);
+};
 //#endregion
-export { decodeOoxmlSymbolCharacter };
+export { decodeOoxmlSymbolCharacter, displayOoxmlSymbolCharacter, isOoxmlSymbolFont, lookupOoxmlSymbolUnicodeTwin };

package/dist/utils/outlineDepth.d.ts

@@ -1,9 +1,8 @@
 import { HeadingInfo } from "./headingCollector.js";
 //#region src/utils/outlineDepth.d.ts
 /** Maximum heading depth displayed in the document outline. */
-type OutlineDepth = 2 | 3 | "all";
-declare const DEFAULT_OUTLINE_DEPTH = 2;
+export type OutlineDepth = 2 | 3 | "all";
+export declare const DEFAULT_OUTLINE_DEPTH = 2;
 /** Filter headings for the outline without changing their document order. */
-declare const filterHeadingsByDepth: (headings: readonly HeadingInfo[], depth: OutlineDepth) => HeadingInfo[];
-//#endregion
-export { DEFAULT_OUTLINE_DEPTH, OutlineDepth, filterHeadingsByDepth };
+export declare const filterHeadingsByDepth: (headings: readonly HeadingInfo[], depth: OutlineDepth) => HeadingInfo[];
+//#endregion

package/dist/utils/paragraphBaseDirection.d.ts

@@ -1,6 +1,5 @@
 import { ParagraphBlock } from "../layout-engine/types.js";
 //#region src/utils/paragraphBaseDirection.d.ts
 /** Resolve the paragraph direction used by both measurement and painting. */
-declare const isRtlParagraph: (block: ParagraphBlock) => boolean;
-//#endregion
-export { isRtlParagraph };
+export declare const isRtlParagraph: (block: ParagraphBlock) => boolean;
+//#endregion

package/dist/utils/paragraphBaseDirection.js

@@ -6,7 +6,8 @@ const isRtlParagraph = (block) => {
 	if (block.attrs?.bidi !== void 0) return block.attrs.bidi;
 	const runs = block.runs.filter(isDirectionalTextRun);
 	if (!runs.some(({ rtl }) => rtl === true)) return false;
-	return detectBaseDirection(runs.map((run) => run.kind === "text" ? run.text : run.fallback ?? "").join("")) !== "ltr";
+	const text = runs.map((run) => run.kind === "text" ? run.text : run.fallback ?? "").join("");
+	return detectBaseDirection(text) !== "ltr";
 };
 //#endregion
 export { isRtlParagraph };

package/dist/utils/paragraphFormattingMerge.d.ts

@@ -9,8 +9,8 @@ import { document_d_exports } from "../types/document.js";
  * clear entry also lets the tab calculator suppress an automatic stop at the
  * same position.
  */
-declare function mergeParagraphTabStops(inherited: document_d_exports.TabStop[] | undefined, direct: document_d_exports.TabStop[]): document_d_exports.TabStop[];
-declare function mergeParagraphTabStops(inherited: document_d_exports.TabStop[] | undefined, direct: document_d_exports.TabStop[] | undefined): document_d_exports.TabStop[] | undefined;
+export declare function mergeParagraphTabStops(inherited: document_d_exports.TabStop[] | undefined, direct: document_d_exports.TabStop[]): document_d_exports.TabStop[];
+export declare function mergeParagraphTabStops(inherited: document_d_exports.TabStop[] | undefined, direct: document_d_exports.TabStop[] | undefined): document_d_exports.TabStop[] | undefined;
 /**
  * Merge paragraph properties for OOXML style cascade resolution.
  *
@@ -19,6 +19,5 @@ declare function mergeParagraphTabStops(inherited: document_d_exports.TabStop[]
  * tabs merge by position; paragraph mark `w:rPr` uses the run-formatting
  * merge rules.
  */
-declare function mergeParagraphFormatting(target: document_d_exports.ParagraphFormatting | undefined, source: document_d_exports.ParagraphFormatting | undefined): document_d_exports.ParagraphFormatting | undefined;
-//#endregion
-export { mergeParagraphFormatting, mergeParagraphTabStops };
+export declare function mergeParagraphFormatting(target: document_d_exports.ParagraphFormatting | undefined, source: document_d_exports.ParagraphFormatting | undefined): document_d_exports.ParagraphFormatting | undefined;
+//#endregion

package/dist/utils/paragraphFormattingMerge.js

@@ -5,6 +5,8 @@ const PARAGRAPH_REPLACE_KEYS = [
 	"alignment",
 	"bidi",
 	"kinsoku",
+	"autoSpaceDE",
+	"autoSpaceDN",
 	"overflowPunctuation",
 	"spaceBefore",
 	"spaceAfter",

package/dist/utils/paragraphFrame.d.ts

@@ -0,0 +1,20 @@
+import { ParagraphBlock, TextBoxBlock } from "../layout-engine/types.js";
+//#region src/utils/paragraphFrame.d.ts
+export type ParagraphFrame = {
+  width?: number;
+  height?: number;
+  hSpace?: number;
+  vSpace?: number;
+  hAnchor?: "text" | "margin" | "page";
+  vAnchor?: "text" | "margin" | "page";
+  x?: number;
+  y?: number;
+  xAlign?: "left" | "center" | "right" | "inside" | "outside";
+  yAlign?: "top" | "center" | "bottom" | "inside" | "outside" | "inline";
+  wrap?: "around" | "auto" | "none" | "notBeside" | "through" | "tight";
+};
+export declare const setParagraphFrame: (block: ParagraphBlock, frame: ParagraphFrame) => void;
+export declare const getParagraphFrame: (block: ParagraphBlock) => ParagraphFrame | undefined;
+export declare const markParagraphFrameTextBox: (block: TextBoxBlock) => void;
+export declare const isParagraphFrameTextBox: (block: TextBoxBlock) => boolean;
+//#endregion

package/dist/utils/paragraphFrame.js

@@ -0,0 +1,13 @@
+//#region src/utils/paragraphFrame.ts
+const paragraphFrames = /* @__PURE__ */ new WeakMap();
+const paragraphFrameTextBoxes = /* @__PURE__ */ new WeakSet();
+const setParagraphFrame = (block, frame) => {
+	paragraphFrames.set(block, frame);
+};
+const getParagraphFrame = (block) => paragraphFrames.get(block);
+const markParagraphFrameTextBox = (block) => {
+	paragraphFrameTextBoxes.add(block);
+};
+const isParagraphFrameTextBox = (block) => paragraphFrameTextBoxes.has(block);
+//#endregion
+export { getParagraphFrame, isParagraphFrameTextBox, markParagraphFrameTextBox, setParagraphFrame };

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 {};