@latentic/live-markdown 0.3.0 → 0.4.0

package/dist/codemirror/core/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/core/registry.ts"],"sourcesContent":["/**\n * Canonical table: every Lezer markdown node name → its {@link NodeRule} —\n * ONE place answering \"how does this construct render\". The Lezer parser\n * handles CommonMark + GFM spec compliance; this file is the visual contract.\n *\n * Why a table of rules (functions), not data:\n *\n *   1. **Completeness is auditable.** `registry.test.ts` reads the live\n *      parser's node set and fails when any node Lezer emits has no entry\n *      here — a lezer-markdown bump that adds a node trips the gate before\n *      it ships unstyled. Only the KEYS matter for that, so entries are free\n *      to be behavior.\n *   2. **Context is first-class.** A node name can mean different things in\n *      different parents (a URL inside `[text](url)` is chrome; a bare\n *      pasted URL is content — hiding it made an invisible dead zone).\n *      Every rule receives context; contextual entries are ordinary inline\n *      functions, readable at the point of definition.\n *   3. **Adding a construct touches one place.** A styled span is a\n *      one-liner via the combinators; a widget construct exports its rule\n *      from its own module and is listed here; an EXTENSION with its own\n *      grammar ships rules via `nodeRulesFacet` and never touches this file.\n *   4. **Deliberate non-styling stays documented.** `raw(why)` /\n *      `structural(why)` tag their rules; the coverage test insists the\n *      `why` is present.\n *\n * The rules speak {@link Paint} — CodeMirror's own mechanisms (line class,\n * span mark, hide, widget, nothing). That union is CLOSED: constructs grow,\n * ways to paint don't, so the single switch over Paint lives in the painter\n * (plugin.ts) and no new construct ever edits it.\n */\n\nimport { horizontalRuleRule } from \"./hrWidget\";\nimport { htmlBlockRule, htmlInlineRule } from \"../html/htmlWidget\";\nimport { imageRule } from \"../image/imageWidget\";\nimport { linkHasVisibleLabel, linkResolves } from \"./linkResolution\";\nimport { listMarkRule } from \"../list/bulletWidget\";\nimport {\n  headingLine,\n  hideAlways,\n  line,\n  mark,\n  none,\n  raw,\n  structural,\n  type NodeContext,\n  type NodeLike,\n  type NodeRules,\n} from \"./paint\";\nimport { taskMarkerRule } from \"../list/taskCheckboxWidget\";\n\n/** The enclosing `Link`, for a rule running on one of its parts. */\nfunction parentLink(ctx: NodeContext): NodeLike | null {\n  return ctx.parentName === \"Link\" ? ctx.node.parent : null;\n}\n\nexport const NODE_RULES: NodeRules = {\n  // ----- Structural wrappers (never directly styled) -----\n  Document: structural(\"top-level wrapper\"),\n  Paragraph: structural(\"body font is the default\"),\n\n  // ----- ATX headings (`# H1` … `###### H6`) -----\n  ATXHeading1: headingLine(\"cm-heading cm-heading--1\"),\n  ATXHeading2: headingLine(\"cm-heading cm-heading--2\"),\n  ATXHeading3: headingLine(\"cm-heading cm-heading--3\"),\n  ATXHeading4: headingLine(\"cm-heading cm-heading--4\"),\n  ATXHeading5: headingLine(\"cm-heading cm-heading--5\"),\n  ATXHeading6: headingLine(\"cm-heading cm-heading--6\"),\n\n  // ----- Setext headings (`=====` / `-----` under text) -----\n  SetextHeading1: raw(\"Phase 2: same line scaling as ATXHeading1\"),\n  SetextHeading2: raw(\"Phase 2: same line scaling as ATXHeading2\"),\n\n  // ----- Block-level constructs -----\n  Blockquote: line(\"cm-blockquote\"),\n  BulletList: structural(\"ListItem children carry the styling\"),\n  OrderedList: structural(\"ListItem children carry the styling\"),\n  ListItem: line(\"cm-list-line\"),\n  FencedCode: line(\"cm-fenced-code\"),\n  CodeBlock: raw(\"Phase 2: indented code-block, same style as FencedCode\"),\n  HorizontalRule: horizontalRuleRule, // `---` → styled `<hr>` widget\n  HTMLBlock: htmlBlockRule,\n  LinkReference: raw(\"Phase 2: reference-style links resolve in click handler\"),\n\n  // ----- Inline styling -----\n  Emphasis: mark(\"cm-emphasis\"),\n  StrongEmphasis: mark(\"cm-strong\"),\n  InlineCode: mark(\"cm-inline-code\"),\n  // A `Link` node is not yet a link: Lezer emits one for every `[…]`, and the\n  // reference lookup CommonMark requires is left to us. Unresolved, it is the\n  // literal brackets the author typed — most `[…]` in prose, and every optional\n  // argument in a LaTeX block.\n  Link: (ctx) =>\n    linkResolves(ctx.node, ctx.state) ? { paint: \"mark\", className: \"cm-link\" } : none,\n  Image: imageRule, // `![alt](src)` → inline `<img>` widget\n\n  // ----- Inline literal sub-nodes (rendered inside their parent) -----\n  // Inside a Link the URL is chrome ONLY when a visible label exists — for\n  // `[](url)` / `[ ](url)` the URL is the link's entire visible content, and\n  // hiding it (with the marks already hidden) left an invisible dead zone.\n  // Bare GFM autolinks and <angle> autolinks emit the SAME node name, and\n  // there the URL IS the content — same class of bug when hidden.\n  URL: (ctx) => {\n    const link = parentLink(ctx);\n    if (!link) return { paint: \"mark\", className: \"cm-link\" };\n    return linkHasVisibleLabel(link, ctx.state)\n      ? { paint: \"hide\" }\n      : { paint: \"mark\", className: \"cm-link\" };\n  },\n  LinkLabel: raw(\"visible inside Link; parent mark styles it\"),\n  LinkTitle: hideAlways(), // `[text](URL \"title\")` — title never visible\n  CodeText: raw(\"interior of FencedCode/InlineCode; parent decoration covers it\"),\n  CodeInfo: mark(\"cm-code-info\"), // language tag on the opener row — visible so typing there is never invisible (§12.4)\n  HardBreak: structural(\"trailing two-spaces or backslash, no visible glyph\"),\n  Comment: raw(\"Phase 2: dim inline HTML comments\"),\n  CommentBlock: raw(\"Phase 2: dim block HTML comments\"),\n  ProcessingInstruction: raw(\"Phase 2: dim like HTML comments\"),\n  ProcessingInstructionBlock: raw(\"Phase 2: dim like HTML comments\"),\n  Entity: raw(\"HTML entities like &amp; render as-is, by design\"),\n  // Backslash-escape: hide only the leading `\\`, so `\\'` renders as `'` per\n  // CommonMark rather than showing a literal backslash.\n  Escape: (ctx) => ({\n    paint: \"hide\",\n    range: { from: ctx.from, to: ctx.from + 1 },\n    expandSpace: false,\n  }),\n  HTMLTag: htmlInlineRule,\n\n  // ----- Syntax markers (hidden always — non-technical UX, distinct from Obsidian's Live Preview) -----\n  // `#` marks on ATX headings hide; a SETEXT heading's underline is that\n  // heading's only marker on its own line — hiding it left an invisible,\n  // unclickable dead line. Visible until setext gets real styling.\n  HeaderMark: (ctx) =>\n    ctx.parentName?.startsWith(\"SetextHeading\") ? { paint: \"none\" } : { paint: \"hide\" },\n  EmphasisMark: hideAlways(), // `*` / `_`\n  CodeMark: hideAlways(), // backticks for inline / fence pairs for blocks\n  // `[`/`]`/`(`/`)` — chrome only where they really are chrome. An unresolved\n  // link's brackets are content, and hiding them rewrote the document on screen.\n  LinkMark: (ctx) => {\n    const link = parentLink(ctx);\n    return link && !linkResolves(link, ctx.state) ? none : { paint: \"hide\" };\n  },\n  QuoteMark: hideAlways(), // `>`\n  ListMark: listMarkRule, // `-`/`1.` → bullet / number / nothing beside a checkbox\n  TaskMarker: taskMarkerRule, // `[ ]` / `[x]` → real checkbox\n\n  // ----- GFM extensions (enabled via `markdownLanguage`) -----\n  Strikethrough: mark(\"cm-strikethrough\"),\n  // `~~` joins the hidden-marker system like EmphasisMark — the flanking\n  // guard and delete normalizer already assume these semantics; leaving the\n  // marks visible made deletion eat single tildes (interaction-spec §8.1).\n  StrikethroughMark: hideAlways(),\n  Subscript: raw(\"Phase 2: vertical-align: sub\"),\n  SubscriptMark: raw(\"Phase 2: hide `~` off-parent\"),\n  Superscript: raw(\"Phase 2: vertical-align: super\"),\n  SuperscriptMark: raw(\"Phase 2: hide `^` off-parent\"),\n  Emoji: raw(\"Phase 2: replace `:smile:` with the emoji glyph\"),\n  Autolink: raw(\"wrapper of a visible URL child; Phase 2 wires click-to-open\"),\n  Task: raw(\"Phase 2: render task list items with a real checkbox\"),\n\n  // GFM tables — handled by a dedicated StateField that emits the block\n  // widget on Table nodes (CM6 forbids multi-line replace from a ViewPlugin,\n  // so this rules-driven plugin can't do that shape; see tableField.ts).\n  Table: structural(\"tableField StateField owns Table rendering\"),\n  TableHeader: structural(\"covered by Table widget\"),\n  TableRow: structural(\"covered by Table widget\"),\n  TableCell: structural(\"covered by Table widget\"),\n  TableDelimiter: structural(\"covered by Table widget\"),\n};\n"],"mappings":"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","names":[]}

