@damiro/stylo 0.4.0

package/dist/inplace/reveal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reveal.d.ts","sourceRoot":"","sources":["../../src/inplace/reveal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAEpD;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,WAAW,GAAG,GAAG,CAAC,MAAM,CAAC,CAQ7D"}

package/dist/inplace/scan.d.ts

@@ -0,0 +1,11 @@
+import type { Tree } from "@lezer/common";
+import type { Text } from "@codemirror/state";
+export type { Tree };
+/**
+ * Is `pos` inside a code span or code block? Regex-scanned syntax (`[[…]]`,
+ * `$…$`) is left literal in those contexts.
+ */
+export declare function inCodeContext(tree: Tree, pos: number): boolean;
+/** Does any line spanned by `[from, to]` currently hold part of a selection? */
+export declare function rangeRevealed(revealed: Set<number>, doc: Text, from: number, to: number): boolean;
+//# sourceMappingURL=scan.d.ts.map

package/dist/inplace/scan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scan.d.ts","sourceRoot":"","sources":["../../src/inplace/scan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAA;AACzC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAA;AAE7C,YAAY,EAAE,IAAI,EAAE,CAAA;AAIpB;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAQ9D;AAED,gFAAgF;AAChF,wBAAgB,aAAa,CAAC,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAKjG"}

package/dist/inplace/selection-bar.d.ts

@@ -0,0 +1,38 @@
+/**
+ * A floating inline-formatting bar that follows a non-empty selection in the
+ * in-place canvas, Notion style. Inline marks only — bold, italic,
+ * strikethrough, inline code, link, wikilink, inline math; block and insert
+ * actions live on the right-click menu.
+ *
+ * It follows an editor selection (`state.selection`) and also a text selection
+ * inside an editable table cell (a DOM selection — the widget is atomic, so it
+ * never reaches `state.selection`). In a cell the mark buttons route through
+ * `runInlineInCell`; the link / wikilink field editors do not apply there, so
+ * those buttons fall back to the plain toggle.
+ */
+import { ViewPlugin, type EditorView, type PluginValue, type ViewUpdate } from "@codemirror/view";
+declare class SelectionBar implements PluginValue {
+    private view;
+    private bar;
+    private ids;
+    private buttons;
+    private linkMenu;
+    private onScroll;
+    private onSelectionChange;
+    constructor(view: EditorView);
+    update(u: ViewUpdate): void;
+    /**
+     * Layout reads (`coordsAtPos`, `getBoundingClientRect`) are illegal inside an
+     * `update`, so the placement is computed in a measure phase and applied in the
+     * write phase. `key: this` collapses repeats within one cycle.
+     */
+    private schedule;
+    /** The screen box of the current text selection — editor or table cell. */
+    private selectionBox;
+    private measure;
+    private apply;
+    destroy(): void;
+}
+export declare const selectionBar: ViewPlugin<SelectionBar, undefined>;
+export {};
+//# sourceMappingURL=selection-bar.d.ts.map

package/dist/inplace/selection-bar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection-bar.d.ts","sourceRoot":"","sources":["../../src/inplace/selection-bar.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,UAAU,EAAE,KAAK,UAAU,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAgBjG,cAAM,YAAa,YAAW,WAAW;IAe3B,OAAO,CAAC,IAAI;IAdxB,OAAO,CAAC,GAAG,CAAa;IACxB,OAAO,CAAC,GAAG,CAAoB;IAC/B,OAAO,CAAC,OAAO,CAAiD;IAChE,OAAO,CAAC,QAAQ,CAAa;IAG7B,OAAO,CAAC,QAAQ,CAEf;IAED,OAAO,CAAC,iBAAiB,CAExB;IAED,YAAoB,IAAI,EAAE,UAAU,EAiDnC;IAED,MAAM,CAAC,CAAC,EAAE,UAAU,QAInB;IAED;;;;OAIG;IACH,OAAO,CAAC,QAAQ;IAQhB,2EAA2E;IAC3E,OAAO,CAAC,YAAY;IAwBpB,OAAO,CAAC,OAAO;IAsCf,OAAO,CAAC,KAAK;IAcb,OAAO,SAMN;CACF;AASD,eAAO,MAAM,YAAY,qCAAqC,CAAA"}

package/dist/inplace/table-cell-dom.d.ts

