@latentic/live-markdown 0.3.0 → 0.4.0

package/dist/codemirror/code/fenceAutoClose.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/code/fenceAutoClose.ts"],"sourcesContent":["/**\n * Fence lifecycle (#91, interaction-spec §9.5, §12.4–.6).\n *\n * An unclosed fence runs to the end of the document per CommonMark, so the\n * moment ``` is typed everything below renders as one giant code block —\n * grammar-correct, wrong WYSIWYG. The behaviors here keep blocks bounded,\n * enterable, and escapable:\n *\n *   - TYPE-TIME close (§12.4): the keystroke completing a fence opener at a\n *     line's CONTENT start — top level, inside a list item, inside a quote\n *     (positions from `lineStructure`, not a line regex) — inserts an empty\n *     content line plus the matching closer at the same content column. The\n *     caret STAYS on the opener, so typing continues the language tag\n *     (```mermaid — the universal fence idiom, rendered live as the visible\n *     pill) and Enter steps onto the content line (§12.5). Quote prefixes are\n *     carried onto the inserted lines; list prefixes become continuation\n *     indent.\n *   - ENTER close: Enter at the end of an unclosed opener line (e.g. pasted)\n *     closes it with the caret inside.\n *   - ENTER step-in (§12.5): Enter on a CLOSED block's opener whose first\n *     content line is empty moves the caret onto that line instead of\n *     inserting another.\n *   - ENTER exit (§12.6): Enter on the block's empty last content line\n *     removes that line and moves the caret below the closing fence,\n *     creating the line when the block ends the document.\n *\n * Typing on a CLOSED fence's own rows re-sites into content (§12.7) — see\n * resiteFenceLineTyping — which also closes the old gap where lengthening\n * the opener in place re-opened the block.\n */\n\nimport { EditorSelection, EditorState, Prec, type Transaction } from \"@codemirror/state\";\nimport { keymap, type Command } from \"@codemirror/view\";\n\nimport { lineStructure } from \"../core/lineStructure\";\nimport { treeAt } from \"../core/treeAt\";\n\n/** The FencedCode syntax node, as a structural stand-in (`@lezer/common` stays\n *  a transitive dep). Exported because `fenceAt` returns it. */\nexport type FenceNode = {\n  readonly name: string;\n  readonly from: number;\n  readonly to: number;\n  readonly parent: FenceNode | null;\n  getChildren(type: string): readonly FenceNode[];\n};\n\n/** Continuation prefix for a line inserted inside the same containers as\n * `line` up to `contentStart`: quote marks carry over, everything else\n * becomes plain indent. */\nfunction containerPrefix(text: string): string {\n  return [...text].map((c) => (c === \">\" ? \">\" : \" \")).join(\"\");\n}\n\n/** §12.7 — typing on a CLOSED fence's own rows can never edit the fence.\n * On the closing line, trailing text stops it closing (CommonMark allows no\n * info string there) and the block re-opens, swallowing everything below.\n * On the opener, typing extends the language tag — which users hit when they\n * click the block's first gray row meaning to type CODE. Both re-site: the\n * closer row onto a fresh content line before the closer; the opener row to\n * the start of the first content line. (An UNCLOSED opener still types in\n * place — that's the language flow for a pasted fence.) Editing an existing\n * language tag moves to RAW mode, spec-noted. Returns the replacement spec,\n * or null when the insertion is elsewhere. */\nfunction resiteFenceLineTyping(\n  tr: Transaction,\n  from: number,\n  text: string,\n): { changes: { from: number; insert: string }; selection: ReturnType<typeof EditorSelection.cursor>; userEvent: string } | null {\n  const state = tr.startState;\n  let node = fenceAt(state, from);\n  if (!node) {\n    // Column 0 of the opener row sits ON the fence node's from-boundary,\n    // where side -1 resolves to the sibling before the block. Probe from the\n    // line's end instead; only accept a fence whose opener IS this line.\n    const line = state.doc.lineAt(from);\n    if (from !== line.from || line.to === line.from) return null;\n    const probed = fenceAt(state, line.to);\n    if (!probed || state.doc.lineAt(probed.from).from !== line.from) return null;\n    node = probed;\n  }\n  const marks = node.getChildren(\"CodeMark\");\n  if (marks.length < 2) return null;\n  const openerLine = state.doc.lineAt(node.from);\n  const closer = marks[marks.length - 1];\n  const closerLine = state.doc.lineAt(closer.from);\n  if (from >= openerLine.from && from <= openerLine.to) {\n    // Fresh-block language flow (§12.4): while the block holds no code yet,\n    // typing after the opening marks extends the info string IN PLACE —\n    // ```mermaid⏎ — with the visible pill as live feedback. A fence character\n    // is excluded (a 4th backtick must not grow the marks), and a block WITH\n    // content keeps the clicked-the-gray-row-means-code re-site below.\n    const bodyIsEmpty =\n      closerLine.number - openerLine.number < 2 ||\n      state.doc\n        .sliceString(openerLine.to, closerLine.from)\n        .split(\"\\n\")\n        .every((lineText) => /^[>\\s]*$/.test(lineText));\n    if (\n      bodyIsEmpty &&\n      from >= marks[0].to &&\n      from <= openerLine.to &&\n      text !== \"`\" &&\n      text !== \"~\"\n    ) {\n      return null;\n    }\n    // No content line exists in a bare ```/``` pair post-§12.4, but a pasted\n    // block may lack one — fall back to a fresh line after the opener.\n    if (openerLine.to + 1 <= closerLine.from - 1) {\n      const contentStart = openerLine.to + 1;\n      return {\n        changes: { from: contentStart, insert: text },\n        selection: EditorSelection.cursor(contentStart + text.length),\n        userEvent: \"input.type\",\n      };\n    }\n    const prefix = containerPrefix(state.doc.sliceString(openerLine.from, node.from));\n    const insert = `${state.lineBreak}${prefix}${text}`;\n    return {\n      changes: { from: openerLine.to, insert },\n      selection: EditorSelection.cursor(openerLine.to + insert.length),\n      userEvent: \"input.type\",\n    };\n  }\n  if (from < closerLine.from || from > closerLine.to) return null;\n  const prefix = containerPrefix(state.doc.sliceString(closerLine.from, closer.from));\n  const insert = `${state.lineBreak}${prefix}${text}`;\n  const at = closerLine.from - 1;\n  return {\n    changes: { from: at, insert },\n    selection: EditorSelection.cursor(at + insert.length),\n    userEvent: \"input.type\",\n  };\n}\n\n/** The keystroke that completes a ```/~~~ opener at a line's content start\n * closes the fence below, before the unclosed state can swallow the rest of\n * the document; a keystroke on a closed fence's closing line re-sites onto a\n * fresh content line (§12.7). */\nexport const fenceTypeAutoClose = EditorState.transactionFilter.of((tr: Transaction) => {\n  if (!tr.docChanged || !tr.isUserEvent(\"input.type\") || tr.isUserEvent(\"input.type.compose\")) {\n    return tr;\n  }\n  let single: { from: number; ch: string } | null = null;\n  let eligible = true;\n  tr.changes.iterChanges((fromA, toA, _fromB, _toB, inserted) => {\n    const ch = inserted.toString();\n    if (single || fromA !== toA || ch.includes(\"\\n\")) eligible = false;\n    else single = { from: fromA, ch };\n  });\n  if (!eligible || !single) return tr;\n\n  const resited = resiteFenceLineTyping(tr, (single as { from: number }).from, (single as { ch: string }).ch);\n  if (resited) return [resited];\n\n  const { ch: typed } = single as { from: number; ch: string };\n  if (typed !== \"`\" && typed !== \"~\") return tr;\n  const { from } = single as { from: number };\n\n  // The line must have been prose before the keystroke — a backtick typed\n  // inside an existing block is literal, and an opener line of a closed\n  // fence (typing a 4th backtick) must not stack another closer.\n  const oldLine = tr.startState.doc.lineAt(from);\n  const info = lineStructure(tr.startState, oldLine);\n  if (info.inCode) return tr;\n\n  // The fence must occupy the line's whole CONTENT — everything after the\n  // block markers the grammar sees (list/task marker, quote marks).\n  const contentStart = info.list ? info.list.markTo : info.contentFrom;\n  const newLine = tr.newDoc.lineAt(from + 1);\n  const content = tr.newDoc.sliceString(contentStart, newLine.to);\n  if (!/^(`{3,}|~{3,})$/.test(content) || from + 1 !== newLine.to) return tr;\n\n  // Continuation prefix for the inserted lines: quote marks carry over,\n  // everything else (list markers, indent) becomes plain indent so the new\n  // lines stay inside the same container at the fence's column.\n  const prefix = containerPrefix(tr.newDoc.sliceString(newLine.from, contentStart));\n  const brk = tr.startState.lineBreak;\n  return [\n    tr,\n    {\n      changes: { from: newLine.to, insert: `${brk}${prefix}${brk}${prefix}${content}` },\n      // The caret STAYS at the end of the opener: typing continues the\n      // language tag (```mermaid), Enter steps into the body (§12.5).\n      selection: EditorSelection.cursor(newLine.to),\n      sequential: true,\n    },\n  ];\n});\n\n/** The FencedCode ancestor at `pos`, or null.\n *\n * Resolves from {@link treeAt}, not `syntaxTree`: a tree that stops short of\n * `pos` reports it as bare `Document`, and the delete guards then merge a code\n * block into the prose above it. */\nexport function fenceAt(state: EditorState, pos: number): FenceNode | null {\n  let node = treeAt(state, pos).resolveInner(pos, -1) as unknown as FenceNode | null;\n  while (node && node.name !== \"FencedCode\") node = node.parent;\n  return node;\n}\n\nexport const fenceAutoClose: 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  if (main.head !== line.to) return false;\n\n  const node = fenceAt(state, main.head);\n  // Only on the fence's OPENING line.\n  if (!node || node.from < line.from) return false;\n  const marks = node.getChildren(\"CodeMark\");\n  const open = marks[0];\n  if (!open) return false;\n\n  if (marks.length >= 2) {\n    // §12.5 — closed block: step onto an existing empty first content line.\n    // \"Empty\" includes container prefixes — inside a blockquote that line is\n    // \"> \", the same shape bodyIsEmpty accepts above.\n    if (line.to < state.doc.length) {\n      const next = state.doc.lineAt(line.to + 1);\n      const closerLine = state.doc.lineAt(marks[marks.length - 1].from);\n      if (next.number < closerLine.number && /^[>\\s]*$/.test(next.text)) {\n        view.dispatch({\n          selection: EditorSelection.cursor(next.to),\n          scrollIntoView: true,\n          userEvent: \"select\",\n        });\n        return true;\n      }\n    }\n    return false;\n  }\n\n  const fence = state.sliceDoc(open.from, open.to);\n  const indent = state.sliceDoc(line.from, open.from);\n  view.dispatch({\n    changes: { from: line.to, insert: `${state.lineBreak}${state.lineBreak}${indent}${fence}` },\n    selection: EditorSelection.cursor(line.to + state.lineBreak.length),\n    scrollIntoView: true,\n    userEvent: \"input\",\n  });\n  return true;\n};\n\n/** Enter on the block's empty last content line exits below the fence. */\nexport const fenceExitBlock: 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  if (line.from !== line.to) return false; // only a fully empty line exits\n\n  const node = fenceAt(state, main.head);\n  if (!node || node.from >= line.from) return false;\n  const marks = node.getChildren(\"CodeMark\");\n  if (marks.length < 2) return false; // unclosed: Enter just adds code lines\n  const closing = marks[marks.length - 1];\n  // The empty line must sit directly above the closing fence line.\n  if (state.doc.lineAt(closing.from).number !== line.number + 1) return false;\n\n  const docLen = state.doc.length;\n  const changes = [{ from: line.from - 1, to: line.to, insert: \"\" }] as {\n    from: number;\n    to?: number;\n    insert: string;\n  }[];\n  if (node.to === docLen) changes.push({ from: docLen, insert: state.lineBreak });\n  const removed = line.to - line.from + 1;\n  view.dispatch({\n    changes,\n    // Just past the (shifted) closing fence's newline — the line below.\n    selection: EditorSelection.cursor(node.to - removed + 1),\n    scrollIntoView: true,\n    userEvent: \"input\",\n  });\n  return true;\n};\n\nexport const fenceAutoCloseKeymap = Prec.highest(\n  keymap.of([\n    { key: \"Enter\", run: fenceAutoClose },\n    { key: \"Enter\", run: fenceExitBlock },\n  ]),\n);\n"],"mappings":"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","names":["prefix","insert"]}

