oasis-editor 0.0.1 → 0.0.3

package/dist/core/html/inlineImageParser.d.ts

@@ -0,0 +1,3 @@
+import { EditorImageRunData } from '../../../model.js';
+
+export declare function parseInlineImage(element: Element): EditorImageRunData | undefined;

package/dist/core/html/inlineStyleParser.d.ts

@@ -0,0 +1,3 @@
+import { EditorTextStyle } from '../../../model.js';
+
+export declare function parseInlineStyles(element: Element): EditorTextStyle | undefined;

package/dist/core/html/paragraphStyleParser.d.ts

@@ -0,0 +1,3 @@
+import { EditorParagraphStyle } from '../../../model.js';
+
+export declare function parseParagraphStyle(element: Element): EditorParagraphStyle | undefined;

package/dist/core/html/styleCss.d.ts

@@ -0,0 +1,5 @@
+import { EditorParagraphStyle, EditorTextStyle } from '../../../model.js';
+
+export declare function textRunStylesToCss(style?: EditorTextStyle): string;
+export declare function getPrimaryTextLanguage(language: EditorTextStyle["language"]): string | null;
+export declare function paragraphStyleToCssText(style?: EditorParagraphStyle): string;

package/dist/core/model/assets.d.ts

@@ -0,0 +1,7 @@
+import { EditorDocument } from '../../types/document.js';
+
+/**
+ * Resolve an `asset:<id>` reference (or pass through any other src) to the
+ * actual URL using the document's asset registry.
+ */
+export declare function resolveImageSrc(document: Pick<EditorDocument, "assets"> | undefined, src: string | undefined): string;

package/dist/core/model/documentIndex.d.ts

@@ -0,0 +1,58 @@
+import { EditorParagraphNode } from '../../types/nodes.js';
+import { EditorDocument } from '../../types/document.js';
+import { EditorEditingZone } from '../../types/selection.js';
+
+export interface EditorParagraphLocation {
+    sectionIndex: number;
+    zone: EditorEditingZone;
+    paragraphIndexInSection: number;
+    /** When `zone === "footnote"`, identifies which footnote owns the paragraph. */
+    footnoteId?: string;
+}
+export interface TableLocation {
+    blockIndex: number;
+    rowIndex: number;
+    cellIndex: number;
+    paragraphIndex: number;
+}
+export interface DocumentParagraphIndexEntry {
+    paragraph: EditorParagraphNode;
+    location: EditorParagraphLocation;
+    tableLocation: TableLocation | null;
+}
+export declare class DocumentIndexBuilder {
+    private readonly document;
+    private readonly index;
+    constructor(document: EditorDocument);
+    build(): Map<string, DocumentParagraphIndexEntry>;
+    private indexZone;
+    private indexBlock;
+    private recordParagraph;
+    private indexFootnotes;
+}
+/**
+ * Cache abstraction so tests can deterministically seed or inspect the
+ * document index without going through WeakMap semantics.
+ */
+export interface DocumentIndexCache {
+    getIndex(document: EditorDocument): Map<string, DocumentParagraphIndexEntry> | undefined;
+    setIndex(document: EditorDocument, index: Map<string, DocumentParagraphIndexEntry>): void;
+    getParagraphs(document: EditorDocument): EditorParagraphNode[] | undefined;
+    setParagraphs(document: EditorDocument, paragraphs: EditorParagraphNode[]): void;
+}
+export declare class WeakMapDocumentIndexCache implements DocumentIndexCache {
+    private readonly indexMap;
+    private readonly paragraphsMap;
+    getIndex(document: EditorDocument): Map<string, DocumentParagraphIndexEntry> | undefined;
+    setIndex(document: EditorDocument, index: Map<string, DocumentParagraphIndexEntry>): void;
+    getParagraphs(document: EditorDocument): EditorParagraphNode[] | undefined;
+    setParagraphs(document: EditorDocument, paragraphs: EditorParagraphNode[]): void;
+}
+export declare function getDocumentParagraphIndex(document: EditorDocument): Map<string, DocumentParagraphIndexEntry>;
+export declare function getDocumentParagraphsCanonical(document: EditorDocument): EditorParagraphNode[];
+export declare function getDocumentParagraphs(document: EditorDocument): EditorParagraphNode[];
+export declare function getParagraphById(document: EditorDocument, paragraphId: string): EditorParagraphNode | undefined;
+export declare function findParagraphLocation(document: EditorDocument, paragraphId: string): EditorParagraphLocation | null;
+export declare function findParagraphTableLocation(document: EditorDocument, paragraphId: string, activeSectionIndex?: number): (TableLocation & {
+    zone: EditorEditingZone;
+}) | null;

