@latentic/live-markdown 0.3.1 → 0.4.0

package/dist/codemirror/interaction/visiblePosition.js

@@ -0,0 +1,98 @@
+import "../../chunk-V6TY7KAL.js";
+import { findClusterBreak } from "@codemirror/state";
+import { markdownDecorationsPlugin } from "../core/plugin.js";
+import { tableField } from "../table/tableField.js";
+function containingAtomic(view, p) {
+  let found = null;
+  const scan = (set) => {
+    if (found || !set) return;
+    set.between(p, p, (from, to) => {
+      if (from < p && p < to) {
+        found = { from, to };
+        return false;
+      }
+    });
+  };
+  scan(view.plugin(markdownDecorationsPlugin)?.atomic);
+  scan(view.state.field(tableField, false));
+  return found;
+}
+function tableEdgeAt(view, p, dir) {
+  let found = null;
+  view.state.field(tableField, false)?.between(p, p, (from, to) => {
+    if (dir === "backward" ? to === p : from === p) {
+      found = { from, to };
+      return false;
+    }
+  });
+  return found;
+}
+function atomicTouching(view, p, side) {
+  let found = null;
+  const scan = (set) => {
+    if (found || !set) return;
+    set.between(p, p, (from, to) => {
+      if (from === to) return;
+      if (side === "before" ? to === p : from === p) {
+        found = { from, to };
+        return false;
+      }
+    });
+  };
+  scan(view.plugin(markdownDecorationsPlugin)?.atomic);
+  scan(view.state.field(tableField, false));
+  return found;
+}
+function visibleCharBefore(view, pos) {
+  let e = pos;
+  for (; ; ) {
+    const range = containingAtomic(view, e) ?? atomicTouching(view, e, "before");
+    if (!range) break;
+    e = range.from;
+  }
+  if (e <= 0) return null;
+  const line = view.state.doc.lineAt(e);
+  if (e === line.from) return { from: e - 1, to: e };
+  return { from: line.from + findClusterBreak(line.text, e - line.from, false), to: e };
+}
+function visibleCharAfter(view, pos) {
+  const docLen = view.state.doc.length;
+  let s = pos;
+  for (; ; ) {
+    const range = containingAtomic(view, s) ?? atomicTouching(view, s, "after");
+    if (!range) break;
+    s = range.to;
+  }
+  if (s >= docLen) return null;
+  const line = view.state.doc.lineAt(s);
+  if (s === line.to) return { from: s, to: s + 1 };
+  return { from: s, to: line.from + findClusterBreak(line.text, s - line.from, true) };
+}
+function previousVisiblePosition(view, pos) {
+  if (pos <= 0) return 0;
+  let p = pos - 1;
+  while (p > 0) {
+    const range = containingAtomic(view, p) ?? tableEdgeAt(view, p, "backward");
+    if (range) p = range.from - 1;
+    else return p;
+  }
+  return 0;
+}
+function nextVisiblePosition(view, pos) {
+  const docLen = view.state.doc.length;
+  if (pos >= docLen) return docLen;
+  let p = pos + 1;
+  while (p < docLen) {
+    const range = containingAtomic(view, p) ?? tableEdgeAt(view, p, "forward");
+    if (range) p = range.to + 1;
+    else return p;
+  }
+  return docLen;
+}
+export {
+  nextVisiblePosition,
+  previousVisiblePosition,
+  visibleCharAfter,
+  visibleCharBefore
+};
+//# sourceMappingURL=visiblePosition.js.map

package/dist/codemirror/interaction/visiblePosition.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/interaction/visiblePosition.ts"],"sourcesContent":["/**\n * Visible-position navigation across hidden, atomic ranges.\n *\n * In Rich Edit Mode the caret may never land *inside* an atomic range — a\n * hidden inline marker (`**`, `[`, `` ` ``, …) or a whole table's `| … |` block\n * source. These helpers return the next / previous position that sits outside\n * every atomic range, so the arrow keys and the delete normalizer step *over* a\n * table the same way they step over an inline marker instead of walking into\n * its hidden source.\n *\n * Two atomic sources are consulted together: the decoration plugin's inline\n * ranges and the table field's block ranges. (The table also registers with\n * CM6's `EditorView.atomicRanges` facet, but that only governs CM6's *default*\n * commands — our `Prec.high` arrow/delete handlers run instead, so they have to\n * consult the table themselves or they march straight through the grid source.)\n *\n * \"Inside\" is strict: a position at a range's `from` or `to` is a boundary the\n * caret may rest on, not inside it.\n */\n\nimport { findClusterBreak } from \"@codemirror/state\";\nimport { type EditorView } from \"@codemirror/view\";\n\nimport { markdownDecorationsPlugin } from \"../core/plugin\";\nimport { tableField } from \"../table/tableField\";\n\ntype RangeQueryable = {\n  between(from: number, to: number, f: (from: number, to: number) => void | false): void;\n};\n\n/** The atomic range strictly containing `p` (inline marker or table), or null. */\nfunction containingAtomic(view: EditorView, p: number): { from: number; to: number } | null {\n  let found: { from: number; to: number } | null = null;\n  const scan = (set: RangeQueryable | null | undefined): void => {\n    if (found || !set) return;\n    set.between(p, p, (from, to) => {\n      if (from < p && p < to) {\n        found = { from, to };\n        return false;\n      }\n    });\n  };\n  scan(view.plugin(markdownDecorationsPlugin)?.atomic);\n  scan(view.state.field(tableField, false));\n  return found;\n}\n\n/**\n * A table whose far edge sits exactly at `p` in the direction of travel — its\n * `to` when stepping backward, its `from` when stepping forward. Block widgets\n * paint position `to` on the blank line just past the table (and `from` on the\n * line just before), so resting the caret there looks identical to the adjacent\n * line — a press that seems to do nothing. Treat the edge like the inside of the\n * table and step over the whole grid, so the caret moves through it in one key.\n */\nfunction tableEdgeAt(\n  view: EditorView,\n  p: number,\n  dir: \"backward\" | \"forward\",\n): { from: number; to: number } | null {\n  let found: { from: number; to: number } | null = null;\n  view.state.field(tableField, false)?.between(p, p, (from, to) => {\n    if (dir === \"backward\" ? to === p : from === p) {\n      found = { from, to };\n      return false;\n    }\n  });\n  return found;\n}\n\n/** The atomic range whose far edge sits exactly at `p` on the given side —\n *  the trailing edge when looking backward, the leading edge when forward. */\nfunction atomicTouching(\n  view: EditorView,\n  p: number,\n  side: \"before\" | \"after\",\n): { from: number; to: number } | null {\n  let found: { from: number; to: number } | null = null;\n  const scan = (set: RangeQueryable | null | undefined): void => {\n    if (found || !set) return;\n    set.between(p, p, (from, to) => {\n      if (from === to) return; // zero-length ranges aren't skippable content\n      if (side === \"before\" ? to === p : from === p) {\n        found = { from, to };\n        return false;\n      }\n    });\n  };\n  scan(view.plugin(markdownDecorationsPlugin)?.atomic);\n  scan(view.state.field(tableField, false));\n  return found;\n}\n\n/**\n * The visible grapheme immediately before/after `pos` as a deletable source\n * range, skipping any hidden markers between it and the caret — or null at the\n * document edge. Unlike {@link previousVisiblePosition} (a caret MOTION stop),\n * this never folds a marker into the range: deleting it removes exactly one\n * visible character, so `**Compose**` backspaced from either side of its\n * hidden closing `**` becomes `**Compos**`, never raw `**Compos`. A newline\n * counts as the adjacent char — callers treat that as a line-join.\n */\nexport function visibleCharBefore(\n  view: EditorView,\n  pos: number,\n): { from: number; to: number } | null {\n  let e = pos;\n  for (;;) {\n    const range = containingAtomic(view, e) ?? atomicTouching(view, e, \"before\");\n    if (!range) break;\n    e = range.from;\n  }\n  if (e <= 0) return null;\n  const line = view.state.doc.lineAt(e);\n  if (e === line.from) return { from: e - 1, to: e };\n  return { from: line.from + findClusterBreak(line.text, e - line.from, false), to: e };\n}\n\nexport function visibleCharAfter(\n  view: EditorView,\n  pos: number,\n): { from: number; to: number } | null {\n  const docLen = view.state.doc.length;\n  let s = pos;\n  for (;;) {\n    const range = containingAtomic(view, s) ?? atomicTouching(view, s, \"after\");\n    if (!range) break;\n    s = range.to;\n  }\n  if (s >= docLen) return null;\n  const line = view.state.doc.lineAt(s);\n  if (s === line.to) return { from: s, to: s + 1 };\n  return { from: s, to: line.from + findClusterBreak(line.text, s - line.from, true) };\n}\n\nexport function previousVisiblePosition(view: EditorView, pos: number): number {\n  if (pos <= 0) return 0;\n  let p = pos - 1;\n  while (p > 0) {\n    const range = containingAtomic(view, p) ?? tableEdgeAt(view, p, \"backward\");\n    if (range) p = range.from - 1;\n    else return p;\n  }\n  return 0;\n}\n\nexport function nextVisiblePosition(view: EditorView, pos: number): number {\n  const docLen = view.state.doc.length;\n  if (pos >= docLen) return docLen;\n  let p = pos + 1;\n  while (p < docLen) {\n    const range = containingAtomic(view, p) ?? tableEdgeAt(view, p, \"forward\");\n    if (range) p = range.to + 1;\n    else return p;\n  }\n  return docLen;\n}\n"],"mappings":"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","names":[]}