package/dist/codemirror/code/fenceCaretGuard.d.ts

@@ -0,0 +1,28 @@
+import * as _codemirror_state from '@codemirror/state';
+
+/**
+ * §12.9 — a closed fence's marker rows never hold the caret.
+ *
+ * The opener/closer lines are block chrome: a caret parked there types
+ * somewhere else (the §12.7 re-site), which reads as a jump. Instead the
+ * caret is re-placed the moment a selection lands on a marker row:
+ *
+ *   - pointer clicks: nearest content edge (opener → first content line's
+ *     start, closer → last content line's end)
+ *   - forward motion (Down/Right): through the row into the block, or out
+ *     below it; holds at the content edge when nothing follows the block
+ *   - backward motion (Up/Left): out above the block, or back to content
+ *
+ * A fence currently rendered as a BLOCK WIDGET (a mermaid diagram) inverts
+ * the rule: moving the caret INTO its content would reveal the source — so a
+ * click landing beside the widget flipped the diagram to code. Those fences
+ * snap the caret to the boundary OUTSIDE the block instead; entering one is
+ * a deliberate act (double-click / Edit chip / click-to-edit).
+ *
+ * Unclosed fences keep the caret — typing a language on a pasted opener
+ * needs it — and blocks with no content line are left alone (§12.7 re-sites
+ * any typing there safely). Range selections and multi-cursor pass through.
+ */
+declare const fenceCaretGuard: _codemirror_state.Extension;
+
+export { fenceCaretGuard };

package/dist/codemirror/code/fenceCaretGuard.js

@@ -0,0 +1,66 @@
+import "../../chunk-V6TY7KAL.js";
+import { EditorSelection, EditorState } from "@codemirror/state";
+import { fenceAt } from "./fenceAutoClose.js";
+import { mermaidField } from "../mermaid/mermaidPlugin.js";
+function widgetCovered(state, from, to) {
+  const field = state.field(mermaidField, false);
+  if (!field) return false;
+  let covered = false;
+  field.decorations.between(from, to, () => {
+    covered = true;
+    return false;
+  });
+  return covered;
+}
+const fenceCaretGuard = EditorState.transactionFilter.of((tr) => {
+  if (tr.docChanged || !tr.selection) return tr;
+  if (tr.selection.ranges.length > 1) return tr;
+  const sel = tr.selection.main;
+  if (!sel.empty) return tr;
+  const state = tr.startState;
+  const line = state.doc.lineAt(sel.head);
+  if (line.to === line.from) return tr;
+  const node = fenceAt(state, line.to);
+  if (!node) return tr;
+  const marks = node.getChildren("CodeMark");
+  if (marks.length < 2) return tr;
+  const openerLine = state.doc.lineAt(node.from);
+  const closerLine = state.doc.lineAt(marks[marks.length - 1].from);
+  if (closerLine.number - openerLine.number < 2) return tr;
+  const onOpener = line.number === openerLine.number;
+  if (!onOpener && line.number !== closerLine.number) return tr;
+  const covered = widgetCovered(state, node.from, node.to);
+  if (!covered) {
+    let bodyEmpty = true;
+    for (let n = openerLine.number + 1; n < closerLine.number; n += 1) {
+      if (!/^[>\s]*$/.test(state.doc.line(n).text)) {
+        bodyEmpty = false;
+        break;
+      }
+    }
+    if (bodyEmpty) return tr;
+  }
+  const oldHead = state.selection.main.head;
+  const pointer = tr.isUserEvent("select.pointer");
+  const backward = !pointer && sel.head < oldHead;
+  let target;
+  if (covered) {
+    target = onOpener ? openerLine.from : closerLine.to;
+  } else {
+    const contentStart = openerLine.to + 1;
+    const lastContentEnd = closerLine.from - 1;
+    if (onOpener) {
+      target = backward && openerLine.from > 0 ? openerLine.from - 1 : contentStart;
+    } else if (pointer || backward) {
+      target = lastContentEnd;
+    } else {
+      target = closerLine.to < state.doc.length ? closerLine.to + 1 : lastContentEnd;
+    }
+  }
+  if (target === sel.head) return tr;
+  return [tr, { selection: EditorSelection.cursor(target), sequential: true }];
+});
+export {
+  fenceCaretGuard
+};
+//# sourceMappingURL=fenceCaretGuard.js.map

