@latentic/live-markdown 0.3.1 → 0.4.1

package/dist/codemirror/tablev2/tableWidgetV2.js

@@ -0,0 +1,139 @@
+import {
+  __publicField
+} from "../../chunk-V6TY7KAL.js";
+import { syntaxTree } from "@codemirror/language";
+import { StateField } from "@codemirror/state";
+import { Decoration, EditorView, WidgetType } from "@codemirror/view";
+import { inlineScanRulesFacet } from "../core/inlineScan.js";
+import { renderCellInto } from "../table/tableCell.js";
+import { parseTableNode } from "../table/tableModel.js";
+import { tableV2Sync } from "./tableV2Sync.js";
+function fillCell(el, cell, row, col, rules) {
+  renderCellInto(el, cell.html, rules);
+  el.dataset.row = String(row);
+  el.dataset.col = String(col);
+  el.dataset.cellFrom = String(cell.from);
+}
+const ROW_LINE_PX = 28;
+const HEADER_PX = 30;
+const ROW_CHARS_PER_LINE = 85;
+function estimateTableHeight(data) {
+  let height = HEADER_PX;
+  for (const row of data.rows) {
+    const rowChars = row.reduce((sum, cell) => sum + Math.max(1, cell.to - cell.from), 0);
+    height += Math.max(1, Math.ceil(rowChars / ROW_CHARS_PER_LINE)) * ROW_LINE_PX;
+  }
+  return height;
+}
+class TableWidgetV2 extends WidgetType {
+  constructor(data, sourceFrom, sourceTo) {
+    super();
+    __publicField(this, "data", data);
+    __publicField(this, "sourceFrom", sourceFrom);
+    __publicField(this, "sourceTo", sourceTo);
+    __publicField(this, "heightEstimate");
+    this.heightEstimate = estimateTableHeight(data);
+  }
+  eq(other) {
+    return other.sourceFrom === this.sourceFrom && other.sourceTo === this.sourceTo && JSON.stringify(other.data) === JSON.stringify(this.data);
+  }
+  toDOM(view) {
+    const rules = view.state.facet(inlineScanRulesFacet);
+    const wrap = document.createElement("div");
+    wrap.className = "cm-tablev2-wrap cm-table-wrap";
+    wrap.dataset.tablev2From = String(this.sourceFrom);
+    wrap.dataset.tableFrom = String(this.sourceFrom);
+    const table = document.createElement("table");
+    table.className = "cm-table-widget";
+    const thead = document.createElement("thead");
+    const headRow = document.createElement("tr");
+    this.data.header.forEach((cell, col) => {
+      const th = document.createElement("th");
+      fillCell(th, cell, 0, col, rules);
+      const align = this.data.alignments[col];
+      if (align) th.style.textAlign = align;
+      headRow.appendChild(th);
+    });
+    thead.appendChild(headRow);
+    table.appendChild(thead);
+    const tbody = document.createElement("tbody");
+    this.data.rows.forEach((cells, r) => {
+      const tr = document.createElement("tr");
+      cells.forEach((cell, col) => {
+        const td = document.createElement("td");
+        fillCell(td, cell, r + 1, col, rules);
+        const align = this.data.alignments[col];
+        if (align) td.style.textAlign = align;
+        tr.appendChild(td);
+      });
+      tbody.appendChild(tr);
+    });
+    table.appendChild(tbody);
+    wrap.appendChild(table);
+    return wrap;
+  }
+  updateDOM(dom, view) {
+    const rules = view.state.facet(inlineScanRulesFacet);
+    if (dom.dataset.tablev2From === void 0) return false;
+    const rows = dom.querySelectorAll("tr");
+    if (rows.length !== 1 + this.data.rows.length) return false;
+    const grid = [this.data.header, ...this.data.rows];
+    for (let r = 0; r < grid.length; r++) {
+      const cells = rows[r].children;
+      if (cells.length !== grid[r].length) return false;
+    }
+    dom.dataset.tablev2From = String(this.sourceFrom);
+    dom.dataset.tableFrom = String(this.sourceFrom);
+    for (let r = 0; r < grid.length; r++) {
+      const cells = rows[r].children;
+      grid[r].forEach((cell, col) => {
+        fillCell(cells[col], cell, r, col, rules);
+      });
+    }
+    return true;
+  }
+  // The surface owns all pointer/keyboard interaction inside the grid; CM
+  // resolving those events against the atomic widget would fight it.
+  ignoreEvent() {
+    return true;
+  }
+  get estimatedHeight() {
+    return this.heightEstimate;
+  }
+}
+function buildDecorations(state) {
+  const ranges = [];
+  syntaxTree(state).iterate({
+    enter(node) {
+      if (node.name !== "Table") return;
+      for (const model of parseTableNode(state, node.node)) {
+        ranges.push(
+          Decoration.replace({
+            widget: new TableWidgetV2(model.data, model.from, model.to),
+            block: true
+          }).range(model.from, model.to)
+        );
+      }
+    }
+  });
+  return Decoration.set(ranges, true);
+}
+function tableV2(surface) {
+  const field = StateField.define({
+    create: buildDecorations,
+    update(value, tr) {
+      if (tr.docChanged || syntaxTree(tr.state) !== syntaxTree(tr.startState)) {
+        return buildDecorations(tr.state);
+      }
+      return value;
+    },
+    provide: (f) => EditorView.decorations.from(f)
+  });
+  return [field, tableV2Sync(surface)];
+}
+export {
+  TableWidgetV2,
+  estimateTableHeight,
+  tableV2
+};
+//# sourceMappingURL=tableWidgetV2.js.map

