xiaodao-editor 0.1.1

package/dist/core/state/EditorState.d.ts

@@ -0,0 +1,26 @@
+import { DocState, Selection } from '../types';
+import { Plugin, PluginState } from '../plugin/Plugin';
+import { Transaction } from './Transaction';
+import { ApplyResult } from './Step';
+export interface EditorState {
+    readonly doc: DocState;
+    readonly selection: Selection;
+    readonly pluginState: Readonly<Record<string, PluginState>>;
+    /** Monotonic counter; bumped once per applied transaction. */
+    readonly version: number;
+}
+export interface ApplyTransactionResult extends ApplyResult {
+    readonly state: EditorState;
+}
+interface TransactionApplier {
+    readonly name: string;
+    readonly applyTransaction?: NonNullable<Plugin['applyTransaction']>;
+}
+/**
+ * Apply a transaction to a state, producing a new state plus a diff
+ * (changed / removed) that the view bridge consumes.
+ */
+export declare function applyTransaction(state: EditorState, tr: Transaction, plugins: readonly TransactionApplier[]): ApplyTransactionResult;
+/** Create the initial state from a document and a (possibly null) selection. */
+export declare function createState(doc: DocState, selection: Selection, pluginState?: Readonly<Record<string, PluginState>>): EditorState;
+export {};

package/dist/core/state/Step.d.ts

@@ -0,0 +1,39 @@
+import { Attrs, BlockId, BlockType, DocState, InlineSeq } from '../types';
+export type Step = {
+    readonly op: 'insertBlock';
+    readonly parent: BlockId | null;
+    readonly index: number;
+    readonly id: BlockId;
+    readonly type: BlockType;
+    readonly attrs: Attrs;
+    readonly content: InlineSeq;
+} | {
+    readonly op: 'removeBlock';
+    readonly id: BlockId;
+} | {
+    readonly op: 'replaceBlock';
+    readonly id: BlockId;
+    readonly type: BlockType;
+    readonly attrs: Attrs;
+} | {
+    readonly op: 'moveBlock';
+    readonly id: BlockId;
+    readonly toParent: BlockId | null;
+    readonly toIndex: number;
+} | {
+    readonly op: 'setText';
+    readonly id: BlockId;
+    readonly content: InlineSeq;
+} | {
+    readonly op: 'setAttrs';
+    readonly id: BlockId;
+    readonly attrs: Attrs;
+};
+export interface ApplyResult {
+    readonly doc: DocState;
+    /** Block ids whose `Block` reference changed (content/attrs/type) or were inserted. */
+    readonly changed: ReadonlySet<BlockId>;
+    /** Block ids removed from the document (the subtree roots and their descendants). */
+    readonly removed: ReadonlySet<BlockId>;
+}
+export declare function applySteps(doc: DocState, steps: readonly Step[]): ApplyResult;

package/dist/core/state/Transaction.d.ts

@@ -0,0 +1,52 @@
+import { Attrs, BlockId, BlockType, InlineSeq, Selection } from '../types';
+import { Step } from './Step';
+export interface TransactionMeta {
+    readonly addToHistory?: boolean;
+    readonly historyGroup?: string | null;
+    readonly viewHints?: {
+        readonly skipDomWrite?: readonly BlockId[];
+    };
+    /** Provenance hint for debugging: 'input' | 'command' | 'clipboard' | ... */
+    readonly source?: string;
+    readonly [key: string]: unknown;
+}
+export interface Transaction {
+    readonly steps: readonly Step[];
+    readonly selectionAfter?: Selection;
+    readonly meta: TransactionMeta;
+}
+export interface InsertBlockParams {
+    readonly parent: BlockId | null;
+    readonly index: number;
+    readonly type: BlockType;
+    readonly attrs?: Attrs;
+    readonly content?: InlineSeq;
+    /** Optional explicit id (otherwise generated). Used by undo/redo & paste. */
+    readonly id?: BlockId;
+}
+/**
+ * Fluent builder. Each step method returns `this` for chaining. `build()`
+ * freezes the result into a `Transaction`.
+ */
+export declare class TransactionBuilder {
+    private readonly steps;
+    private selectionAfter?;
+    private meta;
+    insertBlock(params: InsertBlockParams): BlockId;
+    removeBlock(id: BlockId): this;
+    replaceBlock(id: BlockId, type: BlockType, attrs: Attrs): this;
+    moveBlock(id: BlockId, toParent: BlockId | null, toIndex: number): this;
+    setText(id: BlockId, content: InlineSeq): this;
+    setAttrs(id: BlockId, attrs: Attrs): this;
+    /** Return a snapshot of the steps accumulated so far (read-only). */
+    peek(): readonly Step[];
+    /** Append a pre-built list of steps (used by history undo/redo). */
+    appendSteps(steps: readonly Step[]): this;
+    setSelection(selection: Selection): this;
+    setMeta(meta: Partial<TransactionMeta>): this;
+    addToHistory(value: boolean): this;
+    historyGroup(key: string | null): this;
+    skipDomWrite(ids: readonly BlockId[]): this;
+    build(): Transaction;
+}
+export declare function createTransaction(): TransactionBuilder;

