@lapismd/mira 0.0.1

package/dist/tables/grid-table.js

@@ -0,0 +1,425 @@
+import { fromMarkdown } from "mdast-util-from-markdown";
+import { toMarkdown } from "mdast-util-to-markdown";
+import { gridTablesToMarkdown } from "@adobe/mdast-util-gridtables";
+import { gridTablesFromMarkdown } from "./from-markdown";
+import { Text } from "@codemirror/state";
+import { gridTables } from "./syntax";
+const EMPTY_CELL = {
+    type: "gtCell",
+    content: "",
+    colSpan: 1,
+    rowSpan: 1,
+    children: [],
+    align: null,
+    valign: null,
+    positions: [],
+};
+function arrayMove(arr, old_index, new_index, defaultValue) {
+    if (new_index >= arr.length) {
+        let k = new_index - arr.length + 1;
+        while (k--) {
+            arr.push(structuredClone(defaultValue));
+        }
+    }
+    arr.splice(new_index, 0, arr.splice(old_index, 1)[0]);
+    return arr;
+}
+function createVirtualGrid(table, _doc) {
+    // Collect all rows from all sections
+    const allRows = [];
+    const rowMap = new Map();
+    const cellMap = new Map();
+    for (let i = 0; i < table.children.length; i++) {
+        const section = table.children[i];
+        for (let j = 0; j < section.children.length; j++) {
+            const row = section.children[j];
+            const rowType = { sectionIndex: i, section, row, rowIndex: j, cells: [] };
+            rowMap.set(row, rowType);
+            allRows.push(rowType);
+        }
+    }
+    // Build a virtual grid to track cell occupancy
+    const virtualGrid = [];
+    // Initialize the virtual grid with enough space
+    const maxCols = Math.max(...allRows.map((row) => row.row.children.reduce((sum, cell) => sum + (cell.colSpan ?? 1), 0)));
+    for (let i = 0; i < allRows.length; i++) {
+        virtualGrid[i] = new Array(maxCols).fill(null);
+    }
+    // Fill the virtual grid
+    for (let rowIndex = 0; rowIndex < allRows.length; rowIndex++) {
+        const row = allRows[rowIndex];
+        let colIndex = 0;
+        for (let i = 0; i < row.row.children.length; i++) {
+            const cell = row.row.children[i];
+            const coords = [];
+            cell.rowSpan ||= 1;
+            cell.colSpan ||= 1;
+            // Find the next available column in this row
+            while (colIndex < maxCols && virtualGrid[rowIndex][colIndex] !== null) {
+                colIndex++;
+            }
+            if (colIndex >= maxCols) {
+                break; // No more space in this row
+            }
+            // Fill the virtual grid for this cell's span
+            for (let r = rowIndex; r < Math.min(rowIndex + (cell.rowSpan ?? 1), allRows.length); r++) {
+                for (let c = colIndex; c < Math.min(colIndex + (cell.colSpan ?? 1), maxCols); c++) {
+                    const colType = { ...row, cell, coords, cellIndex: i, y: r, x: c };
+                    virtualGrid[r][c] = colType;
+                    if (!cellMap.has(cell)) {
+                        cellMap.set(cell, colType);
+                        row.cells.push(colType);
+                    }
+                    coords.push({ y: r, x: c });
+                }
+            }
+            colIndex += cell.colSpan ?? 1;
+        }
+    }
+    return { rows: allRows, grid: virtualGrid, maxCols, maxRows: allRows.length };
+}
+/**
+ * Finds the cell at the given coordinates (x, y) in a grid table, taking into
+ * account colspan and rowspan.
+ *
+ * @param table - The grid table to search
+ * @param x - Column index (0-based)
+ * @param y - Row index (0-based)
+ * @returns The cell at the given position, or null if out of bounds
+ */
+function getCellAtPosition(grid, x, y) {
+    if (y < 0 || y >= grid.rows.length) {
+        return null;
+    }
+    // Return the cell at the requested position
+    if (x < 0 || x >= grid.maxCols || grid.grid[y][x] === null) {
+        return null;
+    }
+    return grid.grid[y][x];
+}
+function getCellAtOffset(grid, offset) {
+    for (let y = 0; y < grid.grid.length; y++) {
+        for (let x = 0; x < grid.grid[y].length; x++) {
+            const cell = grid.grid[y][x];
+            if (cell) {
+                if (cell.cell.positions.find((coord) => offset >= coord.from && offset <= coord.to)) {
+                    return cell;
+                }
+            }
+        }
+    }
+    return null;
+}
+export class GridTableNode {
+    /** @internal */
+    __mdastNode;
+    __grid;
+    doc = Text.of([""]);
+    /** @internal */
+    static clone(node) {
+        return new GridTableNode(structuredClone(node.__mdastNode));
+    }
+    static fromMarkdown(doc) {
+        const root = fromMarkdown(doc, {
+            extensions: [gridTables],
+            mdastExtensions: [gridTablesFromMarkdown()],
+        });
+        if (root.children[0]?.type === "gridTable") {
+            const node = new GridTableNode(root.children[0]);
+            node.doc = Text.of(doc.split("\n"));
+            return node;
+        }
+        return null;
+    }
+    static toMarkdown(node) {
+        return toMarkdown(node, {
+            handlers: {
+                text(node) {
+                    return node.value;
+                },
+            },
+            extensions: [gridTablesToMarkdown()],
+        });
+    }
+    toMarkdown() {
+        return toMarkdown(this.__mdastNode, {
+            handlers: {
+                text(node) {
+                    return node.value;
+                },
+            },
+            extensions: [gridTablesToMarkdown()],
+        });
+    }
+    rerender() {
+        const markdown = this.toMarkdown();
+        this.__mdastNode = GridTableNode.fromMarkdown(markdown).__mdastNode;
+        this.doc = Text.of(markdown.split("\n"));
+        this.__grid = createVirtualGrid(this.__mdastNode, this.doc);
+        return this;
+    }
+    /**
+     * Constructs a new {@link TableNode} with the specified MDAST table node as
+     * the object to edit. See
+     * {@link https://github.com/micromark/micromark-extension-gfm-table | micromark/micromark-extension-gfm-table}
+     * for more information on the MDAST table node.
+     */
+    constructor(mdastNode) {
+        this.__mdastNode = mdastNode ?? { type: "gridTable", children: [] };
+        this.doc = Text.of(this.toMarkdown().split("\n"));
+        this.__grid = createVirtualGrid(this.__mdastNode, this.doc);
+    }
+    /** Returns the mdast node that this node is constructed from. */
+    getMdastNode() {
+        return this.__mdastNode;
+    }
+    /** @internal */
+    updateCellContents(x, y, children) {
+        if (typeof children === "string") {
+            const root = fromMarkdown(children, {
+                extensions: [gridTables],
+                mdastExtensions: [gridTablesFromMarkdown()],
+            });
+            this.updateCellContents(x, y, root.children);
+            return;
+        }
+        const gridItem = getCellAtPosition(this.__grid, x, y);
+        if (!gridItem)
+            return;
+        const table = this.__mdastNode;
+        const section = table.children[gridItem.sectionIndex];
+        const row = section.children[gridItem.rowIndex];
+        const cells = row.children;
+        const cell = cells[gridItem.cellIndex];
+        const cellsClone = Array.from(cells);
+        const cellClone = { ...cell, children };
+        const rowClone = { ...row, children: cellsClone };
+        cellsClone[gridItem.cellIndex] = cellClone;
+        section.children[gridItem.rowIndex] = rowClone;
+        this.rerender();
+    }
+    insertColumnAt(colIndex) {
+        for (let rowIndex = 0; rowIndex < this.__grid.maxRows; rowIndex++) {
+            const row = this.__grid.rows[rowIndex];
+            const pos = getCellAtPosition(this.__grid, colIndex, rowIndex);
+            if (pos) {
+                if (pos.cell.colSpan > 1) {
+                    pos.cell.colSpan += 1;
+                }
+                else {
+                    pos.row.children.splice(pos.cellIndex, 0, {
+                        ...structuredClone(EMPTY_CELL),
+                        rowSpan: pos.cell.rowSpan,
+                    });
+                }
+            }
+            else {
+                for (let i = this.__grid.maxCols - 1; i < colIndex; i++) {
+                    row.row.children.push(structuredClone(EMPTY_CELL));
+                }
+            }
+        }
+        this.rerender();
+    }
+    deleteColumnAt(colIndex) {
+        for (let rowIndex = 0; rowIndex < this.__grid.maxRows; rowIndex++) {
+            const row = this.__grid.rows[rowIndex];
+            const pos = getCellAtPosition(this.__grid, colIndex, rowIndex);
+            if (pos) {
+                if (pos.cell.colSpan > 1) {
+                    pos.cell.colSpan -= 1;
+                }
+                else {
+                    pos.row.children.splice(pos.cellIndex, 1);
+                }
+            }
+            else {
+                row.row.children.splice(colIndex);
+            }
+        }
+        this.rerender();
+    }
+    duplicateColumnAt(colIndex) {
+        for (let rowIndex = 0; rowIndex < this.__grid.maxRows; rowIndex++) {
+            const pos = getCellAtPosition(this.__grid, colIndex, rowIndex);
+            if (pos) {
+                pos.row.children.splice(pos.cellIndex, 0, structuredClone(pos.cell));
+            }
+        }
+        this.rerender();
+    }
+    moveColumn(colIndex, newIndex) {
+        for (let rowIndex = 0; rowIndex < this.__grid.maxRows; rowIndex++) {
+            const pos = getCellAtPosition(this.__grid, colIndex, rowIndex);
+            const newPos = getCellAtPosition(this.__grid, newIndex, rowIndex);
+            if (pos && newPos) {
+                arrayMove(pos.row.children, pos.cellIndex, newPos.cellIndex, EMPTY_CELL);
+            }
+        }
+        this.rerender();
+    }
+    position(rowIndex, colIndex) {
+        const element = getCellAtPosition(this.__grid, colIndex ?? 0, rowIndex);
+        if (!element) {
+            return null;
+        }
+        const cell = element.cell;
+        if (cell.position) {
+            const pos = structuredClone(cell.position);
+            pos.start.offset = 1 + pos.start.offset;
+            pos.end.offset = pos.end.offset - 1;
+            return pos;
+        }
+    }
+    positions(rowIndex, colIndex) {
+        const cell = getCellAtPosition(this.__grid, colIndex ?? 0, rowIndex);
+        if (!cell) {
+            return [];
+        }
+        return cell.cell.positions;
+    }
+    coordsAt(position) {
+        const cell = getCellAtOffset(this.__grid, position);
+        if (!cell) {
+            return [-1, -1];
+        }
+        return [cell.x, cell.y];
+    }
+    cellAt(position, delta) {
+        let cell;
+        if (typeof position === "number") {
+            cell = getCellAtOffset(this.__grid, position);
+        }
+        else {
+            cell = getCellAtPosition(this.__grid, position.x, position.y);
+        }
+        return delta ? this.nextColumn(cell, delta) : cell;
+    }
+    nextColumn(cell, { x, y }) {
+        if (!cell || (x == 0 && y === 0)) {
+            return cell;
+        }
+        let next = getCellAtPosition(this.__grid, cell.x + x, cell.y + y);
+        while (next && next.cell === cell.cell) {
+            next = getCellAtPosition(this.__grid, next.x + x, next.y + y);
+        }
+        return next;
+    }
+    get lastCell() {
+        return getCellAtPosition(this.__grid, this.__grid.maxCols - 1, this.__grid.maxRows - 1);
+    }
+    duplicateRowAt(y) {
+        const cell = getCellAtPosition(this.__grid, 0, y);
+        if (!cell) {
+            return;
+        }
+        const row = this.__grid.rows[cell.rowIndex];
+        const newRow = structuredClone(row.row);
+        cell.section.children.splice(cell.rowIndex, 0, newRow);
+        this.rerender();
+    }
+    getColCount() {
+        return this.__grid.maxCols;
+    }
+    getRowCount() {
+        return this.__grid.maxRows;
+    }
+    getRows(type) {
+        if (!type) {
+            return this.__grid.rows;
+        }
+        return this.__grid.rows.filter((it) => it.section.type === type);
+    }
+    get grid() {
+        return this.__grid.grid;
+    }
+    moveRow(oldIndex, newIndex) {
+        const cell = getCellAtPosition(this.__grid, 0, oldIndex);
+        const newCell = getCellAtPosition(this.__grid, 0, newIndex);
+        if (!cell || !newCell) {
+            return;
+        }
+        newCell.section.children.splice(newCell.rowIndex, 0, cell.section.children.splice(cell.rowIndex, 1)[0]);
+        this.rerender();
+    }
+    sort(colIndex, asc = true) {
+        const sections = this.__mdastNode.children.filter((section) => section.type === "gtBody");
+        const sortableSections = sections.length
+            ? sections
+            : this.__mdastNode.children;
+        const direction = asc ? 1 : -1;
+        for (const section of sortableSections) {
+            section.children.sort((a, b) => {
+                const aValue = a.children[colIndex]?.content ?? "";
+                const bValue = b.children[colIndex]?.content ?? "";
+                return (aValue.localeCompare(bValue, undefined, {
+                    numeric: true,
+                    sensitivity: "base",
+                }) * direction);
+            });
+        }
+        this.rerender();
+    }
+    insertRowAt(y) {
+        let cell = null;
+        const newRow = {
+            type: "gtRow",
+            children: Array.from({ length: this.getColCount() }, () => structuredClone(EMPTY_CELL)),
+        };
+        const rows = [];
+        for (let i = y; i >= 0; i--) {
+            cell = getCellAtPosition(this.__grid, 0, i);
+            if (cell)
+                break;
+            rows.push(structuredClone(newRow));
+        }
+        if (!cell) {
+            return;
+        }
+        if (cell.y === y) {
+            cell.section.children.splice(cell.rowIndex, 0, structuredClone(newRow));
+        }
+        else {
+            cell.section.children.push(...rows);
+        }
+        this.rerender();
+    }
+    deleteRowAt(rowIndex) {
+        const cell = getCellAtPosition(this.__grid, 0, rowIndex);
+        if (!cell) {
+            return;
+        }
+        cell.section.children.splice(cell.rowIndex, 1);
+        this.rerender();
+    }
+    addRowToBottom() {
+        this.insertRowAt(this.getRowCount());
+        this.rerender();
+    }
+    addColumnToRight() {
+        this.insertColumnAt(this.getColCount());
+        this.rerender();
+    }
+    setColumnAlign(coords, { align, valign, }) {
+        const cells = Array.isArray(coords) ? coords : [coords];
+        cells.forEach((pos) => {
+            const cell = getCellAtPosition(this.__grid, pos.x, pos.y);
+            if (!cell) {
+                return;
+            }
+            cell.cell.valign = valign ?? cell.cell.valign;
+            cell.cell.align = align ?? cell.cell.align;
+        });
+        this.rerender();
+    }
+}
+/**
+ * Creates a {@link TableNode}. Use this instead of the constructor to follow the
+ * Lexical conventions.
+ *
+ * @param mdastNode - The mdast node to create the {@link TableNode} from.
+ * @group Table
+ */
+export function $createTableNode(mdastNode) {
+    return new GridTableNode(mdastNode);
+}

