@mrakomor/core 0.0.11 → 0.0.13

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

@@ -0,0 +1,46 @@
+/**
+ * Mount a vnode into `.mrakomor-tools-container` under a named wrapper div.
+ * @param {import('#src/types.mjs').Mrakomor} mrakomor
+ * @param {string} className
+ * @param {*} vnode
+ * @returns {{ container: HTMLElement | null, dispose: (() => void) | null }}
+ */
+export function mountIntoToolsContainer(mrakomor: import("#src/types.mjs").Mrakomor, className: string, vnode: any): {
+    container: HTMLElement | null;
+    dispose: (() => void) | null;
+};
+/**
+ * Mount a vnode into `.mrakomor-footer-end` under a named wrapper div.
+ * Requires `footerPlugin` (the slot is not part of the editor shell).
+ * @param {import('#src/types.mjs').Mrakomor} mrakomor
+ * @param {string} className
+ * @param {*} vnode
+ * @returns {{ container: HTMLElement | null, dispose: (() => void) | null }}
+ */
+export function mountIntoFooterEnd(mrakomor: import("#src/types.mjs").Mrakomor, className: string, vnode: any): {
+    container: HTMLElement | null;
+    dispose: (() => void) | null;
+};
+/**
+ * Mount a vnode into `.mrakomor-footer-start` under a named wrapper div.
+ * Requires `footerPlugin` (the slot is not part of the editor shell).
+ * @param {import('#src/types.mjs').Mrakomor} mrakomor
+ * @param {string} className
+ * @param {*} vnode
+ * @returns {{ container: HTMLElement | null, dispose: (() => void) | null }}
+ */
+export function mountIntoFooterStart(mrakomor: import("#src/types.mjs").Mrakomor, className: string, vnode: any): {
+    container: HTMLElement | null;
+    dispose: (() => void) | null;
+};
+/**
+ * Mount a vnode into `.mrakomor-footer-end` (preferred footer actions slot).
+ * @param {import('#src/types.mjs').Mrakomor} mrakomor
+ * @param {string} className
+ * @param {*} vnode
+ * @returns {{ container: HTMLElement | null, dispose: (() => void) | null }}
+ */
+export function mountIntoFooterContainer(mrakomor: import("#src/types.mjs").Mrakomor, className: string, vnode: any): {
+    container: HTMLElement | null;
+    dispose: (() => void) | null;
+};

package/dist/types/dom.d.mts