package/dist/core/state/invert.d.ts

@@ -0,0 +1,19 @@
+import { DocState } from '../types';
+import { Step } from './Step';
+/**
+ * Invert a sequence of steps against the pre-state. Returns a new step list
+ * that, when applied to the post-state, restores the pre-state. Steps are
+ * inverted in reverse order so the last-applied change is undone first.
+ *
+ * Important — forward-step is a sequential program:
+ *   [ setAttrs(A, x'), insertBlock(B), replaceBlock(B), setAttrs(B) ]
+ * When reversing, we may see `replaceBlock(B)` / `setAttrs(B)` BEFORE we see
+ * the `insertBlock(B)` that actually added B to the document. In that case
+ * B is NOT present in `prevDoc` (prevDoc is the pre-transaction snapshot,
+ * not the mid-transaction intermediate). Inverting B's attribute/replace
+ * changes is redundant because the final `insertBlock(B)` → inverse
+ * `removeBlock(B)` already erases B entirely. So these "unknown id" cases
+ * are skipped — the block is handled by its matching insertBlock inverse
+ * further up the step list.
+ */
+export declare function invertSteps(steps: readonly Step[], prevDoc: DocState): Step[];

package/dist/core/state/store.d.ts

@@ -0,0 +1,78 @@
+import { Attrs, Block, BlockId, DocState, DocumentData, InlineSeq } from '../types';
+export interface DocBuildResult {
+    readonly doc: DocState;
+    /** Map from source JSON id (if any) to the assigned stable `BlockId`. */
+    readonly idMap: ReadonlyMap<string, BlockId>;
+}
+/**
+ * Build a normalized `DocState` from nested JSON.
+ *
+ * Id policy (docs §4.1, §17.1): a source id is preserved if it is non-empty
+ * and unique within this document; otherwise a fresh id is generated. The
+ * mapping from source id → assigned id is returned for caller use.
+ *
+ * Legacy migration: if the input JSON is "flat-by-indent" (children never
+ * written; every block sits at root level; attrs.indent encodes depth) we
+ * rebuild the real parent/children tree so the rest of the editor operates
+ * on a real tree. The attrs.indent field on each block is then normalized to
+ * mirror the computed depth so downstream renderers stay consistent.
+ */
+export declare function docFromData(json: DocumentData): DocBuildResult;
+/** Serialize a `DocState` to nested JSON (the external format). */
+export declare function docToData(doc: DocState): DocumentData;
+export declare function getBlock(doc: DocState, id: BlockId): Block | undefined;
+export declare function requireBlock(doc: DocState, id: BlockId): Block;
+export declare function parentOf(doc: DocState, id: BlockId): BlockId | null;
+/**
+ * Nesting depth of a block: count of ancestors.
+ *   • Root blocks: depth 0
+ *   • Direct child of a root block: depth 1
+ *   • etc.
+ *
+ * This is the AUTHORITATIVE source for indent level; `attrs.indent` is only a
+ * synchronized mirror kept for backward compatibility with the CSS class
+ * pipeline (`classesFromAttrs`) and legacy renderers.
+ */
+export declare function depthOf(doc: DocState, id: BlockId): number;
+/** The ordered sibling list a block belongs to (root or a parent's children). */
+export declare function siblingList(doc: DocState, id: BlockId): readonly BlockId[];
+export declare function indexOf(doc: DocState, id: BlockId): number;
+export declare function prevSibling(doc: DocState, id: BlockId): Block | undefined;
+export declare function nextSibling(doc: DocState, id: BlockId): Block | undefined;
+/**
+ * All block ids in document order (root-first, depth-first). Used by the view
+ * bridge to derive the flat render list and by navigation to find the
+ * previous/next *visible* block across nesting boundaries.
+ */
+export declare function flatten(doc: DocState): BlockId[];
+/** The previous block in document (depth-first) order across nesting. */
+export declare function blockBefore(doc: DocState, id: BlockId): Block | undefined;
+export declare function blockAfter(doc: DocState, id: BlockId): Block | undefined;
+/** The deepest last descendant of a block (or the block itself if leaf). */
+export declare function lastDescendant(doc: DocState, id: BlockId): Block;
+/**
+ * Returns the setAttrs patches needed to make every block's `attrs.indent`
+ * exactly equal to `depthOf(doc, id)` (clamped to 0..MAX_INDENT). Any block
+ * whose indent already matches is omitted so we don't emit spurious changed
+ * entries in the next transaction.
+ *
+ * This is the SINGLE place that is allowed to *write* `attrs.indent`.
+ * Commands and transaction callers should NOT manually set attrs.indent;
+ * instead they should manipulate parent/children (via moveBlock /
+ * insertBlock/removeBlock) and then run this synchronizer at the end of the
+ * transaction build.
+ *
+ * If a `schema` is supplied, blocks whose schema does not declare an
+ * `indent` attr have the indent key stripped entirely (matching the
+ * coerceAttrs convention used across extensions).
+ */
+export declare function collectIndentSyncPatches(doc: DocState, schema?: {
+    get(type: string): {
+        attrs: Readonly<Record<string, unknown>>;
+    };
+}): Array<{
+    id: BlockId;
+    attrs: Attrs;
+}>;
+export declare function withContent(block: Block, content: InlineSeq): Block;
+export declare function withAttrs(block: Block, attrs: Block['attrs']): Block;