package/dist/codemirror/list/bulletWidget.d.ts

@@ -0,0 +1,61 @@
+import { WidgetType, EditorView } from '@codemirror/view';
+import { NodeRule } from '../core/paint.js';
+import '@codemirror/state';
+
+/**
+ * Bullet widget — a real DOM element CM6 places where the hidden
+ * `ListMark` (`-` / `*` / `1.`) used to be.
+ *
+ * Why a widget and not a CSS `::before`:
+ *   * `::before` is a pseudo-element. It paints in the right spot
+ *     but is NOT part of CM6's line metric (the requestMeasure
+ *     cycle reads `offsetTop` / `getBoundingClientRect` on real
+ *     elements and lines, not pseudo siblings). With `::before` the
+ *     bullet drifts visually as font size or padding changes, and
+ *     click coordinates on the bullet column return the wrong byte.
+ *   * A `WidgetType` rendered via `Decoration.replace({widget})`
+ *     becomes a real `<span>` in the line — its width, height, and
+ *     baseline participate in measurement. Click→byte is exact;
+ *     scroll alignment is exact.
+ *
+ * Same pattern Zettlr uses for its `BulletWidget` (see
+ * `markdown-editor/renderers/render-emphasis.ts`).
+ */
+
+declare class BulletWidget extends WidgetType {
+    /**
+     * Eq returns true if two widgets are interchangeable — when CM6
+     * reuses the existing DOM instead of replacing it. Bullets are
+     * stateless so any two bullet widgets are equivalent.
+     */
+    eq(_other: BulletWidget): boolean;
+    toDOM(_view: EditorView): HTMLElement;
+    /**
+     * Widgets can swallow input events; we don't want our bullet to.
+     * `ignoreEvent` returning `false` lets the click pass through to
+     * the editor, so clicking on the bullet column lands the caret at
+     * the start of the list item content.
+     */
+    ignoreEvent(): boolean;
+}
+/**
+ * Ordered-list marker widget — the counterpart of {@link BulletWidget} for
+ * `OrderedList` items. An ordered item's hidden `ListMark` is its number
+ * (`1.`, `2.`, …), so unlike a bullet (which swaps `-` for `•`) this renders the
+ * marker's own text — otherwise a numbered list would render as bullets.
+ */
+declare class OrderedMarkerWidget extends WidgetType {
+    private readonly marker;
+    constructor(marker: string);
+    /** Carries its number, so CM6 only rebuilds the DOM when the number changes. */
+    eq(other: OrderedMarkerWidget): boolean;
+    toDOM(_view: EditorView): HTMLElement;
+    ignoreEvent(): boolean;
+}
+/**
+ * A `-`/`*`/`+`/`1.` list mark → bullet, its number, or (for a task item)
+ * nothing beside the checkbox.
+ */
+declare const listMarkRule: NodeRule;
+
+export { BulletWidget, OrderedMarkerWidget, listMarkRule };

package/dist/codemirror/list/bulletWidget.js

@@ -0,0 +1,84 @@
+import {
+  __publicField
+} from "../../chunk-V6TY7KAL.js";
+import { Decoration, WidgetType } from "@codemirror/view";
+import { none } from "../core/paint.js";
+class BulletWidget extends WidgetType {
+  /**
+   * Eq returns true if two widgets are interchangeable — when CM6
+   * reuses the existing DOM instead of replacing it. Bullets are
+   * stateless so any two bullet widgets are equivalent.
+   */
+  eq(_other) {
+    return true;
+  }
+  toDOM(_view) {
+    const el = document.createElement("span");
+    el.className = "cm-bullet-widget";
+    el.textContent = "\u2022";
+    return el;
+  }
+  /**
+   * Widgets can swallow input events; we don't want our bullet to.
+   * `ignoreEvent` returning `false` lets the click pass through to
+   * the editor, so clicking on the bullet column lands the caret at
+   * the start of the list item content.
+   */
+  ignoreEvent() {
+    return false;
+  }
+}
+class OrderedMarkerWidget extends WidgetType {
+  constructor(marker) {
+    super();
+    __publicField(this, "marker", marker);
+  }
+  /** Carries its number, so CM6 only rebuilds the DOM when the number changes. */
+  eq(other) {
+    return other.marker === this.marker;
+  }
+  toDOM(_view) {
+    const el = document.createElement("span");
+    el.className = "cm-bullet-widget cm-ordered-marker";
+    el.textContent = this.marker;
+    return el;
+  }
+  ignoreEvent() {
+    return false;
+  }
+}
+const BULLET_REPLACE = Decoration.replace({ widget: new BulletWidget() });
+const listMarkRule = (ctx) => {
+  if (ctx.state.doc.sliceString(ctx.to, ctx.to + 1) !== " ") {
+    return none;
+  }
+  const atomicTo = ctx.to + 1;
+  const listItem = ctx.node.parent;
+  if (listItem?.getChild("Task")) {
+    return { paint: "hide", atomicTo };
+  }
+  const list = listItem?.parent;
+  if (list?.name === "OrderedList") {
+    const state = ctx.state;
+    const delimiter = state.sliceDoc(ctx.from, ctx.to).replace(/^\d+/, "") || ".";
+    const firstMark = list.firstChild?.getChild("ListMark");
+    const start = firstMark ? Number.parseInt(state.sliceDoc(firstMark.from, firstMark.to), 10) : 1;
+    let offset = 0;
+    for (let sibling = listItem?.prevSibling; sibling; sibling = sibling.prevSibling) {
+      if (sibling.name === "ListItem") offset += 1;
+    }
+    const ordinal = (Number.isNaN(start) ? 1 : start) + offset;
+    return {
+      paint: "widget",
+      deco: Decoration.replace({ widget: new OrderedMarkerWidget(`${ordinal}${delimiter}`) }),
+      atomicTo
+    };
+  }
+  return { paint: "widget", deco: BULLET_REPLACE, atomicTo };
+};
+export {
+  BulletWidget,
+  OrderedMarkerWidget,
+  listMarkRule
+};
+//# sourceMappingURL=bulletWidget.js.map