@@ -0,0 +1,169 @@
+export const BLOCK_ELEMENT: unique symbol;
+export const BLOCK_ELEMENT_BODY: unique symbol;
+/** Drop the stored selection snapshot. */
+export function clearGlobalSelectionState(): void;
+/** Collapse the stored snapshot to its end offset and apply it. */
+export function collapseGlobalSelectionState(): void;
+/**
+ * BSON ObjectId-style 24-char lowercase hex id (timestamp + machine + pid + counter).
+ * @returns {string}
+ */
+export function createComponentId(): string;
+/**
+ * Block body first child — the contenteditable root (`<p>`, `<ul>`, …).
+ * @param {Element | null | undefined} element block wrapper
+ * @returns {Node | null}
+ */
+export function getBlockContentRoot(element: Element | null | undefined): Node | null;
+/**
+ * Child of the block wrapper marked `BLOCK_ELEMENT_BODY`.
+ * @param {Element | null | undefined} element
+ * @returns {Element | null}
+ */
+export function getBlockElementBody(element: Element | null | undefined): Element | null;
+/**
+ * Block wrapper that contains `child`.
+ * @param {Node | null | undefined} child
+ * @returns {Element | null}
+ */
+export function getBlockElementByChild(child: Node | null | undefined): Element | null;
+/**
+ * Block wrapper (`.mrakomor-block-element`) that contains the range start.
+ * @param {Range | null | undefined} range
+ * @returns {Element | null}
+ */
+export function getBlockElementByRange(range: Range | null | undefined): Element | null;
+/**
+ * Block component instance mounted inside the wrapper.
+ * @param {Element | null | undefined} element
+ * @returns {import('#src/types.mjs').BlockInstance | null}
+ */
+export function getBlockElementInstance(element: Element | null | undefined): import("#src/types.mjs").BlockInstance | null;
+/**
+ * Resolve a non-collapsed selection that may span multiple blocks.
+ * Offsets are character indexes within each block's selectable root.
+ * @param {Range | null} [range]
+ * @returns {import('#src/types.mjs').CrossBlockSelectionState | null}
+ */
+export function getCrossBlockSelectionState(range?: Range | null): import("#src/types.mjs").CrossBlockSelectionState | null;
+/**
+ * Collapsed caret offset within the selectable root (or block content root).
+ * @returns {number}
+ */
+export function getCursorPosition(): number;
+/**
+ * Character offset of `(container, offset)` relative to `selectableElement` text.
+ * @param {Node | null | undefined} selectableElement
+ * @param {Node} container
+ * @param {number} offset
+ * @returns {number}
+ */
+export function getOffsetInSelectable(selectableElement: Node | null | undefined, container: Node, offset: number): number;
+/**
+ * Clone of the live selection range, or `null` if there is none.
+ * @returns {Range | null}
+ */
+export function getRange(): Range | null;
+/**
+ * Selectable root that contains `child`.
+ * @param {Node | null | undefined} child
+ * @returns {Element | null}
+ */
+export function getSelectableElementByChild(child: Node | null | undefined): Element | null;
+/**
+ * Walk up from the range to the nearest selectable content root.
+ * Prefer this over tag checks (e.g. closest('li')) so blocks can opt in.
+ * @param {Range | null | undefined} range
+ * @returns {Element | null}
+ */
+export function getSelectableElementByRange(range: Range | null | undefined): Element | null;
+/**
+ * Index of `element` among `root`'s selectable items (see
+ * `getSelectableElementsInBlock`), or `-1` if not found.
+ * @param {Element | null | undefined} root
+ * @param {Element | null | undefined} element
+ * @returns {number}
+ */
+export function getSelectableElementIndex(root: Element | null | undefined, element: Element | null | undefined): number;
+/**
+ * All selectable items owned by one block, in DOM order. `root` is the
+ * block's content root (`getBlockContentRoot(blockElement)`): if it is
+ * itself marked (Paragraph's `<p>`, Headline's `<h*>` — one item), returns
+ * `[root]`; otherwise returns its direct children that are marked (List's
+ * `<li>`s — one per row). Generic replacement for tag-based walks like
+ * `nodeName === 'LI'`, so a future multi-item block needs no new resolver.
+ * @param {Element | null | undefined} root
+ * @returns {Element[]}
+ */
+export function getSelectableElementsInBlock(root: Element | null | undefined): Element[];
+/**
+ * Resolve the selectable item `range` falls in, scoped to `root`, plus its
+ * index among `root`'s selectable items (see `getSelectableElementsInBlock`).
+ * `null` when the range doesn't resolve to a marked item, or the resolved
+ * item isn't actually inside `root` (e.g. the range moved to a different
+ * block). Shared strict resolver behind List's own keydown handlers,
+ * clipboard's list-item range resolution, and
+ * `component/block/helpers.mjs`'s `resolveActiveExchangeItem`.
+ * @param {Element | null | undefined} root
+ * @param {Range | { startContainer: Node, endContainer?: Node } | null | undefined} range
+ * @returns {import('#src/types.mjs').SelectableItem | null}
+ */
+export function getSelectableItemForRange(root: Element | null | undefined, range: Range | {
+    startContainer: Node;
+    endContainer?: Node;
+} | null | undefined): import("#src/types.mjs").SelectableItem | null;
+/**
+ * Selection offsets that survive remount, scoped to the selectable root.
+ * @returns {import('#src/types.mjs').SelectionState | null}
+ */
+export function getSelectionState(): import("#src/types.mjs").SelectionState | null;
+/**
+ * Whether a block wrapper's rendered content root is itself contentEditable
+ * (e.g. Paragraph's `<p>`, Headline's `<h*>` — `true`; a non-editable atomic
+ * block like Figure, or a missing/unmounted block — `false`).
+ * @param {Element | null | undefined} blockElement
+ * @returns {boolean}
+ */
+export function isBlockContentEditable(blockElement: Element | null | undefined): boolean;
+/**
+ * Position an overlay above an anchor, coordinates relative to the editor root.
+ * @param {Element} root
+ * @param {Element | DOMRect | { left: number, top: number }} anchor
+ * @param {Element | null | undefined} overlayEl
+ * @param {number} [offsetY]
+ * @returns {{ x: number, y: number }}
+ */
+export function positionAboveAnchor(root: Element, anchor: Element | DOMRect | {
+    left: number;
+    top: number;
+}, overlayEl: Element | null | undefined, offsetY?: number): {
+    x: number;
+    y: number;
+};
+/**
+ * Center an overlay within the editor root (coordinates relative to root).
+ * @param {Element} root
+ * @param {Element | null | undefined} overlayEl
+ * @returns {{ x: number, y: number }}
+ */
+export function positionCenteredInRoot(root: Element, overlayEl: Element | null | undefined): {
+    x: number;
+    y: number;
+};
+/** Restore the last stored selection, if any. */
+export function restoreGlobalSelectionState(): void;
+/**
+ * Apply a `getSelectionState()` snapshot to the live DOM.
+ * @param {import('#src/types.mjs').SelectionState | null | undefined} state
+ */
+export function restoreSelectionState(state: import("#src/types.mjs").SelectionState | null | undefined): void;
+/** Marks the DOM node selection offsets are relative to (e.g. <p>, <li>). */
+export const SELECTABLE_ELEMENT: unique symbol;
+/**
+ * Place the caret at a character offset inside `contentEle`.
+ * @param {Node} contentEle
+ * @param {number} targetPosition
+ */
+export function setCursorPosition(contentEle: Node, targetPosition: number): void;
+/** Snapshot the current selection for dialog/tooltip restore. */
+export function storeGlobalSelectionState(): void;

