oasis-editor 0.0.1

package/dist/core/model.d.ts

@@ -0,0 +1,447 @@
+export type EditorUnderlineStyle = "single" | "double" | "thick" | "dotted" | "dottedHeavy" | "dash" | "dashedHeavy" | "dashLong" | "dashLongHeavy" | "dotDash" | "dashDotHeavy" | "dotDotDash" | "dashDotDotHeavy" | "wave" | "wavyHeavy" | "wavyDouble" | "words";
+export type EditorLigatures = "none" | "standard" | "contextual" | "historical" | "standardContextual";
+export type EditorNumberSpacing = "default" | "proportional" | "tabular";
+export type EditorNumberForm = "default" | "lining" | "oldStyle";
+export interface EditorTextStyle {
+    styleId?: string;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    underlineStyle?: EditorUnderlineStyle | null;
+    underlineColor?: string | null;
+    strike?: boolean;
+    doubleStrike?: boolean;
+    superscript?: boolean;
+    subscript?: boolean;
+    smallCaps?: boolean;
+    allCaps?: boolean;
+    hidden?: boolean;
+    characterScale?: number | null;
+    characterSpacing?: number | null;
+    baselineShift?: number | null;
+    kerningThreshold?: number | null;
+    ligatures?: EditorLigatures | null;
+    numberSpacing?: EditorNumberSpacing | null;
+    numberForm?: EditorNumberForm | null;
+    stylisticSet?: number | null;
+    contextualAlternates?: boolean;
+    fontFamily?: string | null;
+    fontSize?: number | null;
+    color?: string | null;
+    highlight?: string | null;
+    link?: string | null;
+}
+export interface EditorTabStop {
+    position: number;
+    type: "left" | "center" | "right" | "decimal" | "bar" | "clear";
+    leader?: "none" | "dot" | "hyphen" | "underscore" | "heavy" | "middleDot";
+}
+export interface EditorParagraphStyle {
+    styleId?: string;
+    align?: "left" | "center" | "right" | "justify";
+    spacingBefore?: number | null;
+    spacingAfter?: number | null;
+    lineHeight?: number | null;
+    lineGridPitch?: number | null;
+    lineGridType?: "lines" | "linesAndChars" | "snapToChars" | "implicit" | null;
+    snapToGrid?: boolean;
+    indentLeft?: number | null;
+    indentRight?: number | null;
+    indentFirstLine?: number | null;
+    indentHanging?: number | null;
+    shading?: string | null;
+    borderTop?: EditorBorderStyle | null;
+    borderRight?: EditorBorderStyle | null;
+    borderBottom?: EditorBorderStyle | null;
+    borderLeft?: EditorBorderStyle | null;
+    tabs?: EditorTabStop[] | null;
+    pageBreakBefore?: boolean;
+    keepWithNext?: boolean;
+    keepLinesTogether?: boolean;
+    widowControl?: boolean;
+}
+export interface EditorNamedStyle {
+    id: string;
+    name: string;
+    type: "paragraph" | "character" | "table";
+    basedOn?: string;
+    nextStyle?: string;
+    paragraphStyle?: EditorParagraphStyle;
+    textStyle?: EditorTextStyle;
+    tableStyle?: EditorTableStyle;
+}
+export interface EditorParagraphListStyle {
+    kind: "bullet" | "ordered";
+    level?: number;
+    format?: "decimal" | "lowerLetter" | "upperLetter" | "lowerRoman" | "upperRoman" | "bullet";
+    startAt?: number;
+}
+export interface EditorImageRunData {
+    src: string;
+    width: number;
+    height: number;
+    alt?: string;
+}
+export interface EditorFieldData {
+    type: "PAGE" | "NUMPAGES";
+}
+/**
+ * Inline reference to a footnote body stored in `EditorDocument.footnotes`.
+ * The `run.text` carries the materialized marker (e.g. "1", "2", "*") so
+ * layout, hit-testing and export can treat the run as ordinary text.
+ *
+ * Renumbering rewrites `run.text` to keep markers in sync with document
+ * order. `customMark` (mapped from DOCX `w:customMarkFollows`) signals a
+ * user-provided marker that should not be auto-numbered.
+ */
+export interface EditorFootnoteReferenceData {
+    footnoteId: string;
+    customMark?: string;
+}
+export interface EditorRevision {
+    id: string;
+    type: "insert" | "delete";
+    author: string;
+    date: number;
+}
+export interface EditorTextRun {
+    id: string;
+    text: string;
+    styles?: EditorTextStyle;
+    image?: EditorImageRunData;
+    field?: EditorFieldData;
+    revision?: EditorRevision;
+    /**
+     * When set, this run is the inline marker of a footnote whose body lives in
+     * `EditorDocument.footnotes.items[footnoteReference.footnoteId]`. The run
+     * should be treated as atomic for selection/editing purposes.
+     */
+    footnoteReference?: EditorFootnoteReferenceData;
+}
+export interface EditorParagraphNode {
+    id: string;
+    type: "paragraph";
+    runs: EditorTextRun[];
+    style?: EditorParagraphStyle;
+    list?: EditorParagraphListStyle;
+}
+export interface EditorBorderStyle {
+    width: number;
+    type: "solid" | "dashed" | "dotted" | "none";
+    color: string;
+}
+export interface EditorTableCellStyle {
+    shading?: string;
+    width?: number | string;
+    borderTop?: EditorBorderStyle;
+    borderRight?: EditorBorderStyle;
+    borderBottom?: EditorBorderStyle;
+    borderLeft?: EditorBorderStyle;
+    padding?: number;
+    paddingTop?: number;
+    paddingRight?: number;
+    paddingBottom?: number;
+    paddingLeft?: number;
+    verticalAlign?: "top" | "middle" | "bottom";
+    horizontalAlign?: "left" | "center" | "right" | "justify";
+}
+export interface EditorTableCellNode {
+    id: string;
+    blocks: EditorParagraphNode[];
+    colSpan?: number;
+    rowSpan?: number;
+    vMerge?: "restart" | "continue";
+    style?: EditorTableCellStyle;
+}
+export interface EditorTableRowStyle {
+    height?: number | string;
+}
+export interface EditorTableRowNode {
+    id: string;
+    cells: EditorTableCellNode[];
+    isHeader?: boolean;
+    style?: EditorTableRowStyle;
+}
+export interface EditorTableStyle {
+    styleId?: string;
+    width?: number | string;
+    align?: "left" | "center" | "right";
+    indentLeft?: number;
+    pageBreakBefore?: boolean;
+}
+export interface EditorTableNode {
+    id: string;
+    type: "table";
+    rows: EditorTableRowNode[];
+    gridCols?: number[];
+    style?: EditorTableStyle;
+}
+export type EditorBlockNode = EditorParagraphNode | EditorTableNode;
+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";
+}
+/**
+ * An out-of-band asset bundled with the document (e.g. an embedded image).
+ * Heavy binary data (data URLs) lives here exactly once; runs reference it
+ * via `image.src = "asset:<id>"`. Keeping payloads off the per-paragraph
+ * state lets equality checks, signatures and clones stay cheap on every
+ * keystroke even when a document embeds large images.
+ */
+export interface EditorAsset {
+    id: string;
+    /** Full data URL (e.g. `data:image/png;base64,...`) or remote URL. */
+    url: string;
+}
+export declare const EDITOR_ASSET_REF_PREFIX = "asset:";
+export type EditorFootnoteNumberFormat = "decimal" | "lowerRoman" | "upperRoman" | "lowerLetter" | "upperLetter" | "symbol";
+export type EditorFootnoteRestart = "continuous" | "eachSection";
+/**
+ * Body of a single footnote. `blocks` is fully editable, mirroring the
+ * shape of a section's main content. The DOCX `<w:footnoteRef/>` marker
+ * inside the body is NOT stored here — render/export reinjects it.
+ */
+export interface EditorFootnote {
+    id: string;
+    blocks: EditorBlockNode[];
+    /** Original DOCX `w:id`, kept for round-trip diagnostics only. */
+    docxId?: number;
+}
+export interface EditorFootnoteSettings {
+    numberFormat?: EditorFootnoteNumberFormat;
+    restart?: EditorFootnoteRestart;
+    startAt?: number;
+}
+export interface EditorFootnotes {
+    items: Record<string, EditorFootnote>;
+    settings?: EditorFootnoteSettings;
+    /** Optional imported separator part (Fase futura: render/export). */
+    separator?: EditorBlockNode[];
+    /** Optional imported continuation separator part (Fase futura). */
+    continuationSeparator?: EditorBlockNode[];
+}
+export interface EditorDocument {
+    id: string;
+    pageSettings?: EditorPageSettings;
+    sections?: EditorSection[];
+    styles?: Record<string, EditorNamedStyle>;
+    /**
+     * 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>;
+    /**
+     * Footnote bodies keyed by id. Inline references live in
+     * `EditorTextRun.footnoteReference` and point here. May be undefined when
+     * the document has no notes.
+     */
+    footnotes?: EditorFootnotes;
+    metadata?: {
+        title?: string;
+        [key: string]: any;
+    };
+}
+export { getParagraphLength, getParagraphText, getRunIndex, getRunStartOffset, paragraphOffsetToPosition, positionToParagraphOffset, } from '../model/queries.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;
+export declare const EFFECTIVE_TEXT_STYLE_DEFAULTS: Required<EditorTextStyle>;
+export declare const EFFECTIVE_PARAGRAPH_STYLE_DEFAULTS: Required<EditorParagraphStyle>;
+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>;
+export interface EditorPosition {
+    paragraphId: string;
+    runId: string;
+    offset: number;
+}
+export interface EditorSelection {
+    anchor: EditorPosition;
+    focus: EditorPosition;
+}
+export type EditorEditingZone = "main" | "header" | "footer" | "footnote";
+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 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;
+    revision?: EditorRevision;
+    chars: EditorLayoutFragmentChar[];
+}
+export interface EditorLayoutLine {
+    paragraphId: string;
+    index: number;
+    startOffset: number;
+    endOffset: number;
+    top: number;
+    height: number;
+    slots: EditorCaretSlot[];
+    fragments: EditorLayoutFragment[];
+}
+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;
+    };
+    sourceBlockId?: string;
+    sourceBlock: EditorBlockNode;
+}
+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[];
+}
+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;
+export declare function getDocumentSectionsCanonical(document: EditorDocument): EditorSection[];
+export declare function getDocumentSections(document: EditorDocument): EditorSection[];
+export declare function getEditableBlocksForZone(state: EditorState, zone: EditorEditingZone): EditorBlockNode[];
+export declare function getActiveSectionBlocks(state: EditorState): EditorBlockNode[];
+export declare function getBlockParagraphs(block: EditorBlockNode): EditorParagraphNode[];
+export declare function getDocumentParagraphsCanonical(document: EditorDocument): EditorParagraphNode[];
+export declare function getDocumentParagraphs(document: EditorDocument): EditorParagraphNode[];
+export declare function getParagraphs(state: EditorState): EditorParagraphNode[];
+export declare function getActiveSectionIndex(state: EditorState): number;
+export declare function getActiveZone(state: EditorState): EditorEditingZone;
+export interface EditorParagraphLocation {
+    sectionIndex: number;
+    zone: EditorEditingZone;
+    paragraphIndexInSection: number;
+    /** When `zone === "footnote"`, identifies which footnote owns the paragraph. */
+    footnoteId?: string;
+}
+export interface DocumentParagraphIndexEntry {
+    paragraph: EditorParagraphNode;
+    location: EditorParagraphLocation;
+    tableLocation: {
+        blockIndex: number;
+        rowIndex: number;
+        cellIndex: number;
+        paragraphIndex: number;
+    } | null;
+}
+export declare function getDocumentParagraphIndex(document: EditorDocument): Map<string, DocumentParagraphIndexEntry>;
+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): {
+    blockIndex: number;
+    rowIndex: number;
+    cellIndex: number;
+    paragraphIndex: number;
+    zone: EditorEditingZone;
+} | null;