@@ -0,0 +1,30 @@
+import type { ParsedTable } from "./table-widget";
+/** `[head, ...body]` as raw cell strings — the editable widget's source of truth. */
+export declare const gridOf: (t: ParsedTable) => string[][];
+export declare const trimGrid: (rows: string[][]) => string[][];
+/** A GFM cell escapes a literal pipe as `\|`; unescape before inline parsing. */
+export declare const unescapePipe: (s: string) => string;
+/** Char offset of the DOM selection within `cell`'s rendered text. */
+export declare function renderedCaretOffset(cell: HTMLElement): number;
+/** `[from, to]` char offsets of the DOM selection within `cell`'s text. */
+export declare function selectionOffsets(cell: HTMLElement): {
+    from: number;
+    to: number;
+};
+/** Char offset within `cell`'s rendered text at a screen point, `0` if unresolved. */
+export declare function offsetFromPoint(cell: HTMLElement, x: number, y: number): number;
+/**
+ * Select the word at a screen point in `cell`'s raw text — the cell equivalent
+ * of the canvas's "right-click selects the word under the pointer". A point
+ * inside a marked run (`**bold phrase**`, `[a link](url)`, …) selects the whole
+ * run's text instead, so a Format toggle covers all of it. Returns `false`
+ * (leaving any caret / selection untouched) when the point is on whitespace or
+ * punctuation, so a menu opened there still has a target.
+ */
+export declare function selectWordAtPoint(cell: HTMLElement, x: number, y: number): boolean;
+/**
+ * Select `cell`'s first text node from char `offset` to char `head` (both
+ * clamped). With `head` omitted or equal, the caret is simply parked at `offset`.
+ */
+export declare function placeCaret(cell: HTMLElement, offset: number, head?: number): void;
+//# sourceMappingURL=table-cell-dom.d.ts.map

package/dist/inplace/table-cell-dom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-cell-dom.d.ts","sourceRoot":"","sources":["../../src/inplace/table-cell-dom.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAEjD,qFAAqF;AACrF,eAAO,MAAM,MAAM,MAAO,WAAW,KAAG,MAAM,EAAE,EAA4C,CAAA;AAE5F,eAAO,MAAM,QAAQ,SAAU,MAAM,EAAE,EAAE,KAAG,MAAM,EAAE,EAA6C,CAAA;AAEjG,iFAAiF;AACjF,eAAO,MAAM,YAAY,MAAO,MAAM,KAAG,MAAiC,CAAA;AAa1E,sEAAsE;AACtE,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM,CAM7D;AAED,2EAA2E;AAC3E,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,WAAW,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAYhF;AAMD,sFAAsF;AACtF,wBAAgB,eAAe,CAAC,IAAI,EAAE,WAAW,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAa/E;AAID;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,WAAW,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAelF;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,SAAS,QAgB1E"}

package/dist/inplace/table-enter.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Keyboard entry into a table.
+ *
+ * A GFM table renders as one block widget spanning every table line, registered
+ * as a single atomic range — so stock vertical cursor motion skips the whole
+ * construct and ArrowDown from the line above lands *below* the table, never in
+ * it.
+ *
+ * Here ArrowDown on the line directly above a table (ArrowUp directly below)
+ * steps in instead. In `table: "cells"` it focuses the near edge cell; in
+ * `source` it drops the caret on the adjacent table source line, which reveals
+ * the raw pipe syntax the same way a blockquote or fenced block reveals on
+ * caret entry.
+ */
+import { type Extension } from "@codemirror/state";
+import { type Command } from "@codemirror/view";
+/** ArrowDown that steps into a table on the line below. */
+export declare const enterTableFromAbove: Command;
+/** ArrowUp that steps into a table on the line above. */
+export declare const enterTableFromBelow: Command;
+export declare const inPlaceTableEnter: Extension;
+//# sourceMappingURL=table-enter.d.ts.map

package/dist/inplace/table-enter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-enter.d.ts","sourceRoot":"","sources":["../../src/inplace/table-enter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAQ,KAAK,SAAS,EAAE,MAAM,mBAAmB,CAAA;AACxD,OAAO,EAAE,KAAK,OAAO,EAA4C,MAAM,kBAAkB,CAAA;AA4CzF,2DAA2D;AAC3D,eAAO,MAAM,mBAAmB,EAAE,OAA8B,CAAA;AAChE,yDAAyD;AACzD,eAAO,MAAM,mBAAmB,EAAE,OAA+B,CAAA;AAEjE,eAAO,MAAM,iBAAiB,EAAE,SAK/B,CAAA"}

package/dist/inplace/table-gizmos.d.ts