package/dist/codemirror/code/fenceCaretGuard.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/code/fenceCaretGuard.ts"],"sourcesContent":["/**\n * §12.9 — a closed fence's marker rows never hold the caret.\n *\n * The opener/closer lines are block chrome: a caret parked there types\n * somewhere else (the §12.7 re-site), which reads as a jump. Instead the\n * caret is re-placed the moment a selection lands on a marker row:\n *\n *   - pointer clicks: nearest content edge (opener → first content line's\n *     start, closer → last content line's end)\n *   - forward motion (Down/Right): through the row into the block, or out\n *     below it; holds at the content edge when nothing follows the block\n *   - backward motion (Up/Left): out above the block, or back to content\n *\n * A fence currently rendered as a BLOCK WIDGET (a mermaid diagram) inverts\n * the rule: moving the caret INTO its content would reveal the source — so a\n * click landing beside the widget flipped the diagram to code. Those fences\n * snap the caret to the boundary OUTSIDE the block instead; entering one is\n * a deliberate act (double-click / Edit chip / click-to-edit).\n *\n * Unclosed fences keep the caret — typing a language on a pasted opener\n * needs it — and blocks with no content line are left alone (§12.7 re-sites\n * any typing there safely). Range selections and multi-cursor pass through.\n */\n\nimport { EditorSelection, EditorState, type Transaction } from \"@codemirror/state\";\n\nimport { fenceAt } from \"./fenceAutoClose\";\nimport { mermaidField } from \"../mermaid/mermaidPlugin\";\n\n/** Is this fence currently replaced by a rendered block widget? */\nfunction widgetCovered(state: EditorState, from: number, to: number): boolean {\n  const field = state.field(mermaidField, false);\n  if (!field) return false;\n  let covered = false;\n  field.decorations.between(from, to, () => {\n    covered = true;\n    return false;\n  });\n  return covered;\n}\n\nexport const fenceCaretGuard = EditorState.transactionFilter.of((tr: Transaction) => {\n  if (tr.docChanged || !tr.selection) return tr;\n  if (tr.selection.ranges.length > 1) return tr;\n  const sel = tr.selection.main;\n  if (!sel.empty) return tr;\n\n  const state = tr.startState;\n  const line = state.doc.lineAt(sel.head);\n  if (line.to === line.from) return tr;\n  const node = fenceAt(state, line.to);\n  if (!node) return tr;\n  const marks = node.getChildren(\"CodeMark\");\n  if (marks.length < 2) return tr;\n\n  const openerLine = state.doc.lineAt(node.from);\n  const closerLine = state.doc.lineAt(marks[marks.length - 1].from);\n  if (closerLine.number - openerLine.number < 2) return tr;\n  const onOpener = line.number === openerLine.number;\n  if (!onOpener && line.number !== closerLine.number) return tr;\n\n  const covered = widgetCovered(state, node.from, node.to);\n  // §12.9 exempts no-content blocks, and a body of only blank (or\n  // quote-prefixed blank) lines is no content — the shape type-time\n  // auto-close leaves while the language is still being typed on the\n  // opener, where arrowing over a typo must not throw the caret out.\n  // Widget-rendered fences keep the outside-snap: their opener is hidden\n  // chrome regardless of body.\n  if (!covered) {\n    let bodyEmpty = true;\n    for (let n = openerLine.number + 1; n < closerLine.number; n += 1) {\n      if (!/^[>\\s]*$/.test(state.doc.line(n).text)) {\n        bodyEmpty = false;\n        break;\n      }\n    }\n    if (bodyEmpty) return tr;\n  }\n\n  const oldHead = state.selection.main.head;\n  const pointer = tr.isUserEvent(\"select.pointer\");\n  const backward = !pointer && sel.head < oldHead;\n\n  let target: number;\n  if (covered) {\n    target = onOpener ? openerLine.from : closerLine.to;\n  } else {\n    const contentStart = openerLine.to + 1;\n    const lastContentEnd = closerLine.from - 1;\n    if (onOpener) {\n      target = backward && openerLine.from > 0 ? openerLine.from - 1 : contentStart;\n    } else if (pointer || backward) {\n      target = lastContentEnd;\n    } else {\n      target = closerLine.to < state.doc.length ? closerLine.to + 1 : lastContentEnd;\n    }\n  }\n  if (target === sel.head) return tr;\n  return [tr, { selection: EditorSelection.cursor(target), sequential: true }];\n});\n"],"mappings":";AAwBA,SAAS,iBAAiB,mBAAqC;AAE/D,SAAS,eAAe;AACxB,SAAS,oBAAoB;AAG7B,SAAS,cAAc,OAAoB,MAAc,IAAqB;AAC5E,QAAM,QAAQ,MAAM,MAAM,cAAc,KAAK;AAC7C,MAAI,CAAC,MAAO,QAAO;AACnB,MAAI,UAAU;AACd,QAAM,YAAY,QAAQ,MAAM,IAAI,MAAM;AACxC,cAAU;AACV,WAAO;AAAA,EACT,CAAC;AACD,SAAO;AACT;AAEO,MAAM,kBAAkB,YAAY,kBAAkB,GAAG,CAAC,OAAoB;AACnF,MAAI,GAAG,cAAc,CAAC,GAAG,UAAW,QAAO;AAC3C,MAAI,GAAG,UAAU,OAAO,SAAS,EAAG,QAAO;AAC3C,QAAM,MAAM,GAAG,UAAU;AACzB,MAAI,CAAC,IAAI,MAAO,QAAO;AAEvB,QAAM,QAAQ,GAAG;AACjB,QAAM,OAAO,MAAM,IAAI,OAAO,IAAI,IAAI;AACtC,MAAI,KAAK,OAAO,KAAK,KAAM,QAAO;AAClC,QAAM,OAAO,QAAQ,OAAO,KAAK,EAAE;AACnC,MAAI,CAAC,KAAM,QAAO;AAClB,QAAM,QAAQ,KAAK,YAAY,UAAU;AACzC,MAAI,MAAM,SAAS,EAAG,QAAO;AAE7B,QAAM,aAAa,MAAM,IAAI,OAAO,KAAK,IAAI;AAC7C,QAAM,aAAa,MAAM,IAAI,OAAO,MAAM,MAAM,SAAS,CAAC,EAAE,IAAI;AAChE,MAAI,WAAW,SAAS,WAAW,SAAS,EAAG,QAAO;AACtD,QAAM,WAAW,KAAK,WAAW,WAAW;AAC5C,MAAI,CAAC,YAAY,KAAK,WAAW,WAAW,OAAQ,QAAO;AAE3D,QAAM,UAAU,cAAc,OAAO,KAAK,MAAM,KAAK,EAAE;AAOvD,MAAI,CAAC,SAAS;AACZ,QAAI,YAAY;AAChB,aAAS,IAAI,WAAW,SAAS,GAAG,IAAI,WAAW,QAAQ,KAAK,GAAG;AACjE,UAAI,CAAC,WAAW,KAAK,MAAM,IAAI,KAAK,CAAC,EAAE,IAAI,GAAG;AAC5C,oBAAY;AACZ;AAAA,MACF;AAAA,IACF;AACA,QAAI,UAAW,QAAO;AAAA,EACxB;AAEA,QAAM,UAAU,MAAM,UAAU,KAAK;AACrC,QAAM,UAAU,GAAG,YAAY,gBAAgB;AAC/C,QAAM,WAAW,CAAC,WAAW,IAAI,OAAO;AAExC,MAAI;AACJ,MAAI,SAAS;AACX,aAAS,WAAW,WAAW,OAAO,WAAW;AAAA,EACnD,OAAO;AACL,UAAM,eAAe,WAAW,KAAK;AACrC,UAAM,iBAAiB,WAAW,OAAO;AACzC,QAAI,UAAU;AACZ,eAAS,YAAY,WAAW,OAAO,IAAI,WAAW,OAAO,IAAI;AAAA,IACnE,WAAW,WAAW,UAAU;AAC9B,eAAS;AAAA,IACX,OAAO;AACL,eAAS,WAAW,KAAK,MAAM,IAAI,SAAS,WAAW,KAAK,IAAI;AAAA,IAClE;AAAA,EACF;AACA,MAAI,WAAW,IAAI,KAAM,QAAO;AAChC,SAAO,CAAC,IAAI,EAAE,WAAW,gBAAgB,OAAO,MAAM,GAAG,YAAY,KAAK,CAAC;AAC7E,CAAC;","names":[]}

package/dist/codemirror/code/fenceDeleteGuards.d.ts

@@ -0,0 +1,22 @@
+import { EditorView } from '@codemirror/view';
+
+/**
+ * Fence walls for deletion (interaction-spec §12.1–.3).
+ *
+ * Fence lines are structure, not text: a character-level join that merges a
+ * fence line with its neighbor corrupts the pair — content becomes the
+ * opener's invisible info string, or the closer gains trailing text and
+ * stops closing, re-pairing the opener with a later fence and swallowing
+ * unrelated content. The delete normalizer consults these guards whenever a
+ * Backspace/Delete would cross a line boundary; they answer with the §12
+ * behavior (wall, park, plain code-line join, or whole-block deletion) and
+ * report whether they handled the press.
+ */
+
+/** Backspace whose deletion would cross upward out of `line`. True when the
+ * press was handled (edit, park, or deliberate wall no-op). */
+declare function fenceBackspaceGuard(view: EditorView, pos: number): boolean;
+/** Forward-delete whose deletion would cross downward out of `line`. */
+declare function fenceDeleteGuard(view: EditorView, pos: number): boolean;
+
+export { fenceBackspaceGuard, fenceDeleteGuard };