package/dist/codemirror/tablev2/tableWidgetV2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/tablev2/tableWidgetV2.ts"],"sourcesContent":["/**\n * V2 table widget (ADR 0001): pure render, stable lifecycle, no editors inside.\n *\n * Lifecycle contract — the make-or-break constraint:\n *   - `eq` compares source anchors + data, so ANY doc change (offsets shift)\n *     makes CM consult `updateDOM`.\n *   - `updateDOM` patches cell contents IN PLACE (element identity preserved)\n *     and re-stamps the source anchor; it declines (→ full recreate) only when\n *     the grid SHAPE changed.\n *   - After either path, the tableV2 extension calls the active surface's\n *     `reanchor` so an in-progress cell edit survives.\n *\n * Editing is delegated entirely to a {@link CellEditingSurface}; this file has\n * no caret, focus, or selection logic by design.\n */\n\nimport { syntaxTree } from \"@codemirror/language\";\nimport { type EditorState, StateField, type Extension, type Range } from \"@codemirror/state\";\nimport { Decoration, type DecorationSet, EditorView, WidgetType } from \"@codemirror/view\";\n\nimport { inlineScanRulesFacet, type InlineScanRule } from \"../core/inlineScan\";\nimport { renderCellInto } from \"../table/tableCell\";\nimport { parseTableNode, type TableCellData, type TableData } from \"../table/tableModel\";\nimport { type CellEditingSurface } from \"./cellEditingSurface\";\nimport { tableV2Sync } from \"./tableV2Sync\";\n\nfunction fillCell(\n  el: HTMLElement,\n  cell: TableCellData,\n  row: number,\n  col: number,\n  rules: readonly InlineScanRule[],\n): void {\n  renderCellInto(el, cell.html, rules);\n  el.dataset.row = String(row);\n  el.dataset.col = String(col);\n  // The structure menu's row/column hover-tint locates cells by source pos.\n  el.dataset.cellFrom = String(cell.from);\n}\n\n/** One rendered text line inside a cell (theme line-height + padding). */\nconst ROW_LINE_PX = 28;\n/** Header row + top/bottom borders. */\nconst HEADER_PX = 30;\n/** Characters a full table row fits per rendered line at the panel's usual\n *  width. Auto layout shares this across columns proportionally to content,\n *  so per-ROW totals predict wrapping far better than any per-column guess. */\nconst ROW_CHARS_PER_LINE = 85;\n\n/**\n * Wrap-aware height estimate for an unmeasured table. CM6 places everything\n * below an unmeasured widget using this number; the previous one-line-per-row\n * assumption under-estimated prose-heavy tables by 3-5×, so a fast scroll ran\n * on geometry that was off by hundreds of px per table — and the correction,\n * landing mid-interaction, yanked the viewport and re-anchored selections\n * onto whatever content shifted under the pointer.\n */\nexport function estimateTableHeight(data: TableData): number {\n  let height = HEADER_PX;\n  for (const row of data.rows) {\n    const rowChars = row.reduce((sum, cell) => sum + Math.max(1, cell.to - cell.from), 0);\n    height += Math.max(1, Math.ceil(rowChars / ROW_CHARS_PER_LINE)) * ROW_LINE_PX;\n  }\n  return height;\n}\n\nexport class TableWidgetV2 extends WidgetType {\n  private readonly heightEstimate: number;\n\n  constructor(\n    readonly data: TableData,\n    readonly sourceFrom: number,\n    readonly sourceTo: number,\n  ) {\n    super();\n    this.heightEstimate = estimateTableHeight(data);\n  }\n\n  override eq(other: TableWidgetV2): boolean {\n    return (\n      other.sourceFrom === this.sourceFrom &&\n      other.sourceTo === this.sourceTo &&\n      JSON.stringify(other.data) === JSON.stringify(this.data)\n    );\n  }\n\n  override toDOM(view: EditorView): HTMLElement {\n    const rules = view.state.facet(inlineScanRulesFacet);\n    const wrap = document.createElement(\"div\");\n    // Both generations of class/stamp: cm-table-wrap carries the existing\n    // theme + armed-delete styling; the v2 markers are what the surface reads.\n    wrap.className = \"cm-tablev2-wrap cm-table-wrap\";\n    wrap.dataset.tablev2From = String(this.sourceFrom);\n    wrap.dataset.tableFrom = String(this.sourceFrom);\n\n    const table = document.createElement(\"table\");\n    table.className = \"cm-table-widget\";\n    const thead = document.createElement(\"thead\");\n    const headRow = document.createElement(\"tr\");\n    this.data.header.forEach((cell, col) => {\n      const th = document.createElement(\"th\");\n      fillCell(th, cell, 0, col, rules);\n      const align = this.data.alignments[col];\n      if (align) th.style.textAlign = align;\n      headRow.appendChild(th);\n    });\n    thead.appendChild(headRow);\n    table.appendChild(thead);\n\n    const tbody = document.createElement(\"tbody\");\n    this.data.rows.forEach((cells, r) => {\n      const tr = document.createElement(\"tr\");\n      cells.forEach((cell, col) => {\n        const td = document.createElement(\"td\");\n        fillCell(td, cell, r + 1, col, rules);\n        const align = this.data.alignments[col];\n        if (align) td.style.textAlign = align;\n        tr.appendChild(td);\n      });\n      tbody.appendChild(tr);\n    });\n    table.appendChild(tbody);\n    wrap.appendChild(table);\n    return wrap;\n  }\n\n  override updateDOM(dom: HTMLElement, view: EditorView): boolean {\n    const rules = view.state.facet(inlineScanRulesFacet);\n    if (dom.dataset.tablev2From === undefined) return false;\n    const rows = dom.querySelectorAll(\"tr\");\n    if (rows.length !== 1 + this.data.rows.length) return false;\n    const grid: TableCellData[][] = [this.data.header, ...this.data.rows];\n    for (let r = 0; r < grid.length; r++) {\n      const cells = rows[r].children;\n      if (cells.length !== grid[r].length) return false;\n    }\n    dom.dataset.tablev2From = String(this.sourceFrom);\n    dom.dataset.tableFrom = String(this.sourceFrom);\n    for (let r = 0; r < grid.length; r++) {\n      const cells = rows[r].children;\n      grid[r].forEach((cell, col) => {\n        fillCell(cells[col] as HTMLElement, cell, r, col, rules);\n      });\n    }\n    return true;\n  }\n\n  // The surface owns all pointer/keyboard interaction inside the grid; CM\n  // resolving those events against the atomic widget would fight it.\n  override ignoreEvent(): boolean {\n    return true;\n  }\n\n  override get estimatedHeight(): number {\n    return this.heightEstimate;\n  }\n}\n\nfunction buildDecorations(state: EditorState): DecorationSet {\n  const ranges: Range<Decoration>[] = [];\n  syntaxTree(state).iterate({\n    enter(node) {\n      if (node.name !== \"Table\") return;\n      for (const model of parseTableNode(state, node.node)) {\n        ranges.push(\n          Decoration.replace({\n            widget: new TableWidgetV2(model.data, model.from, model.to),\n            block: true,\n          }).range(model.from, model.to),\n        );\n      }\n    },\n  });\n  return Decoration.set(ranges, true);\n}\n\n/** The V2 table extension: widget field + surface synchronisation. */\nexport function tableV2(surface: CellEditingSurface): Extension {\n  const field = StateField.define<DecorationSet>({\n    create: buildDecorations,\n    update(value, tr) {\n      if (tr.docChanged || syntaxTree(tr.state) !== syntaxTree(tr.startState)) {\n        return buildDecorations(tr.state);\n      }\n      return value;\n    },\n    provide: (f) => EditorView.decorations.from(f),\n  });\n  return [field, tableV2Sync(surface)];\n}\n"],"mappings":"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","names":[]}

package/dist/codemirror/updateBus.d.ts