@@ -0,0 +1,55 @@
+import type { Align } from "../toolbar/table-grid";
+import { type MenuRow } from "./context-menu";
+/** A structural edit requested from an edge `+` or the cell context menu. */
+export type StructOp = {
+    kind: "insertColumn";
+    at: number;
+    focus: [number, number];
+} | {
+    kind: "deleteColumn";
+    at: number;
+    focus: [number, number];
+} | {
+    kind: "insertRow";
+    at: number;
+    focus: [number, number];
+} | {
+    kind: "deleteRow";
+    at: number;
+    focus: [number, number];
+} | {
+    kind: "align";
+    at: number;
+    value: Align;
+};
+export interface GizmoHost {
+    /** Current grid shape, read when the menu opens. */
+    dims: () => {
+        cols: number;
+        rows: number;
+        alignAt: (c: number) => Align;
+    };
+    /** Apply a structural edit to the model and reserialise. */
+    run: (op: StructOp) => void;
+}
+export interface TableGizmos {
+    /** Overlay to append inside the positioned table wrapper. */
+    el: HTMLElement;
+    /** Re-place the edge `+` buttons against the current `<table>` layout. */
+    layout: (table: HTMLTableElement) => void;
+    /** Open the structural menu for `cell` at a screen point. `extra` rows (the
+     *  Format group for a cell selection) are appended below the structural set. */
+    openFor: (cell: HTMLElement, x: number, y: number, extra?: MenuRow[]) => void;
+    /** Drop the document-level menu listeners. */
+    destroy: () => void;
+}
+/**
+ * Editable-table affordances, Obsidian style: a `+` on the right edge (append
+ * column) and the bottom edge (append row), shown on hover, plus a right-click /
+ * long-press context menu on any cell for the full structural set. No persistent
+ * per-row / per-column chrome — the menu is contextual to the clicked cell, so it
+ * stays in reach on a table of any height. The menu reuses the canvas's shared
+ * `ContextMenu` shell (`context-menu.ts`); only the edge strips are bespoke.
+ */
+export declare function createTableGizmos(doc: Document, host: GizmoHost): TableGizmos;
+//# sourceMappingURL=table-gizmos.d.ts.map

package/dist/inplace/table-gizmos.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-gizmos.d.ts","sourceRoot":"","sources":["../../src/inplace/table-gizmos.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAA;AAClD,OAAO,EAAuC,KAAK,OAAO,EAAE,MAAM,gBAAgB,CAAA;AAElF,6EAA6E;AAC7E,MAAM,MAAM,QAAQ,GAChB;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,GAC7D;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,GAC7D;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,GAC1D;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,GAC1D;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,KAAK,CAAA;CAAE,CAAA;AAE/C,MAAM,WAAW,SAAS;IACxB,oDAAoD;IACpD,IAAI,EAAE,MAAM;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,KAAK,CAAA;KAAE,CAAA;IACzE,4DAA4D;IAC5D,GAAG,EAAE,CAAC,EAAE,EAAE,QAAQ,KAAK,IAAI,CAAA;CAC5B;AAED,MAAM,WAAW,WAAW;IAC1B,6DAA6D;IAC7D,EAAE,EAAE,WAAW,CAAA;IACf,0EAA0E;IAC1E,MAAM,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,IAAI,CAAA;IACzC;oFACgF;IAChF,OAAO,EAAE,CAAC,IAAI,EAAE,WAAW,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,EAAE,KAAK,IAAI,CAAA;IAC7E,8CAA8C;IAC9C,OAAO,EAAE,MAAM,IAAI,CAAA;CACpB;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,SAAS,GAAG,WAAW,CAmG7E"}

package/dist/inplace/table-structure.d.ts

@@ -0,0 +1,23 @@
+import type { Align } from "../toolbar/table-grid";
+/**
+ * The editable table's grid model: `rows` is `[header, ...body]` as raw cell
+ * strings, `aligns` is one entry per column. Every operation here mutates both
+ * in place and keeps them dimensionally consistent, so the widget can hand the
+ * result straight to `serializeGrid`. The guards keep the table well-formed —
+ * always a header, at least one body row, at least one column.
+ */
+export interface GridModel {
+    rows: string[][];
+    aligns: Align[];
+}
+/** Insert a blank column before index `at` (`at === cols` appends). */
+export declare function insertColumn(g: GridModel, at: number): void;
+/** Remove column `at`, unless it is the only one. */
+export declare function deleteColumn(g: GridModel, at: number): void;
+/** Insert a blank body row before index `at` (`at === rows.length` appends). */
+export declare function insertRow(g: GridModel, at: number): void;
+/** Remove row `at`, unless it is the header or the last remaining body row. */
+export declare function deleteRow(g: GridModel, at: number): void;
+/** Set column `c`'s alignment (`""` clears it back to default). */
+export declare function setAlign(g: GridModel, c: number, align: Align): void;
+//# sourceMappingURL=table-structure.d.ts.map