package/dist/core/plugin.d.ts

@@ -0,0 +1,64 @@
+import { EditorState } from '../model.js';
+import { Editor } from '../Editor.js';
+import { CommandRef } from '../commands/CommandRef.js';
+
+export type Unsubscribe = () => void;
+export interface OasisCommand<TPayload = unknown, TResult = unknown> {
+    execute: (payload?: TPayload) => TResult;
+    refresh?: (payload?: TPayload) => CommandState;
+}
+export interface OasisCommandRegistry {
+    register: <TPayload = unknown, TResult = unknown>(name: string, command: OasisCommand<TPayload, TResult>) => void;
+    unregister: (name: string) => void;
+    get: (name: string) => OasisCommand | undefined;
+    has: (name: string) => boolean;
+}
+export interface CommandState {
+    isEnabled: boolean;
+    isActive?: boolean;
+    value?: unknown;
+}
+export interface OasisEditor {
+    readonly state: EditorState;
+    readonly commands: OasisCommandRegistry;
+    registerCommand: <TPayload = unknown, TResult = unknown>(name: string, command: OasisCommand<TPayload, TResult>) => void;
+    unregisterCommand: (name: string) => void;
+    execute: <TPayload = unknown, TResult = unknown>(name: string, payload?: TPayload) => TResult;
+    canExecute: (name: string, payload?: unknown) => boolean;
+    on: (event: string, callback: (...args: unknown[]) => void) => Unsubscribe;
+    once: (event: string, callback: (...args: unknown[]) => void) => Unsubscribe;
+    off: (event: string, callback: (...args: unknown[]) => void) => void;
+}
+export type PluginReference = string | OasisPlugin;
+export interface PluginAction {
+    id: string;
+    command: CommandRef;
+    icon?: string;
+    group?: string;
+}
+export interface PluginMenuItem extends PluginAction {
+    path: string;
+    shortcut?: string;
+    separator?: boolean;
+    labelKey?: string;
+}
+export interface OasisPlugin {
+    name: string;
+    requires?: PluginReference[];
+    schema?: {
+        nodes?: Record<string, unknown>;
+        marks?: Record<string, unknown>;
+    };
+    commands?: Record<string, OasisCommand>;
+    keymaps?: Array<{
+        key: string;
+        command: string;
+    }>;
+    toolbar?: PluginAction[];
+    menubar?: PluginMenuItem[];
+    init?: (editor: OasisEditor) => void | Promise<void>;
+    afterInit?: (editor: OasisEditor) => void | Promise<void>;
+    destroy?: (editor: OasisEditor) => void | Promise<void>;
+    install?: (editor: OasisEditor) => void | Unsubscribe;
+}
+export type OasisEditorRuntime = Editor;