package/dist/core/types.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Core domain types for the block editor.
+ *
+ * This module is the single source of truth for the editor's data model. It is
+ * intentionally framework-agnostic (no Vue) and contains only type definitions
+ * plus a few pure type guards. All runtime behavior lives in dedicated modules.
+ *
+ * See docs/editor-architecture.md §4 (Document model) and §8 (Selection).
+ */
+/**
+ * A stable, opaque identifier for a block. Branded so that a plain `string`
+ * cannot be passed where a `BlockId` is expected — this catches an entire
+ * class of bugs at compile time.
+ */
+export type BlockId = string & {
+    readonly __brand: 'BlockId';
+};
+/** A registered block type id (e.g. "paragraph", "heading"). */
+export type BlockType = string;
+export type JSONValue = string | number | boolean | null | JSONValue[] | {
+    [key: string]: JSONValue;
+};
+/** Block-level attributes. A plain JSON object shaped by the block's schema. */
+export type Attrs = Readonly<Record<string, JSONValue>>;
+/** An inline mark applied to a text run (bold, italic, link, …). */
+export interface Mark {
+    readonly type: string;
+    readonly attrs?: Attrs;
+}
+/**
+ * A single inline node. Phase 1 only has text runs; the model is already a
+ * discriminated union so future inline atoms (mention, equation) extend it
+ * without changing the block shape.
+ */
+export interface TextRun {
+    readonly type: 'text';
+    readonly text: string;
+    readonly marks?: readonly Mark[];
+}
+export type InlineNode = TextRun;
+/** The ordered inline content of a block. An empty array means "no text". */
+export type InlineSeq = readonly InlineNode[];
+/**
+ * A block. Treated as immutable within an `EditorState` version: any mutation
+ * produces a new `Block` object while siblings keep referential identity.
+ */
+export interface Block {
+    readonly id: BlockId;
+    readonly type: BlockType;
+    readonly attrs: Attrs;
+    readonly content: InlineSeq;
+    /** Ordered child block ids. Nesting is resolved via the document store. */
+    readonly children: readonly BlockId[];
+}
+/**
+ * The normalized document: a forest of blocks stored in a map keyed by id,
+ * plus the ordered list of top-level ids and a parent index for O(1) upward
+ * navigation. Plain (non-reactive) data; see docs §10.
+ */
+export interface DocState {
+    readonly id: string;
+    readonly root: readonly BlockId[];
+    readonly blocks: ReadonlyMap<BlockId, Block>;
+    /** Parent of each block; `null` means "top-level (child of root)". */
+    readonly parent: ReadonlyMap<BlockId, BlockId | null>;
+}
+export interface Anchor {
+    readonly blockId: BlockId;
+    readonly offset: number;
+}
+export type Selection = {
+    readonly kind: 'caret';
+    readonly blockId: BlockId;
+    readonly offset: number;
+} | {
+    readonly kind: 'text';
+    readonly anchor: Anchor;
+    readonly focus: Anchor;
+} | {
+    readonly kind: 'blocks';
+    readonly blockIds: readonly BlockId[];
+};
+export interface BlockData {
+    readonly id?: string;
+    readonly type: string;
+    readonly attrs?: Attrs;
+    readonly content?: InlineSeq;
+    readonly children?: readonly BlockData[];
+}
+export interface DocumentData {
+    readonly id?: string;
+    readonly blocks: readonly BlockData[];
+}
+export declare function isBlockId(value: unknown): value is BlockId;
+export declare function isTextRun(node: InlineNode): node is TextRun;
+/** Concatenate all text in an inline sequence. */
+export declare function inlineText(seq: InlineSeq): string;
+/** Build an inline sequence from a plain string. */
+export declare function inlineFromString(text: string): InlineSeq;
+/**
+ * Split an InlineSeq at character offset into two halves.
+ * TextRuns that straddle the boundary are split into two TextRun copies
+ * (preserving marks). Empty runs are omitted.
+ */
+export declare function splitInline(seq: InlineSeq, offset: number): readonly [InlineSeq, InlineSeq];