package/dist/codemirror/code/fenceDeleteGuards.js

@@ -0,0 +1,105 @@
+import "../../chunk-V6TY7KAL.js";
+import { EditorSelection } from "@codemirror/state";
+import { fenceAt } from "./fenceAutoClose.js";
+function blockInfo(state, node) {
+  const marks = node.getChildren("CodeMark");
+  const openerLine = state.doc.lineAt(node.from);
+  const closerMark = marks.length >= 2 ? marks[marks.length - 1] : null;
+  const closerLine = closerMark ? state.doc.lineAt(closerMark.from) : null;
+  const contentFrom = Math.min(openerLine.to + 1, node.to);
+  const contentTo = closerLine ? Math.max(closerLine.from - 1, contentFrom) : node.to;
+  const contentEmpty = !closerLine || contentFrom >= closerLine.from || state.doc.sliceString(contentFrom, contentTo).trim() === "";
+  return { openerLine, closerLine, contentFrom, contentTo, contentEmpty };
+}
+function park(view, pos) {
+  view.dispatch({
+    selection: EditorSelection.cursor(pos),
+    scrollIntoView: true,
+    userEvent: "select"
+  });
+  return true;
+}
+function deleteWholeBlock(view, node, userEvent) {
+  const docLen = view.state.doc.length;
+  const to = node.to < docLen ? node.to + 1 : node.to;
+  const from = node.to >= docLen && node.from > 0 ? node.from - 1 : node.from;
+  view.dispatch({
+    changes: { from, to, insert: "" },
+    selection: EditorSelection.cursor(from),
+    scrollIntoView: true,
+    userEvent
+  });
+  return true;
+}
+function joinNewline(view, at, userEvent) {
+  view.dispatch({
+    changes: { from: at, to: at + 1, insert: "" },
+    selection: EditorSelection.cursor(at),
+    scrollIntoView: true,
+    userEvent
+  });
+  return true;
+}
+function fenceBackspaceGuard(view, pos) {
+  const { state } = view;
+  const line = state.doc.lineAt(pos);
+  if (line.from === 0) return false;
+  const prevLine = state.doc.lineAt(line.from - 1);
+  const inside = fenceAt(state, pos);
+  if (inside) {
+    const info = blockInfo(state, inside);
+    if (line.number === info.openerLine.number) {
+      return park(view, prevLine.to);
+    }
+    if (info.closerLine && line.number === info.closerLine.number) {
+      return park(view, prevLine.to);
+    }
+    if (prevLine.number === info.openerLine.number) {
+      if (info.contentEmpty) return deleteWholeBlock(view, inside, "delete.backward");
+      return true;
+    }
+    return joinNewline(view, line.from - 1, "delete.backward");
+  }
+  const prevFence = fenceAt(state, prevLine.to);
+  if (prevFence) {
+    const info = blockInfo(state, prevFence);
+    if (info.closerLine && prevLine.number === info.closerLine.number) {
+      if (info.contentEmpty) return deleteWholeBlock(view, prevFence, "delete.backward");
+      return park(view, info.contentTo);
+    }
+  }
+  return false;
+}
+function fenceDeleteGuard(view, pos) {
+  const { state } = view;
+  const line = state.doc.lineAt(pos);
+  if (line.to >= state.doc.length) return false;
+  const nextLine = state.doc.lineAt(line.to + 1);
+  const inside = fenceAt(state, pos);
+  if (inside) {
+    const info = blockInfo(state, inside);
+    if (line.number === info.openerLine.number) {
+      return park(view, nextLine.from);
+    }
+    if (info.closerLine && line.number === info.closerLine.number) {
+      return park(view, nextLine.from);
+    }
+    if (info.closerLine && nextLine.number === info.closerLine.number) {
+      if (info.contentEmpty) return deleteWholeBlock(view, inside, "delete.forward");
+      return true;
+    }
+    return joinNewline(view, line.to, "delete.forward");
+  }
+  const nextFence = fenceAt(state, Math.min(nextLine.to, state.doc.length));
+  if (nextFence && state.doc.lineAt(nextFence.from).number === nextLine.number) {
+    const info = blockInfo(state, nextFence);
+    if (info.contentEmpty) return deleteWholeBlock(view, nextFence, "delete.forward");
+    return park(view, info.contentFrom);
+  }
+  return false;
+}
+export {
+  fenceBackspaceGuard,
+  fenceDeleteGuard
+};
+//# sourceMappingURL=fenceDeleteGuards.js.map

