superdoc 2.2.1 → 2.3.0

package/dist/layout-engine/painters/dom/src/table/renderTableRow.d.ts

@@ -0,0 +1,146 @@
+import { DrawingBlock, DrawingMeasure, Line, ParagraphBlock, PartialRowInfo, SdtMetadata, TableBlock, TableBorders, TableMeasure } from '../../../../contracts/src/index.js';
+import { ResolvePhysicalFamily } from '../../../../../shared/font-system/src/index.js';
+import { FragmentRenderContext } from '../renderer.js';
+import { SdtAncestorOptions } from '../sdt/container.js';
+type TableRowMeasure = TableMeasure['rows'][number];
+type TableRow = TableBlock['rows'][number];
+/**
+ * Dependencies required for rendering a table row.
+ *
+ * Contains all information needed to render cells in a table row, including
+ * positioning, measurements, border resolution, and rendering functions.
+ */
+type TableRowRenderDependencies = {
+    /** Document object for creating DOM elements */
+    doc: Document;
+    /** Container element to append cell elements to */
+    container: HTMLElement;
+    /** Zero-based index of this row */
+    rowIndex: number;
+    /** Vertical position (top edge) in pixels */
+    y: number;
+    /** Measurement data for this row (height, cell measurements) */
+    rowMeasure: TableRowMeasure;
+    /** Row data (cells, attributes), or undefined for empty rows */
+    row?: TableRow;
+    /** Previous (above) row data + measure, for collapsed-border conflict resolution (§17.4.66). */
+    prevRow?: TableRow;
+    prevRowMeasure?: TableRowMeasure;
+    /** Next (below) row data, to detect a row-level border override that suppresses the shared
+     * horizontal edge so the current row closes the grid itself (§17.4.61/§17.4.66). */
+    nextRow?: TableRow;
+    /** Next (below) row measure, to detect a gridAfter gap under a spanning cell (SD-3345). */
+    nextRowMeasure?: TableRowMeasure;
+    /**
+     * Rightmost occupied grid column (exclusive) for THIS row, counting cells that span into it
+     * via w:vMerge (rowspan) from an earlier row. Falls back to this row's own cells when absent.
+     * Prevents a leftmost cell on a rowspan-continuation row from being treated as the rightmost
+     * column. (SD-1797)
+     */
+    rowOccupiedRightCol?: number;
+    /** Same as {@link rowOccupiedRightCol} for the NEXT row, so a rowspan continuation below is
+     * not mistaken for a gridAfter gap (which would double the shared bottom edge). (SD-1797) */
+    nextRowOccupiedRightCol?: number;
+    /** Total number of rows in the table (for border resolution) */
+    totalRows: number;
+    /** Table-level borders (for resolving cell borders) */
+    tableBorders?: TableBorders;
+    /** Column widths array for calculating x positions from gridColumnStart */
+    columnWidths: number[];
+    /** All row heights for calculating rowspan cell heights */
+    allRowHeights: number[];
+    /** Table indent in pixels (applied to table fragment positioning) */
+    tableIndent?: number;
+    /** Whether the table is visually right-to-left (w:bidiVisual, ECMA-376 §17.4.1) */
+    isRtl?: boolean;
+    /** Rendering context */
+    context: FragmentRenderContext;
+    /** Function to render a line of paragraph content */
+    renderLine: (block: ParagraphBlock, line: Line, context: FragmentRenderContext, lineIndex: number, isLastLine: boolean) => HTMLElement;
+    /** Optional callback invoked after a table line's final styles/markers are applied. */
+    captureLineSnapshot?: (lineEl: HTMLElement, context: FragmentRenderContext, options?: {
+        inTableParagraph?: boolean;
+        wrapperEl?: HTMLElement;
+    }) => void;
+    /** Function to render drawing content (images, shapes, shape groups) */
+    renderDrawingContent?: (block: DrawingBlock, interactionHost: HTMLElement, measure: DrawingMeasure) => HTMLElement;
+    /** Function to apply SDT metadata as data attributes */
+    applySdtDataset: (el: HTMLElement | null, metadata?: SdtMetadata | null) => void;
+    /** Ancestor SDT container key for suppressing duplicate container styling in cells */
+    ancestorContainerKey?: string | null;
+    /** Ancestor SDT metadata for suppressing duplicate id-less container styling in cells */
+    ancestorContainerSdt?: SdtMetadata | null;
+    /** Ancestor SDT keys for suppressing duplicate container styling in cells */
+    ancestorContainerKeys?: SdtAncestorOptions['ancestorContainerKeys'];
+    /** Ancestor SDT metadata chain for suppressing duplicate id-less container styling in cells */
+    ancestorContainerSdts?: SdtAncestorOptions['ancestorContainerSdts'];
+    /** Receives notification when cells render SDT container chrome */
+    onSdtContainerChrome?: () => void;
+    /**
+     * If true, this row is the first body row of a continuation fragment.
+     * MS Word draws borders at split points to visually close the table on each page,
+     * so we do NOT suppress borders - both fragments draw their edge borders.
+     */
+    continuesFromPrev?: boolean;
+    /**
+     * If true, this row is the last body row before a page break continuation.
+     * MS Word draws borders at split points to visually close the table on each page,
+     * so we do NOT suppress borders - both fragments draw their edge borders.
+     */
+    continuesOnNext?: boolean;
+    /**
+     * Partial row information for mid-row splits.
+     * Contains per-cell line ranges (fromLineByCell, toLineByCell) for rendering
+     * only a portion of the row's content.
+     */
+    partialRow?: PartialRowInfo;
+    /**
+     * Cell spacing in pixels (border-spacing between cells).
+     * Applied to cell x positions and row y advancement.
+     */
+    cellSpacingPx?: number;
+    /** Built-in SDT chrome rendering mode. */
+    chrome?: 'default' | 'none';
+    /**
+     * Per-document logical->physical font resolver for in-cell list markers and drop caps. Threaded
+     * from the renderer's per-document resolver so they paint the same physical family they were
+     * measured in. Undefined falls back to the global resolver.
+     */
+    resolvePhysical?: ResolvePhysicalFamily;
+};
+/**
+ * Renders all cells in a table row.
+ *
+ * Iterates through cells in the row, resolving borders based on cell position,
+ * and rendering each cell with its content. Cells are positioned horizontally
+ * by accumulating their widths.
+ *
+ * Border resolution logic:
+ * - Cells with explicit borders use those borders
+ * - Otherwise, cells use position-based borders from table borders:
+ *   - Edge cells use outer table borders
+ *   - Interior cells use inside borders (insideH, insideV)
+ * - If no table borders exist, default borders are applied
+ *
+ * @param deps - All dependencies required for rendering
+ *
+ * @example
+ * ```typescript
+ * renderTableRow({
+ *   doc: document,
+ *   container: tableContainer,
+ *   rowIndex: 0,
+ *   y: 0,
+ *   rowMeasure,
+ *   row,
+ *   totalRows: 3,
+ *   tableBorders,
+ *   context,
+ *   renderLine,
+ *   applySdtDataset
+ * });
+ * // Appends all cell elements to container
+ * ```
+ */
+export declare const renderTableRow: (deps: TableRowRenderDependencies) => void;
+export {};