package/dist/extensions/BulletList.d.ts

@@ -0,0 +1,2 @@
+import { Extension } from '../core/extension/Extension';
+export declare const BulletListExtension: Extension;

package/dist/extensions/CodeBlock.d.ts

@@ -0,0 +1,2 @@
+import { Extension } from '../core/extension/Extension';
+export declare const CodeBlockExtension: Extension;

package/dist/extensions/Divider.d.ts

@@ -0,0 +1,2 @@
+import { Extension } from '../core/extension/Extension';
+export declare const DividerExtension: Extension;

package/dist/extensions/Heading.d.ts

@@ -0,0 +1,2 @@
+import { Extension } from '../core/extension/Extension';
+export declare const HeadingExtension: Extension;

package/dist/extensions/History.d.ts

@@ -0,0 +1,2 @@
+import { Extension } from '../core/extension/Extension';
+export declare const HistoryExtension: Extension;

package/dist/extensions/Image.d.ts

@@ -0,0 +1,34 @@
+import { Extension } from '../core/extension/Extension';
+import { BlockId } from '../core/types';
+export interface ImageAttrs {
+    readonly align: string;
+    readonly src: string;
+    readonly alt: string;
+    readonly title: string;
+    readonly width: number;
+    readonly height: number;
+    readonly caption: string;
+    /**
+     * Optional server-side file identifier (integer). Set by the external
+     * `uploadImage` handler when it returns a result. The editor tracks
+     * reference counts for each fileId and emits `cleanup:image-file` when
+     * the last block referencing a fileId is removed, so the consumer can
+     * reclaim cloud storage.
+     * 0 (the default) means "no file id" / not uploaded yet / no managed file.
+     */
+    readonly fileId: number;
+}
+export interface InsertImageBlockArgs {
+    readonly after?: BlockId;
+    readonly parent?: BlockId | null;
+    readonly index?: number;
+    readonly attrs?: {
+        src?: string;
+        alt?: string;
+        title?: string;
+        width?: number;
+        height?: number;
+        caption?: string;
+    };
+}
+export declare const ImageExtension: Extension;

package/dist/extensions/Keymap.d.ts

@@ -0,0 +1,2 @@
+import { Extension } from '../core/extension/Extension';
+export declare const KeymapExtension: Extension;

package/dist/extensions/OrderedList.d.ts

@@ -0,0 +1,18 @@
+import { Extension } from '../core/extension/Extension';
+import { BlockId } from '../core/types';
+import { siblingList } from '../core/state/store';
+/**
+ * Compute the displayed 1-based ordinal for an ordered-list block.
+ *
+ * Numbering is scoped per **sibling list** (i.e. per
+ * same parent). Consecutive `orderedList` siblings in that single list are
+ * numbered continuously; any non-orderedList sibling in between breaks the
+ * chain; an explicit `attrs.startNumber` acts as a reset anchor.
+ *
+ * This is strictly narrower than the old flat-indent model: blocks under a
+ * DIFFERENT parent (even at the same depthOf) never share a counter —
+ * crossing any parent boundary resets numbering by design. This matches the
+ * rendering (BlockList nests children) and user intuition.
+ */
+export declare function orderedListNumber(doc: Parameters<typeof siblingList>[0], id: BlockId): number;
+export declare const OrderedListExtension: Extension;