package/dist/codemirror/core/testKeys.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Test-only: the chord CodeMirror's `Mod-` prefix resolves to HERE.
+ *
+ * `Mod` is Cmd on macOS and Ctrl everywhere else, and CodeMirror decides that
+ * from `navigator.platform` — so a suite that presses `{Meta>}z{/Meta}`
+ * literally tests undo on a Mac and tests nothing at all on Linux. The
+ * keystroke reaches no binding, the assertion reads the un-undone text, and the
+ * failure looks like a broken editor rather than a mis-aimed key. This picks the
+ * modifier the same way the keymap does, so the two can never disagree.
+ *
+ * Not shipped — nothing in the package imports it outside tests.
+ */
+declare const MOD: string;
+/** A `userEvent.keyboard` sequence for `Mod-<keys>`. */
+declare function modChord(keys: string): string;
+
+export { MOD, modChord };

package/dist/codemirror/core/testKeys.js

@@ -0,0 +1,11 @@
+import "../../chunk-V6TY7KAL.js";
+const nav = typeof navigator === "undefined" ? { platform: "" } : navigator;
+const MOD = /Mac|iP(hone|[oa]d)/.test(nav.platform) ? "Meta" : "Control";
+function modChord(keys) {
+  return `{${MOD}>}${keys}{/${MOD}}`;
+}
+export {
+  MOD,
+  modChord
+};
+//# sourceMappingURL=testKeys.js.map

package/dist/codemirror/core/testKeys.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/core/testKeys.ts"],"sourcesContent":["/**\n * Test-only: the chord CodeMirror's `Mod-` prefix resolves to HERE.\n *\n * `Mod` is Cmd on macOS and Ctrl everywhere else, and CodeMirror decides that\n * from `navigator.platform` — so a suite that presses `{Meta>}z{/Meta}`\n * literally tests undo on a Mac and tests nothing at all on Linux. The\n * keystroke reaches no binding, the assertion reads the un-undone text, and the\n * failure looks like a broken editor rather than a mis-aimed key. This picks the\n * modifier the same way the keymap does, so the two can never disagree.\n *\n * Not shipped — nothing in the package imports it outside tests.\n */\n\nconst nav = typeof navigator === \"undefined\" ? { platform: \"\" } : navigator;\n\nexport const MOD = /Mac|iP(hone|[oa]d)/.test(nav.platform) ? \"Meta\" : \"Control\";\n\n/** A `userEvent.keyboard` sequence for `Mod-<keys>`. */\nexport function modChord(keys: string): string {\n  return `{${MOD}>}${keys}{/${MOD}}`;\n}\n"],"mappings":";AAaA,MAAM,MAAM,OAAO,cAAc,cAAc,EAAE,UAAU,GAAG,IAAI;AAE3D,MAAM,MAAM,qBAAqB,KAAK,IAAI,QAAQ,IAAI,SAAS;AAG/D,SAAS,SAAS,MAAsB;AAC7C,SAAO,IAAI,GAAG,KAAK,IAAI,KAAK,GAAG;AACjC;","names":[]}

package/dist/codemirror/core/treeAt.d.ts

@@ -0,0 +1,31 @@
+import { syntaxTree } from '@codemirror/language';
+import { EditorState } from '@codemirror/state';
+
+/**
+ * A syntax tree that reaches `pos`.
+ *
+ * `syntaxTree` returns only what the **viewport** has driven the parser
+ * through, so `resolveInner` past that point reports the position as bare
+ * `Document`. Every command that asks "am I inside a list / a fence / a table?"
+ * then gets "no" and takes the plain-text path: a wrong answer, not a slow one.
+ *
+ * Measured in WebKit, the engine we ship on, with real layout — two regimes.
+ *
+ * On the frame a document opens the parser has covered a few thousand
+ * characters: 3,009 of 7,902, viewport 0–331, for an editor 11,404px tall. The
+ * idle parse then catches up within about half a second, so near the viewport
+ * this is a race — and it heals before a hand-test can see it.
+ *
+ * Further out it never heals. The idle parse stops 100,000 characters past the
+ * viewport: the tree plateaus at 100,739 for a 167k-character document and a
+ * 341k one alike, and stays there. `ensureSyntaxTree` resumes from that plateau
+ * and finishes the 341k document in 43ms — inside the budget above.
+ *
+ * Only for questions about a *position*. Decoration plugins iterate
+ * `view.visibleRanges` and should keep using `syntaxTree` directly: there,
+ * being limited to the viewport is the point.
+ */
+type Tree = ReturnType<typeof syntaxTree>;
+declare function treeAt(state: EditorState, pos: number): Tree;
+
+export { treeAt };

package/dist/codemirror/core/treeAt.js

@@ -0,0 +1,10 @@
+import "../../chunk-V6TY7KAL.js";
+import { ensureSyntaxTree, syntaxTree } from "@codemirror/language";
+const PARSE_BUDGET_MS = 150;
+function treeAt(state, pos) {
+  return ensureSyntaxTree(state, pos + 1, PARSE_BUDGET_MS) ?? syntaxTree(state);
+}
+export {
+  treeAt
+};
+//# sourceMappingURL=treeAt.js.map