package/dist/types/emitter.d.mts

@@ -0,0 +1,38 @@
+/**
+ * Command bus bound to a Mrakomor instance.
+ * Each `command.*` method emits the matching `EVENT` via `mrakomor.emit`.
+ *
+ * @param {{ mrakomor?: import('#src/types.mjs').Mrakomor }} [options]
+ * @returns {{ emitter: import('@esmj/emitter').Emitter, command: import('#src/types.mjs').MrakomorCommand }}
+ */
+export function createCommands({ mrakomor }?: {
+    mrakomor?: import("#src/types.mjs").Mrakomor;
+}): {
+    emitter: import("@esmj/emitter").Emitter;
+    command: import("#src/types.mjs").MrakomorCommand;
+};
+export namespace EVENT {
+    let INSERT_BLOCK_ELEMENT: string;
+    let REPLACE_BLOCK_ELEMENT: string;
+    let REMOVE_BLOCK_ELEMENT: string;
+    let MERGE_BLOCK_ELEMENT: string;
+    let INSERT_ENTITY_RANGE: string;
+    let REMOVE_ENTITY_RANGE: string;
+    let INSERT_INLINE_STYLE_RANGE: string;
+    let KEYDOWN: string;
+    let BEFORE_INPUT: string;
+    let INPUT: string;
+    let CLICK: string;
+    let FOCUSIN: string;
+    let FOCUSOUT: string;
+    let SELECTION_CHANGE: string;
+    let CONTENT_CHANGE: string;
+    let TRANSFORM_BLOCK_ELEMENT: string;
+    let MOVE_BLOCK_ELEMENT: string;
+}
+/**
+ * Skip the handler when a previous listener called `preventDefault()`.
+ * @param {Function} handler
+ * @returns {Function}
+ */
+export function unlessPrevented(handler: Function): Function;

package/dist/types/index.d.mts