@@ -0,0 +1,29 @@
+import { EditorView, ViewUpdate, ViewPlugin } from '@codemirror/view';
+
+/**
+ * Editor-update fan-out that survives `view.setState`.
+ *
+ * Reactive chrome (toolbar pressed-states, the selection-actions bubble)
+ * needs a callback on every selection/doc change. Injecting an
+ * `EditorView.updateListener` with `StateEffect.appendConfig` only patches
+ * the CURRENT state's configuration — the next `view.setState` (tab switch,
+ * file reload) builds a fresh state from the base extensions and the
+ * listener silently dies, freezing the chrome at the previous document's
+ * context.
+ *
+ * The bus lives IN the base extensions, so every created state carries it,
+ * while subscriptions key on the `EditorView` — the object that is stable
+ * across state swaps.
+ */
+
+/** Include once in the editor's base extension list. */
+declare const updateBus: ViewPlugin<{
+    update(update: ViewUpdate): void;
+}, undefined>;
+/**
+ * Subscribe to every update of `view`, across all its future states.
+ * Returns the unsubscribe function — call it in the effect cleanup.
+ */
+declare function onEditorUpdate(view: EditorView, fn: (update: ViewUpdate) => void): () => void;
+
+export { onEditorUpdate, updateBus };

package/dist/codemirror/updateBus.js

@@ -0,0 +1,26 @@
+import "../chunk-V6TY7KAL.js";
+import { ViewPlugin } from "@codemirror/view";
+const subscribers = /* @__PURE__ */ new WeakMap();
+const updateBus = ViewPlugin.define((view) => ({
+  update(update) {
+    const set = subscribers.get(view);
+    if (!set) return;
+    for (const fn of [...set]) fn(update);
+  }
+}));
+function onEditorUpdate(view, fn) {
+  let set = subscribers.get(view);
+  if (!set) {
+    set = /* @__PURE__ */ new Set();
+    subscribers.set(view, set);
+  }
+  set.add(fn);
+  return () => {
+    set.delete(fn);
+  };
+}
+export {
+  onEditorUpdate,
+  updateBus
+};
+//# sourceMappingURL=updateBus.js.map

package/dist/codemirror/updateBus.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/codemirror/updateBus.ts"],"sourcesContent":["/**\n * Editor-update fan-out that survives `view.setState`.\n *\n * Reactive chrome (toolbar pressed-states, the selection-actions bubble)\n * needs a callback on every selection/doc change. Injecting an\n * `EditorView.updateListener` with `StateEffect.appendConfig` only patches\n * the CURRENT state's configuration — the next `view.setState` (tab switch,\n * file reload) builds a fresh state from the base extensions and the\n * listener silently dies, freezing the chrome at the previous document's\n * context.\n *\n * The bus lives IN the base extensions, so every created state carries it,\n * while subscriptions key on the `EditorView` — the object that is stable\n * across state swaps.\n */\n\nimport { ViewPlugin, type EditorView, type ViewUpdate } from \"@codemirror/view\";\n\nconst subscribers = new WeakMap<EditorView, Set<(update: ViewUpdate) => void>>();\n\n/** Include once in the editor's base extension list. */\nexport const updateBus = ViewPlugin.define((view) => ({\n  update(update: ViewUpdate) {\n    const set = subscribers.get(view);\n    if (!set) return;\n    for (const fn of [...set]) fn(update);\n  },\n}));\n\n/**\n * Subscribe to every update of `view`, across all its future states.\n * Returns the unsubscribe function — call it in the effect cleanup.\n */\nexport function onEditorUpdate(\n  view: EditorView,\n  fn: (update: ViewUpdate) => void,\n): () => void {\n  let set = subscribers.get(view);\n  if (!set) {\n    set = new Set();\n    subscribers.set(view, set);\n  }\n  set.add(fn);\n  return () => {\n    set.delete(fn);\n  };\n}\n"],"mappings":";AAgBA,SAAS,kBAAoD;AAE7D,MAAM,cAAc,oBAAI,QAAuD;AAGxE,MAAM,YAAY,WAAW,OAAO,CAAC,UAAU;AAAA,EACpD,OAAO,QAAoB;AACzB,UAAM,MAAM,YAAY,IAAI,IAAI;AAChC,QAAI,CAAC,IAAK;AACV,eAAW,MAAM,CAAC,GAAG,GAAG,EAAG,IAAG,MAAM;AAAA,EACtC;AACF,EAAE;AAMK,SAAS,eACd,MACA,IACY;AACZ,MAAI,MAAM,YAAY,IAAI,IAAI;AAC9B,MAAI,CAAC,KAAK;AACR,UAAM,oBAAI,IAAI;AACd,gBAAY,IAAI,MAAM,GAAG;AAAA,EAC3B;AACA,MAAI,IAAI,EAAE;AACV,SAAO,MAAM;AACX,QAAI,OAAO,EAAE;AAAA,EACf;AACF;","names":[]}

package/dist/codemirror/wikilink/index.d.ts

@@ -0,0 +1,3 @@
+export { WIKILINK_RE, wikilinkFromPathFacet, wikilinkPlugin, wikilinkTargetsFacet } from './wikilinkPlugin.js';
+import '@codemirror/state';
+import '@codemirror/view';

package/dist/codemirror/wikilink/index.js

@@ -0,0 +1,2 @@
+export * from "./wikilinkPlugin.js";
+//# sourceMappingURL=index.js.map

package/dist/codemirror/wikilink/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/wikilink/index.ts"],"sourcesContent":["/**\n * Wikilinks: `[[Note]]` / `[[Note|label]]` rendered as navigable links.\n * Target resolution lives in `src/links/`; this folder is the editor surface.\n */\nexport * from \"./wikilinkPlugin\";\n"],"mappings":"AAIA,cAAc;","names":[]}

package/dist/codemirror/wikilink/wikilinkPlugin.d.ts

@@ -0,0 +1,40 @@
+import { Facet } from '@codemirror/state';
+import { ViewPlugin, DecorationSet, ViewUpdate } from '@codemirror/view';
+
+/**
+ * Wikilink decoration plugin — recognises `[[target]]` and
+ * `[[target|alias]]` spans in the visible viewport, hides the
+ * `[[` / `|target` / `]]` markup, and styles the visible label as
+ * a clickable link.
+ *
+ * Why a separate plugin from `markdownDecorationsPlugin`: wikilinks
+ * aren't part of CommonMark / GFM, so Lezer's parser doesn't emit a
+ * node for them. We scan the visible text directly, skipping matches
+ * in code contexts (`codeContext.ts`) where `[[…]]` is literal. Same
+ * shape as the Tiptap `wikilinkExtension` — port of that logic, not
+ * a new design.
+ *
+ * Click navigation lives in `clickModel.ts` (it shares the
+ * link-target resolution path).
+ */
+
+declare const WIKILINK_RE: RegExp;
+/**
+ * Workspace-relative current file path. Wired by the editor's React
+ * shell so the navigation click can resolve relative-style
+ * wikilinks (`./note`, `../note`).
+ */
+declare const wikilinkFromPathFacet: Facet<string | undefined, string | undefined>;
+/**
+ * Set of every workspace-relative path. Used to resolve a wikilink
+ * target to a real file. Combine prefers the first registered set
+ * (the editor only adds one).
+ */
+declare const wikilinkTargetsFacet: Facet<ReadonlySet<string>, ReadonlySet<string>>;
+declare const wikilinkPlugin: ViewPlugin<{
+    decorations: DecorationSet;
+    atomic: DecorationSet;
+    update(update: ViewUpdate): void;
+}, undefined>;
+
+export { WIKILINK_RE, wikilinkFromPathFacet, wikilinkPlugin, wikilinkTargetsFacet };