package/dist/core/model/documentSections.d.ts

@@ -0,0 +1,4 @@
+import { EditorDocument, EditorSection } from '../../types/document.js';
+
+export declare function getDocumentSectionsCanonical(document: EditorDocument): EditorSection[];
+export declare function getDocumentSections(document: EditorDocument): EditorSection[];

package/dist/core/model/editingZones.d.ts

@@ -0,0 +1,26 @@
+import { EditorBlockNode, EditorParagraphNode } from '../../types/nodes.js';
+import { EditorState } from '../../editorState.js';
+import { EditorEditingZone } from '../../types/selection.js';
+
+export declare function getActiveSectionIndex(state: EditorState): number;
+export declare function getActiveZone(state: EditorState): EditorEditingZone;
+/**
+ * Strict variant: returns `null` when the state is invalid for the zone
+ * (e.g. footnote zone with no active footnote id). Use this when you
+ * need to distinguish a legitimate empty blocks list from "no such
+ * editing zone available right now".
+ */
+export declare function tryGetEditableBlocksForZone(state: EditorState, zone: EditorEditingZone): EditorBlockNode[] | null;
+/**
+ * Always returns an array. Falls back to `[]` when the state is invalid
+ * for the requested zone. This is the right default for renderers and
+ * command implementations that just want a paragraph stream.
+ */
+export declare function getEditableBlocksForZone(state: EditorState, zone: EditorEditingZone): EditorBlockNode[];
+export declare function getActiveSectionBlocks(state: EditorState): EditorBlockNode[];
+/**
+ * Convenience: paragraphs (in document order) for the active editing zone.
+ * Combines `getEditableBlocksForZone` with the block→paragraph flatten so
+ * callers don't need to know about both helpers.
+ */
+export declare function getParagraphs(state: EditorState): EditorParagraphNode[];

package/dist/core/model/editorState.d.ts

@@ -0,0 +1,18 @@
+import { EditorDocument } from '../../types/document.js';
+import { EditorPosition, EditorSelection, EditorEditingZone } from '../../types/selection.js';
+
+export interface EditorState {
+    document: EditorDocument;
+    selection: EditorSelection;
+    activeSectionIndex?: number;
+    activeZone?: EditorEditingZone;
+    /**
+     * Identifies the footnote currently being edited when `activeZone === "footnote"`.
+     * Ignored for other zones.
+     */
+    activeFootnoteId?: string;
+    trackChangesEnabled?: boolean;
+    showMargins?: boolean;
+    showParagraphMarks?: boolean;
+}
+export type { EditorPosition, EditorSelection, EditorEditingZone };