@@ -0,0 +1,7 @@
+export { EVENT } from "./emitter.mjs";
+export { defaultMrakomorPlugin } from "./plugin/default/defaultMrakomorPlugin.mjs";
+export { Menu } from "./plugin/menu/Menu.mjs";
+export { menuPlugin } from "./plugin/menu/menuPlugin.mjs";
+export { Bold, Italic, Subscript, Superscript, Underline } from "./component/inlineStyle/index.mjs";
+export { createMrakomor, Mrakomor } from "./Mrakomor.mjs";
+export { Dialog, dialogPlugin } from "./plugin/dialog/Dialog.mjs";

package/dist/types/namespaces.d.mts

@@ -0,0 +1,17 @@
+/**
+ * Leaf block-namespace IDs.
+ * Safe to import from helpers/config without pulling component classes
+ * (avoids circular imports such as helpers ↔ Paragraph).
+ */
+/** Default body text block; Enter after atomic blocks, unwraps, clipboard fallback. */
+export const PARAGRAPH_NAMESPACE: "molecule.paragraph.Paragraph";
+export const LIST_NAMESPACE: "molecule.list.List";
+export const EXTERNAL_NAMESPACE: "molecule.external.ExternalComponent";
+export const UNKNOWN_NAMESPACE: "namespace.unknown.UnknownComponent";
+export const HEADLINE_H1_NAMESPACE: "molecule.headline.H1";
+export const HEADLINE_H2_NAMESPACE: "molecule.headline.H2";
+export const HEADLINE_H3_NAMESPACE: "molecule.headline.H3";
+export const HEADLINE_H4_NAMESPACE: "molecule.headline.H4";
+export const HEADLINE_H5_NAMESPACE: "molecule.headline.H5";
+/** Prefix used by isTextBlock checks for any headline level. */
+export const HEADLINE_NAMESPACE_PREFIX: "molecule.headline.";

package/dist/types/plugin/blockChrome/BlockChrome.d.mts

@@ -0,0 +1,11 @@
+/**
+ * Gutter UI: insert (+) and drag handle.
+ * @returns {*}
+ */
+export function BlockChrome(): any;
+/**
+ * Block gutter: insert (+) and drag-to-reorder.
+ * @param {import('#src/types.mjs').PluginContext} options
+ * @returns {import('#src/types.mjs').Plugin}
+ */
+export function blockChromePlugin({ mrakomor }: import("#src/types.mjs").PluginContext): import("#src/types.mjs").Plugin;

package/dist/types/plugin/blockChrome/index.d.mts

@@ -0,0 +1 @@
+export { BlockChrome, blockChromePlugin } from "./BlockChrome.mjs";

package/dist/types/plugin/blockInsertMenu/BlockInsertMenu.d.mts

@@ -0,0 +1,6 @@
+/**
+ * Plus insert menu — opens the shared menu with block registrations.
+ * @param {import('#src/types.mjs').PluginContext} options
+ * @returns {import('#src/types.mjs').Plugin}
+ */
+export function blockInsertMenuPlugin({ mrakomor }: import("#src/types.mjs").PluginContext): import("#src/types.mjs").Plugin;

package/dist/types/plugin/blockInsertMenu/index.d.mts

@@ -0,0 +1 @@
+export { blockInsertMenuPlugin } from "./BlockInsertMenu.mjs";

package/dist/types/plugin/clipboard/clipboardHelpers.d.mts