package/dist/extensions/Paragraph.d.ts

@@ -0,0 +1,5 @@
+import { Extension } from '../core/extension/Extension';
+import { BlockId } from '../core/types';
+/** Slash-menu icon — SVG string from shared icons module. */
+export declare const ParagraphExtension: Extension;
+export declare const CURRENT_BLOCK_PLACEHOLDER: BlockId;

package/dist/extensions/Quote.d.ts

@@ -0,0 +1,2 @@
+import { Extension } from '../core/extension/Extension';
+export declare const QuoteExtension: Extension;

package/dist/extensions/Table.d.ts

@@ -0,0 +1,74 @@
+import { Extension } from '../core/extension/Extension';
+import { EditorRegistries } from '../core/extension/Registry';
+import { BlockId } from '../core/types';
+import { AnyCommandEntry } from '../core/command/Command';
+export interface TableInsertRowArgs {
+    readonly id: BlockId;
+    readonly beforeRow?: number;
+}
+export interface TableRemoveRowArgs {
+    readonly id: BlockId;
+    readonly row?: number;
+}
+export interface TableInsertColArgs {
+    readonly id: BlockId;
+    readonly beforeCol?: number;
+}
+export interface TableRemoveColArgs {
+    readonly id: BlockId;
+    readonly col?: number;
+}
+export interface TableToggleHeaderArgs {
+    readonly id: BlockId;
+}
+export interface TableMergeCellsArgs {
+    readonly id: BlockId;
+    readonly r1: number;
+    readonly c1: number;
+    readonly r2: number;
+    readonly c2: number;
+}
+export interface TableSplitCellArgs {
+    readonly id: BlockId;
+    readonly row: number;
+    readonly col: number;
+}
+export interface TableSplitCellsInRectArgs {
+    readonly id: BlockId;
+    readonly r1: number;
+    readonly c1: number;
+    readonly r2: number;
+    readonly c2: number;
+}
+export interface TableSetColWidthArgs {
+    readonly id: BlockId;
+    readonly col: number;
+    readonly width: number;
+}
+export interface TableDeleteArgs {
+    readonly id: BlockId;
+}
+export interface InsertTableArgs {
+    readonly rows?: number;
+    readonly cols?: number;
+    readonly after?: BlockId;
+    readonly replaceCurrent?: boolean;
+}
+/** Build all table commands. The registry context is accepted for parity with
+ *  other factories but currently unused — kept for future callers that need
+ *  schema-level coordination. */
+export declare function createTableCommands(_registries: EditorRegistries): AnyCommandEntry[];
+export declare const TableExtension: Extension;
+export declare const TABLE_ICONS: {
+    ICON_TABLE: string;
+    ICON_ROW_ABOVE: string;
+    ICON_ROW_BELOW: string;
+    ICON_COL_LEFT: string;
+    ICON_COL_RIGHT: string;
+    ICON_DEL_ROW: string;
+    ICON_DEL_COL: string;
+    ICON_MERGE: string;
+    ICON_SPLIT: string;
+    ICON_HEADER: string;
+    ICON_DELETE_TABLE: string;
+};

package/dist/extensions/TableOfContents.d.ts

@@ -0,0 +1,18 @@
+import { Extension } from '../core/extension/Extension';
+import { BlockId, DocState } from '../core/types';
+/** A single TOC entry: the heading's stable id, level, and display text. */
+export interface TocItem {
+    readonly id: BlockId;
+    readonly level: number;
+    readonly text: string;
+}
+/**
+ * Collect headings from a `DocState`, considering only TOP-LEVEL blocks
+ * (`doc.root`). Nested / indented heading blocks are ignored.
+ *
+ * Only headings that carry text are included (an empty heading is invisible
+ * and skipped). Table cells do not live in the block tree (their content is in
+ * `Block.attrs`), so any headings inside table cells are naturally excluded.
+ */
+export declare function collectHeadings(doc: DocState): readonly TocItem[];
+export declare const TableOfContentsExtension: Extension;