package/dist/core/model/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Barrel file for the refactored `src/core/model/` module.
+ *
+ * The public surface (types, functions, constants) is byte-for-byte
+ * equivalent to the original `src/core/model.ts`, so all `import`
+ * statements that pointed there continue to work via the barrel
+ * re-export in `src/core/model.ts`.
+ */
+export type { EditorUnderlineStyle, EditorLigatures, EditorNumberSpacing, EditorNumberForm, EditorTextLanguage, EditorBorderStyle, EditorTabStop, EditorParagraphListStyle, EditorImageCrop, EditorImageFillMode, EditorImageFloatingPosition, EditorImageFloatingLayout, EditorImageRunData, EditorWrapPolygonPoint, EditorFieldData, EditorFieldChar, EditorFootnoteReferenceData, EditorEndnoteReferenceData, EditorRevision, EditorAsset, EditorFootnoteNumberFormat, EditorFootnoteRestart, EditorDocxWidthValue, EditorTableLayout, EditorTableRowHeightRule, } from '../../types/primitives.js';
+export type { EditorTextStyle, EditorParagraphStyle, EditorTableStyle, EditorTableConditionalFormat, EditorConditionalRowStyle, EditorNamedStyle, } from '../../types/styles.js';
+export type { EditorTextRun, EditorTextBoxShape, EditorTextBoxBody, EditorTextBoxData, EditorDropCap, EditorParagraphNode, EditorTableCellStyle, EditorTableCellNode, EditorTableRowStyle, EditorTableRowNode, EditorTableNode, EditorBlockNode, } from '../../types/nodes.js';
+export type { EditorFootnote } from '../../types/documentFootnotes.js';
+export type { EditorEndnote } from '../../types/documentEndnotes.js';
+export type { EditorBookmark, EditorBookmarkAnchor, EditorBookmarks, } from '../../types/documentBookmarks.js';
+export type { EditorPageMargins, EditorPageSettings, EditorSection, EditorFootnoteSettings, EditorFootnotes, EditorEndnoteSettings, EditorEndnotes, EditorDocument, } from '../../types/document.js';
+export type { EditorPosition, EditorSelection, EditorEditingZone, } from '../../types/selection.js';
+export type { EditorCaretSlot, EditorLayoutFragmentChar, EditorLayoutFragment, EditorLayoutLine, EditorLayoutParagraph, EditorLayoutBlock, TableCellBlockPosition, EditorLayoutPage, EditorLayoutDocument, } from '../../types/layout.js';
+export type { EditorState } from '../../editorState.js';
+export { EDITOR_ASSET_REF_PREFIX } from '../../types/primitives.js';
+export { DEFAULT_TEXT_STYLE, DEFAULT_PARAGRAPH_STYLE, EFFECTIVE_TEXT_STYLE_DEFAULTS, EFFECTIVE_PARAGRAPH_STYLE_DEFAULTS, } from '../../styleDefaults.js';
+export { DEFAULT_EDITOR_PAGE_SETTINGS } from '../../pageGeometry.js';
+export { getParagraphText, getParagraphLength, getRunIndex, getRunStartOffset, paragraphOffsetToPosition, positionToParagraphOffset, } from '../../queries.js';
+export { textStyleMerger, paragraphStyleMerger, mergeTextStyles, mergeParagraphStyles, resolveDefaultParagraphStyleId, resolveNamedTextStyle, resolveNamedParagraphStyle, resolveEffectiveTextStyle, resolveEffectiveTextStyleForParagraph, resolveEffectiveParagraphStyle, } from '../../styleResolution.js';
+export type { StyleMerger, Mergeable } from '../../styleResolution.js';
+export { resolveImageSrc } from '../../assets.js';
+export { normalizePageSettings, getDocumentPageSettings, getPageContentWidth, getPageHeaderZoneTop, getPageBodyTop, getPageFooterReferenceTop, getPageBodyBottom, getPageHeaderZoneHeight, getPageFooterZoneTop, getPageFooterZoneHeight, getPageContentHeight, } from '../../pageGeometry.js';
+export { getDocumentSections, getDocumentSectionsCanonical, } from '../../documentSections.js';
+export { DocumentIndexBuilder, getDocumentParagraphIndex, getDocumentParagraphs, getDocumentParagraphsCanonical, getParagraphById, findParagraphLocation, findParagraphTableLocation, WeakMapDocumentIndexCache, } from '../../documentIndex.js';
+export type { EditorParagraphLocation, TableLocation, DocumentParagraphIndexEntry, DocumentIndexCache, } from '../../documentIndex.js';
+export { getBlockParagraphs, collectSectionParagraphs, } from '../../paragraphWalker.js';
+export { getActiveSectionIndex, getActiveZone, getEditableBlocksForZone, tryGetEditableBlocksForZone, getActiveSectionBlocks, getParagraphs, } from '../../editingZones.js';

