@betteroffice/docx 0.0.1

package/dist/docx/index.d.mts

@@ -0,0 +1,618 @@
+export { parseDocx } from './parser.mjs';
+import { F as FontTable, b as RelationshipMap, M as MediaFile, S as Style } from '../styles-VxNcXLdi.mjs';
+export { createDocx, default as repackDocx, updateMultipleFiles } from './rezip.mjs';
+export { a as attemptSelectiveSave } from '../selectiveSave-oFBJ1n71.mjs';
+export { b as buildPatchedDocumentXml, v as validatePatchSafety } from '../selectiveXmlPatch-ypkxlTD_.mjs';
+import { I as Image, n as Chart, N as NumberingDefinitions, L as ListLevel, A as AbstractNumbering, aD as NumberingInstance, aq as ListRendering, aC as NumberFormat, E as Endnote, F as Footnote, a0 as EndnoteProperties, a8 as FootnoteProperties, R as Run, a5 as FieldType, a1 as Field, b2 as SimpleField, H as Hyperlink, aU as Shape, T as Table, h as TableCell, P as Paragraph, bc as TextBox, ai as ImageSize, ag as ImagePosition, ak as ImageWrap, B as BlockContent, C as Comment } from '../content-sSHuWw49.mjs';
+import { Element } from 'xml-js';
+import { WrapType } from './wrapTypes.mjs';
+import { a as Theme, k as TabStopAlignment, i as TabLeader, j as TabStop, B as BorderSpec, c as CellMargins, F as FloatingTableProperties, S as ShadingProperties, m as TableBorders, p as TableLook, q as TableMeasurement, o as TableFormatting } from '../formatting-DoL7KBSL.mjs';
+export { g as getDocumentWatermark, s as setDocumentWatermark } from '../watermarkApi-DCxjutkg.mjs';
+export { e as emuToPixels, p as pixelsToEmu } from '../units-O5Y02RKQ.mjs';
+import '../types/document.mjs';
+import '../settingsParser-CcGvtmCK.mjs';
+import '../docxInput-DTbCa48g.mjs';
+
+/**
+ * Font Table Parser
+ *
+ * Parses `word/fontTable.xml` into a {@link FontTable}. The main payload we
+ * care about beyond font names is the `w:embed*` elements, which reference the
+ * obfuscated font binaries under `word/fonts/` (resolved via the font table's
+ * own `.rels`) and carry the `w:fontKey` GUID used to de-obfuscate them.
+ *
+ * Structure:
+ * ```xml
+ * <w:fonts>
+ *   <w:font w:name="My Brand Sans">
+ *     <w:family w:val="swiss"/>
+ *     <w:pitch w:val="variable"/>
+ *     <w:embedRegular r:id="rId1" w:fontKey="{GUID}" w:subsetted="true"/>
+ *   </w:font>
+ * </w:fonts>
+ * ```
+ */
+
+/**
+ * Parse `word/fontTable.xml` into a {@link FontTable}. Returns an empty table
+ * for missing/empty/unparseable input.
+ *
+ * @public
+ */
+declare function parseFontTable(fontTableXml: string | null | undefined): FontTable;
+
+/**
+ * Public XmlElement image compatibility adapter.
+ *
+ * Rust S9 owns package drawing/media parsing. This adapter remains for the
+ * published leaf API and pure image-model helpers.
+ */
+
+declare function parseDrawing(drawingEl: Element, rels: RelationshipMap | undefined, media: Map<string, MediaFile> | undefined): Image | null;
+declare function parseImage(node: Element, rels: RelationshipMap | undefined, media: Map<string, MediaFile> | undefined): Image | null;
+declare function isInlineImage(image: Image): boolean;
+declare function isFloatingImage(image: Image): boolean;
+declare function isBehindText(image: Image): boolean;
+declare function isInFrontOfText(image: Image): boolean;
+declare function getImageWidthPx(image: Image): number;
+declare function getImageHeightPx(image: Image): number;
+declare function isDecorativeImage(image: Image): boolean;
+declare function getWrapDistancesPx(image: Image): {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+};
+
+type AnchorWrapType = Exclude<WrapType, 'inline'>;
+type ImageLayoutTarget = AnchorWrapType | 'squareLeft' | 'squareRight' | 'inline';
+type ImageResizeHandle = 'nw' | 'ne' | 'se' | 'sw' | 'n' | 's' | 'e' | 'w';
+/** Compute the preview dimensions for an image resize gesture. */
+declare function calculateResizedImageDimensions(handle: ImageResizeHandle, deltaX: number, deltaY: number, startWidth: number, startHeight: number, lockAspect: boolean): {
+    width: number;
+    height: number;
+};
+interface SetImageWrapTypeOptions {
+    initialPositionEmu?: {
+        horizontalEmu: number;
+        verticalEmu: number;
+    };
+}
+interface ImageLayoutPosition {
+    horizontal?: {
+        relativeTo?: string;
+        posOffset?: number;
+        align?: string;
+    };
+    vertical?: {
+        relativeTo?: string;
+        posOffset?: number;
+        align?: string;
+    };
+}
+interface ImageLayoutCurrentAttrs {
+    wrapType?: string | null;
+    cssFloat?: string | null;
+    position?: ImageLayoutPosition | null;
+}
+interface ImageLayoutAttrs extends Record<string, unknown> {
+    wrapType: WrapType;
+    displayMode: 'inline' | 'float' | 'block';
+    cssFloat: 'left' | 'right' | 'none';
+    wrapText?: 'bothSides' | 'left' | 'right' | 'largest';
+    position?: ImageLayoutPosition;
+    distTop?: number;
+    distBottom?: number;
+    distLeft?: number;
+    distRight?: number;
+}
+/** Resolve the authored image attributes for one Word-style wrap choice. */
+declare function resolveImageLayoutAttrs(target: ImageLayoutTarget, current: ImageLayoutCurrentAttrs, opts?: SetImageWrapTypeOptions): ImageLayoutAttrs;
+/** Map current OOXML image attrs to the shared menu choice vocabulary. */
+declare function deriveLayoutChoice(wrapType: WrapType, cssFloat?: string | null): ImageLayoutTarget | null;
+type ImageLayoutIconHint = 'inline' | 'squareLeft' | 'squareRight' | 'behind' | 'inFront';
+interface ImageLayoutOptionDef {
+    choice: ImageLayoutTarget;
+    i18nLabelKey: string;
+    i18nDescKey: string;
+    iconHint: ImageLayoutIconHint;
+}
+/** Word's five directional Wrap Text menu entries. */
+declare const IMAGE_LAYOUT_OPTIONS: readonly ImageLayoutOptionDef[];
+declare function isImageLayoutOptionEnabled(_option: ImageLayoutOptionDef, _currentWrapType: WrapType): boolean;
+/** Map legacy toolbar wrap values onto the shared image command target. */
+declare function toolbarValueToLayoutTarget(value: string): ImageLayoutTarget | undefined;
+
+/**
+ * Compatibility context retained in public leaf-parser signatures.
+ * Full package chart parsing is owned by Rust S9.
+ */
+type ChartPartsMap = Map<string, Chart>;
+
+/**
+ * Numbering/List Parser for DOCX
+ *
+ * Parses numbering.xml to extract:
+ * - Abstract numbering definitions (templates with levels)
+ * - Numbering instances (concrete references with optional overrides)
+ *
+ * OOXML Structure:
+ * - w:abstractNum - Template definitions with 9 levels (0-8)
+ * - w:num - Instances that reference abstractNum and can override levels
+ * - w:lvl - Level definition with start, format, text pattern, etc.
+ */
+
+type NumberingMap = {
+    definitions: NumberingDefinitions;
+    getLevel: (numId: number, ilvl: number) => ListLevel | null;
+    getAbstract: (abstractNumId: number) => AbstractNumbering | null;
+    getInstance: (numId: number) => NumberingInstance | null;
+    hasNumbering: (numId: number) => boolean;
+};
+/** Rust-backed adapter for the published raw-numbering.xml leaf API. */
+declare function parseNumbering(numberingXml: string | null): NumberingMap;
+declare function getCachedNumberingMap(definitions: NumberingDefinitions): NumberingMap;
+declare function createNumberingMap(definitions: NumberingDefinitions): NumberingMap;
+/**
+ * Resolve a paragraph's `numPr` against the numbering definitions into the
+ * `ListRendering` the layout pipeline needs (marker template, per-level
+ * numFmts, counter key, start override). Returns null when the numPr doesn't
+ * name a real level — including `numId === 0`, "no numbering" per ECMA-376.
+ *
+ * Shared by the parser (document load) and `applyStyle` (style picker), so a
+ * style-attached list renders identically in both paths.
+ */
+declare function computeListRendering(numPr: {
+    numId?: number;
+    ilvl?: number;
+}, numbering: NumberingMap): ListRendering | null;
+/**
+ * Format a number according to the specified format
+ *
+ * @param num - The number to format
+ * @param format - The number format
+ * @returns Formatted string
+ */
+declare function formatNumber(num: number, format: NumberFormat): string;
+/**
+ * Render list marker text by replacing placeholders with formatted numbers
+ *
+ * @param lvlText - The level text pattern (e.g., "%1.", "%1.%2")
+ * @param counters - Array of counter values for each level (index 0 = level 0, etc.)
+ * @param formats - Array of number formats for each level
+ * @returns Rendered marker text
+ */
+declare function renderListMarker(lvlText: string, counters: number[], formats: NumberFormat[]): string;
+/**
+ * Get the bullet character for a bullet list level
+ *
+ * @param level - The list level definition
+ * @returns The bullet character to display
+ */
+declare function getBulletCharacter(level: ListLevel): string;
+/**
+ * Check if a list level is a bullet (not numbered)
+ */
+declare function isBulletLevel(level: ListLevel): boolean;
+
+/** Compatibility context retained in public leaf-parser signatures. */
+interface SmartArtContext {
+    parts: Map<string, string>;
+    warnings?: string[];
+}
+
+/** Compatibility type retained for public XmlElement leaf adapters. */
+type StyleMap = Map<string, Style>;
+
+/** Public note compatibility helpers backed by the Rust story parser. */
+
+interface FootnoteMap {
+    byId: Map<number, Footnote>;
+    footnotes: Footnote[];
+    getFootnote(id: number): Footnote | undefined;
+    hasFootnote(id: number): boolean;
+    getNormalFootnotes(): Footnote[];
+    getSeparator(): Footnote | undefined;
+    getContinuationSeparator(): Footnote | undefined;
+}
+interface EndnoteMap {
+    byId: Map<number, Endnote>;
+    endnotes: Endnote[];
+    getEndnote(id: number): Endnote | undefined;
+    hasEndnote(id: number): boolean;
+    getNormalEndnotes(): Endnote[];
+    getSeparator(): Endnote | undefined;
+    getContinuationSeparator(): Endnote | undefined;
+}
+declare function parseFootnotes(footnotesXml: string | null, _styles?: StyleMap | null, _theme?: Theme | null, _numbering?: NumberingMap | null, _rels?: RelationshipMap | null, _media?: Map<string, MediaFile> | null, _charts?: ChartPartsMap | null, _smartArt?: SmartArtContext | null): FootnoteMap;
+declare function parseEndnotes(endnotesXml: string | null, _styles?: StyleMap | null, _theme?: Theme | null, _numbering?: NumberingMap | null, _rels?: RelationshipMap | null, _media?: Map<string, MediaFile> | null, _charts?: ChartPartsMap | null, _smartArt?: SmartArtContext | null): EndnoteMap;
+declare function parseFootnoteProperties(element: Element | null): FootnoteProperties;
+declare function parseEndnoteProperties(element: Element | null): EndnoteProperties;
+declare function getFootnoteText(footnote: Footnote): string;
+declare function getEndnoteText(endnote: Endnote): string;
+declare function isSeparatorFootnote(note: Footnote): boolean;
+declare function isSeparatorEndnote(note: Endnote): boolean;
+
+/** Public field model helpers and a small XmlElement compatibility adapter. */
+
+declare const KNOWN_FIELD_TYPES: FieldType[];
+declare function parseFieldType(instruction: string): FieldType;
+declare function isKnownFieldType(type: string): type is FieldType;
+interface ParsedFieldInstruction {
+    type: FieldType;
+    raw: string;
+    argument?: string;
+    switches: FieldSwitch[];
+}
+interface FieldSwitch {
+    switch: string;
+    value?: string;
+}
+declare function parseFieldInstruction(instruction: string): ParsedFieldInstruction;
+declare function getFormatSwitch(instruction: ParsedFieldInstruction): string | undefined;
+declare function hasMergeFormat(instruction: ParsedFieldInstruction): boolean;
+declare function parseSimpleField(node: Element, _styles: StyleMap | null, _theme: Theme | null): SimpleField;
+type ComplexFieldState = 'outside' | 'code' | 'result';
+interface ComplexFieldContext {
+    state: ComplexFieldState;
+    instruction: string;
+    codeRuns: Run[];
+    resultRuns: Run[];
+    fldLock: boolean;
+    dirty: boolean;
+    nestingLevel: number;
+}
+declare function createComplexFieldContext(): ComplexFieldContext;
+declare function getFieldDisplayValue(field: Field): string;
+declare function isPageNumberField(field: Field): boolean;
+declare function isTotalPagesField(field: Field): boolean;
+declare function isDateTimeField(field: Field): boolean;
+declare function isDocPropertyField(field: Field): boolean;
+declare function isReferenceField(field: Field): boolean;
+declare function isMergeField(field: Field): boolean;
+declare function isTocField(field: Field): boolean;
+
+/** Public hyperlink helpers and XmlElement compatibility adapter. */
+
+declare function parseHyperlink(node: Element, rels: RelationshipMap | null, _styles?: StyleMap | null, _theme?: Theme | null, _media?: Map<string, MediaFile> | null, _charts?: ChartPartsMap | null, _smartArt?: SmartArtContext | null): Hyperlink;
+declare function getHyperlinkText(hyperlink: Hyperlink): string;
+declare function isExternalLink(hyperlink: Hyperlink): boolean;
+declare function isInternalLink(hyperlink: Hyperlink): boolean;
+declare function getHyperlinkUrl(hyperlink: Hyperlink): string | undefined;
+declare function hasContent(hyperlink: Hyperlink): boolean;
+declare function getHyperlinkRuns(hyperlink: Hyperlink): Run[];
+declare function resolveHyperlinkUrl(hyperlink: Hyperlink, rels: RelationshipMap): string | undefined;
+
+/**
+ * Public XmlElement shape compatibility adapter.
+ *
+ * Rust S9 owns package drawing parsing. These small helpers remain because
+ * the published ./docx surface accepts xml-js elements directly.
+ */
+
+declare function parseShape(node: Element): Shape;
+declare function parseShapeFromDrawing(drawingEl: Element): Shape | null;
+declare function isShapeDrawing(drawingEl: Element): boolean;
+declare function isLineShape(shape: Shape): boolean;
+declare function isTextBoxShape(shape: Shape): boolean;
+declare function hasTextContent(shape: Shape): boolean;
+declare function getShapeWidthPx(shape: Shape): number;
+declare function getShapeHeightPx(shape: Shape): number;
+declare function getShapeDimensionsPx(shape: Shape): {
+    width: number;
+    height: number;
+};
+declare function isFloatingShape(shape: Shape): boolean;
+declare function hasFill(shape: Shape): boolean;
+declare function hasOutline(shape: Shape): boolean;
+declare function getOutlineWidthPx(shape: Shape): number;
+declare function resolveFillColor(shape: Shape): string | undefined;
+declare function resolveOutlineColor(shape: Shape): string | undefined;
+
+/**
+ * Tab Parser - Parse and handle tab stops in DOCX documents
+ *
+ * Tab stops define positions where the cursor jumps when the user presses Tab.
+ * They can have different alignments (left, center, right, decimal) and
+ * leader characters (dots, dashes, underscores).
+ *
+ * OOXML Reference:
+ * - Tab stops container: w:tabs
+ * - Individual tab stop: w:tab
+ * - Tab character in runs: w:tab (different from tab stop definition)
+ *
+ * Attributes of w:tab in w:tabs:
+ * - w:val - alignment type (left, center, right, decimal, bar, clear, num)
+ * - w:pos - position in twips from left margin
+ * - w:leader - leader character (none, dot, hyphen, underscore, heavy, middleDot)
+ */
+
+/**
+ * Default tab stop interval in twips (0.5 inches = 720 twips at 1440 twips/inch)
+ * Word uses this when no explicit tab stops are defined
+ */
+declare const DEFAULT_TAB_INTERVAL_TWIPS = 720;
+/**
+ * Default tab alignment
+ */
+declare const DEFAULT_TAB_ALIGNMENT: TabStopAlignment;
+/**
+ * Default tab leader
+ */
+declare const DEFAULT_TAB_LEADER: TabLeader;
+/**
+ * Parse a single tab stop element (w:tab within w:tabs)
+ *
+ * @param tab - The w:tab XML element
+ * @returns Parsed TabStop or null if invalid
+ */
+declare function parseTabStop(tab: Element): TabStop | null;
+/**
+ * Parse tab stops container (w:tabs)
+ *
+ * @param tabs - The w:tabs XML element
+ * @returns Array of TabStop objects, sorted by position
+ */
+declare function parseTabStops(tabs: Element | null): TabStop[];
+/**
+ * Parse tab stops from paragraph properties element
+ *
+ * @param pPr - The w:pPr XML element
+ * @returns Array of TabStop objects or undefined if none
+ */
+declare function parseTabStopsFromParagraphProperties(pPr: Element | null): TabStop[] | undefined;
+/**
+ * Merge tab stops from different sources (style, direct formatting)
+ *
+ * Direct formatting tab stops override style tab stops at the same position.
+ * "clear" alignment removes a tab stop from the style.
+ *
+ * @param styleTabs - Tab stops from style
+ * @param directTabs - Tab stops from direct formatting (w:pPr in paragraph)
+ * @returns Merged and filtered tab stops
+ */
+declare function mergeTabStops(styleTabs: TabStop[] | undefined, directTabs: TabStop[] | undefined): TabStop[];
+/**
+ * Get the next tab stop position for a given current position
+ *
+ * @param currentPosition - Current position in twips from left margin
+ * @param tabStops - Defined tab stops
+ * @param pageWidth - Page content width in twips (for boundary)
+ * @returns The next tab stop or a default position
+ */
+declare function getNextTabStop(currentPosition: number, tabStops: TabStop[], pageWidth: number): TabStop;
+/**
+ * Calculate the width needed for a tab at a given position
+ *
+ * @param currentPosition - Current position in twips
+ * @param tabStops - Defined tab stops
+ * @param pageWidth - Page content width in twips
+ * @returns Width in twips that the tab should span
+ */
+declare function calculateTabWidth(currentPosition: number, tabStops: TabStop[], pageWidth: number): number;
+/**
+ * Calculate tab width considering alignment
+ *
+ * For non-left alignments (center, right, decimal), the width depends on
+ * the content that follows the tab.
+ *
+ * @param currentPosition - Current position in twips
+ * @param tabStops - Defined tab stops
+ * @param pageWidth - Page content width in twips
+ * @param followingContentWidth - Width of content after the tab (for alignment)
+ * @returns Width in twips
+ */
+declare function calculateTabWidthWithAlignment(currentPosition: number, tabStops: TabStop[], pageWidth: number, followingContentWidth?: number): {
+    width: number;
+    alignment: TabStopAlignment;
+};
+/**
+ * Get the character used for a tab leader
+ *
+ * @param leader - Tab leader type
+ * @returns The character to use for filling
+ */
+declare function getLeaderCharacter(leader: TabLeader | undefined): string;
+/**
+ * Check if a leader type requires visible filling
+ *
+ * @param leader - Tab leader type
+ * @returns true if the leader needs visible characters
+ */
+declare function hasVisibleLeader(leader: TabLeader | undefined): boolean;
+
+/**
+ * Shared border parsing for every `CT_Border` field — table borders
+ * (`w:tblBorders`/`w:tcBorders`), paragraph borders (`w:pBdr`), and page borders
+ * (`w:pgBorders`). Mirrors {@link ../serializer/borderSerializer} on the parse
+ * side: the table/paragraph/section/style parsers all delegate here so a border
+ * is read identically everywhere (one place to fix, one place to harden).
+ */
+
+/**
+ * Parse a single border element (`<w:top>`, `<w:left>`, ...) into a
+ * {@link BorderSpec}.
+ *
+ * A missing `w:val` defaults to `none` (the attribute is required by the schema,
+ * so this only guards malformed input) and `w:color="auto"` maps to
+ * `{ auto: true }` via {@link parseColorValue} rather than being stored as a
+ * literal `rgb`. Returns `undefined` only when the element itself is absent.
+ */
+declare function parseBorderSpec(element: Element | null): BorderSpec | undefined;
+
+/**
+ * Table Atom-level Property Parsers
+ *
+ * Parsers for the small, leaf-style table property elements:
+ * - measurements (w:tblW, w:tcW, w:trHeight twip values + width type)
+ * - borders (w:tblBorders, w:tcBorders, individual side specs)
+ * - cell margins (w:tblCellMar, w:tcMar)
+ * - shading (w:shd background + theme tint/shade)
+ * - table look flags (w:tblLook firstRow/lastRow/etc.)
+ * - floating table positioning (w:tblpPr anchors + offsets)
+ *
+ * These are leaf parsers — they don't recurse into rows/cells. The composite
+ * row/cell/table parsers (in `../tableParser.ts`) compose these.
+ */
+
+/**
+ * Parse a table measurement (width, height, etc.)
+ *
+ * @param element - Element with w:w and w:type attributes
+ * @returns Parsed measurement or undefined
+ */
+declare function parseTableMeasurement(element: Element | null): TableMeasurement | undefined;
+/** Parse physical, logical, inside, and diagonal table/cell border sides. */
+declare function parseTableBorders(element: Element | null): TableBorders | undefined;
+/**
+ * Parse cell margins (w:tblCellMar or w:tcMar)
+ *
+ * @param marginsElement - The margins container element
+ * @returns Parsed margins or undefined
+ */
+declare function parseCellMargins(marginsElement: Element | null): CellMargins | undefined;
+/**
+ * Parse shading properties (w:shd)
+ *
+ * @param shdElement - The w:shd element
+ * @returns Parsed shading or undefined
+ */
+declare function parseShading(shdElement: Element | null): ShadingProperties | undefined;
+/**
+ * Parse table look flags (w:tblLook)
+ *
+ * @param lookElement - The w:tblLook element
+ * @returns Parsed table look or undefined
+ */
+declare function parseTableLook(lookElement: Element | null): TableLook | undefined;
+/**
+ * Parse floating table properties (w:tblpPr)
+ *
+ * @param tblpPrElement - The w:tblpPr element
+ * @returns Parsed floating properties or undefined
+ */
+declare function parseFloatingTableProperties(tblpPrElement: Element | null): FloatingTableProperties | undefined;
+
+/**
+ * Table Query Helpers
+ *
+ * Read-only utilities for inspecting a parsed Table model — column/row
+ * counts, cell merge state, plain-text extraction, header detection,
+ * floating-table detection. No XML access; these operate on the parsed
+ * `Table` shape.
+ */
+
+/**
+ * Get the number of columns in a table
+ *
+ * Uses the table grid if available, otherwise counts cells in first row.
+ *
+ * @param table - The table to measure
+ * @returns Number of columns
+ */
+declare function getTableColumnCount(table: Table): number;
+/**
+ * Get the number of rows in a table
+ *
+ * @param table - The table to measure
+ * @returns Number of rows
+ */
+declare function getTableRowCount(table: Table): number;
+/**
+ * Check if a cell is part of a vertical merge
+ *
+ * @param cell - The cell to check
+ * @returns true if cell continues a vertical merge
+ */
+declare function isCellMergeContinuation(cell: TableCell): boolean;
+/**
+ * Check if a cell starts a vertical merge
+ *
+ * @param cell - The cell to check
+ * @returns true if cell starts a vertical merge
+ */
+declare function isCellMergeStart(cell: TableCell): boolean;
+/**
+ * Check if table has header row
+ *
+ * @param table - The table to check
+ * @returns true if first row is marked as header
+ */
+declare function hasHeaderRow(table: Table): boolean;
+
+/** Public table property/query compatibility helpers; Rust owns table stories. */
+
+declare function parseTableProperties(element: Element | null): TableFormatting | undefined;
+
+/** Public XmlElement text-box compatibility adapter and pure model helpers. */
+
+declare function extractTextBoxContentElements(txbxContent: Element | null): {
+    paragraphElements: Element[];
+    tableElements: Element[];
+};
+type ParagraphParserFn = (node: Element, styles: StyleMap | null, theme: Theme | null, numbering: NumberingMap | null, rels?: RelationshipMap | null) => Paragraph;
+type TableParserFn = (node: Element, styles: StyleMap | null, theme: Theme | null, numbering: NumberingMap | null, rels?: RelationshipMap | null, media?: Map<string, MediaFile>) => Table;
+declare function parseTextBoxContent(txbxContent: Element | null, parseParagraph: ParagraphParserFn, parseTable: TableParserFn | null, styles: StyleMap | null, theme: Theme | null, numbering: NumberingMap | null, rels?: RelationshipMap | null, _media?: Map<string, MediaFile>): Paragraph[];
+declare function isTextBoxDrawing(drawingEl: Element): boolean;
+declare function isShapeTextBox(wsp: Element): boolean;
+declare function parseTextBox(drawingEl: Element): TextBox | null;
+declare function getTextBoxContentElement(wsp: Element): Element | null;
+declare function parseTextBoxFromShape(wsp: Element, size: ImageSize, position?: ImagePosition, wrap?: ImageWrap): TextBox | null;
+declare function getTextBoxWidthPx(textBox: TextBox): number;
+declare function getTextBoxHeightPx(textBox: TextBox): number;
+declare function getTextBoxDimensionsPx(textBox: TextBox): {
+    width: number;
+    height: number;
+};
+declare function getTextBoxMarginsPx(textBox: TextBox): {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+};
+declare function isFloatingTextBox(textBox: TextBox): boolean;
+declare function hasTextBoxFill(textBox: TextBox): boolean;
+declare function hasTextBoxOutline(textBox: TextBox): boolean;
+declare function hasTextBoxContent(textBox: TextBox): boolean;
+declare function getTextBoxText(textBox: TextBox): string;
+declare function resolveTextBoxFillColor(textBox: TextBox): string | undefined;
+declare function resolveTextBoxOutlineColor(textBox: TextBox): string | undefined;
+declare function getTextBoxOutlineWidthPx(textBox: TextBox): number;
+
+/**
+ * Reply-range marker injection for serialization.
+ *
+ * Word / Pages / LibreOffice expect every comment in `comments.xml`
+ * (including REPLY threads) to have matching `commentRangeStart` /
+ * `commentRangeEnd` / `commentReference` markers in `document.xml`.
+ * The PM document only stamps marks for the parent comment because
+ * replies don't have their own visible range — they share the parent
+ * thread's text. So before serialization we walk the body content and
+ * synthesize parallel range markers for every reply.
+ *
+ * Two helpers, one per parent shape:
+ * - `injectReplyRangeMarkers` — replies whose parent is another
+ *   comment (regular threaded discussion). Finds the parent's
+ *   `commentRangeStart`/`End` and adds parallel markers next to them.
+ * - `injectTCReplyRangeMarkers` — replies whose parent is a tracked
+ *   change (insertion/deletion). Wraps the TC content with
+ *   commentRange markers.
+ *
+ * Pre-#... this code lived inside React's DocxEditor.tsx; Vue had no
+ * equivalent and so silently lost reply markers when saving collab
+ * documents. Living in core means both adapters get it for free.
+ */
+
+/**
+ * Inject `commentRangeStart`/`commentRangeEnd` for reply comments
+ * that share their parent comment's text range.
+ */
+declare function injectReplyRangeMarkers(content: BlockContent[], comments: Comment[]): void;
+/**
+ * Inject `commentRangeStart`/`commentRangeEnd` for comments whose
+ * parent is a tracked-change revision (insertion/deletion). The TC
+ * content nodes don't carry the comment's range, so we wrap them.
+ */
+declare function injectTCReplyRangeMarkers(content: BlockContent[], comments: Comment[]): void;
+
+export { type AnchorWrapType, type ComplexFieldContext, type ComplexFieldState, DEFAULT_TAB_ALIGNMENT, DEFAULT_TAB_INTERVAL_TWIPS, DEFAULT_TAB_LEADER, type EndnoteMap, type FieldSwitch, type FootnoteMap, IMAGE_LAYOUT_OPTIONS, type ImageLayoutAttrs, type ImageLayoutCurrentAttrs, type ImageLayoutIconHint, type ImageLayoutOptionDef, type ImageLayoutPosition, type ImageLayoutTarget, type ImageResizeHandle, KNOWN_FIELD_TYPES, type NumberingMap, type ParagraphParserFn, type ParsedFieldInstruction, type SetImageWrapTypeOptions, type TableParserFn, calculateResizedImageDimensions, calculateTabWidth, calculateTabWidthWithAlignment, computeListRendering, createComplexFieldContext, createNumberingMap, deriveLayoutChoice, extractTextBoxContentElements, formatNumber, getBulletCharacter, getCachedNumberingMap, getEndnoteText, getFieldDisplayValue, getFootnoteText, getFormatSwitch, getHyperlinkRuns, getHyperlinkText, getHyperlinkUrl, getImageHeightPx, getImageWidthPx, getLeaderCharacter, getNextTabStop, getOutlineWidthPx, getShapeDimensionsPx, getShapeHeightPx, getShapeWidthPx, getTableColumnCount, getTableRowCount, getTextBoxContentElement, getTextBoxDimensionsPx, getTextBoxHeightPx, getTextBoxMarginsPx, getTextBoxOutlineWidthPx, getTextBoxText, getTextBoxWidthPx, getWrapDistancesPx, hasContent, hasFill, hasHeaderRow, hasMergeFormat, hasOutline, hasTextBoxContent, hasTextBoxFill, hasTextBoxOutline, hasTextContent, hasVisibleLeader, injectReplyRangeMarkers, injectTCReplyRangeMarkers, isBehindText, isBulletLevel, isCellMergeContinuation, isCellMergeStart, isDateTimeField, isDecorativeImage, isDocPropertyField, isExternalLink, isFloatingImage, isFloatingShape, isFloatingTextBox, isImageLayoutOptionEnabled, isInFrontOfText, isInlineImage, isInternalLink, isKnownFieldType, isLineShape, isMergeField, isPageNumberField, isReferenceField, isSeparatorEndnote, isSeparatorFootnote, isShapeDrawing, isShapeTextBox, isTextBoxDrawing, isTextBoxShape, isTocField, isTotalPagesField, mergeTabStops, parseBorderSpec, parseCellMargins, parseDrawing, parseEndnoteProperties, parseEndnotes, parseFieldInstruction, parseFieldType, parseFloatingTableProperties, parseFontTable, parseFootnoteProperties, parseFootnotes, parseHyperlink, parseImage, parseNumbering, parseShading, parseShape, parseShapeFromDrawing, parseSimpleField, parseTabStop, parseTabStops, parseTabStopsFromParagraphProperties, parseTableBorders, parseTableLook, parseTableMeasurement, parseTableProperties, parseTextBox, parseTextBoxContent, parseTextBoxFromShape, renderListMarker, resolveFillColor, resolveHyperlinkUrl, resolveImageLayoutAttrs, resolveOutlineColor, resolveTextBoxFillColor, resolveTextBoxOutlineColor, toolbarValueToLayoutTarget };