package/dist/codemirror/code/fenceDeleteGuards.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/code/fenceDeleteGuards.ts"],"sourcesContent":["/**\n * Fence walls for deletion (interaction-spec §12.1–.3).\n *\n * Fence lines are structure, not text: a character-level join that merges a\n * fence line with its neighbor corrupts the pair — content becomes the\n * opener's invisible info string, or the closer gains trailing text and\n * stops closing, re-pairing the opener with a later fence and swallowing\n * unrelated content. The delete normalizer consults these guards whenever a\n * Backspace/Delete would cross a line boundary; they answer with the §12\n * behavior (wall, park, plain code-line join, or whole-block deletion) and\n * report whether they handled the press.\n */\n\nimport { EditorSelection, type EditorState } from \"@codemirror/state\";\nimport type { EditorView } from \"@codemirror/view\";\n\nimport { fenceAt } from \"./fenceAutoClose\";\n\ninterface BlockInfo {\n  openerLine: { number: number; to: number };\n  closerLine: { number: number; from: number } | null;\n  /** First/last content positions (line-granular). */\n  contentFrom: number;\n  contentTo: number;\n  contentEmpty: boolean;\n}\n\ntype FenceNode = NonNullable<ReturnType<typeof fenceAt>>;\n\nfunction blockInfo(state: EditorState, node: FenceNode): BlockInfo {\n  const marks = node.getChildren(\"CodeMark\");\n  const openerLine = state.doc.lineAt(node.from);\n  const closerMark = marks.length >= 2 ? marks[marks.length - 1] : null;\n  const closerLine = closerMark ? state.doc.lineAt(closerMark.from) : null;\n  const contentFrom = Math.min(openerLine.to + 1, node.to);\n  const contentTo = closerLine ? Math.max(closerLine.from - 1, contentFrom) : node.to;\n  const contentEmpty =\n    !closerLine ||\n    contentFrom >= closerLine.from ||\n    state.doc.sliceString(contentFrom, contentTo).trim() === \"\";\n  return { openerLine, closerLine, contentFrom, contentTo, contentEmpty };\n}\n\nfunction park(view: EditorView, pos: number): true {\n  view.dispatch({\n    selection: EditorSelection.cursor(pos),\n    scrollIntoView: true,\n    userEvent: \"select\",\n  });\n  return true;\n}\n\nfunction deleteWholeBlock(view: EditorView, node: FenceNode, userEvent: string): true {\n  const docLen = view.state.doc.length;\n  // Take one bounding newline with the block so no empty line is left behind.\n  const to = node.to < docLen ? node.to + 1 : node.to;\n  const from = node.to >= docLen && node.from > 0 ? node.from - 1 : node.from;\n  view.dispatch({\n    changes: { from, to, insert: \"\" },\n    selection: EditorSelection.cursor(from),\n    scrollIntoView: true,\n    userEvent,\n  });\n  return true;\n}\n\nfunction joinNewline(view: EditorView, at: number, userEvent: string): true {\n  view.dispatch({\n    changes: { from: at, to: at + 1, insert: \"\" },\n    selection: EditorSelection.cursor(at),\n    scrollIntoView: true,\n    userEvent,\n  });\n  return true;\n}\n\n/** Backspace whose deletion would cross upward out of `line`. True when the\n * press was handled (edit, park, or deliberate wall no-op). */\nexport function fenceBackspaceGuard(view: EditorView, pos: number): boolean {\n  const { state } = view;\n  const line = state.doc.lineAt(pos);\n  if (line.from === 0) return false;\n  const prevLine = state.doc.lineAt(line.from - 1);\n\n  const inside = fenceAt(state, pos);\n  if (inside) {\n    const info = blockInfo(state, inside);\n    if (line.number === info.openerLine.number) {\n      // Caret on the opener line: joining it onto the prose above dissolves\n      // the fence. Move up instead.\n      return park(view, prevLine.to);\n    }\n    if (info.closerLine && line.number === info.closerLine.number) {\n      // Caret on the closer line: pulling it up corrupts the pair.\n      return park(view, prevLine.to);\n    }\n    if (prevLine.number === info.openerLine.number) {\n      // §12.1 — first content line: the wall is solid; an effectively empty\n      // block collapses whole instead.\n      if (info.contentEmpty) return deleteWholeBlock(view, inside, \"delete.backward\");\n      return true;\n    }\n    // Interior code lines join plainly — never through blockPrefixLength,\n    // which would eat code that merely looks like a list marker.\n    return joinNewline(view, line.from - 1, \"delete.backward\");\n  }\n\n  const prevFence = fenceAt(state, prevLine.to);\n  if (prevFence) {\n    const info = blockInfo(state, prevFence);\n    if (info.closerLine && prevLine.number === info.closerLine.number) {\n      // §12.2 — approaching from below: park at the content end (or collapse\n      // an empty block whole).\n      if (info.contentEmpty) return deleteWholeBlock(view, prevFence, \"delete.backward\");\n      return park(view, info.contentTo);\n    }\n  }\n  return false;\n}\n\n/** Forward-delete whose deletion would cross downward out of `line`. */\nexport function fenceDeleteGuard(view: EditorView, pos: number): boolean {\n  const { state } = view;\n  const line = state.doc.lineAt(pos);\n  if (line.to >= state.doc.length) return false;\n  const nextLine = state.doc.lineAt(line.to + 1);\n\n  const inside = fenceAt(state, pos);\n  if (inside) {\n    const info = blockInfo(state, inside);\n    if (line.number === info.openerLine.number) {\n      // Caret on the opener: pulling content up makes it the invisible info\n      // string. Step into the block instead.\n      return park(view, nextLine.from);\n    }\n    if (info.closerLine && line.number === info.closerLine.number) {\n      return park(view, nextLine.from);\n    }\n    if (info.closerLine && nextLine.number === info.closerLine.number) {\n      // §12.1 mirror — last content line.\n      if (info.contentEmpty) return deleteWholeBlock(view, inside, \"delete.forward\");\n      return true;\n    }\n    return joinNewline(view, line.to, \"delete.forward\");\n  }\n\n  const nextFence = fenceAt(state, Math.min(nextLine.to, state.doc.length));\n  if (nextFence && state.doc.lineAt(nextFence.from).number === nextLine.number) {\n    const info = blockInfo(state, nextFence);\n    // §12.2 mirror — approaching from above: park at the content start.\n    if (info.contentEmpty) return deleteWholeBlock(view, nextFence, \"delete.forward\");\n    return park(view, info.contentFrom);\n  }\n  return false;\n}\n"],"mappings":";AAaA,SAAS,uBAAyC;AAGlD,SAAS,eAAe;AAaxB,SAAS,UAAU,OAAoB,MAA4B;AACjE,QAAM,QAAQ,KAAK,YAAY,UAAU;AACzC,QAAM,aAAa,MAAM,IAAI,OAAO,KAAK,IAAI;AAC7C,QAAM,aAAa,MAAM,UAAU,IAAI,MAAM,MAAM,SAAS,CAAC,IAAI;AACjE,QAAM,aAAa,aAAa,MAAM,IAAI,OAAO,WAAW,IAAI,IAAI;AACpE,QAAM,cAAc,KAAK,IAAI,WAAW,KAAK,GAAG,KAAK,EAAE;AACvD,QAAM,YAAY,aAAa,KAAK,IAAI,WAAW,OAAO,GAAG,WAAW,IAAI,KAAK;AACjF,QAAM,eACJ,CAAC,cACD,eAAe,WAAW,QAC1B,MAAM,IAAI,YAAY,aAAa,SAAS,EAAE,KAAK,MAAM;AAC3D,SAAO,EAAE,YAAY,YAAY,aAAa,WAAW,aAAa;AACxE;AAEA,SAAS,KAAK,MAAkB,KAAmB;AACjD,OAAK,SAAS;AAAA,IACZ,WAAW,gBAAgB,OAAO,GAAG;AAAA,IACrC,gBAAgB;AAAA,IAChB,WAAW;AAAA,EACb,CAAC;AACD,SAAO;AACT;AAEA,SAAS,iBAAiB,MAAkB,MAAiB,WAAyB;AACpF,QAAM,SAAS,KAAK,MAAM,IAAI;AAE9B,QAAM,KAAK,KAAK,KAAK,SAAS,KAAK,KAAK,IAAI,KAAK;AACjD,QAAM,OAAO,KAAK,MAAM,UAAU,KAAK,OAAO,IAAI,KAAK,OAAO,IAAI,KAAK;AACvE,OAAK,SAAS;AAAA,IACZ,SAAS,EAAE,MAAM,IAAI,QAAQ,GAAG;AAAA,IAChC,WAAW,gBAAgB,OAAO,IAAI;AAAA,IACtC,gBAAgB;AAAA,IAChB;AAAA,EACF,CAAC;AACD,SAAO;AACT;AAEA,SAAS,YAAY,MAAkB,IAAY,WAAyB;AAC1E,OAAK,SAAS;AAAA,IACZ,SAAS,EAAE,MAAM,IAAI,IAAI,KAAK,GAAG,QAAQ,GAAG;AAAA,IAC5C,WAAW,gBAAgB,OAAO,EAAE;AAAA,IACpC,gBAAgB;AAAA,IAChB;AAAA,EACF,CAAC;AACD,SAAO;AACT;AAIO,SAAS,oBAAoB,MAAkB,KAAsB;AAC1E,QAAM,EAAE,MAAM,IAAI;AAClB,QAAM,OAAO,MAAM,IAAI,OAAO,GAAG;AACjC,MAAI,KAAK,SAAS,EAAG,QAAO;AAC5B,QAAM,WAAW,MAAM,IAAI,OAAO,KAAK,OAAO,CAAC;AAE/C,QAAM,SAAS,QAAQ,OAAO,GAAG;AACjC,MAAI,QAAQ;AACV,UAAM,OAAO,UAAU,OAAO,MAAM;AACpC,QAAI,KAAK,WAAW,KAAK,WAAW,QAAQ;AAG1C,aAAO,KAAK,MAAM,SAAS,EAAE;AAAA,IAC/B;AACA,QAAI,KAAK,cAAc,KAAK,WAAW,KAAK,WAAW,QAAQ;AAE7D,aAAO,KAAK,MAAM,SAAS,EAAE;AAAA,IAC/B;AACA,QAAI,SAAS,WAAW,KAAK,WAAW,QAAQ;AAG9C,UAAI,KAAK,aAAc,QAAO,iBAAiB,MAAM,QAAQ,iBAAiB;AAC9E,aAAO;AAAA,IACT;AAGA,WAAO,YAAY,MAAM,KAAK,OAAO,GAAG,iBAAiB;AAAA,EAC3D;AAEA,QAAM,YAAY,QAAQ,OAAO,SAAS,EAAE;AAC5C,MAAI,WAAW;AACb,UAAM,OAAO,UAAU,OAAO,SAAS;AACvC,QAAI,KAAK,cAAc,SAAS,WAAW,KAAK,WAAW,QAAQ;AAGjE,UAAI,KAAK,aAAc,QAAO,iBAAiB,MAAM,WAAW,iBAAiB;AACjF,aAAO,KAAK,MAAM,KAAK,SAAS;AAAA,IAClC;AAAA,EACF;AACA,SAAO;AACT;AAGO,SAAS,iBAAiB,MAAkB,KAAsB;AACvE,QAAM,EAAE,MAAM,IAAI;AAClB,QAAM,OAAO,MAAM,IAAI,OAAO,GAAG;AACjC,MAAI,KAAK,MAAM,MAAM,IAAI,OAAQ,QAAO;AACxC,QAAM,WAAW,MAAM,IAAI,OAAO,KAAK,KAAK,CAAC;AAE7C,QAAM,SAAS,QAAQ,OAAO,GAAG;AACjC,MAAI,QAAQ;AACV,UAAM,OAAO,UAAU,OAAO,MAAM;AACpC,QAAI,KAAK,WAAW,KAAK,WAAW,QAAQ;AAG1C,aAAO,KAAK,MAAM,SAAS,IAAI;AAAA,IACjC;AACA,QAAI,KAAK,cAAc,KAAK,WAAW,KAAK,WAAW,QAAQ;AAC7D,aAAO,KAAK,MAAM,SAAS,IAAI;AAAA,IACjC;AACA,QAAI,KAAK,cAAc,SAAS,WAAW,KAAK,WAAW,QAAQ;AAEjE,UAAI,KAAK,aAAc,QAAO,iBAAiB,MAAM,QAAQ,gBAAgB;AAC7E,aAAO;AAAA,IACT;AACA,WAAO,YAAY,MAAM,KAAK,IAAI,gBAAgB;AAAA,EACpD;AAEA,QAAM,YAAY,QAAQ,OAAO,KAAK,IAAI,SAAS,IAAI,MAAM,IAAI,MAAM,CAAC;AACxE,MAAI,aAAa,MAAM,IAAI,OAAO,UAAU,IAAI,EAAE,WAAW,SAAS,QAAQ;AAC5E,UAAM,OAAO,UAAU,OAAO,SAAS;AAEvC,QAAI,KAAK,aAAc,QAAO,iBAAiB,MAAM,WAAW,gBAAgB;AAChF,WAAO,KAAK,MAAM,KAAK,WAAW;AAAA,EACpC;AACA,SAAO;AACT;","names":[]}