package/dist/tables/grid-table.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=grid-table.test.d.ts.map

package/dist/tables/grid-table.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grid-table.test.d.ts","sourceRoot":"","sources":["../../src/tables/grid-table.test.ts"],"names":[],"mappings":""}

package/dist/tables/grid-table.test.js

@@ -0,0 +1,140 @@
+import { describe, expect, it } from "vitest";
+import { GridTableNode } from "./grid-table";
+function parseGridTable(markdown) {
+    const node = GridTableNode.fromMarkdown(markdown);
+    expect(node).not.toBeNull();
+    return node;
+}
+function reparseGridTable(node) {
+    return parseGridTable(node.toMarkdown());
+}
+function gridCellContent(node, rowIndex, colIndex) {
+    return node.grid[rowIndex]?.[colIndex]?.cell.content ?? "";
+}
+const sampleGridTable = [
+    "+----------------------+-------------------------+",
+    "| Feature              | Behavior                |",
+    "+======================+=========================+",
+    "| Row and column menus | Kebab dropdown actions  |",
+    "+----------------------+-------------------------+",
+    "| Drag handles         | Reorder rows/columns    |",
+    "+----------------------+-------------------------+",
+    "| Source toggle        | Edit raw Markdown       |",
+    "+----------------------+-------------------------+",
+].join("\n");
+const adobeOverviewGridTable = [
+    "+-------------------+------+",
+    "| Table Headings    | Here |",
+    "+--------+----------+------+",
+    "| Sub    | Headings | Too  |",
+    "+========+=================+",
+    "| cell   | column spanning |",
+    "| spans  +---------:+------+",
+    "| rows   |   normal | cell |",
+    "+---v----+:---------------:+",
+    "|        | cells can be    |",
+    "|        | *formatted*     |",
+    "|        | **paragraphs**  |",
+    "|        | ```             |",
+    "| multi  | and contain     |",
+    "| line   | blocks          |",
+    "| cells  | ```             |",
+    "+========+=========:+======+",
+    "| footer |    cells |      |",
+    "+--------+----------+------+",
+].join("\n");
+const horizontalAlignmentExamples = [
+    { align: "justify", markdown: ["+>-----<+", "| A b C |", "+-------+"] },
+    { align: "center", markdown: ["+:-----:+", "|  ABC  |", "+-------+"] },
+    { align: "left", markdown: ["+:------+", "| ABC   |", "+------+"] },
+    { align: "right", markdown: ["+------:+", "|   ABC |", "+------+"] },
+];
+const verticalAlignmentExamples = [
+    {
+        markdown: [
+            "+---^---+",
+            "| Larum |",
+            "| Ipsum |",
+            "|       |",
+            "|       |",
+            "+-------+",
+        ],
+        valign: "top",
+    },
+    {
+        markdown: [
+            "+---x---+",
+            "|       |",
+            "| Larum |",
+            "| Ipsum |",
+            "|       |",
+            "+-------+",
+        ],
+        valign: "middle",
+    },
+    {
+        markdown: [
+            "+---v---+",
+            "|       |",
+            "|       |",
+            "| Larum |",
+            "| Ipsum |",
+            "+-------+",
+        ],
+        valign: "bottom",
+    },
+];
+describe("GridTableNode", () => {
+    it("uses the Lapis grid table model", () => {
+        const node = GridTableNode.fromMarkdown([
+            "+---------+----------+",
+            "| Feature | Behavior |",
+            "+=========+==========+",
+            "| Handles | Actions  |",
+            "+---------+----------+",
+        ].join("\n"));
+        expect(node).not.toBeNull();
+        expect(node?.getRowCount()).toBe(2);
+        expect(node?.getColCount()).toBe(2);
+        expect(node?.toMarkdown()).toContain("Feature");
+    });
+    it("preserves table shape after inserting rows and columns", () => {
+        const node = parseGridTable(sampleGridTable);
+        node.insertRowAt(node.getRowCount());
+        node.insertColumnAt(node.getColCount());
+        const reparsed = reparseGridTable(node);
+        expect(reparsed.getRowCount()).toBe(5);
+        expect(reparsed.getColCount()).toBe(3);
+        expect(gridCellContent(reparsed, 0, 0)).toBe("Feature");
+        expect(gridCellContent(reparsed, 1, 1)).toBe("Kebab dropdown actions");
+    });
+    it("preserves table shape after moving rows and columns", () => {
+        const node = parseGridTable(sampleGridTable);
+        node.moveRow(2, 1);
+        node.moveColumn(1, 0);
+        const reparsed = reparseGridTable(node);
+        expect(reparsed.getRowCount()).toBe(4);
+        expect(reparsed.getColCount()).toBe(2);
+        expect(gridCellContent(reparsed, 0, 0)).toBe("Behavior");
+        expect(gridCellContent(reparsed, 1, 1)).toBe("Drag handles");
+    });
+    it("parses the Adobe grid-table overview example with merged rows and columns", () => {
+        const node = parseGridTable(adobeOverviewGridTable);
+        const cells = node
+            .getMdastNode()
+            .children.flatMap((section) => section.children.flatMap((row) => row.children));
+        expect(node.getColCount()).toBe(3);
+        expect(cells.some((cell) => cell.colSpan > 1)).toBe(true);
+        expect(cells.some((cell) => cell.rowSpan > 1)).toBe(true);
+        expect(cells.some((cell) => cell.content.includes("*formatted*"))).toBe(true);
+        expect(node.toMarkdown()).toContain("column spanning");
+    });
+    it.each(horizontalAlignmentExamples)("parses Adobe horizontal $align grid-table alignment", ({ align, markdown }) => {
+        const node = parseGridTable(markdown.join("\n"));
+        expect(node.grid[0]?.[0]?.cell.align).toBe(align);
+    });
+    it.each(verticalAlignmentExamples)("parses Adobe vertical $valign grid-table alignment", ({ valign, markdown }) => {
+        const node = parseGridTable(markdown.join("\n"));
+        expect(node.grid[0]?.[0]?.cell.valign).toBe(valign);
+    });
+});