package/dist/layout-engine/painters/dom/src/test-utils/normalize-line.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Test-only normalization helpers for comparing rendered line output
+ * across different rendering contexts (body, table-cell).
+ *
+ * DO NOT import this file from production code. Only *.test.ts and
+ * other test-utils/ files may import from here.
+ */
+export interface NormalizedRun {
+    text: string;
+    fontFamily: string | undefined;
+    fontSize: string | undefined;
+    fontWeight: string | undefined;
+    fontStyle: string | undefined;
+    color: string | undefined;
+    textDecoration: string | undefined;
+    backgroundColor: string | undefined;
+    href: string | undefined;
+    target: string | undefined;
+    rel: string | undefined;
+}
+export interface NormalizedLine {
+    textAlign: string;
+    wordSpacing: string;
+    runs: NormalizedRun[];
+    marker?: {
+        text: string;
+        justification: string | undefined;
+    };
+}
+/**
+ * Normalize a single .superdoc-line element into a semantic representation.
+ * Extracts line-level styles (textAlign, wordSpacing) and per-run styles
+ * from child span elements.
+ */
+export declare function normalizeLine(lineEl: HTMLElement): NormalizedLine;
+/**
+ * Find all .superdoc-line elements within a container and normalize them.
+ */
+export declare function normalizeLines(container: HTMLElement): NormalizedLine[];