package/dist/core/model/pageGeometry.d.ts

@@ -0,0 +1,14 @@
+import { EditorDocument, EditorPageSettings } from '../../types/document.js';
+
+export declare const DEFAULT_EDITOR_PAGE_SETTINGS: EditorPageSettings;
+export declare function normalizePageSettings(pageSettings: EditorPageSettings): EditorPageSettings;
+export declare function getDocumentPageSettings(document: EditorDocument): EditorPageSettings;
+export declare function getPageContentWidth(pageSettings: EditorPageSettings): number;
+export declare function getPageHeaderZoneTop(pageSettings: EditorPageSettings): number;
+export declare function getPageBodyTop(pageSettings: EditorPageSettings): number;
+export declare function getPageFooterReferenceTop(pageSettings: EditorPageSettings): number;
+export declare function getPageBodyBottom(pageSettings: EditorPageSettings): number;
+export declare function getPageHeaderZoneHeight(pageSettings: EditorPageSettings): number;
+export declare function getPageFooterZoneTop(pageSettings: EditorPageSettings): number;
+export declare function getPageFooterZoneHeight(pageSettings: EditorPageSettings): number;
+export declare function getPageContentHeight(pageSettings: EditorPageSettings): number;

package/dist/core/model/paragraphWalker.d.ts

@@ -0,0 +1,5 @@
+import { EditorBlockNode, EditorParagraphNode } from '../../types/nodes.js';
+import { EditorSection } from '../../types/document.js';
+
+export declare function getBlockParagraphs(block: EditorBlockNode): EditorParagraphNode[];
+export declare function collectSectionParagraphs(section: EditorSection): EditorParagraphNode[];

package/dist/core/model/queries.d.ts

@@ -1,4 +1,5 @@
-import { EditorParagraphNode, EditorPosition } from '../../../model.js';
+import { EditorParagraphNode } from '../../types/nodes.js';
+import { EditorPosition } from '../../types/selection.js';
 
 export declare function getParagraphText(paragraph: EditorParagraphNode): string;
 export declare function getParagraphLength(paragraph: EditorParagraphNode): number;

package/dist/core/model/styleDefaults.d.ts

@@ -0,0 +1,6 @@
+import { EditorTextStyle, EditorParagraphStyle } from '../../types/styles.js';
+
+export declare const DEFAULT_TEXT_STYLE: Required<EditorTextStyle>;
+export declare const EFFECTIVE_TEXT_STYLE_DEFAULTS: Required<EditorTextStyle>;
+export declare const DEFAULT_PARAGRAPH_STYLE: Required<EditorParagraphStyle>;
+export declare const EFFECTIVE_PARAGRAPH_STYLE_DEFAULTS: Required<EditorParagraphStyle>;

package/dist/core/model/styleResolution.d.ts

