oasis-editor 0.0.1

package/dist/core/Editor.d.ts

@@ -0,0 +1,33 @@
+import { EditorState, EditorDocument } from '../model.js';
+import { CommandRegistry } from '../commands/CommandRegistry.js';
+import { OasisCommand, OasisEditor, OasisPlugin } from '../plugin.js';
+
+export interface EditorOptions {
+    doc?: EditorDocument;
+    plugins?: OasisPlugin[];
+    keymaps?: Array<{
+        key: string;
+        command: string;
+    }>;
+}
+export declare class Editor implements OasisEditor {
+    private stateStore;
+    private setState;
+    private pluginCollection;
+    private listeners;
+    readonly commands: CommandRegistry;
+    constructor(options?: EditorOptions);
+    static create(options?: EditorOptions): Promise<Editor>;
+    private initializeState;
+    get state(): EditorState;
+    dispatch(updater: (state: EditorState) => EditorState): void;
+    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;
+    destroy(): Promise<void>;
+    on(event: string, callback: (...args: unknown[]) => void): () => void;
+    once(event: string, callback: (...args: unknown[]) => void): () => void;
+    off(event: string, callback: (...args: unknown[]) => void): void;
+    private emit;
+}

package/dist/core/cloneState.d.ts

@@ -0,0 +1,8 @@
+import { EditorBlockNode, EditorFootnote, EditorFootnotes, EditorSection, EditorState } from '../model.js';
+
+export declare function cloneBlock(block: EditorBlockNode): EditorBlockNode;
+export declare const cloneDocumentBlock: typeof cloneBlock;
+export declare function cloneSection(section: EditorSection): EditorSection;
+export declare function cloneFootnote(footnote: EditorFootnote): EditorFootnote;
+export declare function cloneFootnotes(footnotes: EditorFootnotes | undefined): EditorFootnotes | undefined;
+export declare function cloneEditorState(source: EditorState): EditorState;

package/dist/core/commands/CommandBus.d.ts

@@ -0,0 +1,9 @@
+import { CommandState, OasisEditor } from '../../../plugin.js';
+import { CommandRef } from '../../CommandRef.js';
+
+export interface CommandBus<TState = CommandState> {
+    execute(command: CommandRef, payloadOverride?: unknown): unknown;
+    canExecute(command: CommandRef, payloadOverride?: unknown): boolean;
+    state(command: CommandRef): TState;
+}
+export declare function createEditorCommandBus(editor: OasisEditor): CommandBus;

package/dist/core/commands/CommandRef.d.ts

@@ -0,0 +1,10 @@
+export type CommandRef<Name extends string = string, Payload = unknown> = Name | {
+    name: Name;
+    payload?: Payload;
+};
+export interface ResolvedCommandRef {
+    name: string;
+    payload: unknown;
+}
+export declare function commandRefName(ref: CommandRef): string;
+export declare function resolveCommandRef(ref: CommandRef, payloadOverride?: unknown): ResolvedCommandRef;

package/dist/core/commands/CommandRegistry.d.ts

@@ -0,0 +1,10 @@
+import { OasisCommand, OasisCommandRegistry } from '../../../plugin.js';
+
+export declare class CommandRegistry implements OasisCommandRegistry {
+    private commands;
+    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;
+    clear(): void;
+}

package/dist/core/commands/block.d.ts

@@ -0,0 +1,11 @@
+import { EditorParagraphStyle, EditorPosition, EditorState, EditorSection, EditorTabStop } from '../../../model.js';
+import { ValueParagraphStyleKey } from '../../utils.js';
+
+export declare function moveBlockToPosition(state: EditorState, blockId: string, targetPosition: EditorPosition): EditorState;
+export declare function splitBlockAtSelection(state: EditorState): EditorState;
+export declare function insertPageBreakAtSelection(state: EditorState): EditorState;
+export declare function insertSectionBreakAtSelection(state: EditorState, breakType: "nextPage" | "continuous"): EditorState;
+export declare function updateSectionSettings(state: EditorState, sectionIndex: number, settings: Partial<EditorSection>): EditorState;
+export declare function setParagraphNamedStyle(state: EditorState, styleId: string | null): EditorState;
+export declare function setParagraphStyle<K extends ValueParagraphStyleKey>(state: EditorState, key: K, value: EditorParagraphStyle[K] | null): EditorState;
+export declare function setParagraphTabStops(state: EditorState, tabs: EditorTabStop[] | null): EditorState;