package/dist/tables/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./extension";
+export * from "./pipe-table";
+export * from "./types";
+export * from "./widgets/grid-table-widget";
+export * from "./widgets/pipe-table-widget";
+export { GridTableNode, type ColType, type GridType, type RowType, } from "./grid-table";
+export { $convertTableElement, TableNode } from "./table-node";
+import EditorColumn from "./editor-column.svelte";
+import EditorTable from "./editor-table.svelte";
+import GridEditorColumn from "./grid-editor-column.svelte";
+import GridEditorTable from "./grid-editor-table.svelte";
+export { EditorColumn, EditorColumn as column, EditorTable, EditorTable as Table, GridEditorColumn, GridEditorColumn as GridColumn, GridEditorTable, GridEditorTable as GridTable, };
+//# sourceMappingURL=index.d.ts.map

package/dist/tables/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tables/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,SAAS,CAAC;AACxB,cAAc,6BAA6B,CAAC;AAC5C,cAAc,6BAA6B,CAAC;AAC5C,OAAO,EACL,aAAa,EACb,KAAK,OAAO,EACZ,KAAK,QAAQ,EACb,KAAK,OAAO,GACb,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,oBAAoB,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE/D,OAAO,YAAY,MAAM,wBAAwB,CAAC;AAClD,OAAO,WAAW,MAAM,uBAAuB,CAAC;AAChD,OAAO,gBAAgB,MAAM,6BAA6B,CAAC;AAC3D,OAAO,eAAe,MAAM,4BAA4B,CAAC;AAEzD,OAAO,EACL,YAAY,EACZ,YAAY,IAAI,MAAM,EACtB,WAAW,EACX,WAAW,IAAI,KAAK,EACpB,gBAAgB,EAChB,gBAAgB,IAAI,UAAU,EAC9B,eAAe,EACf,eAAe,IAAI,SAAS,GAC7B,CAAC"}