@@ -0,0 +1,44 @@
+import { EditorNamedStyle, EditorParagraphStyle, EditorTextStyle } from '../../types/styles.js';
+
+/**
+ * A "mergeable" style is any object whose own enumerable string keys can
+ * be copied with `Object.entries`. We accept any object shape — real
+ * style interfaces don't declare an index signature and shouldn't have to.
+ */
+export type Mergeable = object;
+export interface StyleMerger<T> {
+    merge(resolved: T, local: Partial<T> | undefined): T;
+}
+export declare function createObjectMerger<T>(): StyleMerger<T>;
+export declare const textStyleMerger: StyleMerger<EditorTextStyle>;
+export declare const paragraphStyleMerger: StyleMerger<EditorParagraphStyle>;
+/**
+ * Merge policy used throughout the editor:
+ *  - `undefined` in `local` → inherit from `resolved` (key is skipped)
+ *  - `null` in `local`    → reset to system default (caller handles `null`)
+ *  - any other value      → override `resolved`
+ */
+export declare function mergeTextStyles(resolved: EditorTextStyle, local: EditorTextStyle | undefined): EditorTextStyle;
+export declare function mergeParagraphStyles(resolved: EditorParagraphStyle, local: EditorParagraphStyle | undefined): EditorParagraphStyle;
+export declare function resolveDefaultParagraphStyleId(styles: Record<string, EditorNamedStyle> | undefined): string | undefined;
+export declare function resolveNamedTextStyle(styleId: string | undefined, styles: Record<string, EditorNamedStyle> | undefined): EditorTextStyle;
+export declare function resolveNamedParagraphStyle(styleId: string | undefined, styles: Record<string, EditorNamedStyle> | undefined): EditorParagraphStyle;
+/**
+ * Resolve the effective text style for a run:
+ * 1. Resolve named style via styleId + basedOn chain
+ * 2. Apply local overrides (undefined → inherit, null → keep as null for reset)
+ * 3. Fill in system defaults for any remaining undefined values
+ */
+export declare function resolveEffectiveTextStyle(style: EditorTextStyle | undefined, styles: Record<string, EditorNamedStyle> | undefined): Required<EditorTextStyle>;
+/**
+ * Resolve the effective text style for a run, inheriting textStyle from the
+ * paragraph named style when the run does not override it locally.
+ */
+export declare function resolveEffectiveTextStyleForParagraph(style: EditorTextStyle | undefined, paragraphStyleId: string | undefined, styles: Record<string, EditorNamedStyle> | undefined): Required<EditorTextStyle>;
+/**
+ * Resolve the effective paragraph style:
+ * 1. Resolve named style via styleId + basedOn chain
+ * 2. Apply local overrides (undefined → inherit, null → keep as null for reset)
+ * 3. Fill in system defaults for any remaining undefined values
+ */
+export declare function resolveEffectiveParagraphStyle(style: EditorParagraphStyle | undefined, styles: Record<string, EditorNamedStyle> | undefined): Required<EditorParagraphStyle>;

package/dist/core/model/types/document.d.ts

@@ -0,0 +1,86 @@
+import { EditorAsset, EditorFootnoteNumberFormat, EditorFootnoteRestart } from '../../../primitives.js';
+import { EditorBlockNode } from '../../../nodes.js';
+import { EditorFootnote } from '../../../documentFootnotes.js';
+import { EditorEndnote } from '../../../documentEndnotes.js';
+import { EditorBookmarks } from '../../../documentBookmarks.js';
+import { EditorNamedStyle } from '../../../styles.js';
+
+export interface EditorPageMargins {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+    header: number;
+    footer: number;
+    gutter: number;
+}
+export interface EditorPageSettings {
+    width: number;
+    height: number;
+    orientation?: "portrait" | "landscape";
+    margins: EditorPageMargins;
+}
+export interface EditorSection {
+    id: string;
+    blocks: EditorBlockNode[];
+    pageSettings: EditorPageSettings;
+    header?: EditorBlockNode[];
+    firstPageHeader?: EditorBlockNode[];
+    evenPageHeader?: EditorBlockNode[];
+    footer?: EditorBlockNode[];
+    firstPageFooter?: EditorBlockNode[];
+    evenPageFooter?: EditorBlockNode[];
+    breakType?: "nextPage" | "continuous";
+}
+export interface EditorFootnoteSettings {
+    numberFormat?: EditorFootnoteNumberFormat;
+    restart?: EditorFootnoteRestart;
+    startAt?: number;
+}
+export interface EditorFootnotes {
+    items: Record<string, EditorFootnote>;
+    settings?: EditorFootnoteSettings;
+    separator?: EditorBlockNode[];
+    continuationSeparator?: EditorBlockNode[];
+}
+/**
+ * Endnote settings. Reuses the note number-format/restart vocabulary shared
+ * with footnotes (both are just "notes" in OOXML terms).
+ */
+export interface EditorEndnoteSettings {
+    numberFormat?: EditorFootnoteNumberFormat;
+    restart?: EditorFootnoteRestart;
+    startAt?: number;
+}
+export interface EditorEndnotes {
+    items: Record<string, EditorEndnote>;
+    settings?: EditorEndnoteSettings;
+    separator?: EditorBlockNode[];
+    continuationSeparator?: EditorBlockNode[];
+}
+export interface EditorDocument {
+    id: string;
+    pageSettings?: EditorPageSettings;
+    sections?: EditorSection[];
+    styles?: Record<string, EditorNamedStyle>;
+    settings?: {
+        defaultTabStop?: number;
+    };
+    /**
+     * Out-of-band asset registry. Image runs reference entries here using
+     * `src = "asset:<id>"`. The map itself is treated as append-only and is
+     * deliberately excluded from per-keystroke equality checks/signatures.
+     */
+    assets?: Record<string, EditorAsset>;
+    footnotes?: EditorFootnotes;
+    endnotes?: EditorEndnotes;
+    /**
+     * Bookmark registry (`w:bookmarkStart`/`w:bookmarkEnd`). Targets for internal
+     * hyperlinks (`#name`) and cross-references.
+     */
+    bookmarks?: EditorBookmarks;
+    metadata?: {
+        title?: string;
+        [key: string]: unknown;
+    };
+}