package/dist/codemirror/code/fenceTabIndent.d.ts

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

package/dist/codemirror/code/fenceTabIndent.js

@@ -0,0 +1,50 @@
+import "../../chunk-V6TY7KAL.js";
+import { EditorSelection, Prec } from "@codemirror/state";
+import { keymap } from "@codemirror/view";
+import { fenceAt } from "./fenceAutoClose.js";
+const INDENT = "  ";
+function inFenceContent(view) {
+  const { state } = view;
+  const head = state.selection.main.head;
+  const node = fenceAt(state, head);
+  if (!node) return false;
+  const line = state.doc.lineAt(head);
+  const marks = node.getChildren("CodeMark");
+  if (line.from <= node.from) return false;
+  const closer = marks.length >= 2 ? marks[marks.length - 1] : null;
+  return !closer || line.to < state.doc.lineAt(closer.from).from;
+}
+const fenceTabIndent = (view) => {
+  if (!inFenceContent(view)) return false;
+  const head = view.state.selection.main.head;
+  view.dispatch({
+    changes: { from: head, insert: INDENT },
+    selection: EditorSelection.cursor(head + INDENT.length),
+    userEvent: "input.type"
+  });
+  return true;
+};
+const fenceTabDedent = (view) => {
+  if (!inFenceContent(view)) return false;
+  const { state } = view;
+  const line = state.doc.lineAt(state.selection.main.head);
+  const leading = line.text.match(/^ {1,2}/)?.[0].length ?? 0;
+  if (leading === 0) return true;
+  view.dispatch({
+    changes: { from: line.from, to: line.from + leading, insert: "" },
+    userEvent: "delete.dedent"
+  });
+  return true;
+};
+const fenceTabKeymap = Prec.high(
+  keymap.of([
+    { key: "Tab", run: fenceTabIndent },
+    { key: "Shift-Tab", run: fenceTabDedent }
+  ])
+);
+export {
+  fenceTabDedent,
+  fenceTabIndent,
+  fenceTabKeymap
+};
+//# sourceMappingURL=fenceTabIndent.js.map

package/dist/codemirror/code/fenceTabIndent.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/code/fenceTabIndent.ts"],"sourcesContent":["/**\n * Tab inside a fenced code block indents; Shift-Tab dedents (§12.8).\n *\n * Without a binding, the browser's default Tab handling moves FOCUS — the\n * caret \"jumped out of the editor to the rich/raw button\" mid-code. Both\n * commands decline outside code so list indentation (`listIndent.ts`) and\n * the accessibility default keep their behavior everywhere else.\n */\n\nimport { EditorSelection, Prec } from \"@codemirror/state\";\nimport { type Command, keymap } from \"@codemirror/view\";\n\nimport { fenceAt } from \"./fenceAutoClose\";\n\nconst INDENT = \"  \";\n\n/** Caret strictly inside a fence (not on the opener/closer lines). */\nfunction inFenceContent(view: Parameters<Command>[0]): boolean {\n  const { state } = view;\n  const head = state.selection.main.head;\n  const node = fenceAt(state, head);\n  if (!node) return false;\n  const line = state.doc.lineAt(head);\n  const marks = node.getChildren(\"CodeMark\");\n  if (line.from <= node.from) return false;\n  const closer = marks.length >= 2 ? marks[marks.length - 1] : null;\n  return !closer || line.to < state.doc.lineAt(closer.from).from;\n}\n\nexport const fenceTabIndent: Command = (view) => {\n  if (!inFenceContent(view)) return false;\n  const head = view.state.selection.main.head;\n  view.dispatch({\n    changes: { from: head, insert: INDENT },\n    selection: EditorSelection.cursor(head + INDENT.length),\n    userEvent: \"input.type\",\n  });\n  return true;\n};\n\nexport const fenceTabDedent: Command = (view) => {\n  if (!inFenceContent(view)) return false;\n  const { state } = view;\n  const line = state.doc.lineAt(state.selection.main.head);\n  const leading = line.text.match(/^ {1,2}/)?.[0].length ?? 0;\n  if (leading === 0) return true;\n  view.dispatch({\n    changes: { from: line.from, to: line.from + leading, insert: \"\" },\n    userEvent: \"delete.dedent\",\n  });\n  return true;\n};\n\nexport const fenceTabKeymap = Prec.high(\n  keymap.of([\n    { key: \"Tab\", run: fenceTabIndent },\n    { key: \"Shift-Tab\", run: fenceTabDedent },\n  ]),\n);\n"],"mappings":";AASA,SAAS,iBAAiB,YAAY;AACtC,SAAuB,cAAc;AAErC,SAAS,eAAe;AAExB,MAAM,SAAS;AAGf,SAAS,eAAe,MAAuC;AAC7D,QAAM,EAAE,MAAM,IAAI;AAClB,QAAM,OAAO,MAAM,UAAU,KAAK;AAClC,QAAM,OAAO,QAAQ,OAAO,IAAI;AAChC,MAAI,CAAC,KAAM,QAAO;AAClB,QAAM,OAAO,MAAM,IAAI,OAAO,IAAI;AAClC,QAAM,QAAQ,KAAK,YAAY,UAAU;AACzC,MAAI,KAAK,QAAQ,KAAK,KAAM,QAAO;AACnC,QAAM,SAAS,MAAM,UAAU,IAAI,MAAM,MAAM,SAAS,CAAC,IAAI;AAC7D,SAAO,CAAC,UAAU,KAAK,KAAK,MAAM,IAAI,OAAO,OAAO,IAAI,EAAE;AAC5D;AAEO,MAAM,iBAA0B,CAAC,SAAS;AAC/C,MAAI,CAAC,eAAe,IAAI,EAAG,QAAO;AAClC,QAAM,OAAO,KAAK,MAAM,UAAU,KAAK;AACvC,OAAK,SAAS;AAAA,IACZ,SAAS,EAAE,MAAM,MAAM,QAAQ,OAAO;AAAA,IACtC,WAAW,gBAAgB,OAAO,OAAO,OAAO,MAAM;AAAA,IACtD,WAAW;AAAA,EACb,CAAC;AACD,SAAO;AACT;AAEO,MAAM,iBAA0B,CAAC,SAAS;AAC/C,MAAI,CAAC,eAAe,IAAI,EAAG,QAAO;AAClC,QAAM,EAAE,MAAM,IAAI;AAClB,QAAM,OAAO,MAAM,IAAI,OAAO,MAAM,UAAU,KAAK,IAAI;AACvD,QAAM,UAAU,KAAK,KAAK,MAAM,SAAS,IAAI,CAAC,EAAE,UAAU;AAC1D,MAAI,YAAY,EAAG,QAAO;AAC1B,OAAK,SAAS;AAAA,IACZ,SAAS,EAAE,MAAM,KAAK,MAAM,IAAI,KAAK,OAAO,SAAS,QAAQ,GAAG;AAAA,IAChE,WAAW;AAAA,EACb,CAAC;AACD,SAAO;AACT;AAEO,MAAM,iBAAiB,KAAK;AAAA,EACjC,OAAO,GAAG;AAAA,IACR,EAAE,KAAK,OAAO,KAAK,eAAe;AAAA,IAClC,EAAE,KAAK,aAAa,KAAK,eAAe;AAAA,EAC1C,CAAC;AACH;","names":[]}