package/dist/codemirror/list/bulletWidget.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/list/bulletWidget.ts"],"sourcesContent":["/**\n * Bullet widget — a real DOM element CM6 places where the hidden\n * `ListMark` (`-` / `*` / `1.`) used to be.\n *\n * Why a widget and not a CSS `::before`:\n *   * `::before` is a pseudo-element. It paints in the right spot\n *     but is NOT part of CM6's line metric (the requestMeasure\n *     cycle reads `offsetTop` / `getBoundingClientRect` on real\n *     elements and lines, not pseudo siblings). With `::before` the\n *     bullet drifts visually as font size or padding changes, and\n *     click coordinates on the bullet column return the wrong byte.\n *   * A `WidgetType` rendered via `Decoration.replace({widget})`\n *     becomes a real `<span>` in the line — its width, height, and\n *     baseline participate in measurement. Click→byte is exact;\n *     scroll alignment is exact.\n *\n * Same pattern Zettlr uses for its `BulletWidget` (see\n * `markdown-editor/renderers/render-emphasis.ts`).\n */\n\nimport { Decoration, WidgetType, type EditorView } from \"@codemirror/view\";\n\nimport { type NodeRule, type Paint, none } from \"../core/paint\";\n\nexport class BulletWidget extends WidgetType {\n  /**\n   * Eq returns true if two widgets are interchangeable — when CM6\n   * reuses the existing DOM instead of replacing it. Bullets are\n   * stateless so any two bullet widgets are equivalent.\n   */\n  override eq(_other: BulletWidget): boolean {\n    return true;\n  }\n\n  override toDOM(_view: EditorView): HTMLElement {\n    const el = document.createElement(\"span\");\n    el.className = \"cm-bullet-widget\";\n    el.textContent = \"•\";\n    return el;\n  }\n\n  /**\n   * Widgets can swallow input events; we don't want our bullet to.\n   * `ignoreEvent` returning `false` lets the click pass through to\n   * the editor, so clicking on the bullet column lands the caret at\n   * the start of the list item content.\n   */\n  override ignoreEvent(): boolean {\n    return false;\n  }\n}\n\n/**\n * Ordered-list marker widget — the counterpart of {@link BulletWidget} for\n * `OrderedList` items. An ordered item's hidden `ListMark` is its number\n * (`1.`, `2.`, …), so unlike a bullet (which swaps `-` for `•`) this renders the\n * marker's own text — otherwise a numbered list would render as bullets.\n */\nexport class OrderedMarkerWidget extends WidgetType {\n  constructor(private readonly marker: string) {\n    super();\n  }\n\n  /** Carries its number, so CM6 only rebuilds the DOM when the number changes. */\n  override eq(other: OrderedMarkerWidget): boolean {\n    return other.marker === this.marker;\n  }\n\n  override toDOM(_view: EditorView): HTMLElement {\n    const el = document.createElement(\"span\");\n    el.className = \"cm-bullet-widget cm-ordered-marker\";\n    el.textContent = this.marker;\n    return el;\n  }\n\n  override ignoreEvent(): boolean {\n    return false;\n  }\n}\n\n/* ---------------- The ListMark rule ---------------- */\n\n\n\nconst BULLET_REPLACE = Decoration.replace({ widget: new BulletWidget() });\n\n/**\n * A `-`/`*`/`+`/`1.` list mark → bullet, its number, or (for a task item)\n * nothing beside the checkbox.\n */\nexport const listMarkRule: NodeRule = (ctx): Paint => {\n  // A marker renders only once it's COMPLETE — followed by a space. A lone\n  // `-` at the end of a line is text the user is still typing; rendering it\n  // as a bullet mid-type is the surprise we avoid (CommonMark does count it\n  // as an empty item).\n  if (ctx.state.doc.sliceString(ctx.to, ctx.to + 1) !== \" \") {\n    return none;\n  }\n  const atomicTo = ctx.to + 1;\n  const listItem = ctx.node.parent;\n  // A task item's checkbox IS its marker (`ListItem` → `ListMark` + `Task`):\n  // hide the list mark rather than drawing a bullet next to the checkbox.\n  if (listItem?.getChild(\"Task\")) {\n    return { paint: \"hide\", atomicTo };\n  }\n  // An ordered item renders its number, never a `•`. Renumber on display\n  // (CommonMark): start at the first item's number and increment by position,\n  // so `1. 1. 1.` shows as `1. 2. 3.`. The source delimiter (`.`/`)`) is kept.\n  const list = listItem?.parent;\n  if (list?.name === \"OrderedList\") {\n    const state = ctx.state;\n    const delimiter = state.sliceDoc(ctx.from, ctx.to).replace(/^\\d+/, \"\") || \".\";\n    const firstMark = list.firstChild?.getChild(\"ListMark\");\n    const start = firstMark\n      ? Number.parseInt(state.sliceDoc(firstMark.from, firstMark.to), 10)\n      : 1;\n    let offset = 0;\n    for (let sibling = listItem?.prevSibling; sibling; sibling = sibling.prevSibling) {\n      if (sibling.name === \"ListItem\") offset += 1;\n    }\n    const ordinal = (Number.isNaN(start) ? 1 : start) + offset;\n    return {\n      paint: \"widget\",\n      deco: Decoration.replace({ widget: new OrderedMarkerWidget(`${ordinal}${delimiter}`) }),\n      atomicTo,\n    };\n  }\n  return { paint: \"widget\", deco: BULLET_REPLACE, atomicTo };\n};\n"],"mappings":";;;AAoBA,SAAS,YAAY,kBAAmC;AAExD,SAAoC,YAAY;AAEzC,MAAM,qBAAqB,WAAW;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMlC,GAAG,QAA+B;AACzC,WAAO;AAAA,EACT;AAAA,EAES,MAAM,OAAgC;AAC7C,UAAM,KAAK,SAAS,cAAc,MAAM;AACxC,OAAG,YAAY;AACf,OAAG,cAAc;AACjB,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQS,cAAuB;AAC9B,WAAO;AAAA,EACT;AACF;AAQO,MAAM,4BAA4B,WAAW;AAAA,EAClD,YAA6B,QAAgB;AAC3C,UAAM;AADqB;AAAA,EAE7B;AAAA;AAAA,EAGS,GAAG,OAAqC;AAC/C,WAAO,MAAM,WAAW,KAAK;AAAA,EAC/B;AAAA,EAES,MAAM,OAAgC;AAC7C,UAAM,KAAK,SAAS,cAAc,MAAM;AACxC,OAAG,YAAY;AACf,OAAG,cAAc,KAAK;AACtB,WAAO;AAAA,EACT;AAAA,EAES,cAAuB;AAC9B,WAAO;AAAA,EACT;AACF;AAMA,MAAM,iBAAiB,WAAW,QAAQ,EAAE,QAAQ,IAAI,aAAa,EAAE,CAAC;AAMjE,MAAM,eAAyB,CAAC,QAAe;AAKpD,MAAI,IAAI,MAAM,IAAI,YAAY,IAAI,IAAI,IAAI,KAAK,CAAC,MAAM,KAAK;AACzD,WAAO;AAAA,EACT;AACA,QAAM,WAAW,IAAI,KAAK;AAC1B,QAAM,WAAW,IAAI,KAAK;AAG1B,MAAI,UAAU,SAAS,MAAM,GAAG;AAC9B,WAAO,EAAE,OAAO,QAAQ,SAAS;AAAA,EACnC;AAIA,QAAM,OAAO,UAAU;AACvB,MAAI,MAAM,SAAS,eAAe;AAChC,UAAM,QAAQ,IAAI;AAClB,UAAM,YAAY,MAAM,SAAS,IAAI,MAAM,IAAI,EAAE,EAAE,QAAQ,QAAQ,EAAE,KAAK;AAC1E,UAAM,YAAY,KAAK,YAAY,SAAS,UAAU;AACtD,UAAM,QAAQ,YACV,OAAO,SAAS,MAAM,SAAS,UAAU,MAAM,UAAU,EAAE,GAAG,EAAE,IAChE;AACJ,QAAI,SAAS;AACb,aAAS,UAAU,UAAU,aAAa,SAAS,UAAU,QAAQ,aAAa;AAChF,UAAI,QAAQ,SAAS,WAAY,WAAU;AAAA,IAC7C;AACA,UAAM,WAAW,OAAO,MAAM,KAAK,IAAI,IAAI,SAAS;AACpD,WAAO;AAAA,MACL,OAAO;AAAA,MACP,MAAM,WAAW,QAAQ,EAAE,QAAQ,IAAI,oBAAoB,GAAG,OAAO,GAAG,SAAS,EAAE,EAAE,CAAC;AAAA,MACtF;AAAA,IACF;AAAA,EACF;AACA,SAAO,EAAE,OAAO,UAAU,MAAM,gBAAgB,SAAS;AAC3D;","names":[]}

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