package/dist/inplace/table-structure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-structure.d.ts","sourceRoot":"","sources":["../../src/inplace/table-structure.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAA;AAElD;;;;;;GAMG;AACH,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,EAAE,EAAE,CAAA;IAChB,MAAM,EAAE,KAAK,EAAE,CAAA;CAChB;AAID,uEAAuE;AACvE,wBAAgB,YAAY,CAAC,CAAC,EAAE,SAAS,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,CAI3D;AAED,qDAAqD;AACrD,wBAAgB,YAAY,CAAC,CAAC,EAAE,SAAS,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,CAI3D;AAED,gFAAgF;AAChF,wBAAgB,SAAS,CAAC,CAAC,EAAE,SAAS,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,CAGxD;AAED,+EAA+E;AAC/E,wBAAgB,SAAS,CAAC,CAAC,EAAE,SAAS,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,CAGxD;AAED,mEAAmE;AACnE,wBAAgB,QAAQ,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI,CAEpE"}

package/dist/inplace/table-widget.d.ts

@@ -0,0 +1,81 @@
+import { EditorView, WidgetType } from "@codemirror/view";
+import { type Align } from "../toolbar/table-grid";
+/** Marks a transaction that came from an editable table widget's own DOM. */
+export declare const fromTableWidget: import("@codemirror/state").AnnotationType<boolean>;
+export interface ParsedTable {
+    head: string[];
+    body: string[][];
+    aligns: Align[];
+}
+/**
+ * A GFM table rendered as an editable `<table>` (`inPlace.table === "cells"`).
+ * The widget owns its DOM while mounted and keeps `rows` — the raw cell strings —
+ * as its source of truth. A cell shows its Markdown **rendered** (`renderInline`)
+ * while unfocused and swaps to the **raw source** as a plain text node while it
+ * has focus, mirroring the per-line reveal on the main canvas. Every edit
+ * re-serializes `rows` into the document with the `fromTableWidget` annotation
+ * so `tableField` remaps rather than rebuilds and DOM focus survives.
+ *
+ * The widget never stores its document range — a serialize dispatch shifts it —
+ * so `bounds()` re-derives it from `posAtDOM` plus a scan of contiguous pipe
+ * lines every time it is needed.
+ */
+export declare class EditableTableWidget extends WidgetType {
+    readonly data: ParsedTable;
+    private table;
+    private rows;
+    private editing;
+    private syncing;
+    /** Rendered-text offset from the mousedown that is bringing a cell into edit. */
+    private pendingOffset;
+    private current;
+    private gizmos;
+    private longPress;
+    /** When a long-press last opened the structural menu; a `contextmenu` the
+     *  browser synthesises from the same gesture and lands within the window is
+     *  swallowed rather than re-opening it. */
+    private longPressAt;
+    constructor(data: ParsedTable);
+    eq(other: EditableTableWidget): boolean;
+    ignoreEvent(): boolean;
+    private cols;
+    /**
+     * The table's current `[from, to]` in the document, derived from the DOM.
+     * `posAtDOM` may land on any line of the widget, so the scan grows the span in
+     * both directions across contiguous non-blank pipe lines.
+     */
+    private bounds;
+    private cellAt;
+    private coords;
+    /** Draw `cell` from `rows[r][c]` — raw text when `raw`, rendered otherwise. */
+    private paint;
+    private mkCell;
+    /** Rebuild `<thead>` / `<tbody>` from the current grid model. */
+    private renderCells;
+    private appendRow;
+    private model;
+    /** Apply a structural edit from a gizmo, rebuild, restore focus, reserialize. */
+    private runOp;
+    /** Commit `cell`'s edited text into `rows` and, unless it keeps focus, re-render it. */
+    private finish;
+    private onFocusIn;
+    private onFocusOut;
+    /** The selection as (row, col, anchor offset, head offset) within the editing cell. */
+    private readCaret;
+    private writeCaret;
+    /** Serialize `rows` into the document. */
+    private sync;
+    private onKey;
+    /**
+     * Focus the first (top-left) or last (bottom-right) cell — keyboard entry into
+     * the table from the line above or below. Returns `false` when the DOM isn't
+     * mounted, so the caller can fall back to stock cursor motion.
+     */
+    focusEdge(edge: "first" | "last"): boolean;
+    /** Open the structural menu for the cell at a screen point, from a right-click
+     *  or a long-press. */
+    private openCellMenuAt;
+    toDOM(view: EditorView): HTMLDivElement;
+    destroy(): void;
+}
+//# sourceMappingURL=table-widget.d.ts.map