@@ -0,0 +1,151 @@
+/**
+ * Normalized text length for a text block; `0` otherwise.
+ * @param {BlockState} state
+ * @returns {number}
+ */
+export function textLength(state: BlockState): number;
+/**
+ * Slice a text block to `[start, end)`, clipping inline/entity ranges.
+ * @param {BlockState} state
+ * @param {number} start
+ * @param {number} end
+ * @returns {BlockState}
+ */
+export function sliceStateByRange(state: BlockState, start: number, end: number): BlockState;
+/**
+ * Wrap a sliced list item as a paragraph (copy/paste of a list selection).
+ * @param {ListItem} item
+ * @param {number} start
+ * @param {number} end
+ * @returns {BlockState}
+ */
+export function listItemToParagraph(item: ListItem, start: number, end: number): BlockState;
+/**
+ * Blocks to write to the clipboard for the current selection.
+ * A selection inside one list, or spanning list items, copies as a paragraph.
+ *
+ * @param {BlockState[]} content
+ * @param {ClipboardSelection} selection
+ * @returns {BlockState[]}
+ */
+export function copyBlocksFromSelection(content: BlockState[], selection: ClipboardSelection): BlockState[];
+/**
+ * Delete `[startOffset, endOffset)` inside one list item.
+ * @param {ListBlockState} listState
+ * @param {number} itemIndex
+ * @param {number} startOffset
+ * @param {number} endOffset
+ * @returns {ListBlockState}
+ */
+export function deleteListItemRange(listState: ListBlockState, itemIndex: number, startOffset: number, endOffset: number): ListBlockState;
+/**
+ * Delete the selection: same-block trim, list-item range, or cross-block merge.
+ *
+ * @param {BlockState[]} content
+ * @param {ClipboardSelection} selection
+ * @returns {ContentMutation}
+ */
+export function deleteSelection(content: BlockState[], selection: ClipboardSelection): ContentMutation;
+/**
+ * Move copied `blocks` from `source` to `drop` in one model update.
+ * Same-list drop coordinates are those from before the delete.
+ *
+ * @param {BlockState[]} content
+ * @param {{ source: ClipboardSelection, drop: { index: number, offset: number, listItemIndex?: number }, blocks: BlockState[] }} payload
+ * @returns {ContentMutation}
+ */
+export function moveSelection(content: BlockState[], { source, drop, blocks }: {
+    source: ClipboardSelection;
+    drop: {
+        index: number;
+        offset: number;
+        listItemIndex?: number;
+    };
+    blocks: BlockState[];
+}): ContentMutation;
+/**
+ * Insert clipboard `blocks` at a caret (or after a list/atomic block).
+ *
+ * @param {BlockState[]} content
+ * @param {{ index: number, offset: number, blocks: BlockState[], listItemIndex?: number }} payload
+ * @returns {ContentMutation}
+ */
+export function applyPaste(content: BlockState[], { index, offset, blocks, listItemIndex }: {
+    index: number;
+    offset: number;
+    blocks: BlockState[];
+    listItemIndex?: number;
+}): ContentMutation;
+/**
+ * Parse the custom MIME JSON envelope; `null` if invalid.
+ * @param {string} text
+ * @returns {BlockState[] | null}
+ */
+export function parseClipboardPayload(text: string): BlockState[] | null;
+/**
+ * Strip HTML to text via `DOMParser`.
+ * @param {string} html
+ * @returns {string}
+ */
+export function htmlToPlainText(html: string): string;
+/**
+ * Split plain text on newlines into paragraph states.
+ * @param {string} text
+ * @param {string} [namespace]
+ * @returns {BlockState[]}
+ */
+export function textToParagraphs(text: string, namespace?: string): BlockState[];
+/**
+ * Human-readable text for one block (list items joined by newlines).
+ * @param {BlockState} block
+ * @returns {string}
+ */
+export function blockToPlainText(block: BlockState): string;
+/**
+ * Join blocks with newlines for `text/plain`.
+ * @param {BlockState[]} blocks
+ * @returns {string}
+ */
+export function blocksToPlainText(blocks: BlockState[]): string;
+/**
+ * JSON envelope written to the custom clipboard MIME.
+ * @param {BlockState[]} blocks
+ * @returns {{ v: number, blocks: BlockState[] }}
+ */
+export function createClipboardPayload(blocks: BlockState[]): {
+    v: number;
+    blocks: BlockState[];
+};
+/**
+ * Write custom MIME JSON and `text/plain` onto a `DataTransfer`.
+ * @param {DataTransfer} clipboardData
+ * @param {BlockState[]} blocks
+ */
+export function writeClipboardData(clipboardData: DataTransfer, blocks: BlockState[]): void;
+/**
+ * Read blocks from clipboard: custom MIME, then JSON in `text/plain`, then plain/HTML text.
+ * @param {DataTransfer | null | undefined} clipboardData
+ * @param {string} [paragraphNamespace]
+ * @returns {BlockState[]}
+ */
+export function readClipboardBlocks(clipboardData: DataTransfer | null | undefined, paragraphNamespace?: string): BlockState[];
+/**
+ * Fresh `componentId`s for a pasted block (and its list items).
+ * @param {BlockState} block
+ * @returns {BlockState}
+ */
+export function assignNewComponentIds(block: BlockState): BlockState;
+/**
+ * @typedef {import('#src/types.mjs').BlockState} BlockState
+ * @typedef {import('#src/types.mjs').ListItem} ListItem
+ * @typedef {import('#src/types.mjs').ListBlockState} ListBlockState
+ * @typedef {import('#src/types.mjs').ClipboardSelection} ClipboardSelection
+ * @typedef {import('#src/types.mjs').ContentMutation} ContentMutation
+ */
+export const CLIPBOARD_MIME: "application/x-mrakomor-blocks+json";
+export const CLIPBOARD_PAYLOAD_VERSION: 1;
+export type BlockState = import("#src/types.mjs").BlockState;
+export type ListItem = import("#src/types.mjs").ListItem;
+export type ListBlockState = import("#src/types.mjs").ListBlockState;
+export type ClipboardSelection = import("#src/types.mjs").ClipboardSelection;
+export type ContentMutation = import("#src/types.mjs").ContentMutation;