@@ -0,0 +1,4 @@
+export { tightListContinuation, tightListKeymap } from './listContinuation.js';
+export { indentListItem, listIndentKeymap, outdentListItem } from './listIndent.js';
+import '@codemirror/state';
+import '@codemirror/view';

package/dist/codemirror/list/index.js

@@ -0,0 +1,3 @@
+export * from "./listContinuation.js";
+export * from "./listIndent.js";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/list/index.ts"],"sourcesContent":["/**\n * Lists and tasks: Enter continuation, Tab/Shift-Tab indent, and the\n * bullet / number / checkbox widgets that render the markers.\n */\nexport * from \"./listContinuation\";\nexport * from \"./listIndent\";\n"],"mappings":"AAIA,cAAc;AACd,cAAc;","names":[]}

package/dist/codemirror/list/listContinuation.d.ts

@@ -0,0 +1,28 @@
+import * as _codemirror_state from '@codemirror/state';
+import { Command } from '@codemirror/view';
+
+/**
+ * Tight list continuation on Enter.
+ *
+ * `@codemirror/lang-markdown`'s stock `insertNewlineContinueMarkup` continues a
+ * list when you press Enter, but for any list it considers "non-tight" (loose —
+ * because a blank line crept in, or a paragraph lazily continues below the
+ * list) it PREPENDS a blank line on every Enter. To the user that reads as the
+ * caret "skipping a line": you wanted a new bullet on the very next line and
+ * got a gap instead. People editing a rich bullet list expect Enter to always
+ * drop the next bullet tight against the current one.
+ *
+ * This command handles two cases: Enter at the END of a NON-EMPTY, non-task
+ * bullet/ordered item — inserting a plain `\n<indent><marker> ` with no blank
+ * line, always tight — and Enter at a TASK item's content start, splitting it
+ * into an empty unchecked box above and the original item below (#95). Empty
+ * items (exit-the-list), task continuation at line end, code blocks,
+ * blockquotes, other mid-line splits, and every non-list case return `false`
+ * and fall through to the stock markdown / default Enter handlers, so their
+ * existing behavior is untouched. Bound at `Prec.highest` so it runs before
+ * the markdown keymap's Enter.
+ */
+declare const tightListContinuation: Command;
+declare const tightListKeymap: _codemirror_state.Extension;
+
+export { tightListContinuation, tightListKeymap };

package/dist/codemirror/list/listContinuation.js

@@ -0,0 +1,61 @@
+import "../../chunk-V6TY7KAL.js";
+import { EditorSelection, Prec } from "@codemirror/state";
+import { keymap } from "@codemirror/view";
+import { lineStructure } from "../core/lineStructure.js";
+import { treeAt } from "../core/treeAt.js";
+const tightListContinuation = (view) => {
+  const { state } = view;
+  const { main } = state.selection;
+  if (!main.empty) return false;
+  const line = state.doc.lineAt(main.head);
+  const info = lineStructure(state, line);
+  if (info.list?.task && !info.inCode && main.head === info.list.markTo && info.list.markTo < line.to) {
+    const mark = state.sliceDoc(info.list.markFrom, info.list.markTo);
+    const indent2 = state.sliceDoc(line.from, info.list.markFrom);
+    const insert2 = `${state.lineBreak}${indent2}${mark}`;
+    view.dispatch({
+      changes: [
+        // Same length as `mark` — the caret math below relies on that.
+        { from: info.list.markFrom, to: info.list.markTo, insert: mark.replace(/\[[xX]\]/, "[ ]") },
+        { from: main.head, insert: insert2 }
+      ],
+      selection: EditorSelection.cursor(main.head + insert2.length),
+      scrollIntoView: true,
+      userEvent: "input"
+    });
+    return true;
+  }
+  if (main.head !== line.to) return false;
+  const match = /^(\s*)([-*+]|\d+[.)])\s+(\S.*)$/.exec(line.text);
+  if (!match) return false;
+  const [, indent, marker, content] = match;
+  if (/^\[[ xX]\]/.test(content)) return false;
+  let inList = false;
+  const cursor = treeAt(state, main.head).resolveInner(main.head, -1).cursor();
+  do {
+    const name = cursor.name;
+    if (name === "ListItem" || name === "BulletList" || name === "OrderedList") {
+      inList = true;
+    }
+    if (/Code/.test(name)) return false;
+  } while (cursor.parent());
+  if (!inList) return false;
+  const ordered = /^(\d+)([.)])$/.exec(marker);
+  const nextMarker = ordered ? `${parseInt(ordered[1], 10) + 1}${ordered[2]}` : marker;
+  const insert = `${state.lineBreak}${indent}${nextMarker} `;
+  view.dispatch({
+    changes: { from: main.head, insert },
+    selection: EditorSelection.cursor(main.head + insert.length),
+    scrollIntoView: true,
+    userEvent: "input"
+  });
+  return true;
+};
+const tightListKeymap = Prec.highest(
+  keymap.of([{ key: "Enter", run: tightListContinuation }])
+);
+export {
+  tightListContinuation,
+  tightListKeymap
+};
+//# sourceMappingURL=listContinuation.js.map

