oasis-editor 0.0.1 → 0.0.3

package/dist/core/Editor.d.ts

@@ -1,6 +1,7 @@
 import { EditorState, EditorDocument } from '../model.js';
 import { CommandRegistry } from '../commands/CommandRegistry.js';
-import { OasisCommand, OasisEditor, OasisPlugin } from '../plugin.js';
+import { PluginUiRegistry } from '../plugins/PluginUiRegistry.js';
+import { OasisEditor, OasisPlugin } from '../plugin.js';
 
 export interface EditorOptions {
     doc?: EditorDocument;
@@ -16,18 +17,16 @@ export declare class Editor implements OasisEditor {
     private pluginCollection;
     private listeners;
     readonly commands: CommandRegistry;
+    readonly ui: PluginUiRegistry;
     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;
+    private createCommandContext;
 }

package/dist/core/cloneState.d.ts

@@ -1,8 +1,10 @@
-import { EditorBlockNode, EditorFootnote, EditorFootnotes, EditorSection, EditorState } from '../model.js';
+import { EditorBlockNode, EditorEndnote, EditorEndnotes, 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 cloneEndnote(endnote: EditorEndnote): EditorEndnote;
+export declare function cloneEndnotes(endnotes: EditorEndnotes | undefined): EditorEndnotes | undefined;
 export declare function cloneEditorState(source: EditorState): EditorState;

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

@@ -1,10 +1,15 @@
-import { OasisCommand, OasisCommandRegistry } from '../../../plugin.js';
+import { CommandState, OasisCommand, OasisCommandContext, OasisCommandRegistry } from '../../../plugin.js';
 
 export declare class CommandRegistry implements OasisCommandRegistry {
     private commands;
+    private contextProvider;
+    setContextProvider(provider: () => OasisCommandContext): void;
     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;
+    execute<TPayload = unknown, TResult = unknown>(name: string, payload?: TPayload): TResult;
+    canExecute(name: string, payload?: unknown): boolean;
+    state(name: string, payload?: unknown): CommandState;
     clear(): void;
 }

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

@@ -1,5 +1,5 @@
 import { EditorParagraphStyle, EditorPosition, EditorState, EditorSection, EditorTabStop } from '../../../model.js';
-import { ValueParagraphStyleKey } from '../../utils.js';
+import { ValueParagraphStyleKey } from '../../../textStyle/textStyleKeys.js';
 
 export declare function moveBlockToPosition(state: EditorState, blockId: string, targetPosition: EditorPosition): EditorState;
 export declare function splitBlockAtSelection(state: EditorState): EditorState;

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

@@ -0,0 +1,2 @@
+export declare const OASIS_BUILTIN_COMMANDS: readonly ["selectAll", "insertFootnote", "pastePlainText", "bold", "italic", "underline", "strike", "superscript", "subscript", "link", "unlink", "alignLeft", "alignCenter", "alignRight", "alignJustify", "orderedList", "bulletList", "find", "replace", "toggleTrackChanges", "acceptRevisions", "rejectRevisions", "toggleShowMargins", "toggleShowParagraphMarks", "togglePreciseFonts", "undo", "redo", "pageBreak", "lineBreak", "splitBlock", "setFontFamily", "setFontSize", "setColor", "setHighlight", "setTextShading", "setStyleId", "setUnderlineStyle", "documentStyles", "print", "copy", "exportDocx", "exportPdf", "importDocument", "insertImage", "editImageAlt", "outdent", "indent", "togglePageBreakBefore", "toggleKeepWithNext", "setSpacingAfter", "setSpacingBefore", "setIndentLeft", "setIndentRight", "setIndentFirstLine", "setIndentHanging", "setParagraphShading", "applyParagraphBorders", "setLineHeight", "setListFormat", "setListStartAt", "toggleOrientation", "sectionBreakNextPage", "sectionBreakContinuous", "setPageMargins", "tableContext", "tableMerge", "tableSplit", "tableInsertColumnBefore", "tableInsertColumnAfter", "tableDeleteColumn", "tableInsertRowBefore", "tableInsertRowAfter", "tableDeleteRow", "tableCellShading", "tableCellBorders", "tableCellNoBorders", "tableWidth100", "tableAlignLeft", "tableAlignCenter", "tableAlignRight", "tableSetCellWidth", "insertTable"];
+export type OasisBuiltinCommand = (typeof OASIS_BUILTIN_COMMANDS)[number];

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

@@ -0,0 +1,29 @@
+import { EditorImageFloatingLayout } from '../../../model.js';
+
+/**
+ * The text-wrapping presets exposed by the Word-style "Layout Options" popup.
+ * Maps onto the `floating` field of an image/text-box run:
+ * - `inline`       → no `floating` (the object flows in line with text)
+ * - `square`/`tight`/`through`/`topAndBottom` → `floating.wrap` of the same name
+ * - `behind`       → `wrap:"none"`, `behindDoc:true` (behind the text)
+ * - `front`        → `wrap:"none"`, `behindDoc:false` (in front of the text)
+ */
+export type WrapPreset = "inline" | "square" | "tight" | "through" | "topAndBottom" | "behind" | "front";
+/**
+ * Builds the `floating` patch for a given preset, preserving the previous
+ * position/offset/distance settings. Returns `undefined` for `inline`, which
+ * callers should use to delete the `floating` field entirely.
+ */
+export declare function wrapPresetToFloating(prev: EditorImageFloatingLayout | undefined, preset: WrapPreset): EditorImageFloatingLayout | undefined;
+/**
+ * Reflects the current `floating` state back to a preset so the popup can mark
+ * the active option.
+ */
+export declare function floatingToWrapPreset(floating: EditorImageFloatingLayout | undefined): WrapPreset;
+/**
+ * Toggles "Move with text" (anchored to the paragraph) vs "Fix position on
+ * page" (anchored to the page) by patching the vertical anchor's `relativeFrom`.
+ */
+export declare function applyMoveWithText(floating: EditorImageFloatingLayout, fixed: boolean): EditorImageFloatingLayout;
+/** True when the object is pinned to the page rather than moving with text. */
+export declare function isFloatingFixedPosition(floating: EditorImageFloatingLayout | undefined): boolean;

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

@@ -1,15 +1,23 @@
-import { EditorParagraphNode, EditorPosition, EditorState, EditorTextRun, EditorImageRunData } from '../../../model.js';
+import { EditorPosition, EditorState, EditorImageRunData } from '../../../model.js';
+import { SelectedObjectRun } from '../../selectedObjectRun.js';
+import { WrapPreset } from '../../floatingLayout.js';
 
-export interface SelectedImageRun {
-    paragraph: EditorParagraphNode;
-    paragraphIndex: number;
-    run: EditorTextRun;
-    runIndex: number;
-    offset: number;
-}
+export type SelectedImageRun = SelectedObjectRun;
 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 rotateSelectedImage(state: EditorState, rotation: number): EditorState;
+export declare function getSelectedImageWrapPreset(state: EditorState): WrapPreset | null;
+export declare function isSelectedImageFixedPosition(state: EditorState): boolean;
+export declare function setSelectedImageWrapPreset(state: EditorState, preset: WrapPreset): EditorState;
+export declare function setSelectedImageFixedPosition(state: EditorState, fixed: boolean): EditorState;
+/**
+ * Sets the tight/through wrap contour for the image run identified by `runId`.
+ * Matches by run id (not the current selection) because the polygon is traced
+ * asynchronously and applied after the alpha decode resolves. Passing an empty
+ * polygon removes the contour. Selection is preserved.
+ */
+export declare function setImageWrapPolygon(state: EditorState, runId: string, polygon: EditorImageRunData["wrapPolygon"]): 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/list.d.ts

@@ -1,5 +1,5 @@
 import { EditorParagraphListStyle, EditorState } from '../../../model.js';
-import { ParagraphListKind } from '../../utils.js';
+import { ParagraphListKind } from '../../../textStyle/textStyleKeys.js';
 
 export declare function splitListItemAtSelection(state: EditorState): EditorState;
 export declare function clearParagraphListAtSelection(state: EditorState): EditorState;

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

@@ -0,0 +1,110 @@
+import { CommandRef } from '../../CommandRef.js';
+import { EditorPageMargins } from '../../../model.js';
+
+export interface InsertTablePayload {
+    rows: number;
+    columns: number;
+}
+export interface SetFontSizePayload {
+    size: number | string | null;
+}
+export interface SetPageMarginsPayload extends Partial<EditorPageMargins> {
+}
+export interface OasisCommandPayloads {
+    selectAll: undefined;
+    insertFootnote: undefined;
+    pastePlainText: undefined;
+    bold: undefined;
+    italic: undefined;
+    underline: undefined;
+    strike: undefined;
+    superscript: undefined;
+    subscript: undefined;
+    link: string | undefined;
+    unlink: undefined;
+    alignLeft: undefined;
+    alignCenter: undefined;
+    alignRight: undefined;
+    alignJustify: undefined;
+    orderedList: undefined;
+    bulletList: undefined;
+    find: undefined;
+    replace: undefined;
+    toggleTrackChanges: undefined;
+    acceptRevisions: undefined;
+    rejectRevisions: undefined;
+    toggleShowMargins: undefined;
+    toggleShowParagraphMarks: undefined;
+    togglePreciseFonts: undefined;
+    undo: undefined;
+    redo: undefined;
+    pageBreak: undefined;
+    lineBreak: undefined;
+    splitBlock: undefined;
+    setFontFamily: string | null;
+    setFontSize: SetFontSizePayload | number | string | null;
+    setColor: string | null;
+    setHighlight: string | null;
+    setTextShading: string | null;
+    setStyleId: string;
+    setUnderlineStyle: string | null;
+    documentStyles: undefined;
+    print: undefined;
+    copy: undefined;
+    exportDocx: undefined;
+    exportPdf: undefined;
+    importDocument: undefined;
+    insertImage: undefined;
+    editImageAlt: undefined;
+    outdent: undefined;
+    indent: undefined;
+    togglePageBreakBefore: undefined;
+    toggleKeepWithNext: undefined;
+    setSpacingAfter: number | null;
+    setSpacingBefore: number | null;
+    setIndentLeft: number | null;
+    setIndentRight: number | null;
+    setIndentFirstLine: number | null;
+    setIndentHanging: number | null;
+    setParagraphShading: string | null;
+    applyParagraphBorders: undefined;
+    setLineHeight: number | null;
+    setListFormat: string;
+    setListStartAt: number | null;
+    toggleOrientation: undefined;
+    sectionBreakNextPage: undefined;
+    sectionBreakContinuous: undefined;
+    setPageMargins: SetPageMarginsPayload;
+    tableContext: undefined;
+    tableMerge: undefined;
+    tableSplit: undefined;
+    tableInsertColumnBefore: undefined;
+    tableInsertColumnAfter: undefined;
+    tableDeleteColumn: undefined;
+    tableInsertRowBefore: undefined;
+    tableInsertRowAfter: undefined;
+    tableDeleteRow: undefined;
+    tableCellShading: string | null;
+    tableCellBorders: undefined;
+    tableCellNoBorders: undefined;
+    tableWidth100: undefined;
+    tableAlignLeft: undefined;
+    tableAlignCenter: undefined;
+    tableAlignRight: undefined;
+    tableSetCellWidth: string | number;
+    insertTable: InsertTablePayload;
+}
+export interface OasisCommandResults {
+    documentStyles: unknown;
+    [command: string]: unknown;
+}
+export type OasisCommandName = keyof OasisCommandPayloads & string;
+export type CommandPayloadArgs<TCommand extends OasisCommandName> = OasisCommandPayloads[TCommand] extends undefined ? [payload?: undefined] : [payload: OasisCommandPayloads[TCommand]];
+export interface TypedCommandBus<TState> {
+    execute<TCommand extends OasisCommandName>(command: TCommand, ...args: CommandPayloadArgs<TCommand>): TCommand extends keyof OasisCommandResults ? OasisCommandResults[TCommand] : unknown;
+    execute(command: CommandRef, payloadOverride?: unknown): unknown;
+    canExecute<TCommand extends OasisCommandName>(command: TCommand, ...args: CommandPayloadArgs<TCommand>): boolean;
+    canExecute(command: CommandRef, payloadOverride?: unknown): boolean;
+    state<TCommand extends OasisCommandName>(command: TCommand): TState;
+    state(command: CommandRef): TState;
+}

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

@@ -0,0 +1,20 @@
+import { EditorParagraphNode, EditorState, EditorTextRun } from '../../../model.js';
+
+/**
+ * A run holding an inline object (image or text box) that is the sole content
+ * of the current selection.
+ */
+export interface SelectedObjectRun {
+    paragraph: EditorParagraphNode;
+    paragraphIndex: number;
+    run: EditorTextRun;
+    runIndex: number;
+    offset: number;
+}
+/**
+ * Finds the object run currently selected, when the selection is exactly one
+ * object-replacement character wide within a single paragraph. `predicate`
+ * decides which kind of object run qualifies (e.g. `run.image` vs
+ * `run.textBox`). Returns `null` when the selection is not a single object.
+ */
+export declare function getSelectedObjectRun(state: EditorState, predicate: (run: EditorTextRun) => boolean): SelectedObjectRun | null;

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

@@ -0,0 +1,3 @@
+import { EditorState } from '../../../../../model.js';
+
+export declare function insertTableAtSelection(state: EditorState, rows: number, cols: number): EditorState;

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

@@ -0,0 +1,5 @@
+import { EditorBorderStyle, EditorState, EditorTableCellStyle } from '../../../../../model.js';
+
+export declare function setTableCellStyleValue<K extends keyof EditorTableCellStyle>(state: EditorState, key: K, value: EditorTableCellStyle[K] | null): EditorState;
+export declare function setTableCellWidth(state: EditorState, width: number | string | null): EditorState;
+export declare function setTableCellBorders(state: EditorState, border: EditorBorderStyle | null): EditorState;

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

@@ -0,0 +1,3 @@
+import { EditorState } from '../../../../../model.js';
+
+export declare function setTableColumnWidths(state: EditorState, tableId: string, columnWidths: Record<number, number | string>, tableWidth?: number | string, tableIndentLeft?: number | string): EditorState;

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

@@ -0,0 +1,16 @@
+import { EditorBlockNode, EditorDocument, EditorEditingZone, EditorState, EditorTableNode, TableLocation } from '../../../../../model.js';
+
+export type StylePatchValue<T, K extends keyof T> = T[K] | null;
+export interface ActiveTableLocation {
+    activeSectionIndex: number;
+    loc: TableLocation & {
+        zone: EditorEditingZone;
+    };
+}
+export declare function patchStyleValue<T extends object, K extends keyof T>(style: T | undefined, key: K, value: StylePatchValue<T, K>): T | undefined;
+export declare function updateStateSections(state: EditorState, updateBlocks: (blocks: EditorBlockNode[]) => EditorBlockNode[]): EditorState;
+export declare function updateTablesInBlocks(blocks: EditorBlockNode[], updateTable: (table: EditorTableNode) => EditorTableNode): EditorBlockNode[];
+export declare function updateNestedTablesInBlocks(blocks: EditorBlockNode[], updateTable: (table: EditorTableNode) => EditorTableNode): EditorBlockNode[];
+export declare function getBlocksForZone(document: EditorDocument, sectionIndex: number, zone: EditorEditingZone): EditorBlockNode[] | undefined;
+export declare function resolveActiveTableLocation(state: EditorState): ActiveTableLocation | null;
+export declare function updateActiveTableBlocks(state: EditorState, updateTable: (table: EditorTableNode) => EditorTableNode): EditorState;

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

@@ -0,0 +1,5 @@
+import { EditorState, EditorTableRowStyle } from '../../../../../model.js';
+
+export declare function setSelectedTableRowStyleValue<K extends keyof EditorTableRowStyle>(state: EditorState, key: K, value: EditorTableRowStyle[K] | null): EditorState;
+export declare function setSelectedTableRowHeader(state: EditorState, value: boolean | null): EditorState;
+export declare function setTableRowHeight(state: EditorState, tableId: string, rowIndex: number, height: number | string | null): EditorState;

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

@@ -0,0 +1,4 @@
+import { EditorState, EditorTableStyle } from '../../../../../model.js';
+
+export declare function setTableStyleValue<K extends keyof EditorTableStyle>(state: EditorState, key: K, value: EditorTableStyle[K] | null): EditorState;
+export declare function setActiveTableStyleValue<K extends keyof EditorTableStyle>(state: EditorState, tableId: string, key: K, value: EditorTableStyle[K] | null): EditorState;

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

@@ -1,10 +1,5 @@
-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;
+export * from '../../table/tableCellStyleCommands.js';
+export * from '../../table/tableStyleCommands.js';
+export * from '../../table/tableRowCommands.js';
+export * from '../../table/tableColumnCommands.js';
+export * from '../../table/insertTableCommand.js';

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

@@ -1,5 +1,5 @@
 import { EditorPosition, EditorState, EditorTextStyle } from '../../../model.js';
-import { ToggleableTextStyleKey, ValueTextStyleKey } from '../../utils.js';
+import { ToggleableTextStyleKey, ValueTextStyleKey } from '../../../textStyle/textStyleKeys.js';
 
 export declare function moveOrCopySelectionToPosition(state: EditorState, targetPosition: EditorPosition, options?: {
     copy?: boolean;

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

@@ -0,0 +1,21 @@
+import { EditorState } from '../../../model.js';
+import { SelectedObjectRun } from '../../selectedObjectRun.js';
+import { WrapPreset } from '../../floatingLayout.js';
+
+export type SelectedTextBoxRun = SelectedObjectRun;
+export declare function getSelectedTextBoxRun(state: EditorState): SelectedTextBoxRun | null;
+export interface ResizeTextBoxOptions {
+    /**
+     * The handle that was dragged (one of the 8 compass directions). Determines
+     * which edges move: a west/north drag must shift the floating anchor offset so
+     * the opposite (east/south) edge stays fixed, and a height-changing drag
+     * disables auto-fit so the manual height sticks.
+     */
+    handleDirection?: string;
+}
+export declare function rotateSelectedTextBox(state: EditorState, rotation: number): EditorState;
+export declare function getSelectedTextBoxWrapPreset(state: EditorState): WrapPreset | null;
+export declare function isSelectedTextBoxFixedPosition(state: EditorState): boolean;
+export declare function setSelectedTextBoxWrapPreset(state: EditorState, preset: WrapPreset): EditorState;
+export declare function setSelectedTextBoxFixedPosition(state: EditorState, fixed: boolean): EditorState;
+export declare function resizeSelectedTextBox(state: EditorState, width: number, height: number, options?: ResizeTextBoxOptions): EditorState;

package/dist/core/document/blockReplacement.d.ts

@@ -0,0 +1,7 @@
+import { EditorBlockNode, EditorParagraphNode, EditorSection, EditorSelection, EditorState, EditorTableCellNode } from '../../../model.js';
+
+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 updateTableCellsInBlocks(blocks: EditorBlockNode[], selectedParagraphIds: Set<string>, updateCell: (cell: EditorTableCellNode) => EditorTableCellNode): EditorBlockNode[];

package/dist/core/document/bookmarkAnchors.d.ts

@@ -0,0 +1,8 @@
+import { EditorBookmarks, EditorParagraphNode } from '../../../model.js';
+
+/**
+ * Remap every bookmark anchor that lives in `oldParagraphs` to its new position
+ * in `newParagraphs`. Anchors whose paragraph is not part of this zone are left
+ * untouched. Returns the same registry instance when nothing changed.
+ */
+export declare function transformBookmarksAcrossParagraphEdit(bookmarks: EditorBookmarks, oldParagraphs: EditorParagraphNode[], newParagraphs: EditorParagraphNode[]): EditorBookmarks;

package/dist/core/document/clone.d.ts

@@ -0,0 +1,8 @@
+import { EditorBlockNode, EditorParagraphListStyle, EditorParagraphNode, EditorTextBoxData, EditorTextRun } from '../../../model.js';
+
+export declare function cloneTextBox(textBox: EditorTextBoxData): EditorTextBoxData;
+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 cloneParagraphs(paragraphs: EditorParagraphNode[]): EditorParagraphNode[];
+export declare function cloneBlocks(blocks: EditorBlockNode[]): EditorBlockNode[];

package/dist/core/document/paragraphRunBuild.d.ts

@@ -0,0 +1,14 @@
+import { EditorParagraphNode, EditorTextRun, EditorTextStyle } from '../../../model.js';
+
+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;

package/dist/core/document/paragraphRunEdit.d.ts

@@ -0,0 +1,3 @@
+import { EditorParagraphNode, EditorTextRun } from '../../../model.js';
+
+export declare function insertRunsAtOffset(paragraph: EditorParagraphNode, offset: number, textRuns: EditorTextRun[]): EditorParagraphNode;

package/dist/core/document/paragraphRunQuery.d.ts

@@ -0,0 +1,14 @@
+import { EditorParagraphNode, EditorTextRun, EditorTextStyle } from '../../../model.js';
+
+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[];

package/dist/core/document/paragraphRuns.d.ts

@@ -0,0 +1,3 @@
+export { buildParagraphFromRuns, clearParagraphList, cloneParagraphWithListLevel, createParagraphFromRuns, createParagraphFromRunsLike, normalizeRuns, } from '../../paragraphRunBuild.js';
+export { expandLinkRangeInParagraph, getRunAtOffset, getStyleAtOffset, sliceRuns, } from '../../paragraphRunQuery.js';
+export { insertRunsAtOffset } from '../../paragraphRunEdit.js';

package/dist/core/editorCommands.d.ts

@@ -2,6 +2,8 @@
  * @deprecated Use imports from `src/core/commands/*` instead.
  */
 export * from '../commands/image.js';
+export * from '../commands/textBox.js';
+export * from '../commands/floatingLayout.js';
 export * from '../commands/text.js';
 export * from '../commands/block.js';
 export * from '../commands/list.js';

package/dist/core/editorState.d.ts

@@ -1,13 +1,15 @@
-import { EditorAsset, EditorBlockNode, EditorDocument, EditorFootnote, EditorPageSettings, EditorParagraphNode, EditorSection, EditorState, EditorTableCellNode, EditorTableNode, EditorTableRowNode, EditorTextRun, EditorTextStyle, EditorImageRunData, EditorNamedStyle } from '../model.js';
+import { EditorAsset, EditorBlockNode, EditorDocument, EditorFootnote, EditorPageSettings, EditorParagraphNode, EditorSection, EditorState, EditorTableCellNode, EditorTableNode, EditorTableRowNode, EditorTextRun, EditorTextStyle, EditorTextBoxData, EditorImageRunData, EditorNamedStyle } from '../model.js';
 
 export declare function resetEditorIds(): void;
+export declare function createEditorBookmarkId(): string;
 export declare function createEditorRun(text?: string): EditorTextRun;
-export declare function createEditorStyledRun(text?: string, styles?: EditorTextStyle, image?: EditorImageRunData): EditorTextRun;
+export declare function createEditorStyledRun(text?: string, styles?: EditorTextStyle, image?: EditorImageRunData, textBox?: EditorTextBoxData): EditorTextRun;
 export declare function createEditorParagraph(text?: string): EditorParagraphNode;
 export declare function createEditorParagraphFromRuns(runs: Array<{
     text: string;
     styles?: EditorTextStyle;
     image?: EditorImageRunData;
+    textBox?: EditorTextBoxData;
 }>): EditorParagraphNode;
 export declare function createEditorTableCell(paragraphs: EditorParagraphNode[], colSpan?: number, options?: {
     rowSpan?: number;
@@ -26,7 +28,7 @@ export declare function createFootnoteReferenceRun(footnoteId: string, marker: s
 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;
+    [key: string]: unknown;
 }, assets?: Record<string, EditorAsset>): EditorDocument;
 export declare function getDocumentCharacterCount(document: EditorDocument): number;
 export declare function getDocumentWordCount(document: EditorDocument): number;

package/dist/core/endnotes.d.ts

@@ -0,0 +1,41 @@
+import { EditorBlockNode, EditorDocument, EditorEndnote, EditorEndnotes, EditorParagraphNode, EditorTextRun } from '../model.js';
+
+export declare function resetEndnoteIds(): void;
+export declare function createEndnoteId(): string;
+/**
+ * Iterate every paragraph in document order (endnote bodies excluded), yielding
+ * each endnote reference run with its owning paragraph. Order matches reading
+ * order, which is what numbering depends on.
+ */
+export declare function iterateEndnoteReferenceRuns(document: EditorDocument): Generator<{
+    paragraph: EditorParagraphNode;
+    run: EditorTextRun;
+}, void, void>;
+export declare function collectEndnoteReferences(document: EditorDocument): Array<{
+    paragraph: EditorParagraphNode;
+    run: EditorTextRun;
+}>;
+export declare function getEndnotes(document: EditorDocument): EditorEndnotes | undefined;
+export declare function getEndnoteBlocks(document: EditorDocument, endnoteId: string): EditorBlockNode[];
+export declare function getEndnoteParagraphs(document: EditorDocument, endnoteId: string): EditorParagraphNode[];
+export declare function findEndnoteByParagraphId(document: EditorDocument, paragraphId: string): {
+    endnoteId: string;
+    endnote: EditorEndnote;
+} | null;
+export declare function findEndnoteReference(document: EditorDocument, endnoteId: string): {
+    paragraph: EditorParagraphNode;
+    run: EditorTextRun;
+} | null;
+export interface EndnoteReferenceInfo {
+    endnoteId: string;
+    customMark?: string;
+    index: number;
+}
+export declare function listReferencedEndnotes(document: EditorDocument): EndnoteReferenceInfo[];
+/**
+ * Rewrite the text of endnote reference runs based on document order. Also
+ * removes endnote bodies that no longer have any reference in the document.
+ *
+ * Returns a new document only if anything actually changed.
+ */
+export declare function renumberEndnotes(document: EditorDocument): EditorDocument;

package/dist/core/engine.d.ts

@@ -1,13 +1,28 @@
-import { EditorLayoutLine, EditorLayoutFragment, EditorNamedStyle, EditorParagraphNode } from '../model.js';
+import { EditorLayoutLine, EditorLayoutFragment, EditorNamedStyle, EditorParagraphNode, EditorTextStyle } from '../model.js';
 
+export interface FloatingExclusionRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    wrap: "none" | "square" | "tight" | "through" | "topAndBottom";
+    sourceRunId: string;
+    /** Absolute-layout-coordinate tight/through contour. When present, the
+     * composer carves per-line intervals from this outline instead of the rect. */
+    polygon?: Array<{
+        x: number;
+        y: number;
+    }>;
+}
 export interface TextMeasureOptions {
     paragraph: EditorParagraphNode;
     fragments: EditorLayoutFragment[];
     styles?: Record<string, EditorNamedStyle>;
     contentWidth?: number;
-    layoutMode?: "fast" | "wordParity";
+    defaultTabStop?: number;
+    exclusions?: FloatingExclusionRect[];
 }
 export interface ITextMeasurer {
     composeMeasuredParagraphLines(options: TextMeasureOptions): EditorLayoutLine[];
-    resolveRenderedLineHeightPx(styles: any, lineHeightMultiple: number): number;
+    resolveRenderedLineHeightPx(styles: EditorTextStyle | undefined, lineHeightMultiple: number): number;
 }

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

@@ -0,0 +1,17 @@
+import { EditorParagraphListStyle, EditorTextRun, EditorTextStyle } from '../../../model.js';
+
+/**
+ * Recursively collects inline runs from a DOM node, propagating inherited text
+ * styles down the tree. Shared between the clipboard paste parser and the HTML
+ * document importer so both treat inline formatting identically.
+ *
+ * - Text nodes become styled runs.
+ * - `<br>` becomes a newline run.
+ * - `<img>` becomes an object-replacement run carrying the parsed image data.
+ * - Any other element merges its inline styles and recurses into its children.
+ */
+export declare function collectInlineRuns(node: Node, inheritedStyle: EditorTextStyle | undefined): EditorTextRun[];
+/** Tags that map to a single editor paragraph. */
+export declare function isParagraphTag(tagName: string): boolean;
+/** Returns the list kind for `<ul>`/`<ol>`, or `null` for other tags. */
+export declare function listKindForTag(tagName: string): EditorParagraphListStyle["kind"] | null;

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

@@ -0,0 +1 @@
+export declare function escapeHtml(text: string): string;

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

@@ -0,0 +1,3 @@
+export { parseInlineImage } from '../../inlineImageParser.js';
+export { parseInlineStyles } from '../../inlineStyleParser.js';
+export { parseParagraphStyle } from '../../paragraphStyleParser.js';

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

@@ -0,0 +1,5 @@
+import { EditorDocument, EditorTextRun } from '../../../model.js';
+
+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;