package/dist/core/commands/clipboard.d.ts

@@ -0,0 +1,13 @@
+import { EditorParagraphListStyle, EditorParagraphStyle, EditorState, EditorTextStyle, EditorImageRunData } from '../../../model.js';
+
+export interface EditorClipboardParagraphSpec {
+    runs: Array<{
+        text: string;
+        styles?: EditorTextStyle;
+        image?: EditorImageRunData;
+    }>;
+    style?: EditorParagraphStyle;
+    list?: EditorParagraphListStyle;
+}
+export declare function serializeEditorSelectionToHtml(state: EditorState): string;
+export declare function insertClipboardParagraphsAtSelection(state: EditorState, paragraphsSpec: EditorClipboardParagraphSpec[]): EditorState;

package/dist/core/commands/footnotes.d.ts

@@ -0,0 +1,27 @@
+import { EditorFootnote, EditorState } from '../../../model.js';
+
+/**
+ * Insert a footnote at the current selection. The reference marker is placed
+ * inline (in the main flow) and a fresh body is created with a single empty
+ * paragraph. After insertion the active zone becomes `"footnote"` so the user
+ * can type the note text directly.
+ */
+export declare function insertFootnote(state: EditorState): EditorState;
+/**
+ * Remove a footnote: deletes the inline reference run and the body. Other
+ * notes are renumbered.
+ */
+export declare function deleteFootnote(state: EditorState, footnoteId: string): EditorState;
+/**
+ * Move the selection into the body of the given footnote, switching the
+ * active zone. Does nothing if the footnote does not exist or has no body.
+ */
+export declare function goToFootnoteBody(state: EditorState, footnoteId: string): EditorState;
+/**
+ * Move the selection back to the inline reference of the given footnote.
+ */
+export declare function goToFootnoteReference(state: EditorState, footnoteId: string): EditorState;
+/**
+ * Re-export helpers expected by callers.
+ */
+export type { EditorFootnote };

package/dist/core/commands/history.d.ts

@@ -0,0 +1,7 @@
+import { EditorState } from '../../../model.js';
+
+export declare function toggleTrackChanges(state: EditorState): EditorState;
+export declare function acceptRevision(state: EditorState, revisionId: string): EditorState;
+export declare function rejectRevision(state: EditorState, revisionId: string): EditorState;
+export declare function acceptRevisionsInSelection(state: EditorState): EditorState;
+export declare function rejectRevisionsInSelection(state: EditorState): EditorState;

package/dist/core/commands/image.d.ts

@@ -0,0 +1,15 @@
+import { EditorParagraphNode, EditorPosition, EditorState, EditorTextRun, EditorImageRunData } from '../../../model.js';
+
+export interface SelectedImageRun {
+    paragraph: EditorParagraphNode;
+    paragraphIndex: number;
+    run: EditorTextRun;
+    runIndex: number;
+    offset: number;
+}
+export declare function getSelectedImageRun(state: EditorState): SelectedImageRun | null;
+export declare function insertImageAtSelection(state: EditorState, image: EditorImageRunData): EditorState;
+export declare function resizeSelectedImage(state: EditorState, width: number, height: number): EditorState;
+export declare function getSelectedImageAlt(state: EditorState): string | null;
+export declare function setSelectedImageAlt(state: EditorState, alt: string | null): EditorState;
+export declare function moveSelectedImageToPosition(state: EditorState, targetPosition: EditorPosition): EditorState;