package/dist/core/plugins/PluginCollection.d.ts

@@ -0,0 +1,16 @@
+import { OasisEditor, OasisPlugin } from '../../../plugin.js';
+
+export declare class PluginCollection {
+    private editorInstance;
+    private plugins;
+    private cleanups;
+    private initialized;
+    private isInitialized;
+    constructor(editorInstance: OasisEditor, plugins?: OasisPlugin[]);
+    private resolvePlugins;
+    initializeAll(): Promise<void>;
+    private initializePlugin;
+    private registerPluginCommands;
+    destroy(): Promise<void>;
+    getPlugins(): OasisPlugin[];
+}

package/dist/core/selection.d.ts

@@ -0,0 +1,19 @@
+import { EditorParagraphNode, EditorPosition, EditorSelection, EditorState } from '../model.js';
+
+export interface NormalizedEditorSelection {
+    start: EditorPosition;
+    end: EditorPosition;
+    startIndex: number;
+    endIndex: number;
+    startParagraphOffset: number;
+    endParagraphOffset: number;
+    isCollapsed: boolean;
+}
+export declare function findParagraphIndex(paragraphs: EditorParagraphNode[], paragraphId: string): number;
+export declare function findParagraphById(paragraphs: EditorParagraphNode[], paragraphId: string): EditorParagraphNode;
+export declare function clampOffset(offset: number, paragraph: EditorParagraphNode): number;
+export declare function clampPosition(state: EditorState, position: EditorPosition): EditorPosition;
+export declare function comparePositions(paragraphs: EditorParagraphNode[], left: EditorPosition, right: EditorPosition): number;
+export declare function createCollapsedSelection(position: EditorPosition): EditorSelection;
+export declare function isSelectionCollapsed(selection: EditorSelection): boolean;
+export declare function normalizeSelection(state: EditorState, providedParagraphs?: EditorParagraphNode[]): NormalizedEditorSelection;