package/dist/codemirror/wikilink/wikilinkPlugin.js

@@ -0,0 +1,89 @@
+import {
+  __publicField
+} from "../../chunk-V6TY7KAL.js";
+import { Facet } from "@codemirror/state";
+import {
+  Decoration,
+  EditorView,
+  ViewPlugin
+} from "@codemirror/view";
+import { parseWikilinkBody } from "../../links/wikilink.js";
+import { inCode, viewportTree } from "../core/codeContext.js";
+const WIKILINK_RE = /\[\[([^\]\n]+?)\]\]/g;
+const HIDE = Decoration.replace({});
+const linkMark = Decoration.mark({ class: "cm-wikilink" });
+const wikilinkFromPathFacet = Facet.define({
+  combine: (vals) => vals[0]
+});
+const wikilinkTargetsFacet = Facet.define({
+  combine: (vals) => vals[0] ?? /* @__PURE__ */ new Set()
+});
+function buildDecorations(view) {
+  const builder = [];
+  const atomicBuilder = [];
+  const tree = viewportTree(view);
+  for (const { from, to } of view.visibleRanges) {
+    const text = view.state.sliceDoc(from, to);
+    WIKILINK_RE.lastIndex = 0;
+    let match;
+    while ((match = WIKILINK_RE.exec(text)) !== null) {
+      const body = match[1] ?? "";
+      const { target } = parseWikilinkBody(body);
+      if (target === "") continue;
+      const matchStart = from + match.index;
+      const matchEnd = matchStart + match[0].length;
+      if (inCode(tree, matchStart) || inCode(tree, matchEnd - 2)) continue;
+      const bodyStart = matchStart + 2;
+      const bodyEnd = matchEnd - 2;
+      const pipe = body.indexOf("|");
+      let labelStart = bodyStart;
+      let labelEnd = bodyEnd;
+      if (pipe !== -1) {
+        const aliasRaw = body.slice(pipe + 1);
+        if (aliasRaw.trim() !== "") {
+          labelStart = bodyStart + pipe + 1;
+        } else {
+          labelEnd = bodyStart + pipe;
+        }
+      }
+      builder.push(HIDE.range(matchStart, labelStart));
+      atomicBuilder.push(HIDE.range(matchStart, labelStart));
+      builder.push(linkMark.range(labelStart, labelEnd));
+      builder.push(HIDE.range(labelEnd, matchEnd));
+      atomicBuilder.push(HIDE.range(labelEnd, matchEnd));
+    }
+  }
+  return {
+    decorations: Decoration.set(builder, true),
+    atomic: Decoration.set(atomicBuilder, true)
+  };
+}
+const wikilinkPlugin = ViewPlugin.fromClass(
+  class {
+    constructor(view) {
+      __publicField(this, "decorations");
+      __publicField(this, "atomic");
+      const built = buildDecorations(view);
+      this.decorations = built.decorations;
+      this.atomic = built.atomic;
+    }
+    update(update) {
+      if (update.docChanged || update.viewportChanged) {
+        const built = buildDecorations(update.view);
+        this.decorations = built.decorations;
+        this.atomic = built.atomic;
+      }
+    }
+  },
+  {
+    decorations: (v) => v.decorations,
+    provide: (plugin) => EditorView.atomicRanges.of((view) => view.plugin(plugin)?.atomic ?? Decoration.none)
+  }
+);
+export {
+  WIKILINK_RE,
+  wikilinkFromPathFacet,
+  wikilinkPlugin,
+  wikilinkTargetsFacet
+};
+//# sourceMappingURL=wikilinkPlugin.js.map