package/dist/layout-engine/painters/dom/src/utils/anchor-helpers.d.ts

@@ -0,0 +1,3 @@
+import { WrapExclusion } from '../../../../contracts/src/index.js';
+import { RenderedLineInfo } from '../renderer.js';
+export declare const applySquareWrapExclusionsToLines: (renderedLines: RenderedLineInfo[], exclusions: WrapExclusion[], contentWidthPx: number, alignmentOffsetY: number) => void;

package/dist/layout-engine/painters/dom/src/utils/apply-styles.d.ts

@@ -0,0 +1 @@
+export declare const applyStyles: (el: HTMLElement, styles: Partial<CSSStyleDeclaration>) => void;

package/dist/layout-engine/painters/dom/src/utils/layout-identity.d.ts

@@ -0,0 +1,9 @@
+import { LayoutSourceIdentity } from '../../../../contracts/src/index.js';
+/**
+ * Stamp the editor-neutral layout-identity dataset (prep-001).
+ *
+ * Additive only — runs alongside legacy `data-pm-*` / `data-block-id` writes.
+ * v1 consumers still read PM-shaped datasets; future editor-neutral consumers
+ * read `data-layout-fragment-id` / `data-layout-story` / `data-layout-block-ref`.
+ */
+export declare function applyLayoutIdentityDataset(element: HTMLElement, identity: LayoutSourceIdentity | undefined): void;

package/dist/layout-engine/painters/dom/src/utils/source-anchor.d.ts

@@ -0,0 +1,2 @@
+import { SourceAnchor } from '../../../../contracts/src/index.js';
+export declare function applySourceAnchorDataset(element: HTMLElement, sourceAnchor?: SourceAnchor): void;

package/dist/layout-engine/style-engine/src/bench/resolveSdtMetadata.bench.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/layout-engine/style-engine/src/cascade.d.ts

@@ -0,0 +1,43 @@
+import { ParagraphProperties, RunFontFamilyProperties, RunProperties } from './ooxml/types.js';
+import { TableCellProperties, TableProperties } from './ooxml/styles-types.js';
+export type PropertyObject = ParagraphProperties | RunProperties | TableCellProperties | TableProperties;
+/**
+ * Performs a deep merge on an ordered list of property objects.
+ *
+ * This is the core cascade function used throughout style resolution.
+ * Properties from later objects in the array override earlier ones.
+ *
+ * @param propertiesArray - Ordered list of property objects to combine (low -> high priority).
+ * @param options - Configuration for full overrides and special handling.
+ * @returns Combined property object.
+ */
+export declare function combineProperties<T extends PropertyObject>(propertiesArray: T[], options?: {
+    /**
+     * Keys that should completely overwrite instead of deep merge.
+     * Use this for complex objects like fontFamily or color that should
+     * be replaced entirely rather than merged property-by-property.
+     */
+    fullOverrideProps?: string[];
+    /**
+     * Custom merge handlers for specific keys.
+     * The handler receives the accumulated target and current source,
+     * and returns the new value for that key.
+     */
+    specialHandling?: Record<string, (target: Record<string, unknown>, source: Record<string, unknown>) => unknown>;
+}): T;
+/**
+ * Combines run property objects while fully overriding certain keys.
+ * This is a convenience wrapper for run properties (w:rPr).
+ *
+ * @param propertiesArray - Ordered list of run property objects.
+ * @returns Combined run property object.
+ */
+export declare const FONT_SLOT_THEME_PAIRS: Array<[keyof RunFontFamilyProperties, keyof RunFontFamilyProperties]>;
+export declare function combineRunProperties(propertiesArray: RunProperties[]): RunProperties;
+/**
+ * Combines indent properties with special handling for firstLine/hanging mutual exclusivity.
+ *
+ * @param indentChain - Ordered list of indent property objects (or objects with indent property).
+ * @returns Combined indent object.
+ */
+export declare function combineIndentProperties(indentChain: ParagraphProperties[]): ParagraphProperties;