package/dist/tables/index.js

@@ -0,0 +1,12 @@
+export * from "./extension";
+export * from "./pipe-table";
+export * from "./types";
+export * from "./widgets/grid-table-widget";
+export * from "./widgets/pipe-table-widget";
+export { GridTableNode, } from "./grid-table";
+export { $convertTableElement, TableNode } from "./table-node";
+import EditorColumn from "./editor-column.svelte";
+import EditorTable from "./editor-table.svelte";
+import GridEditorColumn from "./grid-editor-column.svelte";
+import GridEditorTable from "./grid-editor-table.svelte";
+export { EditorColumn, EditorColumn as column, EditorTable, EditorTable as Table, GridEditorColumn, GridEditorColumn as GridColumn, GridEditorTable, GridEditorTable as GridTable, };

package/dist/tables/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/dist/tables/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../src/tables/index.test.ts"],"names":[],"mappings":""}

package/dist/tables/index.test.js

@@ -0,0 +1,7 @@
+import { describe, expect, it } from "vitest";
+import { createTableExtensions } from ".";
+describe("codemirror tables public API", () => {
+    it("creates the default table extensions", () => {
+        expect(createTableExtensions()).toHaveLength(3);
+    });
+});

package/dist/tables/inline-editor-extensions.d.ts