package/dist/inplace/table-widget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-widget.d.ts","sourceRoot":"","sources":["../../src/inplace/table-widget.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAEzD,OAAO,EAAE,KAAK,KAAK,EAAiB,MAAM,uBAAuB,CAAA;AAuBjE,6EAA6E;AAC7E,eAAO,MAAM,eAAe,qDAA+B,CAAA;AAE3D,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,EAAE,CAAA;IACd,IAAI,EAAE,MAAM,EAAE,EAAE,CAAA;IAChB,MAAM,EAAE,KAAK,EAAE,CAAA;CAChB;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,mBAAoB,SAAQ,UAAU;IAerC,QAAQ,CAAC,IAAI,EAAE,WAAW;IAdtC,OAAO,CAAC,KAAK,CAAgC;IAC7C,OAAO,CAAC,IAAI,CAAY;IACxB,OAAO,CAAC,OAAO,CAAoC;IACnD,OAAO,CAAC,OAAO,CAAQ;IACvB,iFAAiF;IACjF,OAAO,CAAC,aAAa,CAAsB;IAC3C,OAAO,CAAC,OAAO,CAAY;IAC3B,OAAO,CAAC,MAAM,CAA2B;IACzC,OAAO,CAAC,SAAS,CAA+B;IAChD;;+CAE2C;IAC3C,OAAO,CAAC,WAAW,CAAI;IAEvB,YAAqB,IAAI,EAAE,WAAW,EAIrC;IAEQ,EAAE,CAAC,KAAK,EAAE,mBAAmB,WAQrC;IAEQ,WAAW,YAEnB;IAED,OAAO,CAAC,IAAI;IAIZ;;;;OAIG;IACH,OAAO,CAAC,MAAM;IAad,OAAO,CAAC,MAAM;IAMd,OAAO,CAAC,MAAM;IAId,+EAA+E;IAC/E,OAAO,CAAC,KAAK;IAQb,OAAO,CAAC,MAAM;IAed,iEAAiE;IACjE,OAAO,CAAC,WAAW;IAYnB,OAAO,CAAC,SAAS;IAMjB,OAAO,CAAC,KAAK;IAIb,iFAAiF;IACjF,OAAO,CAAC,KAAK;IAsBb,wFAAwF;IACxF,OAAO,CAAC,MAAM;IAMd,OAAO,CAAC,SAAS;IAajB,OAAO,CAAC,UAAU;IAQlB,uFAAuF;IACvF,OAAO,CAAC,SAAS;IAWjB,OAAO,CAAC,UAAU;IAKlB,0CAA0C;IAC1C,OAAO,CAAC,IAAI;IA0BZ,OAAO,CAAC,KAAK;IAuFb;;;;OAIG;IACH,SAAS,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,GAAG,OAAO,CASzC;IAED;2BACuB;IACvB,OAAO,CAAC,cAAc;IAetB,KAAK,CAAC,IAAI,EAAE,UAAU,kBA2ErB;IAEQ,OAAO,SAOf;CACF"}

package/dist/inplace/tables.d.ts

@@ -0,0 +1,8 @@
+import { StateField } from "@codemirror/state";
+import { type DecorationSet } from "@codemirror/view";
+/**
+ * Renders GFM tables in place. A state field, not the view plugin, because the
+ * replacement spans line breaks. The whole document is scanned — tables are few.
+ */
+export declare const tableField: StateField<DecorationSet>;
+//# sourceMappingURL=tables.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tables.d.ts","sourceRoot":"","sources":["../../src/inplace/tables.ts"],"names":[],"mappings":"AACA,OAAO,EAAgC,UAAU,EAAa,MAAM,mBAAmB,CAAA;AACvF,OAAO,EAAc,KAAK,aAAa,EAA0B,MAAM,kBAAkB,CAAA;AAqHzF;;;GAGG;AACH,eAAO,MAAM,UAAU,2BAuBrB,CAAA"}

