@mrakomor/core 0.0.11 → 0.0.13

package/dist/types/component/AbstractComponent.d.mts

@@ -0,0 +1,69 @@
+export class AbstractComponent extends Component {
+    static get NAMESPACE(): string;
+    static getStateSchema(): import("@esmj/schema").SchemaInterface<{
+        component: string;
+        properties: {
+            [x: string]: unknown;
+        };
+        settings: {
+            [x: string]: unknown;
+        };
+    }, {
+        component: string;
+        properties: {
+            [x: string]: unknown;
+        };
+        settings: {
+            [x: string]: unknown;
+        };
+    }>;
+    static getPropsSchema(): import("@esmj/schema").SchemaInterface<{
+        state: {
+            component: string;
+            properties: {
+                [x: string]: unknown;
+            };
+            settings: {
+                [x: string]: unknown;
+            };
+        };
+        observeDOMChanges: boolean;
+    }, {
+        state: {
+            component: string;
+            properties: {
+                [x: string]: unknown;
+            };
+            settings: {
+                [x: string]: unknown;
+            };
+        };
+        observeDOMChanges: boolean;
+    }>;
+    constructor(props: any);
+    /** @type {import('#src/types.mjs').Signal<import('#src/types.mjs').BlockState>} */
+    state: import("#src/types.mjs").Signal<import("#src/types.mjs").BlockState>;
+    /** @type {Element | null} */
+    element: Element | null;
+    /** @type {import('#src/types.mjs').Mrakomor} */
+    mrakomor: import("#src/types.mjs").Mrakomor;
+    _stale: boolean;
+    _observer: MutationObserver | null;
+    /** @type {(() => void) | null} */
+    _offInputStale: (() => void) | null;
+    /** @type {((event: import('#src/types.mjs').EmitterEvent) => void) | null} */
+    _onInputMarkStale: ((event: import("#src/types.mjs").EmitterEvent) => void) | null;
+    _observeDOMChanges: any;
+    parseFromHTML(node: any): any;
+    getState(): any;
+    /**
+     * Whether live DOM may differ from the item signal (`getState()` parses until re-render).
+     * @returns {boolean}
+     */
+    isStale(): boolean;
+    onMount(): void;
+    onUnmount(): void;
+    #private;
+}
+export { AbstractComponent as SAbstractComponent };
+import { Component } from '@esmj/dom';

package/dist/types/component/Editor.d.mts

@@ -0,0 +1,8 @@
+/**
+ * Editor shell: tools overlay + keyed block list (`Each` by `componentId`).
+ * @param {{ mrakomor: import('#src/types.mjs').Signal<import('#src/types.mjs').Mrakomor> }} props
+ * @returns {*}
+ */
+export function Editor({ mrakomor: mrakomorSignal }: {
+    mrakomor: import("#src/types.mjs").Signal<import("#src/types.mjs").Mrakomor>;
+}): any;

package/dist/types/component/block/BlockComponent.d.mts