package/dist/codemirror/core/treeAt.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/core/treeAt.ts"],"sourcesContent":["import { ensureSyntaxTree, syntaxTree } from \"@codemirror/language\";\nimport type { EditorState } from \"@codemirror/state\";\n\n/**\n * How long a structural lookup may spend parsing. It runs inside a keystroke,\n * so this is a budget rather than a guarantee: past it we answer from whatever\n * has been parsed, exactly as before.\n *\n * 50ms was too thin to be a budget. The worst realistic case below — resuming a\n * 341k-character document — was measured at 43ms on the development machine,\n * and CI on a slower runner duly blew through it: `ensureSyntaxTree` returned\n * null, the guard fell back to the short tree, and a backspace crossed a fence\n * boundary it should have walled. A budget that only holds on the fastest\n * machine available is not a budget.\n *\n * The cost of the larger number is bounded and rare. `parseToEnd` keeps the\n * document covered, so this call normally returns from an already-complete tree\n * in microseconds; the budget only bites in the window after a very large\n * document opens, and there one slow keystroke beats one wrong answer.\n */\nconst PARSE_BUDGET_MS = 150;\n\n/**\n * A syntax tree that reaches `pos`.\n *\n * `syntaxTree` returns only what the **viewport** has driven the parser\n * through, so `resolveInner` past that point reports the position as bare\n * `Document`. Every command that asks \"am I inside a list / a fence / a table?\"\n * then gets \"no\" and takes the plain-text path: a wrong answer, not a slow one.\n *\n * Measured in WebKit, the engine we ship on, with real layout — two regimes.\n *\n * On the frame a document opens the parser has covered a few thousand\n * characters: 3,009 of 7,902, viewport 0–331, for an editor 11,404px tall. The\n * idle parse then catches up within about half a second, so near the viewport\n * this is a race — and it heals before a hand-test can see it.\n *\n * Further out it never heals. The idle parse stops 100,000 characters past the\n * viewport: the tree plateaus at 100,739 for a 167k-character document and a\n * 341k one alike, and stays there. `ensureSyntaxTree` resumes from that plateau\n * and finishes the 341k document in 43ms — inside the budget above.\n *\n * Only for questions about a *position*. Decoration plugins iterate\n * `view.visibleRanges` and should keep using `syntaxTree` directly: there,\n * being limited to the viewport is the point.\n */\n/// The tree type, named without importing `@lezer/common` — it is a transitive\n/// dependency, and a declaration referring to it by pnpm path is not portable\n/// for anyone consuming the built package.\ntype Tree = ReturnType<typeof syntaxTree>;\n\nexport function treeAt(state: EditorState, pos: number): Tree {\n  return ensureSyntaxTree(state, pos + 1, PARSE_BUDGET_MS) ?? syntaxTree(state);\n}\n"],"mappings":";AAAA,SAAS,kBAAkB,kBAAkB;AAoB7C,MAAM,kBAAkB;AA+BjB,SAAS,OAAO,OAAoB,KAAmB;AAC5D,SAAO,iBAAiB,OAAO,MAAM,GAAG,eAAe,KAAK,WAAW,KAAK;AAC9E;","names":[]}

package/dist/codemirror/extensions/footnoteExtension.d.ts

@@ -0,0 +1,9 @@
+import { MarkdownExtension } from './types.js';
+import '@codemirror/view';
+import '@codemirror/state';
+import 'react';
+import '../core/paint.js';
+
+declare const footnoteExtension: MarkdownExtension;
+
+export { footnoteExtension };

package/dist/codemirror/extensions/footnoteExtension.js

@@ -0,0 +1,14 @@
+import "../../chunk-V6TY7KAL.js";
+import { footnotePlugin } from "../footnote/index.js";
+import { inlineScanRulesFacet } from "../core/inlineScan.js";
+import { footnoteScanRule } from "../footnote/footnoteScanRule.js";
+const footnoteExtension = {
+  name: "@compose/footnote",
+  version: "0.1.0",
+  description: "Renders `[^id]` references and `[^id]:` definitions with tooltip jump.",
+  extensions: [footnotePlugin, inlineScanRulesFacet.of(footnoteScanRule)]
+};
+export {
+  footnoteExtension
+};
+//# sourceMappingURL=footnoteExtension.js.map

package/dist/codemirror/extensions/footnoteExtension.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/extensions/footnoteExtension.ts"],"sourcesContent":["import { footnotePlugin } from \"../footnote\";\nimport { inlineScanRulesFacet } from \"../core/inlineScan\";\nimport { footnoteScanRule } from \"../footnote/footnoteScanRule\";\n\nimport { type MarkdownExtension } from \"./types\";\n\nexport const footnoteExtension: MarkdownExtension = {\n  name: \"@compose/footnote\",\n  version: \"0.1.0\",\n  description: \"Renders `[^id]` references and `[^id]:` definitions with tooltip jump.\",\n  extensions: [footnotePlugin, inlineScanRulesFacet.of(footnoteScanRule)],\n};\n"],"mappings":";AAAA,SAAS,sBAAsB;AAC/B,SAAS,4BAA4B;AACrC,SAAS,wBAAwB;AAI1B,MAAM,oBAAuC;AAAA,EAClD,MAAM;AAAA,EACN,SAAS;AAAA,EACT,aAAa;AAAA,EACb,YAAY,CAAC,gBAAgB,qBAAqB,GAAG,gBAAgB,CAAC;AACxE;","names":[]}

package/dist/codemirror/extensions/highlightExtension.d.ts

@@ -0,0 +1,9 @@
+import { MarkdownExtension } from './types.js';
+import '@codemirror/view';
+import '@codemirror/state';
+import 'react';
+import '../core/paint.js';
+
+declare const highlightExtension: MarkdownExtension;
+
+export { highlightExtension };

package/dist/codemirror/extensions/highlightExtension.js

@@ -0,0 +1,14 @@
+import "../../chunk-V6TY7KAL.js";
+import { highlightPlugin } from "../highlight/index.js";
+import { inlineScanRulesFacet } from "../core/inlineScan.js";
+import { highlightScanRule } from "../highlight/highlightScanRule.js";
+const highlightExtension = {
+  name: "@compose/highlight",
+  version: "0.1.0",
+  description: "Renders `==text==` with a yellow highlight background.",
+  extensions: [highlightPlugin, inlineScanRulesFacet.of(highlightScanRule)]
+};
+export {
+  highlightExtension
+};
+//# sourceMappingURL=highlightExtension.js.map

package/dist/codemirror/extensions/highlightExtension.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/extensions/highlightExtension.ts"],"sourcesContent":["import { highlightPlugin } from \"../highlight\";\nimport { inlineScanRulesFacet } from \"../core/inlineScan\";\nimport { highlightScanRule } from \"../highlight/highlightScanRule\";\n\nimport { type MarkdownExtension } from \"./types\";\n\nexport const highlightExtension: MarkdownExtension = {\n  name: \"@compose/highlight\",\n  version: \"0.1.0\",\n  description: \"Renders `==text==` with a yellow highlight background.\",\n  extensions: [highlightPlugin, inlineScanRulesFacet.of(highlightScanRule)],\n};\n"],"mappings":";AAAA,SAAS,uBAAuB;AAChC,SAAS,4BAA4B;AACrC,SAAS,yBAAyB;AAI3B,MAAM,qBAAwC;AAAA,EACnD,MAAM;AAAA,EACN,SAAS;AAAA,EACT,aAAa;AAAA,EACb,YAAY,CAAC,iBAAiB,qBAAqB,GAAG,iBAAiB,CAAC;AAC1E;","names":[]}

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

@@ -0,0 +1,12 @@
+export { CaretContextSnapshot, MarkdownExtension, ToolbarContribution } from './types.js';
+export { ComposedExtension, composeExtensions, mergeExtensions } from './loader.js';
+export { highlightExtension } from './highlightExtension.js';
+export { footnoteExtension } from './footnoteExtension.js';
+export { mathExtension } from './mathExtension.js';
+export { mermaidExtension } from './mermaidExtension.js';
+export { tableExtension } from './tableExtension.js';
+export { wikilinkExtension } from './wikilinkExtension.js';
+import '@codemirror/view';
+import '@codemirror/state';
+import 'react';
+import '../core/paint.js';