package/dist/codemirror/wikilink/wikilinkPlugin.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/wikilink/wikilinkPlugin.ts"],"sourcesContent":["/**\n * Wikilink decoration plugin — recognises `[[target]]` and\n * `[[target|alias]]` spans in the visible viewport, hides the\n * `[[` / `|target` / `]]` markup, and styles the visible label as\n * a clickable link.\n *\n * Why a separate plugin from `markdownDecorationsPlugin`: wikilinks\n * aren't part of CommonMark / GFM, so Lezer's parser doesn't emit a\n * node for them. We scan the visible text directly, skipping matches\n * in code contexts (`codeContext.ts`) where `[[…]]` is literal. Same\n * shape as the Tiptap `wikilinkExtension` — port of that logic, not\n * a new design.\n *\n * Click navigation lives in `clickModel.ts` (it shares the\n * link-target resolution path).\n */\n\nimport { Facet, type Range } from \"@codemirror/state\";\nimport {\n  Decoration,\n  type DecorationSet,\n  EditorView,\n  ViewPlugin,\n  type PluginValue,\n  type ViewUpdate,\n} from \"@codemirror/view\";\n\nimport { parseWikilinkBody } from \"../../links/wikilink\";\nimport { inCode, viewportTree } from \"../core/codeContext\";\n\nexport const WIKILINK_RE = /\\[\\[([^\\]\\n]+?)\\]\\]/g;\n\n/** Hides the `[[ … | ]]` syntax characters. */\nconst HIDE = Decoration.replace({});\n\n/** Class on the visible label so CSS can paint it as a link. */\nconst linkMark = Decoration.mark({ class: \"cm-wikilink\" });\n\n/**\n * Workspace-relative current file path. Wired by the editor's React\n * shell so the navigation click can resolve relative-style\n * wikilinks (`./note`, `../note`).\n */\nexport const wikilinkFromPathFacet = Facet.define<string | undefined, string | undefined>({\n  combine: (vals) => vals[0],\n});\n\n/**\n * Set of every workspace-relative path. Used to resolve a wikilink\n * target to a real file. Combine prefers the first registered set\n * (the editor only adds one).\n */\nexport const wikilinkTargetsFacet = Facet.define<\n  ReadonlySet<string>,\n  ReadonlySet<string>\n>({\n  combine: (vals) => vals[0] ?? new Set(),\n});\n\n/**\n * Build the decoration set for the visible viewport. Walks visible\n * ranges, scans each line's text for `[[…]]` matches, and emits\n * hide-replace + mark decorations.\n */\nfunction buildDecorations(view: EditorView): { decorations: DecorationSet; atomic: DecorationSet } {\n  const builder: Range<Decoration>[] = [];\n  const atomicBuilder: Range<Decoration>[] = [];\n  const tree = viewportTree(view);\n\n  for (const { from, to } of view.visibleRanges) {\n    const text = view.state.sliceDoc(from, to);\n    WIKILINK_RE.lastIndex = 0;\n    let match: RegExpExecArray | null;\n    while ((match = WIKILINK_RE.exec(text)) !== null) {\n      const body = match[1] ?? \"\";\n      const { target } = parseWikilinkBody(body);\n      if (target === \"\") continue;\n\n      const matchStart = from + match.index;\n      const matchEnd = matchStart + match[0].length;\n      if (inCode(tree, matchStart) || inCode(tree, matchEnd - 2)) continue;\n      const bodyStart = matchStart + 2; // after `[[`\n      const bodyEnd = matchEnd - 2; // before `]]`\n\n      // Compute the visible-label range. `[[target|alias]]` shows\n      // `alias`; `[[target]]` shows `target`.\n      const pipe = body.indexOf(\"|\");\n      let labelStart = bodyStart;\n      let labelEnd = bodyEnd;\n      if (pipe !== -1) {\n        const aliasRaw = body.slice(pipe + 1);\n        if (aliasRaw.trim() !== \"\") {\n          labelStart = bodyStart + pipe + 1;\n        } else {\n          labelEnd = bodyStart + pipe;\n        }\n      }\n\n      // Hide `[[` (and the `target|` prefix if there's an alias).\n      builder.push(HIDE.range(matchStart, labelStart));\n      atomicBuilder.push(HIDE.range(matchStart, labelStart));\n      // Style the visible label.\n      builder.push(linkMark.range(labelStart, labelEnd));\n      // Hide `]]` (and the trailing target if the alias was empty).\n      builder.push(HIDE.range(labelEnd, matchEnd));\n      atomicBuilder.push(HIDE.range(labelEnd, matchEnd));\n    }\n  }\n\n  // Decorations must be sorted by `from` then `startSide`. The\n  // produced order from the regex scan is already document-order so\n  // `sort: true` is a cheap defensive insurance.\n  return {\n    decorations: Decoration.set(builder, true),\n    atomic: Decoration.set(atomicBuilder, true),\n  };\n}\n\nexport const wikilinkPlugin = ViewPlugin.fromClass(\n  class implements PluginValue {\n    decorations: DecorationSet;\n    atomic: DecorationSet;\n    constructor(view: EditorView) {\n      const built = buildDecorations(view);\n      this.decorations = built.decorations;\n      this.atomic = built.atomic;\n    }\n    update(update: ViewUpdate) {\n      if (update.docChanged || update.viewportChanged) {\n        const built = buildDecorations(update.view);\n        this.decorations = built.decorations;\n        this.atomic = built.atomic;\n      }\n    }\n  },\n  {\n    decorations: (v) => v.decorations,\n    provide: (plugin) =>\n      EditorView.atomicRanges.of((view) => view.plugin(plugin)?.atomic ?? Decoration.none),\n  },\n);\n"],"mappings":";;;AAiBA,SAAS,aAAyB;AAClC;AAAA,EACE;AAAA,EAEA;AAAA,EACA;AAAA,OAGK;AAEP,SAAS,yBAAyB;AAClC,SAAS,QAAQ,oBAAoB;AAE9B,MAAM,cAAc;AAG3B,MAAM,OAAO,WAAW,QAAQ,CAAC,CAAC;AAGlC,MAAM,WAAW,WAAW,KAAK,EAAE,OAAO,cAAc,CAAC;AAOlD,MAAM,wBAAwB,MAAM,OAA+C;AAAA,EACxF,SAAS,CAAC,SAAS,KAAK,CAAC;AAC3B,CAAC;AAOM,MAAM,uBAAuB,MAAM,OAGxC;AAAA,EACA,SAAS,CAAC,SAAS,KAAK,CAAC,KAAK,oBAAI,IAAI;AACxC,CAAC;AAOD,SAAS,iBAAiB,MAAyE;AACjG,QAAM,UAA+B,CAAC;AACtC,QAAM,gBAAqC,CAAC;AAC5C,QAAM,OAAO,aAAa,IAAI;AAE9B,aAAW,EAAE,MAAM,GAAG,KAAK,KAAK,eAAe;AAC7C,UAAM,OAAO,KAAK,MAAM,SAAS,MAAM,EAAE;AACzC,gBAAY,YAAY;AACxB,QAAI;AACJ,YAAQ,QAAQ,YAAY,KAAK,IAAI,OAAO,MAAM;AAChD,YAAM,OAAO,MAAM,CAAC,KAAK;AACzB,YAAM,EAAE,OAAO,IAAI,kBAAkB,IAAI;AACzC,UAAI,WAAW,GAAI;AAEnB,YAAM,aAAa,OAAO,MAAM;AAChC,YAAM,WAAW,aAAa,MAAM,CAAC,EAAE;AACvC,UAAI,OAAO,MAAM,UAAU,KAAK,OAAO,MAAM,WAAW,CAAC,EAAG;AAC5D,YAAM,YAAY,aAAa;AAC/B,YAAM,UAAU,WAAW;AAI3B,YAAM,OAAO,KAAK,QAAQ,GAAG;AAC7B,UAAI,aAAa;AACjB,UAAI,WAAW;AACf,UAAI,SAAS,IAAI;AACf,cAAM,WAAW,KAAK,MAAM,OAAO,CAAC;AACpC,YAAI,SAAS,KAAK,MAAM,IAAI;AAC1B,uBAAa,YAAY,OAAO;AAAA,QAClC,OAAO;AACL,qBAAW,YAAY;AAAA,QACzB;AAAA,MACF;AAGA,cAAQ,KAAK,KAAK,MAAM,YAAY,UAAU,CAAC;AAC/C,oBAAc,KAAK,KAAK,MAAM,YAAY,UAAU,CAAC;AAErD,cAAQ,KAAK,SAAS,MAAM,YAAY,QAAQ,CAAC;AAEjD,cAAQ,KAAK,KAAK,MAAM,UAAU,QAAQ,CAAC;AAC3C,oBAAc,KAAK,KAAK,MAAM,UAAU,QAAQ,CAAC;AAAA,IACnD;AAAA,EACF;AAKA,SAAO;AAAA,IACL,aAAa,WAAW,IAAI,SAAS,IAAI;AAAA,IACzC,QAAQ,WAAW,IAAI,eAAe,IAAI;AAAA,EAC5C;AACF;AAEO,MAAM,iBAAiB,WAAW;AAAA,EACvC,MAA6B;AAAA,IAG3B,YAAY,MAAkB;AAF9B;AACA;AAEE,YAAM,QAAQ,iBAAiB,IAAI;AACnC,WAAK,cAAc,MAAM;AACzB,WAAK,SAAS,MAAM;AAAA,IACtB;AAAA,IACA,OAAO,QAAoB;AACzB,UAAI,OAAO,cAAc,OAAO,iBAAiB;AAC/C,cAAM,QAAQ,iBAAiB,OAAO,IAAI;AAC1C,aAAK,cAAc,MAAM;AACzB,aAAK,SAAS,MAAM;AAAA,MACtB;AAAA,IACF;AAAA,EACF;AAAA,EACA;AAAA,IACE,aAAa,CAAC,MAAM,EAAE;AAAA,IACtB,SAAS,CAAC,WACR,WAAW,aAAa,GAAG,CAAC,SAAS,KAAK,OAAO,MAAM,GAAG,UAAU,WAAW,IAAI;AAAA,EACvF;AACF;","names":[]}