package/dist/types/plugin/clipboard/clipboardPlugin.d.mts

@@ -0,0 +1,6 @@
+/**
+ * Copy / cut / paste: native listeners + `command.copy|cut|paste`.
+ * @param {import('#src/types.mjs').PluginContext} options
+ * @returns {import('#src/types.mjs').Plugin}
+ */
+export function clipboardPlugin({ root, mrakomor }: import("#src/types.mjs").PluginContext): import("#src/types.mjs").Plugin;

package/dist/types/plugin/clipboard/index.d.mts

@@ -0,0 +1 @@
+export { clipboardPlugin } from "./clipboardPlugin.mjs";

package/dist/types/plugin/default/defaultMrakomorPlugin.d.mts

@@ -0,0 +1,21 @@
+/**
+ * Replace one block in content by DOM element index. Normalizes only the
+ * changed entry and writes via the internal `_setContentState()` (not the
+ * public `setContent()`) so an unrelated stale/unresolvable entry elsewhere
+ * in `getContent()` can't turn this single-block update into a crash. Core
+ * plugin export — optional plugins (e.g. `list`) may import and reuse this
+ * instead of reimplementing the same splice-one-then-write pattern.
+ * @param {import('#src/types.mjs').Mrakomor} mrakomor
+ * @param {Element} blockElement
+ * @param {import('#src/types.mjs').ComponentStateInput} nextState
+ * @returns {boolean}
+ */
+export function updateBlockAt(mrakomor: import("#src/types.mjs").Mrakomor, blockElement: Element, nextState: import("#src/types.mjs").ComponentStateInput): boolean;
+/**
+ * Core editor defaults: External/Unknown resolve, command handlers, KEYDOWN,
+ * and the native DOM → emitter bridge. Always appended last by Mrakomor.
+ *
+ * @param {import('#src/types.mjs').PluginContext} [_options]
+ * @returns {import('#src/types.mjs').Plugin}
+ */
+export function defaultMrakomorPlugin(_options?: import("#src/types.mjs").PluginContext): import("#src/types.mjs").Plugin;

package/dist/types/plugin/dialog/Dialog.d.mts