package/dist/codemirror/extensions/index.js

@@ -0,0 +1,19 @@
+import "../../chunk-V6TY7KAL.js";
+import { mergeExtensions, composeExtensions } from "./loader.js";
+import { highlightExtension } from "./highlightExtension.js";
+import { footnoteExtension } from "./footnoteExtension.js";
+import { mathExtension } from "./mathExtension.js";
+import { mermaidExtension } from "./mermaidExtension.js";
+import { tableExtension } from "./tableExtension.js";
+import { wikilinkExtension } from "./wikilinkExtension.js";
+export {
+  composeExtensions,
+  footnoteExtension,
+  highlightExtension,
+  mathExtension,
+  mergeExtensions,
+  mermaidExtension,
+  tableExtension,
+  wikilinkExtension
+};
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/extensions/index.ts"],"sourcesContent":["export { type MarkdownExtension, type ToolbarContribution, type CaretContextSnapshot } from \"./types\";\nexport { mergeExtensions, composeExtensions, type ComposedExtension } from \"./loader\";\nexport { highlightExtension } from \"./highlightExtension\";\nexport { footnoteExtension } from \"./footnoteExtension\";\nexport { mathExtension } from \"./mathExtension\";\nexport { mermaidExtension } from \"./mermaidExtension\";\nexport { tableExtension } from \"./tableExtension\";\nexport { wikilinkExtension } from \"./wikilinkExtension\";\n"],"mappings":";AACA,SAAS,iBAAiB,yBAAiD;AAC3E,SAAS,0BAA0B;AACnC,SAAS,yBAAyB;AAClC,SAAS,qBAAqB;AAC9B,SAAS,wBAAwB;AACjC,SAAS,sBAAsB;AAC/B,SAAS,yBAAyB;","names":[]}

package/dist/codemirror/extensions/loader.d.ts

@@ -0,0 +1,24 @@
+import { Extension } from '@codemirror/state';
+import { ToolbarContribution, MarkdownExtension } from './types.js';
+import '@codemirror/view';
+import 'react';
+import '../core/paint.js';
+
+interface ComposedExtension {
+    extensions: Extension[];
+    toolbar: ToolbarContribution[];
+}
+/**
+ * Merge extension modules into one set of CodeMirror extensions plus the
+ * toolbar items they contribute. Later modules win: a host's rules are applied
+ * after the built-ins, so it can deliberately override a construct.
+ */
+declare function mergeExtensions(modules: readonly MarkdownExtension[]): ComposedExtension;
+/**
+ * @deprecated Renamed to {@link mergeExtensions}. "compose" reads as the app
+ * this package was extracted from rather than as the verb; the editor is meant
+ * for more hosts than that one. Kept as an alias so the rename is not breaking.
+ */
+declare const composeExtensions: typeof mergeExtensions;
+
+export { type ComposedExtension, composeExtensions, mergeExtensions };

package/dist/codemirror/extensions/loader.js

@@ -0,0 +1,33 @@
+import "../../chunk-V6TY7KAL.js";
+import { keymap as cmKeymap } from "@codemirror/view";
+import { nodeRulesFacet } from "../core/index.js";
+function mergeExtensions(modules) {
+  const extensions = [];
+  const toolbar = [];
+  const allKeyBindings = [];
+  const seenRuleNames = /* @__PURE__ */ new Set();
+  for (const mod of modules) {
+    if (mod.extensions?.length) extensions.push(...mod.extensions);
+    if (mod.keymap?.length) allKeyBindings.push(...mod.keymap);
+    if (mod.toolbar?.length) toolbar.push(...mod.toolbar);
+    if (mod.rules) {
+      extensions.push(nodeRulesFacet.of(mod.rules));
+      for (const name of Object.keys(mod.rules)) {
+        if (seenRuleNames.has(name)) {
+          console.warn(
+            `MarkdownExtension "${mod.name}" overrides node rule "${name}" already provided by another extension.`
+          );
+        }
+        seenRuleNames.add(name);
+      }
+    }
+  }
+  if (allKeyBindings.length) extensions.push(cmKeymap.of(allKeyBindings));
+  return { extensions, toolbar };
+}
+const composeExtensions = mergeExtensions;
+export {
+  composeExtensions,
+  mergeExtensions
+};
+//# sourceMappingURL=loader.js.map

package/dist/codemirror/extensions/loader.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/extensions/loader.ts"],"sourcesContent":["import { type Extension } from \"@codemirror/state\";\nimport { keymap as cmKeymap } from \"@codemirror/view\";\n\nimport { nodeRulesFacet } from \"../core\";\nimport { type MarkdownExtension, type ToolbarContribution } from \"./types\";\n\nexport interface ComposedExtension {\n  extensions: Extension[];\n  toolbar: ToolbarContribution[];\n}\n\n/**\n * Merge extension modules into one set of CodeMirror extensions plus the\n * toolbar items they contribute. Later modules win: a host's rules are applied\n * after the built-ins, so it can deliberately override a construct.\n */\nexport function mergeExtensions(modules: readonly MarkdownExtension[]): ComposedExtension {\n  const extensions: Extension[] = [];\n  const toolbar: ToolbarContribution[] = [];\n  const allKeyBindings: import(\"@codemirror/view\").KeyBinding[] = [];\n  const seenRuleNames = new Set<string>();\n\n  for (const mod of modules) {\n    if (mod.extensions?.length) extensions.push(...mod.extensions);\n    if (mod.keymap?.length) allKeyBindings.push(...mod.keymap);\n    if (mod.toolbar?.length) toolbar.push(...mod.toolbar);\n    if (mod.rules) {\n      // An extension's node rules feed the decoration painter through the\n      // facet — introducing (or deliberately overriding) a construct never\n      // touches the base table.\n      extensions.push(nodeRulesFacet.of(mod.rules));\n      for (const name of Object.keys(mod.rules)) {\n        if (seenRuleNames.has(name)) {\n          // eslint-disable-next-line no-console\n          console.warn(\n            `MarkdownExtension \"${mod.name}\" overrides node rule \"${name}\" already provided by another extension.`,\n          );\n        }\n        seenRuleNames.add(name);\n      }\n    }\n  }\n\n  if (allKeyBindings.length) extensions.push(cmKeymap.of(allKeyBindings));\n\n  return { extensions, toolbar };\n}\n\n/**\n * @deprecated Renamed to {@link mergeExtensions}. \"compose\" reads as the app\n * this package was extracted from rather than as the verb; the editor is meant\n * for more hosts than that one. Kept as an alias so the rename is not breaking.\n */\nexport const composeExtensions = mergeExtensions;\n"],"mappings":";AACA,SAAS,UAAU,gBAAgB;AAEnC,SAAS,sBAAsB;AAaxB,SAAS,gBAAgB,SAA0D;AACxF,QAAM,aAA0B,CAAC;AACjC,QAAM,UAAiC,CAAC;AACxC,QAAM,iBAA0D,CAAC;AACjE,QAAM,gBAAgB,oBAAI,IAAY;AAEtC,aAAW,OAAO,SAAS;AACzB,QAAI,IAAI,YAAY,OAAQ,YAAW,KAAK,GAAG,IAAI,UAAU;AAC7D,QAAI,IAAI,QAAQ,OAAQ,gBAAe,KAAK,GAAG,IAAI,MAAM;AACzD,QAAI,IAAI,SAAS,OAAQ,SAAQ,KAAK,GAAG,IAAI,OAAO;AACpD,QAAI,IAAI,OAAO;AAIb,iBAAW,KAAK,eAAe,GAAG,IAAI,KAAK,CAAC;AAC5C,iBAAW,QAAQ,OAAO,KAAK,IAAI,KAAK,GAAG;AACzC,YAAI,cAAc,IAAI,IAAI,GAAG;AAE3B,kBAAQ;AAAA,YACN,sBAAsB,IAAI,IAAI,0BAA0B,IAAI;AAAA,UAC9D;AAAA,QACF;AACA,sBAAc,IAAI,IAAI;AAAA,MACxB;AAAA,IACF;AAAA,EACF;AAEA,MAAI,eAAe,OAAQ,YAAW,KAAK,SAAS,GAAG,cAAc,CAAC;AAEtE,SAAO,EAAE,YAAY,QAAQ;AAC/B;AAOO,MAAM,oBAAoB;","names":[]}