package/dist/codemirror/wikilink/wikilinkScanRule.d.ts

@@ -0,0 +1,9 @@
+import { InlineScanRule } from '../core/inlineScan.js';
+import '@codemirror/state';
+
+/** `[[target]]` / `[[target|alias]]` for the string renderers — the label the
+ *  editor shows, styled by the same `.cm-wikilink` rule as body text. */
+
+declare const wikilinkScanRule: InlineScanRule;
+
+export { wikilinkScanRule };

package/dist/codemirror/wikilink/wikilinkScanRule.js

@@ -0,0 +1,13 @@
+import "../../chunk-V6TY7KAL.js";
+import { parseWikilinkBody } from "../../links/wikilink.js";
+import { escapeText } from "../core/htmlEscape.js";
+import { WIKILINK_RE } from "./wikilinkPlugin.js";
+const wikilinkScanRule = {
+  name: "wikilink",
+  pattern: WIKILINK_RE,
+  render: (match) => `<span class="cm-wikilink">${escapeText(parseWikilinkBody(match[1] ?? "").label)}</span>`
+};
+export {
+  wikilinkScanRule
+};
+//# sourceMappingURL=wikilinkScanRule.js.map

package/dist/codemirror/wikilink/wikilinkScanRule.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/wikilink/wikilinkScanRule.ts"],"sourcesContent":["/** `[[target]]` / `[[target|alias]]` for the string renderers — the label the\n *  editor shows, styled by the same `.cm-wikilink` rule as body text. */\n\nimport { parseWikilinkBody } from \"../../links/wikilink\";\nimport { escapeText } from \"../core/htmlEscape\";\nimport { type InlineScanRule } from \"../core/inlineScan\";\nimport { WIKILINK_RE } from \"./wikilinkPlugin\";\n\nexport const wikilinkScanRule: InlineScanRule = {\n  name: \"wikilink\",\n  pattern: WIKILINK_RE,\n  render: (match) =>\n    `<span class=\"cm-wikilink\">${escapeText(parseWikilinkBody(match[1] ?? \"\").label)}</span>`,\n};\n"],"mappings":";AAGA,SAAS,yBAAyB;AAClC,SAAS,kBAAkB;AAE3B,SAAS,mBAAmB;AAErB,MAAM,mBAAmC;AAAA,EAC9C,MAAM;AAAA,EACN,SAAS;AAAA,EACT,QAAQ,CAAC,UACP,6BAA6B,WAAW,kBAAkB,MAAM,CAAC,KAAK,EAAE,EAAE,KAAK,CAAC;AACpF;","names":[]}

package/dist/frontmatter.d.ts

@@ -0,0 +1,79 @@
+/**
+ * YAML frontmatter parsing + serialization.
+ *
+ * Convention: `--- yaml ---` block at the very top of a markdown
+ * file (before any other content). Format:
+ *
+ *   ---
+ *   status: draft
+ *   tags:
+ *     - application
+ *     - fellowship
+ *   ---
+ *
+ *   # Real content starts here
+ *
+ * This module separates the YAML chunk from the prose chunk so
+ * the WYSIWYG editor can render only the prose (no raw `key:
+ * value` lines bleeding into the user's writing surface) while a
+ * separate properties UI shows / edits the frontmatter.
+ *
+ * Round-trip rules:
+ *   - If a file has no frontmatter on disk, we MUST NOT add one
+ *     on save just because the properties panel exists.
+ *   - If a file has frontmatter, we serialize it using the same
+ *     keys/order the user wrote (best effort — yaml lib preserves
+ *     scalar formatting but not always blank lines / comments).
+ *   - The fence marker is always exactly `---` on its own line.
+ *     Some Obsidian users prefer `+++` (TOML) — out of scope for
+ *     v1; we round-trip those as body content unchanged.
+ */
+/**
+ * The frontmatter value type. Each entry is whatever YAML can
+ * decode to — strings, numbers, booleans, arrays, nested objects.
+ * The properties UI handles primitives + flat arrays cleanly;
+ * nested objects fall back to a raw YAML editor.
+ */
+type FrontmatterValue = string | number | boolean | null | FrontmatterValue[] | {
+    [key: string]: FrontmatterValue;
+};
+type Frontmatter = Record<string, FrontmatterValue>;
+interface MarkdownDocument {
+    /** Parsed YAML key/values. `null` means "no frontmatter block present". */
+    frontmatter: Frontmatter | null;
+    /** The prose portion — everything after the closing `---`. */
+    body: string;
+}
+/**
+ * Split a markdown string into its frontmatter + body. Tolerant
+ * of:
+ *   - No frontmatter at all → `frontmatter: null, body: input`
+ *   - Malformed YAML → `frontmatter: null, body: input` (we treat
+ *     the whole thing as prose rather than show parse errors)
+ *   - Empty frontmatter block (`---\n---`) → `frontmatter: {}`
+ */
+declare function parseFrontmatter(markdown: string): MarkdownDocument;
+/**
+ * Recombine frontmatter + body into a markdown string. Inverse
+ * of `parseFrontmatter` for legal inputs.
+ *
+ *   - `frontmatter: null` → just the body, no `---` fences added
+ *   - `frontmatter: {}` → no fences either (an empty frontmatter
+ *     block is semantically the same as "no frontmatter" and we
+ *     prefer the cleaner shape on save)
+ *   - Otherwise → `---\n<yaml>\n---\n<body>`
+ */
+declare function serializeMarkdown(doc: MarkdownDocument): string;
+/**
+ * Helper: update a single frontmatter field in a markdown string
+ * without touching the body. Used by the Properties UI when the
+ * user edits one value at a time.
+ *
+ * If the file had no frontmatter, this adds one with just the
+ * one field. If the value is `null` and the key exists, removes
+ * the key (and removes the whole frontmatter block if it becomes
+ * empty).
+ */
+declare function setFrontmatterField(markdown: string, key: string, value: FrontmatterValue | null): string;
+
+export { type Frontmatter, type FrontmatterValue, type MarkdownDocument, parseFrontmatter, serializeMarkdown, setFrontmatterField };