package/dist/codemirror/list/listContinuation.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/list/listContinuation.ts"],"sourcesContent":["import { EditorSelection, Prec } from \"@codemirror/state\";\nimport { keymap, type Command } from \"@codemirror/view\";\n\nimport { lineStructure } from \"../core/lineStructure\";\nimport { treeAt } from \"../core/treeAt\";\n\n/**\n * Tight list continuation on Enter.\n *\n * `@codemirror/lang-markdown`'s stock `insertNewlineContinueMarkup` continues a\n * list when you press Enter, but for any list it considers \"non-tight\" (loose —\n * because a blank line crept in, or a paragraph lazily continues below the\n * list) it PREPENDS a blank line on every Enter. To the user that reads as the\n * caret \"skipping a line\": you wanted a new bullet on the very next line and\n * got a gap instead. People editing a rich bullet list expect Enter to always\n * drop the next bullet tight against the current one.\n *\n * This command handles two cases: Enter at the END of a NON-EMPTY, non-task\n * bullet/ordered item — inserting a plain `\\n<indent><marker> ` with no blank\n * line, always tight — and Enter at a TASK item's content start, splitting it\n * into an empty unchecked box above and the original item below (#95). Empty\n * items (exit-the-list), task continuation at line end, code blocks,\n * blockquotes, other mid-line splits, and every non-list case return `false`\n * and fall through to the stock markdown / default Enter handlers, so their\n * existing behavior is untouched. Bound at `Prec.highest` so it runs before\n * the markdown keymap's Enter.\n */\nexport const tightListContinuation: Command = (view) => {\n  const { state } = view;\n  const { main } = state.selection;\n  if (!main.empty) return false;\n  const line = state.doc.lineAt(main.head);\n\n  // Task-item split at the content start (#95). The stock handler leaves the\n  // remaining empty item spelled `- [ ]` — WITHOUT the trailing space — and\n  // the grammar reads that as a bullet whose text is a literal `[ ]`, so the\n  // checkbox markdown shows raw. Emit the split ourselves: the current line\n  // keeps an empty UNCHECKED box (`- [ ] `, space intact), the text moves to\n  // a new item that keeps the original marker and checked state.\n  const info = lineStructure(state, line);\n  if (\n    info.list?.task &&\n    !info.inCode &&\n    main.head === info.list.markTo &&\n    info.list.markTo < line.to\n  ) {\n    const mark = state.sliceDoc(info.list.markFrom, info.list.markTo);\n    const indent = state.sliceDoc(line.from, info.list.markFrom);\n    const insert = `${state.lineBreak}${indent}${mark}`;\n    view.dispatch({\n      changes: [\n        // Same length as `mark` — the caret math below relies on that.\n        { from: info.list.markFrom, to: info.list.markTo, insert: mark.replace(/\\[[xX]\\]/, \"[ ]\") },\n        { from: main.head, insert },\n      ],\n      selection: EditorSelection.cursor(main.head + insert.length),\n      scrollIntoView: true,\n      userEvent: \"input\",\n    });\n    return true;\n  }\n\n  // Only when continuing from the very end of the line — not splitting mid-item.\n  if (main.head !== line.to) return false;\n\n  const match = /^(\\s*)([-*+]|\\d+[.)])\\s+(\\S.*)$/.exec(line.text);\n  if (!match) return false; // empty item or not a list line → let the stock handler decide\n  const [, indent, marker, content] = match;\n  if (/^\\[[ xX]\\]/.test(content)) return false; // task item → stock handler keeps the checkbox\n\n  // Confirm we're genuinely inside a list and NOT a code block (a `- x` line\n  // inside a fenced block matches the regex but must not be auto-continued).\n  let inList = false;\n  const cursor = treeAt(state, main.head).resolveInner(main.head, -1).cursor();\n  do {\n    const name = cursor.name;\n    if (name === \"ListItem\" || name === \"BulletList\" || name === \"OrderedList\") {\n      inList = true;\n    }\n    if (/Code/.test(name)) return false;\n  } while (cursor.parent());\n  if (!inList) return false;\n\n  const ordered = /^(\\d+)([.)])$/.exec(marker);\n  const nextMarker = ordered ? `${parseInt(ordered[1], 10) + 1}${ordered[2]}` : marker;\n  const insert = `${state.lineBreak}${indent}${nextMarker} `;\n  view.dispatch({\n    changes: { from: main.head, insert },\n    selection: EditorSelection.cursor(main.head + insert.length),\n    scrollIntoView: true,\n    userEvent: \"input\",\n  });\n  return true;\n};\n\nexport const tightListKeymap = Prec.highest(\n  keymap.of([{ key: \"Enter\", run: tightListContinuation }]),\n);\n"],"mappings":";AAAA,SAAS,iBAAiB,YAAY;AACtC,SAAS,cAA4B;AAErC,SAAS,qBAAqB;AAC9B,SAAS,cAAc;AAuBhB,MAAM,wBAAiC,CAAC,SAAS;AACtD,QAAM,EAAE,MAAM,IAAI;AAClB,QAAM,EAAE,KAAK,IAAI,MAAM;AACvB,MAAI,CAAC,KAAK,MAAO,QAAO;AACxB,QAAM,OAAO,MAAM,IAAI,OAAO,KAAK,IAAI;AAQvC,QAAM,OAAO,cAAc,OAAO,IAAI;AACtC,MACE,KAAK,MAAM,QACX,CAAC,KAAK,UACN,KAAK,SAAS,KAAK,KAAK,UACxB,KAAK,KAAK,SAAS,KAAK,IACxB;AACA,UAAM,OAAO,MAAM,SAAS,KAAK,KAAK,UAAU,KAAK,KAAK,MAAM;AAChE,UAAMA,UAAS,MAAM,SAAS,KAAK,MAAM,KAAK,KAAK,QAAQ;AAC3D,UAAMC,UAAS,GAAG,MAAM,SAAS,GAAGD,OAAM,GAAG,IAAI;AACjD,SAAK,SAAS;AAAA,MACZ,SAAS;AAAA;AAAA,QAEP,EAAE,MAAM,KAAK,KAAK,UAAU,IAAI,KAAK,KAAK,QAAQ,QAAQ,KAAK,QAAQ,YAAY,KAAK,EAAE;AAAA,QAC1F,EAAE,MAAM,KAAK,MAAM,QAAAC,QAAO;AAAA,MAC5B;AAAA,MACA,WAAW,gBAAgB,OAAO,KAAK,OAAOA,QAAO,MAAM;AAAA,MAC3D,gBAAgB;AAAA,MAChB,WAAW;AAAA,IACb,CAAC;AACD,WAAO;AAAA,EACT;AAGA,MAAI,KAAK,SAAS,KAAK,GAAI,QAAO;AAElC,QAAM,QAAQ,kCAAkC,KAAK,KAAK,IAAI;AAC9D,MAAI,CAAC,MAAO,QAAO;AACnB,QAAM,CAAC,EAAE,QAAQ,QAAQ,OAAO,IAAI;AACpC,MAAI,aAAa,KAAK,OAAO,EAAG,QAAO;AAIvC,MAAI,SAAS;AACb,QAAM,SAAS,OAAO,OAAO,KAAK,IAAI,EAAE,aAAa,KAAK,MAAM,EAAE,EAAE,OAAO;AAC3E,KAAG;AACD,UAAM,OAAO,OAAO;AACpB,QAAI,SAAS,cAAc,SAAS,gBAAgB,SAAS,eAAe;AAC1E,eAAS;AAAA,IACX;AACA,QAAI,OAAO,KAAK,IAAI,EAAG,QAAO;AAAA,EAChC,SAAS,OAAO,OAAO;AACvB,MAAI,CAAC,OAAQ,QAAO;AAEpB,QAAM,UAAU,gBAAgB,KAAK,MAAM;AAC3C,QAAM,aAAa,UAAU,GAAG,SAAS,QAAQ,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,QAAQ,CAAC,CAAC,KAAK;AAC9E,QAAM,SAAS,GAAG,MAAM,SAAS,GAAG,MAAM,GAAG,UAAU;AACvD,OAAK,SAAS;AAAA,IACZ,SAAS,EAAE,MAAM,KAAK,MAAM,OAAO;AAAA,IACnC,WAAW,gBAAgB,OAAO,KAAK,OAAO,OAAO,MAAM;AAAA,IAC3D,gBAAgB;AAAA,IAChB,WAAW;AAAA,EACb,CAAC;AACD,SAAO;AACT;AAEO,MAAM,kBAAkB,KAAK;AAAA,EAClC,OAAO,GAAG,CAAC,EAAE,KAAK,SAAS,KAAK,sBAAsB,CAAC,CAAC;AAC1D;","names":["indent","insert"]}