package/dist/inplace/theme.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Display styling for the in-place canvas. Scoped to editors that include this
+ * extension (via `EditorView.theme`), so `source` mode is untouched. Sizes are
+ * relative to the editor font so they track the host's type scale; colour stays
+ * inherited from the `--stylo-*` tokens.
+ *
+ * Vertical rhythm mirrors the `preview` surface, which follows Tailwind's
+ * `prose` scale (reference only, no plugin). The match is approximate here: a
+ * `.cm-line` cannot take a `margin` without drifting click-to-position (see the
+ * 2026-09-02 click-mapping note), and a blank source line already supplies most
+ * of the inter-block gap, so heading `padding-top` is trimmed accordingly.
+ */
+export declare const inPlaceTheme: import("@codemirror/state").Extension;
+//# sourceMappingURL=theme.d.ts.map

package/dist/inplace/theme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme.d.ts","sourceRoot":"","sources":["../../src/inplace/theme.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,YAAY,uCAyavB,CAAA"}

package/dist/inplace/widgets.d.ts

@@ -0,0 +1,25 @@
+import { type EditorView, WidgetType } from "@codemirror/view";
+/** Rendered `<hr>` replacing a `---` / `***` / `___` line. */
+export declare class HrWidget extends WidgetType {
+    eq(): boolean;
+    toDOM(): HTMLHRElement;
+    ignoreEvent(): boolean;
+}
+/** `•` glyph replacing a `-` / `*` / `+` list marker. */
+export declare class BulletWidget extends WidgetType {
+    eq(): boolean;
+    toDOM(): HTMLSpanElement;
+    ignoreEvent(): boolean;
+}
+/**
+ * Interactive checkbox replacing a `[ ]` / `[x]` task marker. Toggling it
+ * dispatches a one-character change to the source (`" "` ⇄ `"x"`).
+ */
+export declare class CheckboxWidget extends WidgetType {
+    readonly checked: boolean;
+    constructor(checked: boolean);
+    eq(other: CheckboxWidget): boolean;
+    toDOM(view: EditorView): HTMLInputElement;
+    ignoreEvent(): boolean;
+}
+//# sourceMappingURL=widgets.d.ts.map

package/dist/inplace/widgets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"widgets.d.ts","sourceRoot":"","sources":["../../src/inplace/widgets.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAE9D,8DAA8D;AAC9D,qBAAa,QAAS,SAAQ,UAAU;IAC7B,EAAE,YAEV;IAED,KAAK,kBAIJ;IAEQ,WAAW,YAEnB;CACF;AAED,yDAAyD;AACzD,qBAAa,YAAa,SAAQ,UAAU;IACjC,EAAE,YAEV;IAED,KAAK,oBAKJ;IAEQ,WAAW,YAEnB;CACF;AAED;;;GAGG;AACH,qBAAa,cAAe,SAAQ,UAAU;IAChC,QAAQ,CAAC,OAAO,EAAE,OAAO;IAArC,YAAqB,OAAO,EAAE,OAAO,EAEpC;IAEQ,EAAE,CAAC,KAAK,EAAE,cAAc,WAEhC;IAED,KAAK,CAAC,IAAI,EAAE,UAAU,oBAWrB;IAEQ,WAAW,YAEnB;CACF"}

package/dist/inplace/wikilinks.d.ts

@@ -0,0 +1,10 @@
+import type { Range } from "@codemirror/state";
+import { Decoration, type EditorView } from "@codemirror/view";
+import { type Tree } from "./scan";
+/**
+ * Regex pass for `[[wikilinks]]` — the CodeMirror grammar has no node for them.
+ * Collapses each match to its label and tags it with `data-stylo-wikilink`
+ * (the delegated click handler in `inPlaceExtension` reads that attribute).
+ */
+export declare function scanWikilinks(view: EditorView, from: number, to: number, revealed: Set<number>, tree: Tree, out: Range<Decoration>[]): void;
+//# sourceMappingURL=wikilinks.d.ts.map

package/dist/inplace/wikilinks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wikilinks.d.ts","sourceRoot":"","sources":["../../src/inplace/wikilinks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAC9C,OAAO,EAAE,UAAU,EAAE,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAE9D,OAAO,EAAiB,KAAK,IAAI,EAAE,MAAM,QAAQ,CAAA;AAEjD;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAC,EACrB,IAAI,EAAE,IAAI,EACV,GAAG,EAAE,KAAK,CAAC,UAAU,CAAC,EAAE,GACvB,IAAI,CAyBN"}