package/dist/extensions/TodoList.d.ts

@@ -0,0 +1,2 @@
+import { Extension } from '../core/extension/Extension';
+export declare const TodoListExtension: Extension;

package/dist/extensions/_commonAttrs.d.ts

@@ -0,0 +1,84 @@
+import { Attrs } from '../core/types';
+export type AlignValue = 'left' | 'center' | 'right' | 'justify';
+/** 支持缩进属性的块类型。 */
+export declare const INDENT_TYPES: readonly string[];
+/** 缩进上限。 */
+export declare const MAX_INDENT = 10;
+export declare const COMMON_ATTRS: {
+    readonly align: {
+        readonly default: "left";
+        readonly validate: (v: unknown) => boolean;
+    };
+    readonly color: {
+        readonly default: "default";
+        readonly validate: (v: unknown) => boolean;
+    };
+    readonly bgColor: {
+        readonly default: "default";
+        readonly validate: (v: unknown) => boolean;
+    };
+    readonly indent: {
+        readonly default: 0;
+        readonly validate: (v: unknown) => boolean;
+    };
+};
+/**
+ * 不支持缩进的块类型（quote）使用此子集，
+ * coerceAttrs 会自动丢弃 indent 属性。
+ */
+export declare const COMMON_ATTRS_NO_INDENT: {
+    readonly align: {
+        readonly default: "left";
+        readonly validate: (v: unknown) => boolean;
+    };
+    readonly color: {
+        readonly default: "default";
+        readonly validate: (v: unknown) => boolean;
+    };
+    readonly bgColor: {
+        readonly default: "default";
+        readonly validate: (v: unknown) => boolean;
+    };
+};
+/**
+ * 既不支持缩进也不支持对齐的块类型（codeBlock）使用此子集。
+ * 代码块只能左对齐：coerceAttrs 会自动丢弃 align 和 indent 属性，
+ * 这样将文本块转为代码块时会自动清除对齐属性。
+ */
+export declare const COMMON_ATTRS_NO_INDENT_NO_ALIGN: {
+    readonly color: {
+        readonly default: "default";
+        readonly validate: (v: unknown) => boolean;
+    };
+    readonly bgColor: {
+        readonly default: "default";
+        readonly validate: (v: unknown) => boolean;
+    };
+};
+/**
+ * 代码块（codeBlock）使用的 attrs 集合。
+ * 代码块不允许 color / bgColor / align，但允许 indent（作为子块时需要 be-indent-n 类）。
+ * coerceAttrs 会自动丢弃 color / bgColor / align 属性，转换时自动清除。
+ */
+export declare const CODE_BLOCK_ATTRS: {
+    readonly indent: {
+        readonly default: 0;
+        readonly validate: (v: unknown) => boolean;
+    };
+};
+/**
+ * Apply common attrs (align/color/bgColor) as CSS classes so the playground
+ * stylesheet can render them. The renderer uses `classList` instead of
+ * inline styles for theming consistency.
+ */
+export declare function classesFromAttrs(attrs: Attrs): string[];
+/** Preset text + background colors shown in the block settings menu. */
+export interface ColorPreset {
+    readonly key: string;
+    readonly label: string;
+    readonly cssValue: string;
+    /** Background opacity (0-1). Only meaningful for bg color presets. */
+    readonly opacity: number;
+}
+export declare const TEXT_COLOR_PRESETS: readonly ColorPreset[];
+export declare const BG_COLOR_PRESETS: readonly ColorPreset[];

package/dist/extensions/builtin.d.ts

@@ -0,0 +1,15 @@
+import { Extension } from '../core/extension/Extension';
+export declare const BuiltinExtensions: readonly Extension[];
+export { ParagraphExtension } from './Paragraph';
+export { HeadingExtension } from './Heading';
+export { KeymapExtension } from './Keymap';
+export { HistoryExtension } from './History';
+export { BulletListExtension } from './BulletList';
+export { OrderedListExtension } from './OrderedList';
+export { TodoListExtension } from './TodoList';
+export { QuoteExtension } from './Quote';
+export { CodeBlockExtension } from './CodeBlock';
+export { ImageExtension } from './Image';
+export { TableExtension, createTableCommands } from './Table';
+export { DividerExtension } from './Divider';
+export { TableOfContentsExtension } from './TableOfContents';