package/dist/codemirror/list/listIndent.d.ts

@@ -0,0 +1,8 @@
+import * as _codemirror_state from '@codemirror/state';
+import { Command } from '@codemirror/view';
+
+declare const indentListItem: Command;
+declare const outdentListItem: Command;
+declare const listIndentKeymap: _codemirror_state.Extension;
+
+export { indentListItem, listIndentKeymap, outdentListItem };

package/dist/codemirror/list/listIndent.js

@@ -0,0 +1,95 @@
+import "../../chunk-V6TY7KAL.js";
+import { Prec } from "@codemirror/state";
+import { keymap } from "@codemirror/view";
+import { treeAt } from "../core/treeAt.js";
+const LIST_LINE = /^(\s*)([-*+] |\d+[.)] )/;
+function listMarker(text) {
+  const m = LIST_LINE.exec(text);
+  if (!m) return null;
+  return { indent: m[1].length, markerWidth: m[2].length, ordered: /\d/.test(m[2]) };
+}
+function inListContext(state, pos) {
+  if (!listMarker(state.doc.lineAt(pos).text)) return false;
+  const cursor = treeAt(state, pos).resolveInner(pos, -1).cursor();
+  do {
+    if (/Code/.test(cursor.name)) return false;
+  } while (cursor.parent());
+  return true;
+}
+function nestingParent(state, lineNo, indent) {
+  for (let n = lineNo - 1; n >= 1; n--) {
+    const text = state.doc.line(n).text;
+    if (text.trim() === "") continue;
+    const info = listMarker(text);
+    if (!info) return null;
+    if (info.indent === indent) return info;
+    if (info.indent < indent) return null;
+  }
+  return null;
+}
+function outdentTarget(state, lineNo, indent) {
+  for (let n = lineNo - 1; n >= 1; n--) {
+    const text = state.doc.line(n).text;
+    if (text.trim() === "") continue;
+    const info = listMarker(text);
+    if (!info) return null;
+    if (info.indent < indent) return info;
+  }
+  return null;
+}
+function changeForLine(state, lineNo, dir) {
+  const line = state.doc.line(lineNo);
+  const info = listMarker(line.text);
+  if (!info) return null;
+  if (dir === "indent") {
+    const parent = nestingParent(state, lineNo, info.indent);
+    if (!parent) return null;
+    const newIndent2 = parent.indent + parent.markerWidth;
+    if (newIndent2 <= info.indent) return null;
+    if (info.ordered) {
+      const digits = /^\d+/.exec(line.text.slice(info.indent))?.[0] ?? "";
+      return {
+        from: line.from,
+        to: line.from + info.indent + digits.length,
+        insert: " ".repeat(newIndent2) + "1"
+      };
+    }
+    return { from: line.from, insert: " ".repeat(newIndent2 - info.indent) };
+  }
+  if (info.indent === 0) return null;
+  const newIndent = outdentTarget(state, lineNo, info.indent)?.indent ?? 0;
+  return { from: line.from, to: line.from + (info.indent - newIndent), insert: "" };
+}
+function changeListIndent(view, dir) {
+  const { state } = view;
+  const range = state.selection.main;
+  if (!inListContext(state, range.from)) return false;
+  const changes = [];
+  const firstLine = state.doc.lineAt(range.from).number;
+  const lastLine = state.doc.lineAt(range.to).number;
+  for (let n = firstLine; n <= lastLine; n++) {
+    const change = changeForLine(state, n, dir);
+    if (change) changes.push(change);
+  }
+  if (changes.length === 0) return true;
+  view.dispatch({
+    changes,
+    scrollIntoView: true,
+    userEvent: dir === "indent" ? "input.indent" : "delete.dedent"
+  });
+  return true;
+}
+const indentListItem = (view) => changeListIndent(view, "indent");
+const outdentListItem = (view) => changeListIndent(view, "outdent");
+const listIndentKeymap = Prec.highest(
+  keymap.of([
+    { key: "Tab", run: indentListItem },
+    { key: "Shift-Tab", run: outdentListItem }
+  ])
+);
+export {
+  indentListItem,
+  listIndentKeymap,
+  outdentListItem
+};
+//# sourceMappingURL=listIndent.js.map