@@ -0,0 +1,105 @@
+/**
+ * Base class for content blocks (paragraph, headline, list, figure, …).
+ * Subclasses override `onKeydown` for block-owned keys and may override
+ * `setCursor` / `isAtomic` for neighbor Backspace behavior.
+ */
+export class BlockComponent extends AbstractComponent {
+    /**
+     * Visual label for insert menus / tooltip toolbar (string or renderable).
+     * @returns {string | Function}
+     */
+    static get LABEL(): string | Function;
+    /**
+     * Extra slash-filter tokens (label and namespace leaf are added when empty).
+     * @returns {string[]}
+     */
+    static get KEYWORDS(): string[];
+    /**
+     * Menu group for insert / slash menus (`register` row `group`).
+     * @returns {string}
+     */
+    static get GROUP(): string;
+    /**
+     * Convert this block type's own state into the generic cross-component
+     * exchange shape: `properties.items` with exactly one entry (this block
+     * type has no per-item DOM identity). Records this block type's own
+     * `NAMESPACE` as `originComponent` for provenance (authoritative — not
+     * read from `state.component`, which a caller could omit or get wrong).
+     * Normalizes the item's text via `normalizeBlockText` so the empty-
+     * contenteditable `'\n'`/`'\r\n'` DOM sentinel never leaks into the
+     * exchange state as a fake 1-character text. `inlineStyleRanges`/
+     * `entityRanges` are included on the item ONLY when the real
+     * `state.properties` actually has that key — never fabricated to `[]` —
+     * so generic callers (`resolveActiveExchangeItem`/insert-range handlers)
+     * can tell "supports this range kind" (key present, even if empty) apart
+     * from "doesn't support it at all" (key absent), e.g. a plain Headline
+     * has neither key, `TtsHeadline` has `entityRanges` only. Override for
+     * blocks whose properties should not leak into the exchange state (e.g.
+     * atomic blocks), or that have more than one item (e.g. List).
+     * @param {import('#src/types.mjs').BlockState} state
+     * @returns {import('#src/types.mjs').ExchangeBlockState}
+     */
+    static toExchangeState(state: import("#src/types.mjs").BlockState): import("#src/types.mjs").ExchangeBlockState;
+    /**
+     * Convert a generic cross-component exchange state into this block type's
+     * own `properties`/`settings` fragment: unwraps `properties.items[0]` back
+     * into a flat `{ text, inlineStyleRanges, entityRanges }` (this block type
+     * has no per-item identity, so any additional incoming items are dropped —
+     * matches `unwrapListItem`'s per-item transform semantics, transform
+     * always targets ONE item). Override to reshape it (e.g. List wraps every
+     * item into its own row). Callers always finish with
+     * `Constructor.getStateSchema().parse(...)` for final validation/defaults.
+     * @param {import('#src/types.mjs').ExchangeBlockState} exchangeState
+     * @returns {import('#src/types.mjs').BlockStateInput}
+     */
+    static fromExchangeState(exchangeState: import("#src/types.mjs").ExchangeBlockState): import("#src/types.mjs").BlockStateInput;
+    /**
+     * Append an incoming exchange state onto this block's own state (Backspace
+     * merge join, previous block keeps its own type). Default text-concats via
+     * `deepMergeBlockState`, which keeps `state`'s own `component`/`componentId`
+     * and merges `properties`/`settings`. The incoming exchange state's items
+     * are joined into one flat item first (`joinExchangeItems`, `'\n'` between
+     * items) since this block type can only hold flat text — matters when the
+     * removed block is multi-item (e.g. a List being merged into a preceding
+     * Paragraph). Override to reshape the join (e.g. List appends the incoming
+     * text as a new item) or return `null` to opt out of merging entirely
+     * (e.g. atomic external blocks — see `ExternalComponent.appendExchangeState`).
+     * @param {import('#src/types.mjs').BlockState} state
+     * @param {import('#src/types.mjs').ExchangeBlockState} exchangeState
+     * @returns {{ state: import('#src/types.mjs').BlockState, cursor: number } | null}
+     */
+    static appendExchangeState(state: import("#src/types.mjs").BlockState, exchangeState: import("#src/types.mjs").ExchangeBlockState): {
+        state: import("#src/types.mjs").BlockState;
+        cursor: number;
+    } | null;
+    /**
+     * Whether Backspace on an empty neighbor should remove this block.
+     * Non-atomic blocks receive the cursor via `setCursor` instead.
+     * @returns {boolean}
+     */
+    isAtomic(): boolean;
+    /**
+     * Place the cursor in this block’s selectable root.
+     * Omitting `cursor` places it at the end of `properties.text`.
+     * Restores immediately and again in `afterRender`.
+     * @param {{ cursor?: number, itemIndex?: number }} [options] `itemIndex`
+     *   targets a specific item for multi-item blocks (e.g. `List.setCursor`);
+     *   this flat/single-item base has only one item, so it accepts
+     *   `itemIndex` for a consistent cross-block `setCursor` contract (generic
+     *   callers like `restoreCaretAfterMerge` forward it blindly) but ignores it.
+     * @returns {void}
+     */
+    setCursor({ cursor }?: {
+        cursor?: number;
+        itemIndex?: number;
+    }): void;
+    /**
+     * Handle keydown while this block is focused. Override in subclasses.
+     * Call `event.preventDefault()` when the block owns the key so default
+     * Backspace merge / insert is skipped (`unlessPrevented`).
+     * @param {import('#src/types.mjs').KeydownEvent} event
+     * @returns {void}
+     */
+    onKeydown(_event: any): void;
+}
+import { AbstractComponent } from '../AbstractComponent.mjs';