package/dist/core/tableLayout.d.ts

@@ -0,0 +1,13 @@
+import { EditorLayoutBlock, EditorTableCellNode, EditorTableNode } from '../model.js';
+
+export interface TableCellLayoutEntry {
+    rowIndex: number;
+    cellIndex: number;
+    visualRowIndex: number;
+    visualColumnIndex: number;
+    rowSpan: number;
+    colSpan: number;
+    cell: EditorTableCellNode;
+}
+export declare function buildTableCellLayout(table: EditorTableNode): TableCellLayoutEntry[];
+export declare function buildSegmentTable(table: EditorTableNode, segment: NonNullable<EditorLayoutBlock["tableSegment"]>): EditorTableNode;

package/dist/core/textStyleMappings.d.ts

@@ -0,0 +1,8 @@
+import { EditorTextStyle } from '../model.js';
+
+export type UnderlineStyle = EditorTextStyle["underlineStyle"];
+export declare function underlineStyleToCssDecorationStyle(underlineStyle: UnderlineStyle): string | null;
+export declare function isDoubleUnderlineStyle(underlineStyle: UnderlineStyle): boolean;
+export declare function isWavyUnderlineStyle(underlineStyle: UnderlineStyle): boolean;
+export declare function underlineStyleLineWidthPx(underlineStyle: UnderlineStyle): number;
+export declare function underlineStyleDashArray(underlineStyle: UnderlineStyle): number[] | undefined;