package/dist/codemirror/list/listIndent.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/list/listIndent.ts"],"sourcesContent":["/**\n * List indent / outdent on Tab / Shift-Tab.\n *\n * Tab nests the current list item one level under its preceding sibling;\n * Shift-Tab promotes it one level. The step is the *parent's marker width*\n * (3 columns under `1. `, 2 under `- `), never a fixed unit — that's what lets\n * CommonMark parse the result as a real sublist; a naive two-space indent\n * mis-nests ordered items. A freshly nested ordered item is renumbered to `1`\n * so its sublist renders from one (the decoration plugin renumbers the rest by\n * position).\n *\n * Both commands are gated on the caret sitting in a list line, so anywhere else\n * — prose, a fenced code block — they return false and Tab keeps its normal\n * behaviour rather than hijacking focus or inserting a stray indent.\n */\n\nimport { type ChangeSpec, type EditorState, Prec } from \"@codemirror/state\";\nimport { type Command, EditorView, keymap } from \"@codemirror/view\";\nimport { treeAt } from \"../core/treeAt\";\n\ninterface ListMarker {\n  /** Leading-space count. */\n  indent: number;\n  /** Marker plus its one trailing space: `- ` → 2, `12. ` → 4. */\n  markerWidth: number;\n  ordered: boolean;\n}\n\nconst LIST_LINE = /^(\\s*)([-*+] |\\d+[.)] )/;\n\nfunction listMarker(text: string): ListMarker | null {\n  const m = LIST_LINE.exec(text);\n  if (!m) return null;\n  return { indent: m[1].length, markerWidth: m[2].length, ordered: /\\d/.test(m[2]) };\n}\n\n/** A list line, but not one that's actually inside a fenced code block. */\nfunction inListContext(state: EditorState, pos: number): boolean {\n  if (!listMarker(state.doc.lineAt(pos).text)) return false;\n  const cursor = treeAt(state, pos).resolveInner(pos, -1).cursor();\n  do {\n    if (/Code/.test(cursor.name)) return false;\n  } while (cursor.parent());\n  return true;\n}\n\n/** The preceding sibling to nest under, or null when this is the first item at\n *  its level (nothing above to nest under) or the list breaks above. Blank\n *  lines — a loose list — are stepped over. */\nfunction nestingParent(state: EditorState, lineNo: number, indent: number): ListMarker | null {\n  for (let n = lineNo - 1; n >= 1; n--) {\n    const text = state.doc.line(n).text;\n    if (text.trim() === \"\") continue;\n    const info = listMarker(text);\n    if (!info) return null;\n    if (info.indent === indent) return info;\n    if (info.indent < indent) return null;\n  }\n  return null;\n}\n\n/** The nearest shallower list line; its indent is where an outdent lands. Null\n *  → outdent all the way to column 0. */\nfunction outdentTarget(state: EditorState, lineNo: number, indent: number): ListMarker | null {\n  for (let n = lineNo - 1; n >= 1; n--) {\n    const text = state.doc.line(n).text;\n    if (text.trim() === \"\") continue;\n    const info = listMarker(text);\n    if (!info) return null;\n    if (info.indent < indent) return info;\n  }\n  return null;\n}\n\nfunction changeForLine(\n  state: EditorState,\n  lineNo: number,\n  dir: \"indent\" | \"outdent\",\n): ChangeSpec | null {\n  const line = state.doc.line(lineNo);\n  const info = listMarker(line.text);\n  if (!info) return null;\n\n  if (dir === \"indent\") {\n    const parent = nestingParent(state, lineNo, info.indent);\n    if (!parent) return null; // first item at its level — can't nest\n    const newIndent = parent.indent + parent.markerWidth;\n    if (newIndent <= info.indent) return null;\n    if (info.ordered) {\n      // Rewrite the indent and the leading number together so the new sublist\n      // starts at `1`; the plugin renumbers any siblings by position.\n      const digits = /^\\d+/.exec(line.text.slice(info.indent))?.[0] ?? \"\";\n      return {\n        from: line.from,\n        to: line.from + info.indent + digits.length,\n        insert: \" \".repeat(newIndent) + \"1\",\n      };\n    }\n    return { from: line.from, insert: \" \".repeat(newIndent - info.indent) };\n  }\n\n  if (info.indent === 0) return null; // top level — nothing to outdent\n  const newIndent = outdentTarget(state, lineNo, info.indent)?.indent ?? 0;\n  return { from: line.from, to: line.from + (info.indent - newIndent), insert: \"\" };\n}\n\nfunction changeListIndent(view: EditorView, dir: \"indent\" | \"outdent\"): boolean {\n  const { state } = view;\n  const range = state.selection.main;\n  if (!inListContext(state, range.from)) return false;\n\n  const changes: ChangeSpec[] = [];\n  const firstLine = state.doc.lineAt(range.from).number;\n  const lastLine = state.doc.lineAt(range.to).number;\n  for (let n = firstLine; n <= lastLine; n++) {\n    const change = changeForLine(state, n, dir);\n    if (change) changes.push(change);\n  }\n  // Still consume Tab inside a list when nothing moves (first item, or top-level\n  // outdent), so it never drops a literal tab into the list.\n  if (changes.length === 0) return true;\n\n  view.dispatch({\n    changes,\n    scrollIntoView: true,\n    userEvent: dir === \"indent\" ? \"input.indent\" : \"delete.dedent\",\n  });\n  return true;\n}\n\nexport const indentListItem: Command = (view) => changeListIndent(view, \"indent\");\nexport const outdentListItem: Command = (view) => changeListIndent(view, \"outdent\");\n\nexport const listIndentKeymap = Prec.highest(\n  keymap.of([\n    { key: \"Tab\", run: indentListItem },\n    { key: \"Shift-Tab\", run: outdentListItem },\n  ]),\n);\n"],"mappings":"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","names":["newIndent"]}

package/dist/codemirror/list/taskCheckboxWidget.d.ts

@@ -0,0 +1,42 @@
+import { WidgetType, EditorView } from '@codemirror/view';
+import { NodeRule } from '../core/paint.js';
+import '@codemirror/state';
+
+/**
+ * Task checkbox widget — renders `[ ]` / `[x]` as a real interactive
+ * `<input type="checkbox">`. Clicking toggles the source.
+ *
+ * Per spec section 16.4: source `- [ ] Task` becomes a visible
+ * `☐ Task` with a real checkbox. Toggling persists as source change
+ * (`[ ]` ↔ `[x]`).
+ */
+
+declare class TaskCheckboxWidget extends WidgetType {
+    readonly checked: boolean;
+    /**
+     * Source position of the marker's first character (`[`). Used at
+     * click time to dispatch the toggling change. Included in `eq()`
+     * so CM6 doesn't reuse a widget whose `from` has drifted under
+     * us — if the document was edited above the task item, the
+     * dispatched range must be the *current* source position, not a
+     * stale one.
+     */
+    readonly from: number;
+    constructor(checked: boolean, 
+    /**
+     * Source position of the marker's first character (`[`). Used at
+     * click time to dispatch the toggling change. Included in `eq()`
+     * so CM6 doesn't reuse a widget whose `from` has drifted under
+     * us — if the document was edited above the task item, the
+     * dispatched range must be the *current* source position, not a
+     * stale one.
+     */
+    from: number);
+    eq(other: TaskCheckboxWidget): boolean;
+    toDOM(view: EditorView): HTMLElement;
+    ignoreEvent(): boolean;
+}
+/** `[ ]` / `[x]` → a real checkbox widget, checked state from the source. */
+declare const taskMarkerRule: NodeRule;
+
+export { TaskCheckboxWidget, taskMarkerRule };

package/dist/codemirror/list/taskCheckboxWidget.js