package/dist/layout-engine/style-engine/src/index.d.ts

@@ -0,0 +1,121 @@
+import { TabStop, FieldAnnotationMetadata, StructuredContentMetadata, DocumentSectionMetadata, DocPartMetadata, SdtMetadata } from '../../contracts/src/index.js';
+/**
+ * @superdoc/style-engine
+ *
+ * Resolves OOXML styles to normalized ComputedStyle objects that engines can consume.
+ * This module owns the cascade rules (defaults -> styles -> numbering -> direct formatting).
+ *
+ * Tab Stops:
+ * - Passes through OOXML TabStop values unchanged (positions in twips, val: start/end/etc.)
+ * - No unit conversion happens here - preserves exact OOXML values for round-trip fidelity
+ * - Conversion to pixels happens at measurement boundary only
+ */
+export { combineProperties, combineRunProperties, combineIndentProperties, type PropertyObject } from './cascade.js';
+export type { FieldAnnotationMetadata, StructuredContentMetadata, DocumentSectionMetadata, DocPartMetadata, SdtMetadata, };
+export type SdtNodeType = 'fieldAnnotation' | 'structuredContent' | 'structuredContentBlock' | 'documentSection' | 'docPartObject';
+export interface ResolveSdtMetadataInput {
+    nodeType?: SdtNodeType | string | null;
+    attrs?: Record<string, unknown> | null;
+    /**
+     * Optional cache key for reusing normalized metadata between identical SDT nodes.
+     * When omitted, the helper derives a key from attrs.hash/id when available.
+     */
+    cacheKey?: string | null;
+}
+export interface ResolveStyleOptions {
+    sdt?: ResolveSdtMetadataInput | null;
+}
+export interface BorderStyle {
+    style?: 'none' | 'solid' | 'dashed' | 'dotted' | 'double';
+    width?: number;
+    color?: string;
+}
+export interface ComputedParagraphStyle {
+    alignment?: 'left' | 'center' | 'right' | 'justify';
+    spacing?: {
+        before?: number;
+        after?: number;
+        line?: number;
+        lineRule?: 'auto' | 'exact' | 'atLeast';
+    };
+    indent?: {
+        left?: number;
+        right?: number;
+        firstLine?: number;
+        hanging?: number;
+    };
+    borders?: {
+        top?: BorderStyle;
+        right?: BorderStyle;
+        bottom?: BorderStyle;
+        left?: BorderStyle;
+    };
+    shading?: {
+        fill?: string;
+        pattern?: string;
+    };
+    tabs?: TabStop[];
+}
+export interface StyleContext {
+    styles?: Record<string, unknown>;
+    numbering?: Record<string, unknown>;
+    theme?: Record<string, unknown>;
+    defaults?: {
+        paragraphFont?: string;
+        fontSize?: number;
+        paragraphFontFallback?: string;
+        paragraphFontFamily?: string;
+        decimalSeparator?: string;
+        defaultTabIntervalTwips?: number;
+    };
+}
+/**
+ * Clears the internal SDT metadata cache.
+ *
+ * This is primarily useful for testing to ensure a clean state between test runs.
+ * In production, the cache persists for the lifetime of the module to maximize performance.
+ *
+ * @example
+ * ```typescript
+ * import { clearSdtMetadataCache } from './index.js';
+ *
+ * // Before each test
+ * beforeEach(() => {
+ *   clearSdtMetadataCache();
+ * });
+ * ```
+ */
+export declare function clearSdtMetadataCache(): void;
+/**
+ * Normalizes Structured Document Tag (SDT) metadata into a stable contract shape.
+ *
+ * Supports the following SDT node types:
+ * - `fieldAnnotation`: Inline field annotations with display labels, colors, and visibility
+ * - `structuredContent` / `structuredContentBlock`: Inline or block-level structured content containers
+ * - `documentSection`: Document section metadata with locks and descriptions
+ * - `docPartObject`: Document part objects (e.g., TOC, bibliography)
+ *
+ * Results are cached by hash/id to avoid recomputing metadata for identical SDT instances.
+ *
+ * @param input - SDT node information including nodeType, attrs, and optional cacheKey
+ * @returns Normalized SdtMetadata or undefined if nodeType is unsupported/missing
+ *
+ * @example
+ * ```typescript
+ * import { resolveSdtMetadata } from './index.js';
+ *
+ * const metadata = resolveSdtMetadata({
+ *   nodeType: 'fieldAnnotation',
+ *   attrs: {
+ *     fieldId: 'CLIENT_NAME',
+ *     displayLabel: 'Client Name',
+ *     fieldColor: '#980043',
+ *     visibility: 'visible'
+ *   }
+ * });
+ *
+ * console.log(metadata?.type); // 'fieldAnnotation'
+ * console.log(metadata?.fieldColor); // '#980043'
+ * ```
+ */
+export declare function resolveSdtMetadata(input?: ResolveSdtMetadataInput | null): SdtMetadata | undefined;