package/dist/core/commands/link.d.ts

@@ -0,0 +1,4 @@
+import { EditorState } from '../../../model.js';
+
+export declare function getLinkAtSelection(state: EditorState): string | null;
+export declare function setLinkAtSelection(state: EditorState, href: string | null): EditorState;

package/dist/core/commands/list.d.ts

@@ -0,0 +1,10 @@
+import { EditorParagraphListStyle, EditorState } from '../../../model.js';
+import { ParagraphListKind } from '../../utils.js';
+
+export declare function splitListItemAtSelection(state: EditorState): EditorState;
+export declare function clearParagraphListAtSelection(state: EditorState): EditorState;
+export declare function indentParagraphList(state: EditorState): EditorState;
+export declare function outdentParagraphList(state: EditorState): EditorState;
+export declare function toggleParagraphList(state: EditorState, kind: ParagraphListKind): EditorState;
+export declare function setParagraphListFormat(state: EditorState, format: EditorParagraphListStyle["format"] | null): EditorState;
+export declare function setParagraphListStartAt(state: EditorState, startAt: number | null): EditorState;

package/dist/core/commands/misc.d.ts

@@ -0,0 +1,3 @@
+import { EditorState } from '../../../model.js';
+
+export declare function insertFieldAtSelection(state: EditorState, fieldType: "PAGE" | "NUMPAGES"): EditorState;

package/dist/core/commands/selection.d.ts

@@ -0,0 +1,12 @@
+import { EditorSelection, EditorState } from '../../../model.js';
+
+export declare function getSelectedText(state: EditorState): string;
+export declare function setSelection(state: EditorState, selection: EditorSelection): EditorState;
+export declare function moveSelectionLeft(state: EditorState): EditorState;
+export declare function moveSelectionRight(state: EditorState): EditorState;
+export declare function moveSelectionUp(state: EditorState): EditorState;
+export declare function moveSelectionDown(state: EditorState): EditorState;
+export declare function extendSelectionLeft(state: EditorState): EditorState;
+export declare function extendSelectionRight(state: EditorState): EditorState;
+export declare function extendSelectionUp(state: EditorState): EditorState;
+export declare function extendSelectionDown(state: EditorState): EditorState;

package/dist/core/commands/table.d.ts

@@ -0,0 +1,10 @@
+import { EditorState, EditorTableCellStyle, EditorBorderStyle, EditorTableStyle } from '../../../model.js';
+
+export declare function setTableCellStyleValue<K extends keyof EditorTableCellStyle>(state: EditorState, key: K, value: EditorTableCellStyle[K] | null): EditorState;
+export declare function setTableStyleValue<K extends keyof EditorTableStyle>(state: EditorState, key: K, value: EditorTableStyle[K] | null): EditorState;
+export declare function setTableCellWidth(state: EditorState, width: number | string | null): EditorState;
+export declare function setTableRowHeight(state: EditorState, tableId: string, rowIndex: number, height: number | string | null): EditorState;
+export declare function setTableColumnWidths(state: EditorState, tableId: string, columnWidths: Record<number, number | string>, // visualColumnIndex -> width
+tableWidth?: number | string, tableIndentLeft?: number | string): EditorState;
+export declare function setTableCellBorders(state: EditorState, border: EditorBorderStyle | null): EditorState;
+export declare function insertTableAtSelection(state: EditorState, rows: number, cols: number): EditorState;

package/dist/core/commands/text.d.ts