@@ -0,0 +1,47 @@
+import {
+  __publicField
+} from "../../chunk-V6TY7KAL.js";
+import { Decoration, WidgetType } from "@codemirror/view";
+class TaskCheckboxWidget extends WidgetType {
+  constructor(checked, from) {
+    super();
+    __publicField(this, "checked", checked);
+    __publicField(this, "from", from);
+  }
+  eq(other) {
+    return other.checked === this.checked && other.from === this.from;
+  }
+  toDOM(view) {
+    const input = document.createElement("input");
+    input.type = "checkbox";
+    input.checked = this.checked;
+    input.className = "cm-task-checkbox";
+    input.addEventListener("mousedown", (e) => e.stopPropagation());
+    input.addEventListener("click", (e) => {
+      e.stopPropagation();
+      const newMarker = this.checked ? "[ ]" : "[x]";
+      view.dispatch({
+        changes: { from: this.from, to: this.from + 3, insert: newMarker },
+        userEvent: "input.format.task"
+      });
+    });
+    return input;
+  }
+  ignoreEvent() {
+    return false;
+  }
+}
+const taskMarkerRule = (ctx) => {
+  const checked = /\[[xX]\]/.test(ctx.state.sliceDoc(ctx.from, ctx.to));
+  const spaceFollows = ctx.state.doc.sliceString(ctx.to, ctx.to + 1) === " ";
+  return {
+    paint: "widget",
+    deco: Decoration.replace({ widget: new TaskCheckboxWidget(checked, ctx.from) }),
+    ...spaceFollows ? { atomicTo: ctx.to + 1 } : {}
+  };
+};
+export {
+  TaskCheckboxWidget,
+  taskMarkerRule
+};
+//# sourceMappingURL=taskCheckboxWidget.js.map

package/dist/codemirror/list/taskCheckboxWidget.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/list/taskCheckboxWidget.ts"],"sourcesContent":["/**\n * Task checkbox widget — renders `[ ]` / `[x]` as a real interactive\n * `<input type=\"checkbox\">`. Clicking toggles the source.\n *\n * Per spec section 16.4: source `- [ ] Task` becomes a visible\n * `☐ Task` with a real checkbox. Toggling persists as source change\n * (`[ ]` ↔ `[x]`).\n */\n\nimport { Decoration, EditorView, WidgetType } from \"@codemirror/view\";\n\nimport { type NodeRule, type Paint } from \"../core/paint\";\n\nexport class TaskCheckboxWidget extends WidgetType {\n  constructor(\n    readonly checked: boolean,\n    /**\n     * Source position of the marker's first character (`[`). Used at\n     * click time to dispatch the toggling change. Included in `eq()`\n     * so CM6 doesn't reuse a widget whose `from` has drifted under\n     * us — if the document was edited above the task item, the\n     * dispatched range must be the *current* source position, not a\n     * stale one.\n     */\n    readonly from: number,\n  ) {\n    super();\n  }\n\n  override eq(other: TaskCheckboxWidget): boolean {\n    return other.checked === this.checked && other.from === this.from;\n  }\n\n  override toDOM(view: EditorView): HTMLElement {\n    const input = document.createElement(\"input\");\n    input.type = \"checkbox\";\n    input.checked = this.checked;\n    input.className = \"cm-task-checkbox\";\n    // Stop propagation so clicking the checkbox doesn't also place\n    // the caret at the marker position.\n    input.addEventListener(\"mousedown\", (e) => e.stopPropagation());\n    input.addEventListener(\"click\", (e) => {\n      e.stopPropagation();\n      const newMarker = this.checked ? \"[ ]\" : \"[x]\";\n      view.dispatch({\n        changes: { from: this.from, to: this.from + 3, insert: newMarker },\n        userEvent: \"input.format.task\",\n      });\n    });\n    return input;\n  }\n\n  override ignoreEvent(): boolean {\n    return false;\n  }\n}\n\n/* ---------------- The TaskMarker rule ---------------- */\n\n\n\n/** `[ ]` / `[x]` → a real checkbox widget, checked state from the source. */\nexport const taskMarkerRule: NodeRule = (ctx): Paint => {\n  const checked = /\\[[xX]\\]/.test(ctx.state.sliceDoc(ctx.from, ctx.to));\n  const spaceFollows = ctx.state.doc.sliceString(ctx.to, ctx.to + 1) === \" \";\n  return {\n    paint: \"widget\",\n    deco: Decoration.replace({ widget: new TaskCheckboxWidget(checked, ctx.from) }),\n    ...(spaceFollows ? { atomicTo: ctx.to + 1 } : {}),\n  };\n};\n"],"mappings":";;;AASA,SAAS,YAAwB,kBAAkB;AAI5C,MAAM,2BAA2B,WAAW;AAAA,EACjD,YACW,SASA,MACT;AACA,UAAM;AAXG;AASA;AAAA,EAGX;AAAA,EAES,GAAG,OAAoC;AAC9C,WAAO,MAAM,YAAY,KAAK,WAAW,MAAM,SAAS,KAAK;AAAA,EAC/D;AAAA,EAES,MAAM,MAA+B;AAC5C,UAAM,QAAQ,SAAS,cAAc,OAAO;AAC5C,UAAM,OAAO;AACb,UAAM,UAAU,KAAK;AACrB,UAAM,YAAY;AAGlB,UAAM,iBAAiB,aAAa,CAAC,MAAM,EAAE,gBAAgB,CAAC;AAC9D,UAAM,iBAAiB,SAAS,CAAC,MAAM;AACrC,QAAE,gBAAgB;AAClB,YAAM,YAAY,KAAK,UAAU,QAAQ;AACzC,WAAK,SAAS;AAAA,QACZ,SAAS,EAAE,MAAM,KAAK,MAAM,IAAI,KAAK,OAAO,GAAG,QAAQ,UAAU;AAAA,QACjE,WAAW;AAAA,MACb,CAAC;AAAA,IACH,CAAC;AACD,WAAO;AAAA,EACT;AAAA,EAES,cAAuB;AAC9B,WAAO;AAAA,EACT;AACF;AAOO,MAAM,iBAA2B,CAAC,QAAe;AACtD,QAAM,UAAU,WAAW,KAAK,IAAI,MAAM,SAAS,IAAI,MAAM,IAAI,EAAE,CAAC;AACpE,QAAM,eAAe,IAAI,MAAM,IAAI,YAAY,IAAI,IAAI,IAAI,KAAK,CAAC,MAAM;AACvE,SAAO;AAAA,IACL,OAAO;AAAA,IACP,MAAM,WAAW,QAAQ,EAAE,QAAQ,IAAI,mBAAmB,SAAS,IAAI,IAAI,EAAE,CAAC;AAAA,IAC9E,GAAI,eAAe,EAAE,UAAU,IAAI,KAAK,EAAE,IAAI,CAAC;AAAA,EACjD;AACF;","names":[]}

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

@@ -0,0 +1,3 @@
+export { INLINE_MATH_RE, mathPlugin } from './mathPlugin.js';
+import '@codemirror/state';
+import '@codemirror/view';

package/dist/codemirror/math/index.js

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

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/math/index.ts"],"sourcesContent":["/** Math: `$…$` / `$$…$$` rendered with KaTeX. */\nexport * from \"./mathPlugin\";\n"],"mappings":"AACA,cAAc;","names":[]}

package/dist/codemirror/math/mathPlugin.d.ts

@@ -0,0 +1,10 @@
+import { StateField } from '@codemirror/state';
+import { DecorationSet } from '@codemirror/view';
+
+declare const INLINE_MATH_RE: RegExp;
+declare const mathPlugin: StateField<{
+    decorations: DecorationSet;
+    atomic: DecorationSet;
+}>;
+
+export { INLINE_MATH_RE, mathPlugin };