package/dist/layout-engine/style-engine/src/normalize/colors.d.ts

@@ -0,0 +1,13 @@
+import { WordThemeColorPalette } from '../ooxml/word-style-model/parse-theme.js';
+export declare function normalizeHexColor(value: string | undefined | null): string | undefined;
+export declare function resolveThemeColor(themeColor: string | undefined, palette: WordThemeColorPalette | undefined): string | undefined;
+/**
+ * Apply OOXML theme tint / shade to a base hex color.
+ *
+ * Both attributes are encoded as a hex byte (00..FF). tint blends the color
+ * toward white; shade blends it toward black. This is an approximation of
+ * the HSL-based Word behavior good enough for first-paint visual parity
+ * and proven elsewhere in the v1 pipeline. The painter / pm-adapter parity
+ * gate will harden corner cases if needed.
+ */
+export declare function applyThemeTintShade(hexInput: string, themeTint?: string, themeShade?: string): string;

package/dist/layout-engine/style-engine/src/normalize/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Editor-neutral normalize layer.
+ *
+ * Maps the typed style-engine `ParagraphProperties` / `RunProperties` into
+ * the visual subset of `@superdoc/contracts` `ParagraphAttrs` / `TextRun`
+ * that the v2 review-layout adapter can safely emit without depending on
+ * ProseMirror or v1 editor runtime.
+ */
+export { normalizeParagraphAttrsFromOoxml } from './paragraph-attrs.js';
+export { normalizeRunAttrsFromOoxml, type NormalizeRunAttrsContext } from './run-attrs.js';
+export type { TextRunStyleAttrs, ParagraphAttrs } from './types.js';
+export { applyThemeTintShade, normalizeHexColor, resolveThemeColor } from './colors.js';
+export { PX_PER_EIGHTH_POINT, PX_PER_POINT, PX_PER_TWIP, eighthPointsToPx, halfPointsToPx, twipsToPx, } from './units.js';

package/dist/layout-engine/style-engine/src/normalize/paragraph-attrs.d.ts

@@ -0,0 +1,3 @@
+import { ParagraphProperties } from '../ooxml/types.js';
+import { ParagraphAttrs } from '../../../contracts/src/index.js';
+export declare function normalizeParagraphAttrsFromOoxml(props: ParagraphProperties | null | undefined): Partial<ParagraphAttrs>;

package/dist/layout-engine/style-engine/src/normalize/run-attrs.d.ts