@@ -0,0 +1,3 @@
+import type { Extension } from "@codemirror/state";
+export declare function createInlineTableMarkdownExtensions(): Extension[];
+//# sourceMappingURL=inline-editor-extensions.d.ts.map

package/dist/tables/inline-editor-extensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-editor-extensions.d.ts","sourceRoot":"","sources":["../../src/tables/inline-editor-extensions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAMnD,wBAAgB,mCAAmC,IAAI,SAAS,EAAE,CAUjE"}

package/dist/tables/inline-editor-extensions.js

@@ -0,0 +1,16 @@
+import { syntaxHighlighting } from "@codemirror/language";
+import { EditorView, drawSelection } from "@codemirror/view";
+import { history } from "@codemirror/commands";
+import { miraClassHighlighter } from "@lapismd/mira/codemirror";
+import { createMarkdownCodeMirrorExtensions } from "@lapismd/mira/codemirror";
+export function createInlineTableMarkdownExtensions() {
+    return [
+        drawSelection(),
+        EditorView.lineWrapping,
+        history(),
+        EditorView.editable.of(true),
+        EditorView.editorAttributes.of({ class: "mod-inline" }),
+        syntaxHighlighting(miraClassHighlighter),
+        createMarkdownCodeMirrorExtensions(),
+    ];
+}