package/dist/core/model/types/documentBookmarks.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Bookmark registry (Word's `w:bookmarkStart` / `w:bookmarkEnd`).
+ *
+ * Bookmarks are *ranges* that are independent of the run/paragraph tree: a
+ * bookmark can span paragraphs, start and end in different blocks, nest,
+ * overlap, or be zero-width. They are therefore modeled as a document-level
+ * registry (like footnotes/endnotes) rather than as run attributes. Each
+ * bookmark owns two logical anchors — `start` and `end` — expressed as a
+ * paragraph id plus a character offset into that paragraph's flattened text.
+ *
+ * This is the "Phase 1" representation: faithful import/export round-trip and a
+ * real target for internal hyperlinks (`#name`). Live-edit transforms
+ * (split/merge/paste keeping anchors correct) are intentionally out of scope
+ * here.
+ */
+export interface EditorBookmarkAnchor {
+    /** Id of the paragraph this anchor lives in (`EditorParagraphNode.id`). */
+    paragraphId: string;
+    /** Character offset into the paragraph's flattened text stream. */
+    offset: number;
+    /**
+     * Document order in which the original marker appeared. Used purely to keep a
+     * deterministic emit order when several boundaries share one offset.
+     */
+    seq?: number;
+}
+export interface EditorBookmark {
+    /** Stable editor-local id (not the DOCX `w:id`). */
+    id: string;
+    /** Word bookmark name; this is the hyperlink / cross-reference target. */
+    name: string;
+    /** Hidden bookmarks (name starts with "_", e.g. `_Toc...`, `_Ref...`). */
+    hidden?: boolean;
+    /** Original DOCX `w:id`, used only as a hint for export id stability. */
+    docxIdHint?: number;
+    /** Table column bookmark range start column (`w:bookmarkStart/@w:colFirst`). */
+    colFirst?: number;
+    /** Table column bookmark range end column (`w:bookmarkStart/@w:colLast`). */
+    colLast?: number;
+    /** Start anchor. May be absent for malformed imports (orphan end). */
+    start?: EditorBookmarkAnchor;
+    /** End anchor. May be absent for malformed imports (orphan start). */
+    end?: EditorBookmarkAnchor;
+}
+export interface EditorBookmarks {
+    items: Record<string, EditorBookmark>;
+    /** Stable creation/import order for deterministic export. */
+    order: string[];
+}

package/dist/core/model/types/documentEndnotes.d.ts

@@ -0,0 +1,8 @@
+import { EditorBlockNode } from '../../../nodes.js';
+
+export interface EditorEndnote {
+    id: string;
+    blocks: EditorBlockNode[];
+    /** Original DOCX `w:id`, kept for round-trip diagnostics only. */
+    docxId?: number;
+}

package/dist/core/model/types/documentFootnotes.d.ts

@@ -0,0 +1,8 @@
+import { EditorBlockNode } from '../../../nodes.js';
+
+export interface EditorFootnote {
+    id: string;
+    blocks: EditorBlockNode[];
+    /** Original DOCX `w:id`, kept for round-trip diagnostics only. */
+    docxId?: number;
+}

package/dist/core/model/types/layout.d.ts

@@ -0,0 +1,93 @@
+import { EditorBlockNode, EditorTextBoxData } from '../../../nodes.js';
+import { EditorPageSettings } from '../../../document.js';
+import { EditorRevision, EditorImageRunData } from '../../../primitives.js';
+import { EditorTextStyle } from '../../../styles.js';
+
+export interface EditorCaretSlot {
+    paragraphId: string;
+    offset: number;
+    left: number;
+    top: number;
+    height: number;
+}
+export interface EditorLayoutFragmentChar {
+    char: string;
+    paragraphOffset: number;
+    runOffset: number;
+}
+export interface EditorLayoutFragment {
+    paragraphId: string;
+    runId: string;
+    startOffset: number;
+    endOffset: number;
+    text: string;
+    styles?: EditorTextStyle;
+    image?: EditorImageRunData;
+    textBox?: EditorTextBoxData;
+    revision?: EditorRevision;
+    chars: EditorLayoutFragmentChar[];
+}
+export interface EditorLayoutLine {
+    paragraphId: string;
+    index: number;
+    startOffset: number;
+    endOffset: number;
+    top: number;
+    height: number;
+    slots: EditorCaretSlot[];
+    fragments: EditorLayoutFragment[];
+    availableWidth?: number;
+}
+export interface EditorLayoutParagraph {
+    paragraphId: string;
+    text: string;
+    fragments: EditorLayoutFragment[];
+    lines: EditorLayoutLine[];
+    startOffset?: number;
+    endOffset?: number;
+    contentWidth?: number;
+}
+export interface EditorLayoutBlock {
+    blockId: string;
+    blockType: EditorBlockNode["type"];
+    paragraphId?: string;
+    globalIndex: number;
+    estimatedHeight: number;
+    layout?: EditorLayoutParagraph;
+    tableSegment?: {
+        startRowIndex: number;
+        endRowIndex: number;
+        repeatedHeaderRowCount: number;
+        startRowCellBlockStarts?: number[];
+        endRowCellBlockEnds?: number[];
+        startRowCellBlockPositions?: TableCellBlockPosition[];
+        endRowCellBlockPositions?: TableCellBlockPosition[];
+    };
+    sourceBlockId?: string;
+    sourceBlock: EditorBlockNode;
+}
+export interface TableCellBlockPosition {
+    blockIndex: number;
+    offset?: number;
+}
+export interface EditorLayoutPage {
+    id: string;
+    index: number;
+    height: number;
+    maxHeight: number;
+    blocks: EditorLayoutBlock[];
+    pageSettings: EditorPageSettings;
+    headerBlocks?: EditorLayoutBlock[];
+    footerBlocks?: EditorLayoutBlock[];
+    footnoteBlocks?: EditorLayoutBlock[];
+    footnoteReferenceIds?: string[];
+    bodyTop?: number;
+    bodyBottom?: number;
+    headerTop?: number;
+    footerTop?: number;
+    footnoteTop?: number;
+    footnoteSeparatorTop?: number;
+}
+export interface EditorLayoutDocument {
+    pages: EditorLayoutPage[];
+}