@@ -0,0 +1,12 @@
+import { EditorPosition, EditorState, EditorTextStyle } from '../../../model.js';
+import { ToggleableTextStyleKey, ValueTextStyleKey } from '../../utils.js';
+
+export declare function moveOrCopySelectionToPosition(state: EditorState, targetPosition: EditorPosition, options?: {
+    copy?: boolean;
+}): EditorState;
+export declare function insertTextAtSelection(state: EditorState, text: string, styleOverride?: EditorTextStyle): EditorState;
+export declare function insertPlainTextAtSelection(state: EditorState, text: string, styleOverride?: EditorTextStyle): EditorState;
+export declare function deleteBackward(state: EditorState): EditorState;
+export declare function deleteForward(state: EditorState): EditorState;
+export declare function toggleTextStyle(state: EditorState, key: ToggleableTextStyleKey): EditorState;
+export declare function setTextStyleValue<K extends ValueTextStyleKey>(state: EditorState, key: K, value: EditorTextStyle[K] | null): EditorState;

package/dist/core/commands/utils.d.ts

@@ -0,0 +1,69 @@
+import { EditorBlockNode, EditorDocument, EditorParagraphListStyle, EditorParagraphStyle, EditorParagraphNode, EditorPosition, EditorSelection, EditorState, EditorTextRun, EditorTextStyle, EditorImageRunData, EditorSection, EditorTableCellNode } from '../../../model.js';
+import { normalizeSelection } from '../../../selection.js';
+
+export type ToggleableTextStyleKey = "bold" | "italic" | "underline" | "strike" | "doubleStrike" | "superscript" | "subscript" | "smallCaps" | "allCaps" | "hidden" | "contextualAlternates";
+export type ValueTextStyleKey = "fontFamily" | "fontSize" | "color" | "highlight" | "link" | "underlineStyle" | "underlineColor" | "characterScale" | "characterSpacing" | "baselineShift" | "kerningThreshold" | "ligatures" | "numberSpacing" | "numberForm" | "stylisticSet";
+export type ValueParagraphStyleKey = "styleId" | "align" | "spacingBefore" | "spacingAfter" | "lineHeight" | "indentLeft" | "indentRight" | "indentFirstLine" | "indentHanging" | "shading" | "borderTop" | "borderRight" | "borderBottom" | "borderLeft" | "tabs" | "pageBreakBefore" | "keepWithNext";
+export type ParagraphListKind = EditorParagraphListStyle["kind"];
+export declare function cloneStyle(style?: EditorTextStyle): EditorTextStyle | undefined;
+export declare function stylesEqual(left?: EditorTextStyle, right?: EditorTextStyle): boolean;
+export declare function setBooleanStyle(style: EditorTextStyle | undefined, key: ToggleableTextStyleKey, enabled: boolean): EditorTextStyle | undefined;
+export declare function setValueStyle<K extends ValueTextStyleKey>(style: EditorTextStyle | undefined, key: K, value: EditorTextStyle[K] | null): EditorTextStyle | undefined;
+export declare function cloneRun(run: EditorTextRun): EditorTextRun;
+export declare function cloneParagraph(paragraph: EditorParagraphNode): EditorParagraphNode;
+export declare function cloneParagraphList(list?: EditorParagraphListStyle): EditorParagraphListStyle | undefined;
+export declare function setParagraphStyleValue<K extends ValueParagraphStyleKey>(style: EditorParagraphStyle | undefined, key: K, value: EditorParagraphStyle[K] | null): EditorParagraphStyle | undefined;
+export declare function cloneParagraphs(paragraphs: EditorParagraphNode[]): EditorParagraphNode[];
+export declare function cloneBlocks(blocks: EditorBlockNode[]): EditorBlockNode[];
+export declare function normalizeRuns(runs: EditorTextRun[], fallbackStyles?: EditorTextStyle): EditorTextRun[];
+export declare function buildParagraphFromRuns(paragraph: EditorParagraphNode, runs: EditorTextRun[], fallbackStyles?: EditorTextStyle): EditorParagraphNode;
+export declare function createParagraphFromRuns(textRuns: Array<{
+    text: string;
+    styles?: EditorTextStyle;
+}>): EditorParagraphNode;
+export declare function createParagraphFromRunsLike(paragraph: EditorParagraphNode, textRuns: Array<{
+    text: string;
+    styles?: EditorTextStyle;
+}>): EditorParagraphNode;
+export declare function cloneParagraphWithListLevel(paragraph: EditorParagraphNode, level: number): EditorParagraphNode;
+export declare function clearParagraphList(paragraph: EditorParagraphNode): EditorParagraphNode;
+export declare function blocksContainTables(nodes: EditorBlockNode[]): boolean;
+export declare function replaceParagraphsInBlocks(blocks: EditorBlockNode[], newParagraphs: EditorParagraphNode[]): EditorBlockNode[];
+export declare function replaceParagraphsInSection(section: EditorSection, paragraphs: EditorParagraphNode[], zone: "main" | "header" | "footer"): EditorSection;
+export declare function cloneStateWithParagraphs(state: EditorState, paragraphs: EditorParagraphNode[], selection: EditorSelection): EditorState;
+export declare function withSelection(position: EditorPosition): EditorSelection;
+export declare function getFocusParagraph(state: EditorState): {
+    paragraph: EditorParagraphNode;
+    index: number;
+    offset: number;
+};
+export declare function getStyleAtOffset(paragraph: EditorParagraphNode, offset: number): EditorTextStyle | undefined;
+export declare function getRunAtOffset(paragraph: EditorParagraphNode, offset: number): {
+    run: EditorTextRun;
+    startOffset: number;
+    endOffset: number;
+} | null;
+export declare function expandLinkRangeInParagraph(paragraph: EditorParagraphNode, offset: number): {
+    href: string;
+    startOffset: number;
+    endOffset: number;
+} | null;
+export declare function sliceRuns(paragraph: EditorParagraphNode, startOffset: number, endOffset: number): EditorTextRun[];
+export declare function insertRunsAtOffset(paragraph: EditorParagraphNode, offset: number, textRuns: EditorTextRun[]): EditorParagraphNode;
+export declare function deleteSelectionRange(state: EditorState): EditorState;
+export declare function mapRunsInRange(paragraph: EditorParagraphNode, startOffset: number, endOffset: number, mapper: (run: EditorTextRun) => EditorTextRun): EditorParagraphNode;
+export declare function preserveSelectionByParagraphOffsets(paragraphs: EditorParagraphNode[], normalized: ReturnType<typeof normalizeSelection>): EditorSelection;
+export declare function collapseToBoundary(state: EditorState, direction: "start" | "end"): EditorState;
+export declare function escapeHtml(text: string): string;
+export declare function textRunStylesToCss(style?: EditorTextStyle): string;
+export declare function paragraphStyleToCssText(style?: EditorParagraphStyle): string;
+export declare function serializeImageRunToHtml(run: EditorTextRun, document?: Pick<EditorDocument, "assets">): string;
+export declare function serializeTextRunToHtml(run: EditorTextRun, document?: Pick<EditorDocument, "assets">): string;
+export declare function serializeParagraphRunsToHtml(runs: EditorTextRun[], document?: Pick<EditorDocument, "assets">): string;
+export declare function parseInlineStyles(element: Element): EditorTextStyle | undefined;
+export declare function parseInlineImage(element: Element): EditorImageRunData | undefined;
+export declare function parseParagraphStyle(element: Element): EditorParagraphStyle | undefined;
+export declare function updateTableCellsInBlocks(blocks: EditorBlockNode[], selectedParagraphIds: Set<string>, updateCell: (cell: EditorTableCellNode) => EditorTableCellNode): EditorBlockNode[];
+export declare function moveVertical(state: EditorState, delta: -1 | 1): EditorState;
+export declare function moveFocusHorizontally(state: EditorState, delta: -1 | 1): EditorState;
+export declare function moveFocusVertical(state: EditorState, delta: -1 | 1): EditorState;