package/dist/core/wordBoundaries.d.ts

@@ -0,0 +1,7 @@
+export declare function isWordCharacter(char: string): boolean;
+export declare function resolveWordSelection(text: string, offset: number): {
+    start: number;
+    end: number;
+};
+export declare function findPreviousWordBoundary(text: string, offset: number): number;
+export declare function findNextWordBoundary(text: string, offset: number): number;

package/dist/demo/OasisSiteApp.d.ts

@@ -0,0 +1 @@
+export declare function OasisSiteApp(): import("solid-js").JSX.Element;

package/dist/export/docx/docxTypes.d.ts

@@ -0,0 +1,66 @@
+import { EditorBlockNode, EditorParagraphListStyle } from '../../../../core/model.js';
+
+export interface DocContext {
+    numberingInfo: Map<string, {
+        numId: number;
+        level: number;
+    }>;
+    definitions: Array<{
+        kind: EditorParagraphListStyle["kind"];
+        level: number;
+        abstractNumId: number;
+        numId: number;
+    }>;
+    images: Array<{
+        rId: string;
+        target: string;
+        base64: string;
+        runId: string;
+        cx: number;
+        cy: number;
+        alt?: string;
+    }>;
+    imageMap: Map<string, string>;
+    hyperlinks: Array<{
+        rId: string;
+        href: string;
+    }>;
+    hyperlinkMap: Map<string, string>;
+    /**
+     * Maps `EditorFootnote.id` to the numeric `w:id` value used when emitting
+     * `<w:footnoteReference w:id="N"/>` in the document body. Empty when the
+     * document has no footnotes.
+     */
+    footnoteIdMap?: Map<string, number>;
+}
+export interface NumberingContext {
+    numberingInfo: Map<string, {
+        numId: number;
+        level: number;
+    }>;
+    definitions: Array<{
+        kind: EditorParagraphListStyle["kind"];
+        level: number;
+        abstractNumId: number;
+        numId: number;
+    }>;
+}
+export interface ExportBuildState {
+    nextImageId: number;
+}
+export interface PartDefinition {
+    kind: "header" | "footer";
+    type: "default" | "first" | "even";
+    path: string;
+    relId: string;
+    blocks: EditorBlockNode[];
+    context: DocContext;
+}
+export interface SectionReferenceDefinition {
+    header?: Partial<Record<"default" | "first" | "even", {
+        relId: string;
+    }>>;
+    footer?: Partial<Record<"default" | "first" | "even", {
+        relId: string;
+    }>>;
+}

package/dist/export/docx/exportEditorDocumentToDocx.d.ts

@@ -0,0 +1,4 @@
+import { EditorDocument } from '../../../../core/model.js';
+
+export declare function exportEditorDocumentToDocx(document: EditorDocument): Promise<ArrayBuffer>;
+export declare function exportEditorDocumentToDocxBlob(document: EditorDocument): Promise<Blob>;