@@ -0,0 +1,23 @@
+/**
+ * Floating dialog overlay.
+ * @param {{ open: import('#src/types.mjs').Signal<boolean>, placement: import('#src/types.mjs').Signal<string>, positionX: import('#src/types.mjs').Signal<number>, positionY: import('#src/types.mjs').Signal<number>, block: import('#src/types.mjs').Signal<*>, dialogRef: import('#src/types.mjs').ElementRef }} props
+ * @returns {*}
+ */
+export function Dialog({ open, placement, positionX, positionY, block, dialogRef, }: {
+    open: import("#src/types.mjs").Signal<boolean>;
+    placement: import("#src/types.mjs").Signal<string>;
+    positionX: import("#src/types.mjs").Signal<number>;
+    positionY: import("#src/types.mjs").Signal<number>;
+    block: import("#src/types.mjs").Signal<any>;
+    dialogRef: import("#src/types.mjs").ElementRef;
+}): any;
+export namespace Dialog {
+    export { DIALOG_NAMESPACE as NAMESPACE };
+}
+/**
+ * Registers `command.openDialog` / `closeDialog` and mounts the dialog overlay.
+ * @param {import('#src/types.mjs').PluginContext} options
+ * @returns {import('#src/types.mjs').Plugin}
+ */
+export function dialogPlugin({ mrakomor }: import("#src/types.mjs").PluginContext): import("#src/types.mjs").Plugin;
+export const DIALOG_NAMESPACE: "mrakomor.dialog.Dialog";

package/dist/types/plugin/footer/footerPlugin.d.mts

@@ -0,0 +1,7 @@
+/**
+ * Optional status bar plugin (block/character counts + action slots).
+ * List before `helpPlugin` so Help can mount into `.mrakomor-footer-end`.
+ * @param {import('#src/types.mjs').PluginContext} options
+ * @returns {import('#src/types.mjs').Plugin}
+ */
+export function footerPlugin({ mrakomor }: import("#src/types.mjs").PluginContext): import("#src/types.mjs").Plugin;

package/dist/types/plugin/footer/index.d.mts

@@ -0,0 +1 @@
+export { footerPlugin } from "./footerPlugin.mjs";

package/dist/types/plugin/headline/Headline.d.mts

@@ -0,0 +1,29 @@
+/**
+ * Registers H1–H5 headline blocks.
+ * @returns {import('#src/types.mjs').Plugin}
+ */
+export function headlinePlugin(): import("#src/types.mjs").Plugin;
+export class HeadlineComponent extends BlockComponent {
+    static getStateSchema(node: any): any;
+    _level: number;
+    _buildContent(state: any): any;
+    render(): any;
+    onKeydown(event: any): void;
+    #private;
+}
+export class Headline1 extends HeadlineComponent {
+    static get LABEL(): string;
+}
+export class Headline2 extends HeadlineComponent {
+    static get LABEL(): string;
+}
+export class Headline3 extends HeadlineComponent {
+    static get LABEL(): string;
+}
+export class Headline4 extends HeadlineComponent {
+    static get LABEL(): string;
+}
+export class Headline5 extends HeadlineComponent {
+    static get LABEL(): string;
+}
+import { BlockComponent } from '#src/component/block/BlockComponent.mjs';

package/dist/types/plugin/headline/index.d.mts

@@ -0,0 +1 @@
+export { HeadlineComponent, headlinePlugin } from "./Headline.mjs";

package/dist/types/plugin/help/HelpRegister.d.mts

@@ -0,0 +1,15 @@
+/**
+ * Display-only help dialog register.
+ */
+export class HelpRegister extends Register {
+    /**
+     * @param {import('#src/types.mjs').Mrakomor} mrakomor
+     */
+    constructor(mrakomor: import("#src/types.mjs").Mrakomor);
+    /**
+     * @param {import('#src/types.mjs').HelpEntry} raw
+     * @returns {import('#src/types.mjs').HelpEntry | null}
+     */
+    normalize(raw: import("#src/types.mjs").HelpEntry): import("#src/types.mjs").HelpEntry | null;
+}
+import Register from '#src/register/Register.mjs';

package/dist/types/plugin/help/helpPlugin.d.mts