package/dist/codemirror/extensions/mathExtension.d.ts

@@ -0,0 +1,9 @@
+import { MarkdownExtension } from './types.js';
+import '@codemirror/view';
+import '@codemirror/state';
+import 'react';
+import '../core/paint.js';
+
+declare const mathExtension: MarkdownExtension;
+
+export { mathExtension };

package/dist/codemirror/extensions/mathExtension.js

@@ -0,0 +1,14 @@
+import "../../chunk-V6TY7KAL.js";
+import { mathPlugin } from "../math/index.js";
+import { inlineScanRulesFacet } from "../core/inlineScan.js";
+import { mathScanRule } from "../math/mathScanRule.js";
+const mathExtension = {
+  name: "@compose/math",
+  version: "0.1.0",
+  description: "Renders `$x$` inline and `$$x$$` block math via KaTeX.",
+  extensions: [mathPlugin, inlineScanRulesFacet.of(mathScanRule)]
+};
+export {
+  mathExtension
+};
+//# sourceMappingURL=mathExtension.js.map

package/dist/codemirror/extensions/mathExtension.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/extensions/mathExtension.ts"],"sourcesContent":["import { mathPlugin } from \"../math\";\nimport { inlineScanRulesFacet } from \"../core/inlineScan\";\nimport { mathScanRule } from \"../math/mathScanRule\";\n\nimport { type MarkdownExtension } from \"./types\";\n\nexport const mathExtension: MarkdownExtension = {\n  name: \"@compose/math\",\n  version: \"0.1.0\",\n  description: \"Renders `$x$` inline and `$$x$$` block math via KaTeX.\",\n  extensions: [mathPlugin, inlineScanRulesFacet.of(mathScanRule)],\n};\n"],"mappings":";AAAA,SAAS,kBAAkB;AAC3B,SAAS,4BAA4B;AACrC,SAAS,oBAAoB;AAItB,MAAM,gBAAmC;AAAA,EAC9C,MAAM;AAAA,EACN,SAAS;AAAA,EACT,aAAa;AAAA,EACb,YAAY,CAAC,YAAY,qBAAqB,GAAG,YAAY,CAAC;AAChE;","names":[]}

package/dist/codemirror/extensions/mermaidExtension.d.ts

@@ -0,0 +1,9 @@
+import { MarkdownExtension } from './types.js';
+import '@codemirror/view';
+import '@codemirror/state';
+import 'react';
+import '../core/paint.js';
+
+declare const mermaidExtension: MarkdownExtension;
+
+export { mermaidExtension };

package/dist/codemirror/extensions/mermaidExtension.js

@@ -0,0 +1,12 @@
+import "../../chunk-V6TY7KAL.js";
+import { mermaidField } from "../mermaid/index.js";
+const mermaidExtension = {
+  name: "@compose/mermaid",
+  version: "0.1.0",
+  description: "Renders closed ```mermaid fences as diagrams; click a diagram to edit its source.",
+  extensions: [mermaidField]
+};
+export {
+  mermaidExtension
+};
+//# sourceMappingURL=mermaidExtension.js.map

package/dist/codemirror/extensions/mermaidExtension.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/extensions/mermaidExtension.ts"],"sourcesContent":["import { mermaidField } from \"../mermaid\";\n\nimport { type MarkdownExtension } from \"./types\";\n\nexport const mermaidExtension: MarkdownExtension = {\n  name: \"@compose/mermaid\",\n  version: \"0.1.0\",\n  description:\n    \"Renders closed ```mermaid fences as diagrams; click a diagram to edit its source.\",\n  extensions: [mermaidField],\n};\n"],"mappings":";AAAA,SAAS,oBAAoB;AAItB,MAAM,mBAAsC;AAAA,EACjD,MAAM;AAAA,EACN,SAAS;AAAA,EACT,aACE;AAAA,EACF,YAAY,CAAC,YAAY;AAC3B;","names":[]}

package/dist/codemirror/extensions/tableExtension.d.ts

@@ -0,0 +1,13 @@
+import { MarkdownExtension } from './types.js';
+import '@codemirror/view';
+import '@codemirror/state';
+import 'react';
+import '../core/paint.js';
+
+/**
+ * A FACTORY, not a const: each composition gets its own editing surface (the
+ * one-active-edit state), so two mounted editors can never share a cell edit.
+ */
+declare function tableExtension(): MarkdownExtension;
+
+export { tableExtension };

package/dist/codemirror/extensions/tableExtension.js

@@ -0,0 +1,39 @@
+import "../../chunk-V6TY7KAL.js";
+import { EditorView } from "@codemirror/view";
+import { armedTableField, tableArmedHighlight, tableField } from "../table/index.js";
+import { InlineCellSurface } from "../tablev2/inlineCellSurface.js";
+import { tableV2HoverControls } from "../tablev2/tableV2HoverControls.js";
+import { tableV2Interaction } from "../tablev2/tableV2Interaction.js";
+import { tableV2Sync } from "../tablev2/tableV2Sync.js";
+function tableExtension() {
+  const surface = new InlineCellSurface();
+  return {
+    name: "@compose/table",
+    version: "0.2.0",
+    description: "Renders GFM tables as a grid widget; cells edit natively in place (ADR 0001).",
+    extensions: [
+      tableField,
+      // Treat each table as one atomic block: the caret, clicks, and selection
+      // skip over it instead of landing on its hidden `| … |` source. Without
+      // this, arrows/clicks resolve to hidden offsets and Backspace edits a
+      // hidden pipe — corrupting the grid (and eating the blank-line separator).
+      EditorView.atomicRanges.of((view) => view.state.field(tableField)),
+      // Two-step delete: the field records which table the next press deletes;
+      // the plugin outlines it and draws the "armed" edge line.
+      armedTableField,
+      tableArmedHighlight,
+      // Keep the surface's table anchor + active edit alive across doc changes.
+      tableV2Sync(surface),
+      // Click-to-edit at the clicked character, bridge keys (Tab/arrows/
+      // Backspace/Delete/Enter), whole-cell drag selection + TSV copy, the
+      // structure menu, and table entry/exit from the main document.
+      tableV2Interaction(surface),
+      // Hover "+" quick inserters (row below / column right).
+      tableV2HoverControls()
+    ]
+  };
+}
+export {
+  tableExtension
+};
+//# sourceMappingURL=tableExtension.js.map