@@ -0,0 +1,17 @@
+import { RunProperties } from '../ooxml/types.js';
+import { WordThemeColorPalette, WordThemeFontScheme } from '../ooxml/word-style-model/parse-theme.js';
+import { TextRunStyleAttrs } from './types.js';
+export interface NormalizeRunAttrsContext {
+    /** Compiled theme color palette from the Word style model. */
+    themeColors?: WordThemeColorPalette;
+    /** Compiled theme font scheme. */
+    themeFontScheme?: WordThemeFontScheme;
+    /**
+     * Resolved background color in which the run will render (e.g. shaded cell
+     * background). When set and the run color resolves to `auto`, the
+     * normalizer picks a contrasting color so dark-on-dark text does not
+     * silently render unreadable inside shaded cells.
+     */
+    backgroundColor?: string;
+}
+export declare function normalizeRunAttrsFromOoxml(props: RunProperties | null | undefined, context?: NormalizeRunAttrsContext): TextRunStyleAttrs;

package/dist/layout-engine/style-engine/src/normalize/types.d.ts

@@ -0,0 +1,36 @@
+import { ParagraphAttrs, TextRun } from '../../../contracts/src/index.js';
+/**
+ * Visual text-run style attributes the adapter is allowed to emit safely.
+ * This is the **partial** typed shape — every field is optional because
+ * the resolver may only know a subset and must not invent defaults.
+ *
+ * Caller responsibility:
+ * - `fontFamily` / `fontSize` are visual defaults; only emit when resolved.
+ * - Run text is always built with a non-empty `fontFamily` and a positive
+ *   `fontSize` at the projection layer; partial attrs only override.
+ */
+export interface TextRunStyleAttrs {
+    fontFamily?: string;
+    fontSize?: number;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: NonNullable<TextRun['underline']>;
+    strike?: boolean;
+    doubleStrike?: boolean;
+    color?: string;
+    highlight?: string;
+    textTransform?: TextRun['textTransform'];
+    allCaps?: boolean;
+    smallCaps?: boolean;
+    vertAlign?: TextRun['vertAlign'];
+    baselineShift?: number;
+    letterSpacing?: number;
+    horizontalScale?: number;
+    script?: TextRun['script'];
+    vanish?: boolean;
+    specVanish?: boolean;
+    noProof?: boolean;
+    bidi?: NonNullable<TextRun['bidi']>;
+}
+/** Re-export so v2 adapter can consume one paragraph attrs type. */
+export type { ParagraphAttrs };

package/dist/layout-engine/style-engine/src/normalize/units.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Unit helpers used by the editor-neutral normalize layer.
+ *
+ * Kept tiny and pure so v2 rendering can map twips/half-points/eighth-points
+ * into the layout-engine pixel domain without depending on pm-adapter or v1
+ * editor runtime.
+ */
+export declare const PX_PER_TWIP: number;
+export declare const PX_PER_POINT: number;
+export declare const PX_PER_EIGHTH_POINT: number;
+export declare function twipsToPx(value: number): number;
+export declare function halfPointsToPx(value: number): number;
+export declare function eighthPointsToPx(value: number): number;

package/dist/layout-engine/style-engine/src/ooxml/index.d.ts