@@ -0,0 +1,26 @@
+/**
+ * Group help entries by `group` for dialog rendering.
+ * @param {import('#src/types.mjs').HelpEntry[]} entries
+ * @returns {Map<string, import('#src/types.mjs').HelpEntry[]>}
+ */
+export function groupHelpEntries(entries: import("#src/types.mjs").HelpEntry[]): Map<string, import("#src/types.mjs").HelpEntry[]>;
+/**
+ * Build help dialog vDOM from registered entries.
+ * @param {import('#src/types.mjs').HelpEntry[]} entries
+ * @returns {*}
+ */
+export function buildHelpDialogContent(entries: import("#src/types.mjs").HelpEntry[]): any;
+/**
+ * Optional help plugin: display-only registry + help dialog + `/help` slash action.
+ * Needs `footerPlugin` listed earlier so the trigger can mount in the status bar.
+ * Registers `HELP_SLASH_ACTION` on `mrakomor.register.slashActions` in `registerCommands`
+ * (not `config.slashActions` / not `resolveConfig`).
+ * @param {import('#src/types.mjs').PluginContext} options
+ * @returns {import('#src/types.mjs').Plugin}
+ */
+export function helpPlugin({ mrakomor }: import("#src/types.mjs").PluginContext): import("#src/types.mjs").Plugin;
+/**
+ * Core `/help` slash action — owned by help plugin (optional; only when help is loaded).
+ * @type {import('#src/types.mjs').SlashActionRegistration}
+ */
+export const HELP_SLASH_ACTION: import("#src/types.mjs").SlashActionRegistration;

package/dist/types/plugin/help/helpSchema.d.mts

@@ -0,0 +1,11 @@
+/**
+ * Display-only help registry row.
+ * @returns {*} `@esmj/schema` object schema
+ */
+export function helpEntrySchema(): any;
+/**
+ * Parse a help registry entry; returns `null` when invalid.
+ * @param {import('#src/types.mjs').HelpEntry} entry
+ * @returns {import('#src/types.mjs').HelpEntry | null}
+ */
+export function normalizeHelpEntry(entry: import("#src/types.mjs").HelpEntry): import("#src/types.mjs").HelpEntry | null;

package/dist/types/plugin/help/index.d.mts

@@ -0,0 +1 @@
+export { buildHelpDialogContent, groupHelpEntries, HELP_SLASH_ACTION, helpPlugin } from "./helpPlugin.mjs";

package/dist/types/plugin/linkEntity/LinkEntity.d.mts

@@ -0,0 +1,37 @@
+/**
+ * Sanitize a link href with `@esmj/schema` (allow-list + catch to empty).
+ * @param {string | null | undefined} href
+ * @returns {string}
+ */
+export function sanitizeLinkHref(href: string | null | undefined): string;
+/**
+ * Registers the link entity and Cmd/Ctrl+K insert shortcut.
+ * @param {import('#src/types.mjs').PluginContext} options
+ * @returns {import('#src/types.mjs').Plugin}
+ */
+export function linkEntityPlugin({ mrakomor }: import("#src/types.mjs").PluginContext): import("#src/types.mjs").Plugin;
+export class LinkEntity extends EntityRangeElement {
+    static getStateSchema(node: any): import("@esmj/schema").SchemaInterface<{
+        entity: {
+            type: string;
+            data: unknown;
+        };
+        length: number;
+        offset: number;
+    }, {
+        entity: {
+            type: string;
+            data: unknown;
+        };
+        length: number;
+        offset: number;
+    }>;
+    input: {
+        get: () => null;
+        set: (element: any) => null;
+        [Symbol.toPrimitive](): string;
+    };
+    onMount(): void;
+    #private;
+}
+import { EntityRangeElement } from '../../component/entityRange/EntityRangeElement.mjs';

package/dist/types/plugin/linkEntity/index.d.mts

@@ -0,0 +1 @@
+export { LinkEntity, linkEntityPlugin } from "./LinkEntity.mjs";