package/dist/tables/inline-editor-extensions.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=inline-editor-extensions.test.d.ts.map

package/dist/tables/inline-editor-extensions.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-editor-extensions.test.d.ts","sourceRoot":"","sources":["../../src/tables/inline-editor-extensions.test.ts"],"names":[],"mappings":""}

package/dist/tables/inline-editor-extensions.test.js

@@ -0,0 +1,23 @@
+import { syntaxTree } from "@codemirror/language";
+import { EditorState } from "@codemirror/state";
+import { describe, expect, it } from "vitest";
+import { createInlineTableMarkdownExtensions } from "./inline-editor-extensions";
+describe("createInlineTableMarkdownExtensions", () => {
+    it("uses the shared Mira Markdown parser for rich table cell editing", () => {
+        const state = EditorState.create({
+            doc: [
+                "**bold** _italic_ `code` [[Project Plan|Plan]] ![[Diagram]] #mira/table",
+                "\\(x + 1\\)",
+            ].join("\n"),
+            extensions: createInlineTableMarkdownExtensions(),
+        });
+        const tree = syntaxTree(state).toString();
+        expect(tree).toContain("StrongEmphasis");
+        expect(tree).toContain("Emphasis");
+        expect(tree).toContain("InlineCode");
+        expect(tree).toContain("WikiLink");
+        expect(tree).toContain("EmbedLink");
+        expect(tree).toContain("Tag");
+        expect(tree).toContain("InlineMathBracket");
+    });
+});