package/dist/frontmatter.js

@@ -0,0 +1,58 @@
+import "./chunk-V6TY7KAL.js";
+import { parse, stringify } from "yaml";
+const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---(\r?\n)?/;
+function parseFrontmatter(markdown) {
+  const match = markdown.match(FRONTMATTER_RE);
+  if (!match) {
+    return { frontmatter: null, body: markdown };
+  }
+  const yamlBody = match[1];
+  const afterFence = markdown.slice(match[0].length);
+  try {
+    const parsed = parse(yamlBody);
+    if (parsed == null) {
+      return { frontmatter: {}, body: afterFence };
+    }
+    if (typeof parsed !== "object" || Array.isArray(parsed)) {
+      return { frontmatter: null, body: markdown };
+    }
+    return { frontmatter: parsed, body: afterFence };
+  } catch {
+    return { frontmatter: null, body: markdown };
+  }
+}
+function serializeMarkdown(doc) {
+  if (doc.frontmatter == null || Object.keys(doc.frontmatter).length === 0) {
+    return doc.body;
+  }
+  const yamlBlock = stringify(doc.frontmatter, {
+    // Match the conventional GitHub / Obsidian dialect: 2-space
+    // indent for lists, no leading dashes shift, plain string
+    // style when possible.
+    indent: 2,
+    lineWidth: 0
+  }).trimEnd();
+  return `---
+${yamlBlock}
+---
+${doc.body}`;
+}
+function setFrontmatterField(markdown, key, value) {
+  const doc = parseFrontmatter(markdown);
+  const current = doc.frontmatter ?? {};
+  if (value === null) {
+    delete current[key];
+  } else {
+    current[key] = value;
+  }
+  return serializeMarkdown({
+    frontmatter: Object.keys(current).length === 0 ? null : current,
+    body: doc.body
+  });
+}
+export {
+  parseFrontmatter,
+  serializeMarkdown,
+  setFrontmatterField
+};
+//# sourceMappingURL=frontmatter.js.map

package/dist/frontmatter.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/frontmatter.ts"],"sourcesContent":["/**\n * YAML frontmatter parsing + serialization.\n *\n * Convention: `--- yaml ---` block at the very top of a markdown\n * file (before any other content). Format:\n *\n *   ---\n *   status: draft\n *   tags:\n *     - application\n *     - fellowship\n *   ---\n *\n *   # Real content starts here\n *\n * This module separates the YAML chunk from the prose chunk so\n * the WYSIWYG editor can render only the prose (no raw `key:\n * value` lines bleeding into the user's writing surface) while a\n * separate properties UI shows / edits the frontmatter.\n *\n * Round-trip rules:\n *   - If a file has no frontmatter on disk, we MUST NOT add one\n *     on save just because the properties panel exists.\n *   - If a file has frontmatter, we serialize it using the same\n *     keys/order the user wrote (best effort — yaml lib preserves\n *     scalar formatting but not always blank lines / comments).\n *   - The fence marker is always exactly `---` on its own line.\n *     Some Obsidian users prefer `+++` (TOML) — out of scope for\n *     v1; we round-trip those as body content unchanged.\n */\n\nimport { parse, stringify } from \"yaml\";\n\n/**\n * The frontmatter value type. Each entry is whatever YAML can\n * decode to — strings, numbers, booleans, arrays, nested objects.\n * The properties UI handles primitives + flat arrays cleanly;\n * nested objects fall back to a raw YAML editor.\n */\nexport type FrontmatterValue = string | number | boolean | null | FrontmatterValue[] | { [key: string]: FrontmatterValue };\nexport type Frontmatter = Record<string, FrontmatterValue>;\n\nexport interface MarkdownDocument {\n  /** Parsed YAML key/values. `null` means \"no frontmatter block present\". */\n  frontmatter: Frontmatter | null;\n  /** The prose portion — everything after the closing `---`. */\n  body: string;\n}\n\n/**\n * Regex matches the frontmatter block at the start of a file:\n * a `---` line, then any content (lazy), then a `---` line.\n * Multiline mode + dot-matches-newline. The block must start at\n * the very first character — frontmatter in the middle of a doc\n * doesn't count.\n *\n * Capture groups:\n *   1. The raw YAML body between the fences (no fences included)\n *   2. The optional newline after the closing fence\n */\nconst FRONTMATTER_RE = /^---\\r?\\n([\\s\\S]*?)\\r?\\n---(\\r?\\n)?/;\n\n/**\n * Split a markdown string into its frontmatter + body. Tolerant\n * of:\n *   - No frontmatter at all → `frontmatter: null, body: input`\n *   - Malformed YAML → `frontmatter: null, body: input` (we treat\n *     the whole thing as prose rather than show parse errors)\n *   - Empty frontmatter block (`---\\n---`) → `frontmatter: {}`\n */\nexport function parseFrontmatter(markdown: string): MarkdownDocument {\n  const match = markdown.match(FRONTMATTER_RE);\n  if (!match) {\n    return { frontmatter: null, body: markdown };\n  }\n  const yamlBody = match[1];\n  const afterFence = markdown.slice(match[0].length);\n  try {\n    const parsed = parse(yamlBody) as unknown;\n    // Empty block → empty record; primitive at top level → not\n    // a valid frontmatter shape, treat as no frontmatter.\n    if (parsed == null) {\n      return { frontmatter: {}, body: afterFence };\n    }\n    if (typeof parsed !== \"object\" || Array.isArray(parsed)) {\n      return { frontmatter: null, body: markdown };\n    }\n    return { frontmatter: parsed as Frontmatter, body: afterFence };\n  } catch {\n    // Malformed YAML — surface as plain content. Better to show\n    // the raw chars than to drop user-visible bytes silently.\n    return { frontmatter: null, body: markdown };\n  }\n}\n\n/**\n * Recombine frontmatter + body into a markdown string. Inverse\n * of `parseFrontmatter` for legal inputs.\n *\n *   - `frontmatter: null` → just the body, no `---` fences added\n *   - `frontmatter: {}` → no fences either (an empty frontmatter\n *     block is semantically the same as \"no frontmatter\" and we\n *     prefer the cleaner shape on save)\n *   - Otherwise → `---\\n<yaml>\\n---\\n<body>`\n */\nexport function serializeMarkdown(doc: MarkdownDocument): string {\n  if (doc.frontmatter == null || Object.keys(doc.frontmatter).length === 0) {\n    return doc.body;\n  }\n  const yamlBlock = stringify(doc.frontmatter, {\n    // Match the conventional GitHub / Obsidian dialect: 2-space\n    // indent for lists, no leading dashes shift, plain string\n    // style when possible.\n    indent: 2,\n    lineWidth: 0,\n  }).trimEnd();\n  // Exactly one newline between the closing fence and the body.\n  // That single newline gets consumed by `FRONTMATTER_RE` on\n  // re-parse, so `body` round-trips byte-identical. If the\n  // caller wants a blank line between the frontmatter and a\n  // heading, they should include the leading `\\n` in `body`.\n  return `---\\n${yamlBlock}\\n---\\n${doc.body}`;\n}\n\n/**\n * Helper: update a single frontmatter field in a markdown string\n * without touching the body. Used by the Properties UI when the\n * user edits one value at a time.\n *\n * If the file had no frontmatter, this adds one with just the\n * one field. If the value is `null` and the key exists, removes\n * the key (and removes the whole frontmatter block if it becomes\n * empty).\n */\nexport function setFrontmatterField(\n  markdown: string,\n  key: string,\n  value: FrontmatterValue | null,\n): string {\n  const doc = parseFrontmatter(markdown);\n  const current: Frontmatter = doc.frontmatter ?? {};\n  if (value === null) {\n    delete current[key];\n  } else {\n    current[key] = value;\n  }\n  return serializeMarkdown({\n    frontmatter: Object.keys(current).length === 0 ? null : current,\n    body: doc.body,\n  });\n}\n"],"mappings":";AA+BA,SAAS,OAAO,iBAAiB;AA6BjC,MAAM,iBAAiB;AAUhB,SAAS,iBAAiB,UAAoC;AACnE,QAAM,QAAQ,SAAS,MAAM,cAAc;AAC3C,MAAI,CAAC,OAAO;AACV,WAAO,EAAE,aAAa,MAAM,MAAM,SAAS;AAAA,EAC7C;AACA,QAAM,WAAW,MAAM,CAAC;AACxB,QAAM,aAAa,SAAS,MAAM,MAAM,CAAC,EAAE,MAAM;AACjD,MAAI;AACF,UAAM,SAAS,MAAM,QAAQ;AAG7B,QAAI,UAAU,MAAM;AAClB,aAAO,EAAE,aAAa,CAAC,GAAG,MAAM,WAAW;AAAA,IAC7C;AACA,QAAI,OAAO,WAAW,YAAY,MAAM,QAAQ,MAAM,GAAG;AACvD,aAAO,EAAE,aAAa,MAAM,MAAM,SAAS;AAAA,IAC7C;AACA,WAAO,EAAE,aAAa,QAAuB,MAAM,WAAW;AAAA,EAChE,QAAQ;AAGN,WAAO,EAAE,aAAa,MAAM,MAAM,SAAS;AAAA,EAC7C;AACF;AAYO,SAAS,kBAAkB,KAA+B;AAC/D,MAAI,IAAI,eAAe,QAAQ,OAAO,KAAK,IAAI,WAAW,EAAE,WAAW,GAAG;AACxE,WAAO,IAAI;AAAA,EACb;AACA,QAAM,YAAY,UAAU,IAAI,aAAa;AAAA;AAAA;AAAA;AAAA,IAI3C,QAAQ;AAAA,IACR,WAAW;AAAA,EACb,CAAC,EAAE,QAAQ;AAMX,SAAO;AAAA,EAAQ,SAAS;AAAA;AAAA,EAAU,IAAI,IAAI;AAC5C;AAYO,SAAS,oBACd,UACA,KACA,OACQ;AACR,QAAM,MAAM,iBAAiB,QAAQ;AACrC,QAAM,UAAuB,IAAI,eAAe,CAAC;AACjD,MAAI,UAAU,MAAM;AAClB,WAAO,QAAQ,GAAG;AAAA,EACpB,OAAO;AACL,YAAQ,GAAG,IAAI;AAAA,EACjB;AACA,SAAO,kBAAkB;AAAA,IACvB,aAAa,OAAO,KAAK,OAAO,EAAE,WAAW,IAAI,OAAO;AAAA,IACxD,MAAM,IAAI;AAAA,EACZ,CAAC;AACH;","names":[]}