package/dist/types/component/block/BlockRegister.d.mts

@@ -0,0 +1,29 @@
+/**
+ * Block insert/slash register with namespace → constructor lookup.
+ */
+export class BlockRegister extends Register {
+    /**
+     * NAMESPACE → Constructor from block register rows (first registration wins).
+     * @param {import('#src/types.mjs').BlockComponentRegistration[]} registrations
+     * @returns {Map<string, import('#src/types.mjs').BlockConstructor>}
+     */
+    static buildNamespaceMap(registrations: import("#src/types.mjs").BlockComponentRegistration[]): Map<string, import("#src/types.mjs").BlockConstructor>;
+    /**
+     * @param {import('#src/types.mjs').Mrakomor} mrakomor
+     */
+    constructor(mrakomor: import("#src/types.mjs").Mrakomor);
+    /**
+     * @param {*} raw
+     * @param {number} index
+     * @returns {import('#src/types.mjs').BlockComponentRegistration | null}
+     */
+    normalize(raw: any, index: number): import("#src/types.mjs").BlockComponentRegistration | null;
+    /**
+     * Resolve block component by dotted namespace (first register row wins).
+     * @param {string} namespace
+     * @returns {import('#src/types.mjs').BlockConstructor | undefined}
+     */
+    getByNamespace(namespace: string): import("#src/types.mjs").BlockConstructor | undefined;
+    #private;
+}
+import Register from '#src/register/Register.mjs';

package/dist/types/component/block/ExternalComponent.d.mts

@@ -0,0 +1,42 @@
+/**
+ * Non-text embed block (CMS external widget). Hosts opaque content in
+ * `this.root` and a thin contenteditable strip so the block can take focus.
+ * Atomic: empty neighbor Backspace removes this block.
+ */
+export class ExternalComponent extends BlockComponent {
+    /**
+     * Schema for external block state (`component`, `componentId`, empty props/settings).
+     * @param {Element | null | undefined} node
+     * @returns {*}
+     */
+    static getStateSchema(node: Element | null | undefined): any;
+    /**
+     * Atomic blocks never merge with a neighbor (Backspace removes them via
+     * `isAtomic` instead of appending text into them).
+     * @returns {null}
+     */
+    static appendExchangeState(): null;
+    /**
+     * @param {object} props
+     */
+    constructor(props: object);
+    /** @type {Element | null} host for embed content */
+    root: Element | null;
+    /**
+     * Current signal value (external blocks do not re-parse from DOM).
+     * @returns {import('#src/types.mjs').BlockState}
+     */
+    getState(): import("#src/types.mjs").BlockState;
+    /**
+     * Opaque container plus a focusable strip for selection / Enter.
+     * @returns {*}
+     */
+    render(): any;
+    /**
+     * Suppress most typing; Enter inserts an empty paragraph below.
+     * @param {import('#src/types.mjs').KeydownEvent} event
+     * @returns {void}
+     */
+    onKeydown(event: import("#src/types.mjs").KeydownEvent): void;
+}
+import { BlockComponent } from './BlockComponent.mjs';

package/dist/types/component/block/UnknownComponent.d.mts

@@ -0,0 +1,3 @@
+export class UnknownComponent extends ExternalComponent {
+}
+import { ExternalComponent } from './ExternalComponent.mjs';

package/dist/types/component/block/blockItemEquals.d.mts

@@ -0,0 +1,6 @@
+/**
+ * `Each` item equals for `#content` blocks: `deepEqual`, unless the live instance is stale.
+ * @param {import('#src/types.mjs').Mrakomor} mrakomor
+ * @returns {(prev: import('#src/types.mjs').BlockState, next: import('#src/types.mjs').BlockState) => boolean}
+ */
+export function createBlockItemEquals(mrakomor: import("#src/types.mjs").Mrakomor): (prev: import("#src/types.mjs").BlockState, next: import("#src/types.mjs").BlockState) => boolean;