package/dist/codemirror/code/highlightFence.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Synchronous fence highlighting for the clipboard (#149).
+ *
+ * A copy event writes `text/html` synchronously, so highlighting must not
+ * await anything. The trick: the grammars are the SAME `@codemirror/language-data`
+ * singletons the editor's nested fence parse loads — any fence visible in the
+ * editor has its grammar warm, so highlighting the copied code is a sync parse.
+ * A cold grammar (copy from a doc whose fence never rendered) kicks the load
+ * and returns null: THIS copy ships plain, the next one is highlighted.
+ *
+ * Output is inline-styled spans (the palette from
+ * [codePalette](./codePalette.ts), same colors as the editor) — pasted HTML
+ * carries no stylesheet, so classes would be dead weight in Docs/Word.
+ */
+interface HighlightedSpan {
+    text: string;
+    /** Inline CSS for the span; absent for unstyled text (incl. line breaks). */
+    style?: string;
+}
+/** Highlight `code` as `lang` into inline-styled spans, or null when no
+ *  grammar matches or the grammar isn't loaded yet (the load is kicked so a
+ *  later copy succeeds). Never throws — a parser hiccup falls back to null. */
+declare function highlightFenceSpans(lang: string, code: string): HighlightedSpan[] | null;
+
+export { type HighlightedSpan, highlightFenceSpans };

package/dist/codemirror/code/highlightFence.js

@@ -0,0 +1,45 @@
+import "../../chunk-V6TY7KAL.js";
+import { LanguageDescription } from "@codemirror/language";
+import { languages } from "@codemirror/language-data";
+import { highlightCode, tagHighlighter } from "@lezer/highlight";
+import { CODE_PALETTE } from "./codePalette.js";
+const styleByClass = new Map(
+  CODE_PALETTE.map((spec, index) => [
+    `tok${index}`,
+    `color:${spec.color}${spec.fontStyle ? `;font-style:${spec.fontStyle}` : ""}`
+  ])
+);
+const paletteHighlighter = tagHighlighter(
+  CODE_PALETTE.map((spec, index) => ({ tag: spec.tag, class: `tok${index}` }))
+);
+function styleFor(classes) {
+  const styles = classes.split(" ").map((cls) => styleByClass.get(cls)).filter(Boolean);
+  return styles.length > 0 ? styles.join(";") : void 0;
+}
+function highlightFenceSpans(lang, code) {
+  const description = LanguageDescription.matchLanguageName(languages, lang, true);
+  if (!description) return null;
+  if (!description.support) {
+    void description.load().catch(() => {
+    });
+    return null;
+  }
+  try {
+    const parser = description.support.language.parser;
+    const spans = [];
+    highlightCode(
+      code,
+      parser.parse(code),
+      paletteHighlighter,
+      (text, classes) => spans.push(classes ? { text, style: styleFor(classes) } : { text }),
+      () => spans.push({ text: "\n" })
+    );
+    return spans;
+  } catch {
+    return null;
+  }
+}
+export {
+  highlightFenceSpans
+};
+//# sourceMappingURL=highlightFence.js.map

package/dist/codemirror/code/highlightFence.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/code/highlightFence.ts"],"sourcesContent":["/**\n * Synchronous fence highlighting for the clipboard (#149).\n *\n * A copy event writes `text/html` synchronously, so highlighting must not\n * await anything. The trick: the grammars are the SAME `@codemirror/language-data`\n * singletons the editor's nested fence parse loads — any fence visible in the\n * editor has its grammar warm, so highlighting the copied code is a sync parse.\n * A cold grammar (copy from a doc whose fence never rendered) kicks the load\n * and returns null: THIS copy ships plain, the next one is highlighted.\n *\n * Output is inline-styled spans (the palette from\n * [codePalette](./codePalette.ts), same colors as the editor) — pasted HTML\n * carries no stylesheet, so classes would be dead weight in Docs/Word.\n */\n\nimport { LanguageDescription } from \"@codemirror/language\";\nimport { languages } from \"@codemirror/language-data\";\nimport { highlightCode, tagHighlighter } from \"@lezer/highlight\";\n\nimport { CODE_PALETTE } from \"./codePalette\";\n\nexport interface HighlightedSpan {\n  text: string;\n  /** Inline CSS for the span; absent for unstyled text (incl. line breaks). */\n  style?: string;\n}\n\nconst styleByClass = new Map(\n  CODE_PALETTE.map((spec, index) => [\n    `tok${index}`,\n    `color:${spec.color}${spec.fontStyle ? `;font-style:${spec.fontStyle}` : \"\"}`,\n  ]),\n);\n\n// tagHighlighter implements lezer's tag-containment matching (a token tagged\n// `function(variableName)` matches a spec on either tag) — hand-rolling that\n// gets the precedence subtly wrong.\nconst paletteHighlighter = tagHighlighter(\n  CODE_PALETTE.map((spec, index) => ({ tag: spec.tag as never, class: `tok${index}` })),\n);\n\nfunction styleFor(classes: string): string | undefined {\n  const styles = classes\n    .split(\" \")\n    .map((cls) => styleByClass.get(cls))\n    .filter(Boolean);\n  return styles.length > 0 ? styles.join(\";\") : undefined;\n}\n\n/** Highlight `code` as `lang` into inline-styled spans, or null when no\n *  grammar matches or the grammar isn't loaded yet (the load is kicked so a\n *  later copy succeeds). Never throws — a parser hiccup falls back to null. */\nexport function highlightFenceSpans(lang: string, code: string): HighlightedSpan[] | null {\n  const description = LanguageDescription.matchLanguageName(languages, lang, true);\n  if (!description) return null;\n  if (!description.support) {\n    void description.load().catch(() => {});\n    return null;\n  }\n  try {\n    const parser = description.support.language.parser;\n    const spans: HighlightedSpan[] = [];\n    highlightCode(\n      code,\n      parser.parse(code),\n      paletteHighlighter,\n      (text, classes) => spans.push(classes ? { text, style: styleFor(classes) } : { text }),\n      () => spans.push({ text: \"\\n\" }),\n    );\n    return spans;\n  } catch {\n    return null;\n  }\n}\n"],"mappings":";AAeA,SAAS,2BAA2B;AACpC,SAAS,iBAAiB;AAC1B,SAAS,eAAe,sBAAsB;AAE9C,SAAS,oBAAoB;AAQ7B,MAAM,eAAe,IAAI;AAAA,EACvB,aAAa,IAAI,CAAC,MAAM,UAAU;AAAA,IAChC,MAAM,KAAK;AAAA,IACX,SAAS,KAAK,KAAK,GAAG,KAAK,YAAY,eAAe,KAAK,SAAS,KAAK,EAAE;AAAA,EAC7E,CAAC;AACH;AAKA,MAAM,qBAAqB;AAAA,EACzB,aAAa,IAAI,CAAC,MAAM,WAAW,EAAE,KAAK,KAAK,KAAc,OAAO,MAAM,KAAK,GAAG,EAAE;AACtF;AAEA,SAAS,SAAS,SAAqC;AACrD,QAAM,SAAS,QACZ,MAAM,GAAG,EACT,IAAI,CAAC,QAAQ,aAAa,IAAI,GAAG,CAAC,EAClC,OAAO,OAAO;AACjB,SAAO,OAAO,SAAS,IAAI,OAAO,KAAK,GAAG,IAAI;AAChD;AAKO,SAAS,oBAAoB,MAAc,MAAwC;AACxF,QAAM,cAAc,oBAAoB,kBAAkB,WAAW,MAAM,IAAI;AAC/E,MAAI,CAAC,YAAa,QAAO;AACzB,MAAI,CAAC,YAAY,SAAS;AACxB,SAAK,YAAY,KAAK,EAAE,MAAM,MAAM;AAAA,IAAC,CAAC;AACtC,WAAO;AAAA,EACT;AACA,MAAI;AACF,UAAM,SAAS,YAAY,QAAQ,SAAS;AAC5C,UAAM,QAA2B,CAAC;AAClC;AAAA,MACE;AAAA,MACA,OAAO,MAAM,IAAI;AAAA,MACjB;AAAA,MACA,CAAC,MAAM,YAAY,MAAM,KAAK,UAAU,EAAE,MAAM,OAAO,SAAS,OAAO,EAAE,IAAI,EAAE,KAAK,CAAC;AAAA,MACrF,MAAM,MAAM,KAAK,EAAE,MAAM,KAAK,CAAC;AAAA,IACjC;AACA,WAAO;AAAA,EACT,QAAQ;AACN,WAAO;AAAA,EACT;AACF;","names":[]}

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

@@ -0,0 +1,9 @@
+export { codeHighlight } from './codeHighlight.js';
+export { codeLanguageUI } from './codeLangAffordance.js';
+export { FenceNode, fenceAt, fenceAutoClose, fenceAutoCloseKeymap, fenceExitBlock, fenceTypeAutoClose } from './fenceAutoClose.js';
+export { fenceCaretGuard } from './fenceCaretGuard.js';
+export { fenceBackspaceGuard, fenceDeleteGuard } from './fenceDeleteGuards.js';
+export { fenceTabDedent, fenceTabIndent, fenceTabKeymap } from './fenceTabIndent.js';
+export { HighlightedSpan, highlightFenceSpans } from './highlightFence.js';
+import '@codemirror/state';
+import '@codemirror/view';

package/dist/codemirror/code/index.js