package/dist/codemirror/extensions/tableExtension.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/extensions/tableExtension.ts"],"sourcesContent":["import { EditorView } from \"@codemirror/view\";\n\nimport { armedTableField, tableArmedHighlight, tableField } from \"../table\";\nimport { InlineCellSurface } from \"../tablev2/inlineCellSurface\";\nimport { tableV2HoverControls } from \"../tablev2/tableV2HoverControls\";\nimport { tableV2Interaction } from \"../tablev2/tableV2Interaction\";\nimport { tableV2Sync } from \"../tablev2/tableV2Sync\";\n\nimport { type MarkdownExtension } from \"./types\";\n\n/**\n * A FACTORY, not a const: each composition gets its own editing surface (the\n * one-active-edit state), so two mounted editors can never share a cell edit.\n */\nexport function tableExtension(): MarkdownExtension {\n  const surface = new InlineCellSurface();\n  return {\n    name: \"@compose/table\",\n    version: \"0.2.0\",\n    description:\n      \"Renders GFM tables as a grid widget; cells edit natively in place (ADR 0001).\",\n    extensions: [\n      tableField,\n      // Treat each table as one atomic block: the caret, clicks, and selection\n      // skip over it instead of landing on its hidden `| … |` source. Without\n      // this, arrows/clicks resolve to hidden offsets and Backspace edits a\n      // hidden pipe — corrupting the grid (and eating the blank-line separator).\n      EditorView.atomicRanges.of((view) => view.state.field(tableField)),\n      // Two-step delete: the field records which table the next press deletes;\n      // the plugin outlines it and draws the \"armed\" edge line.\n      armedTableField,\n      tableArmedHighlight,\n      // Keep the surface's table anchor + active edit alive across doc changes.\n      tableV2Sync(surface),\n      // Click-to-edit at the clicked character, bridge keys (Tab/arrows/\n      // Backspace/Delete/Enter), whole-cell drag selection + TSV copy, the\n      // structure menu, and table entry/exit from the main document.\n      tableV2Interaction(surface),\n      // Hover \"+\" quick inserters (row below / column right).\n      tableV2HoverControls(),\n    ],\n  };\n}\n"],"mappings":";AAAA,SAAS,kBAAkB;AAE3B,SAAS,iBAAiB,qBAAqB,kBAAkB;AACjE,SAAS,yBAAyB;AAClC,SAAS,4BAA4B;AACrC,SAAS,0BAA0B;AACnC,SAAS,mBAAmB;AAQrB,SAAS,iBAAoC;AAClD,QAAM,UAAU,IAAI,kBAAkB;AACtC,SAAO;AAAA,IACL,MAAM;AAAA,IACN,SAAS;AAAA,IACT,aACE;AAAA,IACF,YAAY;AAAA,MACV;AAAA;AAAA;AAAA;AAAA;AAAA,MAKA,WAAW,aAAa,GAAG,CAAC,SAAS,KAAK,MAAM,MAAM,UAAU,CAAC;AAAA;AAAA;AAAA,MAGjE;AAAA,MACA;AAAA;AAAA,MAEA,YAAY,OAAO;AAAA;AAAA;AAAA;AAAA,MAInB,mBAAmB,OAAO;AAAA;AAAA,MAE1B,qBAAqB;AAAA,IACvB;AAAA,EACF;AACF;","names":[]}

package/dist/codemirror/extensions/types.d.ts

@@ -0,0 +1,39 @@
+import * as _codemirror_view from '@codemirror/view';
+import { KeyBinding } from '@codemirror/view';
+import { Extension } from '@codemirror/state';
+import { ReactNode } from 'react';
+import { NodeRules } from '../core/paint.js';
+
+interface ToolbarContribution {
+    readonly id: string;
+    readonly group: "heading" | "format" | "block" | "insert" | string;
+    readonly label: string;
+    readonly icon: ReactNode;
+    readonly shortcut?: string;
+    readonly isActive?: (caretContext: CaretContextSnapshot) => boolean;
+    readonly run: (view: _codemirror_view.EditorView) => void;
+}
+interface CaretContextSnapshot {
+    readonly bold: boolean;
+    readonly italic: boolean;
+    readonly code: boolean;
+    readonly link: boolean;
+    readonly heading: 1 | 2 | 3 | 4 | 5 | 6 | 0;
+    readonly bulletList: boolean;
+    readonly orderedList: boolean;
+    readonly blockquote: boolean;
+}
+interface MarkdownExtension {
+    readonly name: string;
+    readonly version: string;
+    readonly description?: string;
+    /** Node rules for constructs this extension's grammar introduces (or
+     *  deliberately overrides) — merged into the decoration painter via
+     *  `nodeRulesFacet`, so an extension never edits the base table. */
+    readonly rules?: NodeRules;
+    readonly extensions?: Extension[];
+    readonly keymap?: KeyBinding[];
+    readonly toolbar?: ToolbarContribution[];
+}
+
+export type { CaretContextSnapshot, MarkdownExtension, ToolbarContribution };

package/dist/codemirror/extensions/types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=types.js.map

package/dist/codemirror/extensions/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/codemirror/extensions/wikilinkExtension.d.ts

@@ -0,0 +1,9 @@
+import { MarkdownExtension } from './types.js';
+import '@codemirror/view';
+import '@codemirror/state';
+import 'react';
+import '../core/paint.js';
+
+declare const wikilinkExtension: MarkdownExtension;
+
+export { wikilinkExtension };

package/dist/codemirror/extensions/wikilinkExtension.js

@@ -0,0 +1,14 @@
+import "../../chunk-V6TY7KAL.js";
+import { wikilinkPlugin } from "../wikilink/index.js";
+import { inlineScanRulesFacet } from "../core/inlineScan.js";
+import { wikilinkScanRule } from "../wikilink/wikilinkScanRule.js";
+const wikilinkExtension = {
+  name: "@compose/wikilink",
+  version: "0.1.0",
+  description: "Renders `[[target]]` / `[[target|alias]]` as clickable links.",
+  extensions: [wikilinkPlugin, inlineScanRulesFacet.of(wikilinkScanRule)]
+};
+export {
+  wikilinkExtension
+};
+//# sourceMappingURL=wikilinkExtension.js.map

package/dist/codemirror/extensions/wikilinkExtension.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/extensions/wikilinkExtension.ts"],"sourcesContent":["import { wikilinkPlugin } from \"../wikilink\";\nimport { inlineScanRulesFacet } from \"../core/inlineScan\";\nimport { wikilinkScanRule } from \"../wikilink/wikilinkScanRule\";\n\nimport { type MarkdownExtension } from \"./types\";\n\nexport const wikilinkExtension: MarkdownExtension = {\n  name: \"@compose/wikilink\",\n  version: \"0.1.0\",\n  description: \"Renders `[[target]]` / `[[target|alias]]` as clickable links.\",\n  extensions: [wikilinkPlugin, inlineScanRulesFacet.of(wikilinkScanRule)],\n};\n"],"mappings":";AAAA,SAAS,sBAAsB;AAC/B,SAAS,4BAA4B;AACrC,SAAS,wBAAwB;AAI1B,MAAM,oBAAuC;AAAA,EAClD,MAAM;AAAA,EACN,SAAS;AAAA,EACT,aAAa;AAAA,EACb,YAAY,CAAC,gBAAgB,qBAAqB,GAAG,gBAAgB,CAAC;AACxE;","names":[]}