package/dist/types/component/block/helpers.d.mts

@@ -0,0 +1,319 @@
+/**
+ * @typedef {import('#src/types.mjs').BlockState} BlockState
+ * @typedef {import('#src/types.mjs').RichTextState} RichTextState
+ * @typedef {import('#src/types.mjs').InlineStyleRange} InlineStyleRange
+ * @typedef {import('#src/types.mjs').EntityRange} EntityRange
+ * @typedef {import('#src/types.mjs').RichTextComponents} RichTextComponents
+ * @typedef {import('#src/types.mjs').SplitBlockResult} SplitBlockResult
+ * @typedef {import('#src/types.mjs').ContentMutation} ContentMutation
+ * @typedef {import('#src/types.mjs').ClipboardSelection} ClipboardSelection
+ * @typedef {import('#src/types.mjs').RichTextBlockInstance} RichTextBlockInstance
+ * @typedef {import('#src/types.mjs').RangeMeta} RangeMeta
+ */
+/**
+ * Empty contenteditable often serializes as a lone newline; treat that as `''`.
+ * @param {string | null | undefined} text
+ * @returns {string}
+ */
+export function normalizeBlockText(text: string | null | undefined): string;
+/**
+ * Build a generic cross-component exchange state (see
+ * `BlockComponent.toExchangeState` / `fromExchangeState`). The only
+ * text-shaped field is `properties.items` — always an array. Pass
+ * `properties.items` directly to preserve it as-is (real multi-item
+ * producers like `List.toExchangeState`, including an intentionally empty
+ * array); otherwise (`items` absent) `properties.text`/`inlineStyleRanges`/
+ * `entityRanges` (or their absence) are wrapped into a single-item array —
+ * this is the convenience path most callers use to build a flat exchange
+ * state. `component`/`originComponent` record the target/source namespace.
+ * @param {Partial<import('#src/types.mjs').ExchangeBlockState> & { properties?: { items?: import('#src/types.mjs').ExchangeItem[] } & Record<string, *> }} [overrides]
+ * @returns {import('#src/types.mjs').ExchangeBlockState}
+ */
+export function createExchangeState({ component, originComponent, properties, settings, }?: Partial<import("#src/types.mjs").ExchangeBlockState> & {
+    properties?: {
+        items?: import("#src/types.mjs").ExchangeItem[];
+    } & Record<string, any>;
+}): import("#src/types.mjs").ExchangeBlockState;
+/**
+ * Collapse multiple exchange items into one flat text-shaped item:
+ * concatenates each item's text (`'\n'` between items) and shifts each
+ * item's inline/entity ranges by the joined text's length so far. Used by
+ * `BlockComponent`'s default `appendExchangeState` to merge a possibly
+ * multi-item incoming exchange state (e.g. a List being merged into a flat
+ * text block) down to the single flat shape a text block can hold. A
+ * single-item input (the common case — merging two flat blocks) passes
+ * through unchanged (no separator, no shift).
+ * @param {import('#src/types.mjs').ExchangeItem[] | null | undefined} items
+ * @returns {{ text: string, inlineStyleRanges: InlineStyleRange[], entityRanges: EntityRange[] }}
+ */
+export function joinExchangeItems(items: import("#src/types.mjs").ExchangeItem[] | null | undefined): {
+    text: string;
+    inlineStyleRanges: InlineStyleRange[];
+    entityRanges: EntityRange[];
+};
+/**
+ * Wrap a single item's `text`/`inlineStyleRanges`/`entityRanges` (e.g. one
+ * List row) as the flat rich-text shape accepted by
+ * `splitStateByCursor`/`deepMergeBlockState`'s per-item helpers. Distinct
+ * from `createExchangeState`, which builds a full `properties.items[]`
+ * `ExchangeBlockState` — this is the single-item building block used to
+ * construct one entry of that array, or to feed the flat-shape line-split
+ * helpers with one item's data (e.g. splitting one list item at the caret).
+ * @param {Partial<import('#src/types.mjs').ExchangeItem> | null | undefined} item
+ * @returns {RichTextState}
+ */
+export function wrapExchangeItem(item: Partial<import("#src/types.mjs").ExchangeItem> | null | undefined): RichTextState;
+/**
+ * Write a patched item's ranges back into a block's own persisted state by
+ * round-tripping through its own `toExchangeState`/`fromExchangeState` pair
+ * (same-type, in-place patch — NOT a cross-type conversion). Shared by the
+ * generic INSERT_INLINE_STYLE_RANGE/INSERT_ENTITY_RANGE handlers so every
+ * block type (flat text blocks and List) writes through one path instead of
+ * each implementing its own mutation. Relies on `Constructor.toExchangeState`
+ * including a stable per-item `componentId` for blocks with per-item DOM
+ * identity (e.g. List's `<li>`s), so `fromExchangeState` doesn't mint fresh
+ * ids on every keystroke. Returns `state` unchanged when `itemIndex` is out
+ * of range.
+ * @param {import('#src/types.mjs').BlockConstructor} Constructor
+ * @param {import('#src/types.mjs').BlockState} state
+ * @param {number} itemIndex
+ * @param {Partial<import('#src/types.mjs').ExchangeItem>} patch
+ * @returns {import('#src/types.mjs').BlockState}
+ */
+export function patchBlockExchangeItem(Constructor: import("#src/types.mjs").BlockConstructor, state: import("#src/types.mjs").BlockState, itemIndex: number, patch: Partial<import("#src/types.mjs").ExchangeItem>): import("#src/types.mjs").BlockState;
+/**
+ * Resolve the active exchange item (and its element/index/Constructor) for
+ * the block at `blockElement`/`range`, via the generic `toExchangeState` +
+ * `getSelectableItemForRange` contract. Works for ANY block type without a
+ * block-specific special case: a flat text block (Paragraph/Headline)
+ * always resolves item 0; a List resolves the active `<li>`'s own index.
+ * Falls back to item 0 when `range` doesn't resolve to a marked item at all
+ * (e.g. a stale/lost selection) — a best-effort default appropriate for
+ * single-item flat blocks; List's own key handlers use
+ * `getSelectableItemForRange` directly instead and bail (no-op) on the same
+ * failure, since guessing item 0 there would silently apply an action to
+ * the wrong `<li>`. Shared by the default plugin's insert-range/
+ * formatting-query handlers AND `Tooltip` (called directly, not through an
+ * emitter round trip — this is a pure read/compute with no plugin ever
+ * needing to intercept it; a block that needs different resolution
+ * overrides `toExchangeState` instead, the existing per-block extension
+ * point). See `patchBlockExchangeItem` for the matching write-back half of
+ * this contract.
+ * @param {import('#src/types.mjs').Mrakomor} mrakomor
+ * @param {Element} blockElement
+ * @param {Range | null} range
+ * @returns {{ Constructor: import('#src/types.mjs').BlockConstructor, current: import('#src/types.mjs').BlockState, element: Element, itemIndex: number, item: import('#src/types.mjs').ExchangeItem } | null}
+ */
+export function resolveActiveExchangeItem(mrakomor: import("#src/types.mjs").Mrakomor, blockElement: Element, range: Range | null): {
+    Constructor: import("#src/types.mjs").BlockConstructor;
+    current: import("#src/types.mjs").BlockState;
+    element: Element;
+    itemIndex: number;
+    item: import("#src/types.mjs").ExchangeItem;
+} | null;
+/**
+ * Restore caret after a block merge (`afterRender` is a macrotask). Goes
+ * through the block instance's own `setCursor` (e.g. `List.setCursor`
+ * targets a specific `<li>`) instead of `getBlockContentRoot` +
+ * `setCursorPosition` directly — a multi-item block's content root (e.g.
+ * List's `<ul>/<ol>`) counts characters from the START of the whole
+ * concatenated text, landing in the wrong item otherwise. Shared by
+ * `defaultMrakomorPlugin`'s `onMergeBlockElement` and the list plugin's own
+ * adjacent-list re-merge Backspace handler.
+ * @param {{
+ *   mrakomor: import('#src/types.mjs').Mrakomor,
+ *   resultIndex: number,
+ *   cursor?: number,
+ *   fallbackBlockElement?: Element | null,
+ *   itemIndex?: number,
+ * }} options `resultIndex` indexes the merged block in the (already
+ *   committed) content array; `cursor` is the caret offset in the merged
+ *   block at the join; `fallbackBlockElement` is used before `afterRender`
+ *   has synced `#blockElements`, or if `resultIndex` cannot resolve one;
+ *   `itemIndex` is for multi-item blocks (e.g. List) — the index of the
+ *   item the join landed in, passed through as `setCursor`'s `itemIndex`
+ *   field (part of `BlockComponent.setCursor`'s shared contract, ignored by
+ *   single-item blocks) so a merge that also appended items after the
+ *   joined one still targets the right item instead of the block's
+ *   default (e.g. last item)
+ * @returns {void}
+ */
+export function restoreCaretAfterMerge({ mrakomor, resultIndex, cursor, fallbackBlockElement, itemIndex, }: {
+    mrakomor: import("#src/types.mjs").Mrakomor;
+    resultIndex: number;
+    cursor?: number;
+    fallbackBlockElement?: Element | null;
+    itemIndex?: number;
+}): void;
+/**
+ * Paragraph or headline — blocks with `properties.text`.
+ * @param {BlockState} state
+ * @returns {boolean}
+ */
+export function isTextBlock(state: BlockState): boolean;
+/**
+ * List block — `properties.items` is an array.
+ * @param {BlockState} state
+ * @returns {boolean}
+ */
+export function isListBlock(state: BlockState): boolean;
+/**
+ * Two text blocks of the same component can merge on paste/delete.
+ * @param {BlockState} left
+ * @param {BlockState} right
+ * @returns {boolean}
+ */
+export function canMergeBlocks(left: BlockState, right: BlockState): boolean;
+/**
+ * Nested vDOM for one text segment with all active inline styles and entity
+ * ranges applied (entity wraps inline).
+ *
+ * @param {string} substring
+ * @param {InlineStyleRange[]} inlineRanges
+ * @param {EntityRange[]} entityRanges
+ * @param {RichTextComponents} components
+ * @returns {string | Node | object}
+ */
+export function buildRichTextSegment(substring: string, inlineRanges: InlineStyleRange[], entityRanges: EntityRange[], { inlineStyleComponents, entityRangeComponents }: RichTextComponents): string | Node | object;
+/**
+ * Render paragraph rich text without duplicating overlapping ranges.
+ *
+ * @param {RichTextState} state block state with `properties.text` / ranges
+ * @param {RichTextComponents} components
+ * @returns {DocumentFragment}
+ */
+export function buildRichTextFragment(state: RichTextState, { inlineStyleComponents, entityRangeComponents }: RichTextComponents): DocumentFragment;
+/**
+ * Walk block child nodes and collect inline/entity ranges with correct offsets.
+ * Recurses into matched inline/entity elements so nested markup round-trips.
+ *
+ * @param {NodeList | Node[]} childNodes
+ * @param {RichTextState} state mutated; ranges are pushed onto `properties`
+ * @param {number} offset starting character index
+ * @param {RichTextComponents} components
+ * @returns {number} character index after the last consumed node
+ */
+export function parseRichTextChildNodes(childNodes: NodeList | Node[], state: RichTextState, offset: number, { inlineStyleComponents, entityRangeComponents }: RichTextComponents): number;
+/**
+ * Concatenate two text-block states: `original` text then `newData` text,
+ * shifting `newData` ranges by the original length.
+ *
+ * @param {RichTextState} original
+ * @param {RichTextState} newData
+ * @returns {{ state: RichTextState, cursor: number }} merged state and caret at the join
+ */
+export function deepMergeBlockState(original: RichTextState, newData: RichTextState): {
+    state: RichTextState;
+    cursor: number;
+};
+/**
+ * Trim selection across blocks and merge remnants into one block.
+ * Keeps the start block's identity; removes indexes startIndex..endIndex.
+ *
+ * @param {BlockState[]} content
+ * @param {ClipboardSelection} selection
+ * @returns {ContentMutation}
+ */
+export function mergeBlocksAcrossSelection(content: BlockState[], { startIndex, endIndex, startOffset, endOffset }: ClipboardSelection): ContentMutation;
+/**
+ * Split a text block at `cursor`: before keeps the original `componentId`,
+ * after gets a new one. Inline and entity ranges are clipped/shifted.
+ *
+ * @param {RichTextState} state
+ * @param {number} cursor
+ * @returns {SplitBlockResult}
+ */
+export function splitStateByCursor(state: RichTextState, cursor: number): SplitBlockResult;
+/**
+ * Split a text block at the caret and insert the remainder as a new block.
+ * Used by Paragraph and Headline on Enter — not a BlockComponent protocol.
+ *
+ * @param {RichTextBlockInstance} block
+ * @param {import('#src/types.mjs').KeydownEvent} event
+ * @param {{ namespace?: string }} [options]
+ * @returns {boolean} whether Enter was handled
+ */
+export function splitAtCursorAndInsert(block: RichTextBlockInstance, event: import("#src/types.mjs").KeydownEvent, { namespace }?: {
+    namespace?: string;
+}): boolean;
+/**
+ * Insert an empty paragraph below the current selection (non-splitting blocks).
+ * @param {{ mrakomor: import('#src/types.mjs').Mrakomor }} block
+ * @param {import('#src/types.mjs').KeydownEvent} event
+ * @returns {boolean} whether Enter was handled
+ */
+export function insertEmptyParagraphBelow(block: {
+    mrakomor: import("#src/types.mjs").Mrakomor;
+}, event: import("#src/types.mjs").KeydownEvent): boolean;
+/**
+ * Parse a rich-text block from DOM: schema defaults plus inline/entity ranges
+ * from child nodes.
+ *
+ * @param {RichTextBlockInstance} block
+ * @param {Element | null | undefined} node
+ * @returns {RichTextState}
+ */
+export function parseRichTextBlock(block: RichTextBlockInstance, node: Element | null | undefined): RichTextState;
+/**
+ * Computes text-range metadata (`offset` and `length`) for a DOM `Range`
+ * relative to the concatenated text content of a root element.
+ *
+ * @function getEntityRangeMeta
+ * @param {Element} element - Root element used as the text traversal boundary.
+ * @param {Range} range - DOM Range whose start position is used to compute the offset.
+ * @returns {RangeMeta} Range metadata:
+ * - `offset`: zero-based character index from the start of `element` text content to `range.startContainer + range.startOffset`
+ * - `length`: selected character count (`range.endOffset - range.startOffset`)
+ *
+ */
+export function getEntityRangeMeta(element: Element, range: Range): RangeMeta;
+/**
+ * Toggle an inline style over a selection: remove a covering same-style range,
+ * otherwise append a new range.
+ * @param {InlineStyleRange[]} ranges
+ * @param {InlineStyleRange} next
+ * @returns {InlineStyleRange[]}
+ */
+export function toggleInlineStyleRange(ranges: InlineStyleRange[], { style, offset, length }: InlineStyleRange): InlineStyleRange[];
+/**
+ * Toggle or apply an entity range exclusively: exact same-span+same-type removes
+ * that range; otherwise carve overlapping ranges then append. Adjacent spans are
+ * allowed. Returns `null` when length is 0.
+ * @param {EntityRange[]} ranges
+ * @param {EntityRange} entityRangeState
+ * @returns {EntityRange[] | null}
+ */
+export function toggleEntityRange(ranges: EntityRange[], entityRangeState: EntityRange): EntityRange[] | null;
+/**
+ * Toggle an inline style range for a selection against `element`. Returns the
+ * next `inlineStyleRanges` array, or `null` when the selection is collapsed.
+ * @param {InlineStyleRange[] | undefined} ranges
+ * @param {Element} element - root used to compute the range's text offset/length
+ * @param {Range} range
+ * @param {string} style
+ * @returns {InlineStyleRange[] | null}
+ */
+export function applyInlineStyleRange(ranges: InlineStyleRange[] | undefined, element: Element, range: Range, style: string): InlineStyleRange[] | null;
+/**
+ * Toggle an entity range for a selection against `element`. Returns the next
+ * `entityRanges` array, or `null` when the selection is collapsed.
+ * @param {EntityRange[] | undefined} ranges
+ * @param {Element} element - root used to compute the range's text offset/length
+ * @param {Range} range
+ * @param {{ namespace: string, entityData?: object }} options
+ * @returns {EntityRange[] | null}
+ */
+export function applyEntityRange(ranges: EntityRange[] | undefined, element: Element, range: Range, { namespace, entityData }: {
+    namespace: string;
+    entityData?: object;
+}): EntityRange[] | null;
+export type BlockState = import("#src/types.mjs").BlockState;
+export type RichTextState = import("#src/types.mjs").RichTextState;
+export type InlineStyleRange = import("#src/types.mjs").InlineStyleRange;
+export type EntityRange = import("#src/types.mjs").EntityRange;
+export type RichTextComponents = import("#src/types.mjs").RichTextComponents;
+export type SplitBlockResult = import("#src/types.mjs").SplitBlockResult;
+export type ContentMutation = import("#src/types.mjs").ContentMutation;
+export type ClipboardSelection = import("#src/types.mjs").ClipboardSelection;
+export type RichTextBlockInstance = import("#src/types.mjs").RichTextBlockInstance;
+export type RangeMeta = import("#src/types.mjs").RangeMeta;