@@ -0,0 +1,64 @@
+import { combineIndentProperties, combineProperties, combineRunProperties, FONT_SLOT_THEME_PAIRS, PropertyObject } from '../cascade.js';
+import { ParagraphConditionalFormatting, ParagraphProperties, RunProperties } from './types.js';
+import { NumberingProperties } from './numbering-types.js';
+import { StylesDocumentProperties, TableProperties, TableLookProperties, TableCellProperties } from './styles-types.js';
+export { combineIndentProperties, combineProperties, combineRunProperties, FONT_SLOT_THEME_PAIRS };
+export type { PropertyObject };
+export type * from './types.js';
+export type * from './numbering-types.js';
+export type * from './styles-types.js';
+export { TABLE_STYLE_ID_TABLE_GRID, TABLE_STYLE_ID_TABLE_NORMAL, TABLE_FALLBACK_BORDER, TABLE_FALLBACK_BORDERS, TABLE_FALLBACK_CELL_PADDING, isKnownTableStyleId, findTypeDefaultTableStyleId, resolveExistingTableEffectiveStyleId, resolvePreferredNewTableStyleId, } from './table-style-selection.js';
+export type { ResolvedStyle, ResolvedStyleSource, TableSemanticStyleHints } from './table-style-selection.js';
+export interface OoxmlResolverParams {
+    translatedNumbering: NumberingProperties | null | undefined;
+    translatedLinkedStyles: StylesDocumentProperties | null | undefined;
+    /** Actual `w:type="paragraph" w:default="1"` style ID. */
+    defaultParagraphStyleId?: string;
+    /** Bounded read-only aliases for legacy dangling semantic references. */
+    styleIdAliases?: Readonly<Record<string, string>>;
+    /**
+     * Opt-in memoization of `resolveStyleChain` results, keyed per params
+     * object. Only set this when `translatedLinkedStyles` is immutable for the
+     * lifetime of this params object (the compiled WordStyleModel guarantees
+     * that; callers that rebuild styles in place must not opt in).
+     */
+    enableChainMemo?: boolean;
+}
+export interface TableInfo {
+    tableProperties: TableProperties | null | undefined;
+    directTableProperties?: TableProperties | null | undefined;
+    rowIndex: number;
+    cellIndex: number;
+    numCells: number;
+    numRows: number;
+    rowCnfStyle?: ParagraphConditionalFormatting | null;
+    cellCnfStyle?: ParagraphConditionalFormatting | null;
+}
+/**
+ * OOXML default tblLook value (0x04A0) per ECMA-376 §17.4.56.
+ * Word applies these flags when a table has no explicit w:tblLook element.
+ */
+export declare const DEFAULT_TBL_LOOK: TableLookProperties;
+export declare function resolveRunProperties(params: OoxmlResolverParams, inlineRpr: RunProperties | null | undefined, resolvedPpr: ParagraphProperties | null | undefined, tableInfo?: TableInfo | null | undefined, isListNumber?: boolean, numberingDefinedInline?: boolean): RunProperties;
+export declare function resolveParagraphProperties(params: OoxmlResolverParams, inlineProps: ParagraphProperties | null | undefined, tableInfo: TableInfo | null | undefined): ParagraphProperties;
+export declare function resolveStyleChain<T extends PropertyObject>(propertyType: 'paragraphProperties' | 'runProperties' | 'tableProperties', params: OoxmlResolverParams, styleId: string | undefined, followBasedOnChain?: boolean): T;
+export declare function getNumberingProperties<T extends ParagraphProperties | RunProperties>(propertyType: 'paragraphProperties' | 'runProperties', params: OoxmlResolverParams, ilvl: number, numId: number, tries?: number): T;
+/**
+ * Resolves table-level properties (borders, cellMargins, justification,
+ * tableWidth, tableCellSpacing) by walking the full basedOn chain.
+ *
+ * Returns raw OOXML-translated shapes exactly as stored in
+ * `translatedLinkedStyles`. Conversion to layout units (px, pt)
+ * remains in the pm-adapter hydrator.
+ */
+export declare function resolveTableProperties(tableStyleId: string | null | undefined, translatedLinkedStyles: StylesDocumentProperties | null | undefined): TableProperties;
+export declare function resolveDocxFontFamily(attributes: Record<string, unknown> | null | undefined, docx: Record<string, unknown> | null | undefined, toCssFontFamily?: (fontName: string, docx?: Record<string, unknown>) => string): string | null;
+export declare function resolveCellStyles<T extends PropertyObject>(propertyType: 'paragraphProperties' | 'runProperties' | 'tableCellProperties', tableInfo: TableInfo | null | undefined, translatedLinkedStyles: StylesDocumentProperties): T[];
+/**
+ * Resolve table cell properties (shading, borders, margins) by cascading
+ * conditional table style properties with inline cell properties.
+ *
+ * Cascade order (low → high priority):
+ *   wholeTable → bands → firstRow/lastRow/firstCol/lastCol → corner cells → inline
+ */
+export declare function resolveTableCellProperties(inlineProps: TableCellProperties | null | undefined, tableInfo: TableInfo | null | undefined, translatedLinkedStyles: StylesDocumentProperties | null | undefined): TableCellProperties;