package/dist/core/editorCommands.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @deprecated Use imports from `src/core/commands/*` instead.
+ */
+export * from '../commands/image.js';
+export * from '../commands/text.js';
+export * from '../commands/block.js';
+export * from '../commands/list.js';
+export * from '../commands/table.js';
+export * from '../commands/link.js';
+export * from '../commands/history.js';
+export * from '../commands/clipboard.js';
+export * from '../commands/selection.js';
+export * from '../commands/misc.js';
+export * from '../commands/footnotes.js';

package/dist/core/editorState.d.ts

@@ -0,0 +1,66 @@
+import { EditorAsset, EditorBlockNode, EditorDocument, EditorFootnote, EditorPageSettings, EditorParagraphNode, EditorSection, EditorState, EditorTableCellNode, EditorTableNode, EditorTableRowNode, EditorTextRun, EditorTextStyle, EditorImageRunData, EditorNamedStyle } from '../model.js';
+
+export declare function resetEditorIds(): void;
+export declare function createEditorRun(text?: string): EditorTextRun;
+export declare function createEditorStyledRun(text?: string, styles?: EditorTextStyle, image?: EditorImageRunData): EditorTextRun;
+export declare function createEditorParagraph(text?: string): EditorParagraphNode;
+export declare function createEditorParagraphFromRuns(runs: Array<{
+    text: string;
+    styles?: EditorTextStyle;
+    image?: EditorImageRunData;
+}>): EditorParagraphNode;
+export declare function createEditorTableCell(paragraphs: EditorParagraphNode[], colSpan?: number, options?: {
+    rowSpan?: number;
+    vMerge?: "restart" | "continue";
+}): EditorTableCellNode;
+export declare function createEditorTableRow(cells: EditorTableCellNode[], options?: {
+    isHeader?: boolean;
+}): EditorTableRowNode;
+export declare function createEditorTable(rows: EditorTableRowNode[], gridCols?: number[]): EditorTableNode;
+export declare function createEditorFootnoteId(): string;
+export declare function createEditorFootnote(blocks?: EditorBlockNode[]): EditorFootnote;
+export declare function createFootnoteReferenceRun(footnoteId: string, marker: string, options?: {
+    customMark?: string;
+    styles?: EditorTextStyle;
+}): EditorTextRun;
+export declare const DEFAULT_EDITOR_STYLES: Record<string, EditorNamedStyle>;
+export declare function createEditorDocument(blocks: EditorBlockNode[], pageSettings?: EditorPageSettings, sections?: EditorSection[], styles?: Record<string, EditorNamedStyle>, metadata?: {
+    title?: string;
+    [key: string]: any;
+}, assets?: Record<string, EditorAsset>): EditorDocument;
+export declare function getDocumentCharacterCount(document: EditorDocument): number;
+export declare function getDocumentWordCount(document: EditorDocument): number;
+export declare function createEditorStateFromDocument(document: EditorDocument, selection?: {
+    paragraphIndex?: number;
+    offset?: number;
+}): EditorState;
+export declare function createSectionBoundaryParagraph(zone: "header" | "footer"): EditorParagraphNode;
+export declare function createInitialEditorState(): EditorState;
+export declare function createEditorStateFromTexts(texts: string[], selection?: {
+    anchor?: {
+        blockIndex: number;
+        offset: number;
+    };
+    focus?: {
+        blockIndex: number;
+        offset: number;
+    };
+    blockIndex?: number;
+    offset?: number;
+}): EditorState;
+export declare function createEditorStateFromParagraphRuns(paragraphsSpec: Array<Array<{
+    text: string;
+    styles?: EditorTextStyle;
+    image?: EditorImageRunData;
+}>>, selection?: {
+    anchor?: {
+        blockIndex: number;
+        offset: number;
+    };
+    focus?: {
+        blockIndex: number;
+        offset: number;
+    };
+    blockIndex?: number;
+    offset?: number;
+}): EditorState;