package/dist/imageInsert.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Image-insertion pipeline. Used by both paste-from-clipboard and
+ * drag-and-drop. Both produce a `Blob`; this module turns the blob
+ * into a markdown-reference-able path:
+ *
+ *   * When a `saveBytes` writer is injected (a desktop host): writes
+ *     the bytes to `images/<timestamp>-<hash>.<ext>` and returns the
+ *     relative path. The markdown reference is portable across
+ *     machines because it's a real on-disk file.
+ *   * Otherwise (plain browser, or the write fails): falls back to a
+ *     data URL embedded directly in the markdown. The markdown file
+ *     bloats but the image stays visible through page reload without
+ *     needing a binary file API.
+ *
+ * The writer is injected rather than imported so this module stays
+ * environment-agnostic — the editor reads it off a CM6 facet
+ * ({@link saveImageBytesFacet}) the host wires up.
+ *
+ * Returned `markdownReference` is what the caller drops into
+ * `![alt](…)`. `warning` is set in the data-URL fallback case so
+ * the caller can surface a note to the user.
+ */
+interface ImageInsertOptions {
+    blob: Blob;
+    /**
+     * Persist the bytes at a workspace-relative path. `null`/omitted ⇒
+     * inline as a data URL (browser fallback).
+     */
+    saveBytes?: ((relPath: string, bytes: Uint8Array) => Promise<void>) | null;
+    /**
+     * Alt text the user typed (currently always synthesized as
+     * "pasted-image" or "dropped-image"; in phase 3d the inline
+     * rename UI lets the user edit it post-insert).
+     */
+    alt?: string;
+}
+interface ImageInsertResult {
+    markdownReference: string;
+    alt: string;
+    warning?: string;
+}
+/**
+ * Save the blob and return the markdown reference. Errors are
+ * structured (the caller decides whether to retry with a fallback
+ * or surface a notification).
+ */
+declare function insertImageBlob(opts: ImageInsertOptions): Promise<ImageInsertResult>;
+/**
+ * Build a markdown image insertion string from the result. Keeps
+ * the call site (handlePaste / handleDrop) tidy.
+ */
+declare function buildImageMarkdown(result: ImageInsertResult): string;
+/**
+ * Scan a DataTransferItemList for image blobs. Returns every
+ * image found, in order. Empty array when nothing matches —
+ * caller treats that as "fall through to text paste".
+ */
+declare function extractImageBlobs(items: DataTransferItemList | null | undefined): Blob[];
+/**
+ * Scan a FileList (drag-and-drop's `dataTransfer.files`) for
+ * image files. Drag-drop and paste use different shapes; this
+ * keeps the two paths symmetrical at the call site.
+ */
+declare function extractImageFiles(files: FileList | null | undefined): File[];
+
+export { type ImageInsertOptions, type ImageInsertResult, buildImageMarkdown, extractImageBlobs, extractImageFiles, insertImageBlob };