@@ -0,0 +1,8 @@
+export * from "./codeHighlight.js";
+export * from "./codeLangAffordance.js";
+export * from "./fenceAutoClose.js";
+export * from "./fenceCaretGuard.js";
+export * from "./fenceDeleteGuards.js";
+export * from "./fenceTabIndent.js";
+export * from "./highlightFence.js";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/code/index.ts"],"sourcesContent":["/**\n * Fenced code blocks: syntax colors, the opener-row language pill + chooser,\n * fence typing/deletion/caret guards, Tab indentation, and the synchronous\n * highlighter the clipboard uses. Internal: `codeLanguageMenu`, `codePalette`.\n */\nexport * from \"./codeHighlight\";\nexport * from \"./codeLangAffordance\";\nexport * from \"./fenceAutoClose\";\nexport * from \"./fenceCaretGuard\";\nexport * from \"./fenceDeleteGuards\";\nexport * from \"./fenceTabIndent\";\nexport * from \"./highlightFence\";\n"],"mappings":"AAKA,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;","names":[]}

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

@@ -0,0 +1,32 @@
+import { syntaxTree } from '@codemirror/language';
+import { EditorState } from '@codemirror/state';
+import { EditorView } from '@codemirror/view';
+
+/**
+ * Grammar-level code-context test for the regex-scanning inline plugins
+ * (wikilink, highlight, footnote, math). Lezer emits no nodes for those
+ * constructs, so the plugins scan raw text — but code is literal, and the
+ * scans must skip it, exactly as the export pre-pass does (`protected_regions`
+ * in `src-tauri/src/export/html.rs`, derived from comrak's parse).
+ *
+ * A plugin guards a match by its OPENER and CLOSER positions: either sitting
+ * in code disqualifies the match, while a code span strictly inside the body
+ * (`[[a `b` c]]`) does not — the same rule the export applies.
+ */
+
+type Tree = ReturnType<typeof syntaxTree>;
+/** The tree parsed through the viewport — the painter's forced-parse bound
+ * (see `plugin.ts`), so a just-typed fence is already in the tree when a
+ * viewport-scanning plugin consults the guard. */
+declare function viewportTree(view: EditorView): Tree;
+/** The tree parsed through the whole document, for doc-wide state-level scans
+ * (math). Falls back to the partial tree when the parse budget runs out —
+ * the guard then degrades to the unguarded behavior past the parse frontier. */
+declare function docTree(state: EditorState): Tree;
+/** Whether the character at `pos` is code — inside a fenced or indented code
+ * block or an inline code span. `resolveInner` descends into a fence's nested
+ * `codeLanguages` parse; the parent walk crosses back into the markdown tree,
+ * so the enclosing FencedCode still answers. */
+declare function inCode(tree: Tree, pos: number): boolean;
+
+export { docTree, inCode, viewportTree };

package/dist/codemirror/core/codeContext.js

@@ -0,0 +1,22 @@
+import "../../chunk-V6TY7KAL.js";
+import { ensureSyntaxTree, syntaxTree } from "@codemirror/language";
+const CODE_NODES = /* @__PURE__ */ new Set(["FencedCode", "CodeBlock", "InlineCode"]);
+function viewportTree(view) {
+  return ensureSyntaxTree(view.state, view.viewport.to, 100) ?? syntaxTree(view.state);
+}
+function docTree(state) {
+  return ensureSyntaxTree(state, state.doc.length, 20) ?? syntaxTree(state);
+}
+function inCode(tree, pos) {
+  let node = tree.resolveInner(pos, 1);
+  for (; node; node = node.parent) {
+    if (CODE_NODES.has(node.name)) return true;
+  }
+  return false;
+}
+export {
+  docTree,
+  inCode,
+  viewportTree
+};
+//# sourceMappingURL=codeContext.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/core/codeContext.ts"],"sourcesContent":["/**\n * Grammar-level code-context test for the regex-scanning inline plugins\n * (wikilink, highlight, footnote, math). Lezer emits no nodes for those\n * constructs, so the plugins scan raw text — but code is literal, and the\n * scans must skip it, exactly as the export pre-pass does (`protected_regions`\n * in `src-tauri/src/export/html.rs`, derived from comrak's parse).\n *\n * A plugin guards a match by its OPENER and CLOSER positions: either sitting\n * in code disqualifies the match, while a code span strictly inside the body\n * (`[[a `b` c]]`) does not — the same rule the export applies.\n */\n\nimport { ensureSyntaxTree, syntaxTree } from \"@codemirror/language\";\nimport type { EditorState } from \"@codemirror/state\";\nimport type { EditorView } from \"@codemirror/view\";\n\ntype Tree = ReturnType<typeof syntaxTree>;\n\n/** The slice of Lezer's SyntaxNode the ancestor walk touches. */\ntype NodeLike = { readonly name: string; readonly parent: NodeLike | null };\n\nconst CODE_NODES = new Set([\"FencedCode\", \"CodeBlock\", \"InlineCode\"]);\n\n/** The tree parsed through the viewport — the painter's forced-parse bound\n * (see `plugin.ts`), so a just-typed fence is already in the tree when a\n * viewport-scanning plugin consults the guard. */\nexport function viewportTree(view: EditorView): Tree {\n  return ensureSyntaxTree(view.state, view.viewport.to, 100) ?? syntaxTree(view.state);\n}\n\n/** The tree parsed through the whole document, for doc-wide state-level scans\n * (math). Falls back to the partial tree when the parse budget runs out —\n * the guard then degrades to the unguarded behavior past the parse frontier. */\nexport function docTree(state: EditorState): Tree {\n  return ensureSyntaxTree(state, state.doc.length, 20) ?? syntaxTree(state);\n}\n\n/** Whether the character at `pos` is code — inside a fenced or indented code\n * block or an inline code span. `resolveInner` descends into a fence's nested\n * `codeLanguages` parse; the parent walk crosses back into the markdown tree,\n * so the enclosing FencedCode still answers. */\nexport function inCode(tree: Tree, pos: number): boolean {\n  let node = tree.resolveInner(pos, 1) as unknown as NodeLike | null;\n  for (; node; node = node.parent) {\n    if (CODE_NODES.has(node.name)) return true;\n  }\n  return false;\n}\n"],"mappings":";AAYA,SAAS,kBAAkB,kBAAkB;AAS7C,MAAM,aAAa,oBAAI,IAAI,CAAC,cAAc,aAAa,YAAY,CAAC;AAK7D,SAAS,aAAa,MAAwB;AACnD,SAAO,iBAAiB,KAAK,OAAO,KAAK,SAAS,IAAI,GAAG,KAAK,WAAW,KAAK,KAAK;AACrF;AAKO,SAAS,QAAQ,OAA0B;AAChD,SAAO,iBAAiB,OAAO,MAAM,IAAI,QAAQ,EAAE,KAAK,WAAW,KAAK;AAC1E;AAMO,SAAS,OAAO,MAAY,KAAsB;AACvD,MAAI,OAAO,KAAK,aAAa,KAAK,CAAC;AACnC,SAAO,MAAM,OAAO,KAAK,QAAQ;AAC/B,QAAI,WAAW,IAAI,KAAK,IAAI,EAAG,QAAO;AAAA,EACxC;AACA,SAAO;AACT;","names":[]}

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

@@ -0,0 +1,31 @@
+import { Extension } from '@codemirror/state';
+import { EditorView } from '@codemirror/view';
+
+/**
+ * Test-only harness: a headless CodeMirror `EditorView` wired with the markdown
+ * language + the live-preview decoration plugin, for keystroke-level tests of
+ * the editor commands (cursor motion, delete, list continuation, formatting).
+ *
+ * CodeMirror runs under jsdom; each test FILE that uses this must declare
+ * `// @vitest-environment jsdom` at its top. The Lezer tree is built eagerly so
+ * the plugin's atomic/hidden ranges (which the commands consult) are present.
+ *
+ * Not shipped — nothing in the app imports it, so it tree-shakes out.
+ */
+
+/** A headless editor over `doc` with the caret at `caret`. Extra extensions
+ *  (e.g. a keymap under test) can be appended. Track-and-cleanup via
+ *  {@link destroyEditors} in an `afterEach`. */
+declare function makeEditor(doc: string, caret?: number, extra?: Extension[]): EditorView;
+/** Like {@link makeEditor} but with every rendering extension the real editor
+ *  loads — for tests that assert the user-visible rendered output, not just the
+ *  source. */
+declare function makeFullEditor(doc: string, caret?: number, extra?: Extension[]): EditorView;
+/** Tear down every editor made since the last call. Call in `afterEach`. */
+declare function destroyEditors(): void;
+/** The current caret offset (head of the main selection). */
+declare function caret(view: EditorView): number;
+/** The current document text. */
+declare function text(view: EditorView): string;
+
+export { caret, destroyEditors, makeEditor, makeFullEditor, text };