package/dist/core/engine.d.ts

@@ -0,0 +1,13 @@
+import { EditorLayoutLine, EditorLayoutFragment, EditorNamedStyle, EditorParagraphNode } from '../model.js';
+
+export interface TextMeasureOptions {
+    paragraph: EditorParagraphNode;
+    fragments: EditorLayoutFragment[];
+    styles?: Record<string, EditorNamedStyle>;
+    contentWidth?: number;
+    layoutMode?: "fast" | "wordParity";
+}
+export interface ITextMeasurer {
+    composeMeasuredParagraphLines(options: TextMeasureOptions): EditorLayoutLine[];
+    resolveRenderedLineHeightPx(styles: any, lineHeightMultiple: number): number;
+}

package/dist/core/footnotes.d.ts

@@ -0,0 +1,42 @@
+import { EditorBlockNode, EditorDocument, EditorFootnote, EditorFootnoteNumberFormat, EditorFootnotes, EditorParagraphNode, EditorTextRun } from '../model.js';
+
+export declare function resetFootnoteIds(): void;
+export declare function createFootnoteId(): string;
+/**
+ * Iterate every paragraph in document order (sections + footnotes excluded),
+ * yielding each footnote reference run along with the owning paragraph. Order
+ * matches reading order, which is what numbering depends on.
+ */
+export declare function iterateFootnoteReferenceRuns(document: EditorDocument): Generator<{
+    paragraph: EditorParagraphNode;
+    run: EditorTextRun;
+}, void, void>;
+export declare function collectFootnoteReferences(document: EditorDocument): Array<{
+    paragraph: EditorParagraphNode;
+    run: EditorTextRun;
+}>;
+export declare function getFootnoteDisplayMarker(oneBasedIndex: number, format?: EditorFootnoteNumberFormat | undefined): string;
+export declare function getFootnotes(document: EditorDocument): EditorFootnotes | undefined;
+export declare function getFootnoteBlocks(document: EditorDocument, footnoteId: string): EditorBlockNode[];
+export declare function getFootnoteParagraphs(document: EditorDocument, footnoteId: string): EditorParagraphNode[];
+export declare function findFootnoteByParagraphId(document: EditorDocument, paragraphId: string): {
+    footnoteId: string;
+    footnote: EditorFootnote;
+} | null;
+export declare function findFootnoteReference(document: EditorDocument, footnoteId: string): {
+    paragraph: EditorParagraphNode;
+    run: EditorTextRun;
+} | null;
+export interface FootnoteReferenceInfo {
+    footnoteId: string;
+    customMark?: string;
+    index: number;
+}
+export declare function listReferencedFootnotes(document: EditorDocument): FootnoteReferenceInfo[];
+/**
+ * Rewrite the text of footnote reference runs based on document order. Also
+ * removes footnote bodies that no longer have any reference in the document.
+ *
+ * Returns a new document only if anything actually changed.
+ */
+export declare function renumberFootnotes(document: EditorDocument): EditorDocument;

package/dist/core/headings.d.ts

@@ -0,0 +1,9 @@
+import { EditorDocument } from '../model.js';
+
+export interface OutlineItem {
+    id: string;
+    level: number;
+    text: string;
+    anchor: string;
+}
+export declare function outlineFrom(doc: EditorDocument): OutlineItem[];

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

@@ -0,0 +1,8 @@
+import { EditorParagraphNode, EditorPosition } from '../../../model.js';
+
+export declare function getParagraphText(paragraph: EditorParagraphNode): string;
+export declare function getParagraphLength(paragraph: EditorParagraphNode): number;
+export declare function getRunIndex(paragraph: EditorParagraphNode, runId: string): number;
+export declare function getRunStartOffset(paragraph: EditorParagraphNode, runId: string): number;
+export declare function paragraphOffsetToPosition(paragraph: EditorParagraphNode, paragraphOffset: number): EditorPosition;
+export declare function positionToParagraphOffset(paragraph: EditorParagraphNode, position: EditorPosition): number;