package/dist/types/component/editorContext.d.mts

@@ -0,0 +1,4 @@
+export const EditorContext: {
+    id: symbol;
+    defaultValue: any;
+};

package/dist/types/component/entityRange/EntityRangeElement.d.mts

@@ -0,0 +1,15 @@
+export class EntityRangeElement extends Component {
+    static get nodeName(): string;
+    static get NAMESPACE(): string;
+    static match(node: any): boolean;
+    static getStateSchema(_node: any): import("@esmj/schema").SchemaInterface<unknown, unknown>;
+    constructor(props: any);
+    mrakomor: any;
+    element: {
+        get: () => null;
+        set: (element: any) => null;
+        [Symbol.toPrimitive](): string;
+    };
+    render(): any;
+}
+import { Component } from '@esmj/dom';

package/dist/types/component/inlineStyle/Bold.d.mts

@@ -0,0 +1,4 @@
+export class Bold extends InlineElement {
+    static get LABEL(): any;
+}
+import { InlineElement } from './InlineElement.mjs';

package/dist/types/component/inlineStyle/InlineElement.d.mts

@@ -0,0 +1,10 @@
+export class InlineElement extends Component {
+    static get nodeName(): string;
+    static get style(): string;
+    static match(node: any): boolean;
+    getState(): {
+        style: any;
+    };
+    render(): any;
+}
+import { Component } from '@esmj/dom';