package/dist/codemirror/features/blockCommandSteps.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Shared Given/When/Then steps for the block-command feature files.
+ *
+ * The whole block-command surface has one regular shape — a document with a
+ * caret (or selection) goes in, a command runs, a document with a caret comes
+ * out — so these steps drive every scenario across the `.feature` files. They're
+ * registered once as a shared pool via {@link defineBlockSteps}; each scenario
+ * draws the steps it needs.
+ *
+ * Marker convention in the doc strings: `‸` marks the caret; a second `‸` turns
+ * it into a selection spanning the two marks. (`|` would collide with table
+ * syntax, so it's deliberately not used.)
+ */
+/** Zero-width space the runner prefixes onto doc-string content lines to hide
+ *  literal markdown from the cucumber parser; stripped back out here. */
+declare const ZWSP: string;
+declare function defineBlockSteps(): void;
+declare function protectMarkdown(raw: string): string;
+
+export { ZWSP, defineBlockSteps, protectMarkdown };

package/dist/codemirror/features/blockCommandSteps.js

@@ -0,0 +1,83 @@
+import "../../chunk-V6TY7KAL.js";
+import { EditorSelection } from "@codemirror/state";
+import { defineSteps } from "@amiceli/vitest-cucumber";
+import { expect } from "vitest";
+import { blockCommands } from "../format/index.js";
+import { indentListItem, outdentListItem } from "../list/index.js";
+import { makeEditor, text } from "../core/editorTestHarness.js";
+const CARET = "\u2038";
+const ZWSP = String.fromCharCode(8203);
+const COMMANDS = {
+  "toggle heading 1": blockCommands.toggleHeading1,
+  "toggle heading 2": blockCommands.toggleHeading2,
+  "toggle heading 3": blockCommands.toggleHeading3,
+  "toggle a bullet list": blockCommands.toggleBulletList,
+  "toggle an ordered list": blockCommands.toggleOrderedList,
+  "toggle a task list": blockCommands.toggleTaskList,
+  "toggle a blockquote": blockCommands.toggleBlockquote,
+  "toggle a code block": blockCommands.toggleCodeBlock,
+  "insert a table": blockCommands.insertTable,
+  "indent the list item": indentListItem,
+  "outdent the list item": outdentListItem
+};
+function cleanDoc(block) {
+  return block.split(ZWSP).join("").replace(/\n+$/, "");
+}
+function parseMarked(marked) {
+  const first = marked.indexOf(CARET);
+  if (first < 0) return { doc: marked, anchor: 0, head: 0 };
+  const afterFirst = marked.slice(0, first) + marked.slice(first + CARET.length);
+  const second = afterFirst.indexOf(CARET);
+  if (second < 0) return { doc: afterFirst, anchor: first, head: first };
+  const doc = afterFirst.slice(0, second) + afterFirst.slice(second + CARET.length);
+  return { doc, anchor: first, head: second };
+}
+function renderMarked(view) {
+  const { anchor, head } = view.state.selection.main;
+  const body = text(view);
+  if (anchor === head) return body.slice(0, head) + CARET + body.slice(head);
+  const [from, to] = anchor < head ? [anchor, head] : [head, anchor];
+  return body.slice(0, from) + CARET + body.slice(from, to) + CARET + body.slice(to);
+}
+function defineBlockSteps() {
+  let view;
+  defineSteps(({ Given, When, Then, And }) => {
+    Given("the document:", (_ctx, doc) => {
+      const { doc: source, anchor, head } = parseMarked(cleanDoc(doc));
+      view = makeEditor(source, head);
+      if (anchor !== head) view.dispatch({ selection: EditorSelection.range(anchor, head) });
+    });
+    const run = (_ctx, phrase) => {
+      const command = COMMANDS[phrase];
+      if (!command) throw new Error(`no editor command bound for "${phrase}"`);
+      command(view);
+    };
+    When("I {string}", run);
+    And("I {string}", run);
+    Then("the document is:", (_ctx, expected) => {
+      const want = cleanDoc(expected);
+      expect(want.includes(CARET) ? renderMarked(view) : text(view)).toBe(want);
+    });
+  });
+}
+function protectMarkdown(raw) {
+  let insideDocString = false;
+  let baseIndent = 0;
+  return raw.split("\n").map((line) => {
+    const trimmed = line.trimStart();
+    if (trimmed.startsWith('"""')) {
+      if (!insideDocString) baseIndent = line.length - trimmed.length;
+      insideDocString = !insideDocString;
+      return line;
+    }
+    if (!insideDocString) return line;
+    const dedented = line.startsWith(" ".repeat(baseIndent)) ? line.slice(baseIndent) : trimmed;
+    return ZWSP + dedented;
+  }).join("\n");
+}
+export {
+  ZWSP,
+  defineBlockSteps,
+  protectMarkdown
+};
+//# sourceMappingURL=blockCommandSteps.js.map

package/dist/codemirror/features/blockCommandSteps.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/features/blockCommandSteps.ts"],"sourcesContent":["/**\n * Shared Given/When/Then steps for the block-command feature files.\n *\n * The whole block-command surface has one regular shape — a document with a\n * caret (or selection) goes in, a command runs, a document with a caret comes\n * out — so these steps drive every scenario across the `.feature` files. They're\n * registered once as a shared pool via {@link defineBlockSteps}; each scenario\n * draws the steps it needs.\n *\n * Marker convention in the doc strings: `‸` marks the caret; a second `‸` turns\n * it into a selection spanning the two marks. (`|` would collide with table\n * syntax, so it's deliberately not used.)\n */\n\nimport { EditorSelection } from \"@codemirror/state\";\nimport { type EditorView } from \"@codemirror/view\";\nimport { defineSteps } from \"@amiceli/vitest-cucumber\";\nimport { expect } from \"vitest\";\n\nimport { blockCommands } from \"../format\";\nimport { indentListItem, outdentListItem } from \"../list\";\nimport { makeEditor, text } from \"../core/editorTestHarness\";\n\nconst CARET = \"‸\";\n\n/** Zero-width space the runner prefixes onto doc-string content lines to hide\n *  literal markdown from the cucumber parser; stripped back out here. */\nexport const ZWSP = String.fromCharCode(0x200b);\n\nconst COMMANDS: Record<string, (view: EditorView) => boolean> = {\n  \"toggle heading 1\": blockCommands.toggleHeading1,\n  \"toggle heading 2\": blockCommands.toggleHeading2,\n  \"toggle heading 3\": blockCommands.toggleHeading3,\n  \"toggle a bullet list\": blockCommands.toggleBulletList,\n  \"toggle an ordered list\": blockCommands.toggleOrderedList,\n  \"toggle a task list\": blockCommands.toggleTaskList,\n  \"toggle a blockquote\": blockCommands.toggleBlockquote,\n  \"toggle a code block\": blockCommands.toggleCodeBlock,\n  \"insert a table\": blockCommands.insertTable,\n  \"indent the list item\": indentListItem,\n  \"outdent the list item\": outdentListItem,\n};\n\n// A Gherkin doc string reaches us with the runner's zero-width guards and the\n// parser's own per-line trim; drop the guards and any trailing blank line so the\n// literal markdown is what the scenario asserts against.\nfunction cleanDoc(block: string): string {\n  return block\n    .split(ZWSP)\n    .join(\"\")\n    .replace(/\\n+$/, \"\");\n}\n\n// `‸` → caret; a second `‸` → a selection from the first mark to the second.\nfunction parseMarked(marked: string): { doc: string; anchor: number; head: number } {\n  const first = marked.indexOf(CARET);\n  if (first < 0) return { doc: marked, anchor: 0, head: 0 };\n  const afterFirst = marked.slice(0, first) + marked.slice(first + CARET.length);\n  const second = afterFirst.indexOf(CARET);\n  if (second < 0) return { doc: afterFirst, anchor: first, head: first };\n  const doc = afterFirst.slice(0, second) + afterFirst.slice(second + CARET.length);\n  return { doc, anchor: first, head: second };\n}\n\n// Re-insert the marker(s) at the current selection, so a `Then` doc string can\n// assert the resulting caret/selection as readably as it set the starting one.\nfunction renderMarked(view: EditorView): string {\n  const { anchor, head } = view.state.selection.main;\n  const body = text(view);\n  if (anchor === head) return body.slice(0, head) + CARET + body.slice(head);\n  const [from, to] = anchor < head ? [anchor, head] : [head, anchor];\n  return body.slice(0, from) + CARET + body.slice(from, to) + CARET + body.slice(to);\n}\n\n// Register the shared step pool. Scenarios run sequentially within the file, so\n// a single live editor is enough to thread Given → When → Then.\nexport function defineBlockSteps(): void {\n  let view: EditorView;\n\n  defineSteps(({ Given, When, Then, And }) => {\n    Given(\"the document:\", (_ctx: unknown, doc: string) => {\n      const { doc: source, anchor, head } = parseMarked(cleanDoc(doc));\n      view = makeEditor(source, head);\n      if (anchor !== head) view.dispatch({ selection: EditorSelection.range(anchor, head) });\n    });\n\n    const run = (_ctx: unknown, phrase: string) => {\n      const command = COMMANDS[phrase];\n      if (!command) throw new Error(`no editor command bound for \"${phrase}\"`);\n      command(view);\n    };\n    When(\"I {string}\", run);\n    And(\"I {string}\", run);\n\n    // A `Then` doc string opts into a caret assertion by including `‸`; without\n    // one it asserts the document text alone.\n    Then(\"the document is:\", (_ctx: unknown, expected: string) => {\n      const want = cleanDoc(expected);\n      expect(want.includes(CARET) ? renderMarked(view) : text(view)).toBe(want);\n    });\n  });\n}\n\n// The cucumber parser treats a `#`-leading line as a comment and a `\"\"\"`/``` line\n// as a doc-string delimiter — even *inside* a doc string — and it strips each\n// content line's leading whitespace, which would also flatten the *relative*\n// indent that list-nesting scenarios assert. So for every doc-string content\n// line: strip the doc string's own base indent (the opening `\"\"\"` column), then\n// prefix a zero-width space at column 0. The ZWSP is now the first character, so\n// the parser strips nothing (relative indent survives) and reads no `#`/`\"\"\"`/```\n// as syntax; the steps drop the ZWSP back out. Source `.feature` files stay clean.\nexport function protectMarkdown(raw: string): string {\n  let insideDocString = false;\n  let baseIndent = 0;\n  return raw\n    .split(\"\\n\")\n    .map((line) => {\n      const trimmed = line.trimStart();\n      if (trimmed.startsWith('\"\"\"')) {\n        if (!insideDocString) baseIndent = line.length - trimmed.length;\n        insideDocString = !insideDocString;\n        return line;\n      }\n      if (!insideDocString) return line;\n      const dedented = line.startsWith(\" \".repeat(baseIndent))\n        ? line.slice(baseIndent)\n        : trimmed;\n      return ZWSP + dedented;\n    })\n    .join(\"\\n\");\n}\n"],"mappings":";AAcA,SAAS,uBAAuB;AAEhC,SAAS,mBAAmB;AAC5B,SAAS,cAAc;AAEvB,SAAS,qBAAqB;AAC9B,SAAS,gBAAgB,uBAAuB;AAChD,SAAS,YAAY,YAAY;AAEjC,MAAM,QAAQ;AAIP,MAAM,OAAO,OAAO,aAAa,IAAM;AAE9C,MAAM,WAA0D;AAAA,EAC9D,oBAAoB,cAAc;AAAA,EAClC,oBAAoB,cAAc;AAAA,EAClC,oBAAoB,cAAc;AAAA,EAClC,wBAAwB,cAAc;AAAA,EACtC,0BAA0B,cAAc;AAAA,EACxC,sBAAsB,cAAc;AAAA,EACpC,uBAAuB,cAAc;AAAA,EACrC,uBAAuB,cAAc;AAAA,EACrC,kBAAkB,cAAc;AAAA,EAChC,wBAAwB;AAAA,EACxB,yBAAyB;AAC3B;AAKA,SAAS,SAAS,OAAuB;AACvC,SAAO,MACJ,MAAM,IAAI,EACV,KAAK,EAAE,EACP,QAAQ,QAAQ,EAAE;AACvB;AAGA,SAAS,YAAY,QAA+D;AAClF,QAAM,QAAQ,OAAO,QAAQ,KAAK;AAClC,MAAI,QAAQ,EAAG,QAAO,EAAE,KAAK,QAAQ,QAAQ,GAAG,MAAM,EAAE;AACxD,QAAM,aAAa,OAAO,MAAM,GAAG,KAAK,IAAI,OAAO,MAAM,QAAQ,MAAM,MAAM;AAC7E,QAAM,SAAS,WAAW,QAAQ,KAAK;AACvC,MAAI,SAAS,EAAG,QAAO,EAAE,KAAK,YAAY,QAAQ,OAAO,MAAM,MAAM;AACrE,QAAM,MAAM,WAAW,MAAM,GAAG,MAAM,IAAI,WAAW,MAAM,SAAS,MAAM,MAAM;AAChF,SAAO,EAAE,KAAK,QAAQ,OAAO,MAAM,OAAO;AAC5C;AAIA,SAAS,aAAa,MAA0B;AAC9C,QAAM,EAAE,QAAQ,KAAK,IAAI,KAAK,MAAM,UAAU;AAC9C,QAAM,OAAO,KAAK,IAAI;AACtB,MAAI,WAAW,KAAM,QAAO,KAAK,MAAM,GAAG,IAAI,IAAI,QAAQ,KAAK,MAAM,IAAI;AACzE,QAAM,CAAC,MAAM,EAAE,IAAI,SAAS,OAAO,CAAC,QAAQ,IAAI,IAAI,CAAC,MAAM,MAAM;AACjE,SAAO,KAAK,MAAM,GAAG,IAAI,IAAI,QAAQ,KAAK,MAAM,MAAM,EAAE,IAAI,QAAQ,KAAK,MAAM,EAAE;AACnF;AAIO,SAAS,mBAAyB;AACvC,MAAI;AAEJ,cAAY,CAAC,EAAE,OAAO,MAAM,MAAM,IAAI,MAAM;AAC1C,UAAM,iBAAiB,CAAC,MAAe,QAAgB;AACrD,YAAM,EAAE,KAAK,QAAQ,QAAQ,KAAK,IAAI,YAAY,SAAS,GAAG,CAAC;AAC/D,aAAO,WAAW,QAAQ,IAAI;AAC9B,UAAI,WAAW,KAAM,MAAK,SAAS,EAAE,WAAW,gBAAgB,MAAM,QAAQ,IAAI,EAAE,CAAC;AAAA,IACvF,CAAC;AAED,UAAM,MAAM,CAAC,MAAe,WAAmB;AAC7C,YAAM,UAAU,SAAS,MAAM;AAC/B,UAAI,CAAC,QAAS,OAAM,IAAI,MAAM,gCAAgC,MAAM,GAAG;AACvE,cAAQ,IAAI;AAAA,IACd;AACA,SAAK,cAAc,GAAG;AACtB,QAAI,cAAc,GAAG;AAIrB,SAAK,oBAAoB,CAAC,MAAe,aAAqB;AAC5D,YAAM,OAAO,SAAS,QAAQ;AAC9B,aAAO,KAAK,SAAS,KAAK,IAAI,aAAa,IAAI,IAAI,KAAK,IAAI,CAAC,EAAE,KAAK,IAAI;AAAA,IAC1E,CAAC;AAAA,EACH,CAAC;AACH;AAUO,SAAS,gBAAgB,KAAqB;AACnD,MAAI,kBAAkB;AACtB,MAAI,aAAa;AACjB,SAAO,IACJ,MAAM,IAAI,EACV,IAAI,CAAC,SAAS;AACb,UAAM,UAAU,KAAK,UAAU;AAC/B,QAAI,QAAQ,WAAW,KAAK,GAAG;AAC7B,UAAI,CAAC,gBAAiB,cAAa,KAAK,SAAS,QAAQ;AACzD,wBAAkB,CAAC;AACnB,aAAO;AAAA,IACT;AACA,QAAI,CAAC,gBAAiB,QAAO;AAC7B,UAAM,WAAW,KAAK,WAAW,IAAI,OAAO,UAAU,CAAC,IACnD,KAAK,MAAM,UAAU,IACrB;AACJ,WAAO,OAAO;AAAA,EAChB,CAAC,EACA,KAAK,IAAI;AACd;","names":[]}