package/dist/types/component/inlineStyle/Italic.d.mts

@@ -0,0 +1,4 @@
+export class Italic extends InlineElement {
+    static get LABEL(): any;
+}
+import { InlineElement } from './InlineElement.mjs';

package/dist/types/component/inlineStyle/Subscript.d.mts

@@ -0,0 +1,4 @@
+export class Subscript extends InlineElement {
+    static get LABEL(): any;
+}
+import { InlineElement } from './InlineElement.mjs';

package/dist/types/component/inlineStyle/Superscript.d.mts

@@ -0,0 +1,4 @@
+export class Superscript extends InlineElement {
+    static get LABEL(): any;
+}
+import { InlineElement } from './InlineElement.mjs';

package/dist/types/component/inlineStyle/Underline.d.mts

@@ -0,0 +1,4 @@
+export class Underline extends InlineElement {
+    static get LABEL(): any;
+}
+import { InlineElement } from './InlineElement.mjs';

package/dist/types/component/inlineStyle/index.d.mts

@@ -0,0 +1,5 @@
+export { Bold } from "./Bold.mjs";
+export { Italic } from "./Italic.mjs";
+export { Subscript } from "./Subscript.mjs";
+export { Superscript } from "./Superscript.mjs";
+export { Underline } from "./Underline.mjs";