@50arms/ui 0.0.0-stage → 35.2.0

package/dist/lib/markdown/convert.js

@@ -0,0 +1,153 @@
+import { lineAt as o } from "./caret.js";
+import { fenceAround as h, tableAround as k, cellsOf as j } from "./commands.js";
+const p = /^(\s*)([-*+])(\s+)/, b = /^(\s*)(\d{1,9})([.)])(\s+)/, x = /^ {0,3}(#{1,6})(\s+)/, $ = /^ {0,3}>\s?/, L = /^ {0,3}([-*_])(?:[ \t]*\1){2,}[ \t]*$/, E = /^\[([ xX])\]\s?/;
+function M(s) {
+  const a = [];
+  let e = 0;
+  for (; ; ) {
+    const t = o(s, e);
+    if (a.push({ start: t.start, end: t.end, text: s.slice(t.start, t.end) }), t.end >= s.length) break;
+    e = t.end + 1;
+  }
+  return a;
+}
+function v(s, a) {
+  const e = h(s, a);
+  if (e)
+    return { kind: "code", language: s.slice(e.start, o(s, e.start).end).replace(/^ {0,3}(`{3,}|~{3,})/, "").trim(), start: e.start, end: e.end };
+  const t = k(s, a);
+  if (t) return { kind: "table", start: t.start, end: t.end };
+  const n = o(s, a), r = s.slice(n.start, n.end), i = { start: n.start, end: n.end };
+  if (L.test(r)) return { kind: "rule", ...i };
+  const l = x.exec(r);
+  if (l) return { kind: "heading", level: l[1].length, ...i };
+  if ($.test(r)) return { kind: "quote", ...i };
+  const c = p.exec(r), d = b.exec(r);
+  if (c || d) {
+    const f = r.slice((c ?? d)[0].length), u = E.exec(f);
+    return u ? { kind: "task", checked: u[1] !== " ", ...i } : { kind: c ? "bullet" : "ordered", ...i };
+  }
+  return { kind: "paragraph", ...i };
+}
+function w(s, a) {
+  const e = s.slice(a.start, a.end);
+  if (a.kind === "code") {
+    const t = h(s, a.start);
+    return s.slice(t.bodyStart, t.bodyEnd).split(`
+`);
+  }
+  if (a.kind === "table") {
+    const t = k(s, a.start);
+    return M(s).filter((n) => n.start >= t.start && n.end <= t.end).filter((n) => !/^\s*\|?[\s:|-]+\|?\s*$/.test(n.text)).map((n) => j(n.text).join(" — "));
+  }
+  return a.kind === "rule" ? [""] : e.split(`
+`).map((t) => {
+    let n = t;
+    n = n.replace(x, ""), n = n.replace($, "");
+    const r = p.exec(n) ?? b.exec(n);
+    return r && (n = n.slice(r[0].length).replace(E, "")), n.trim();
+  });
+}
+function y(s, a, e, t) {
+  const n = t.length ? t : [""];
+  switch (s) {
+    case "paragraph":
+      return n.join(`
+`);
+    case "heading":
+      return `${"#".repeat(Math.min(6, Math.max(1, a)))} ${n.join(" ").trim()}`;
+    case "quote":
+      return n.map((r) => `> ${r}`.trimEnd()).join(`
+`);
+    case "bullet":
+      return n.map((r) => `- ${r}`.trimEnd()).join(`
+`);
+    case "ordered":
+      return n.map((r, i) => `${i + 1}. ${r}`.trimEnd()).join(`
+`);
+    case "task":
+      return n.map((r) => `- [ ] ${r}`.trimEnd()).join(`
+`);
+    case "code":
+      return ["```" + e, ...n, "```"].join(`
+`);
+    case "rule":
+      return "---";
+    case "table": {
+      const [r, ...i] = n;
+      return [`| ${r} |`, "| --- |", ...i.map((l) => `| ${l} |`)].join(`
+`);
+    }
+  }
+}
+function B(s, a = {}) {
+  return (e, t) => {
+    const n = Math.min(t.anchor, t.head), r = Math.max(t.anchor, t.head), i = v(e, n), l = i.kind === "code" || i.kind === "table" ? i.start : o(e, n).start, c = i.kind === "code" || i.kind === "table" ? i.end : o(e, r).end, d = a.level ?? i.level ?? 1, f = a.language ?? i.language ?? "", u = w(e, { ...i, start: l, end: c }), m = y(s, d, f, u);
+    if (m === e.slice(l, c)) return null;
+    const g = m.split(`
+`)[0];
+    return { splice: { start: l, end: c, text: m }, select: { anchor: l + g.length, head: l + g.length } };
+  };
+}
+function O(s) {
+  return (a, e) => {
+    const t = h(a, Math.min(e.anchor, e.head));
+    if (!t) return null;
+    const n = o(a, t.start), r = a.slice(n.start, n.end), i = /^ {0,3}(`{3,}|~{3,})/.exec(r);
+    if (!i) return null;
+    const l = `${i[0]}${s}`;
+    return l === r ? null : {
+      splice: { start: n.start, end: n.end, text: l },
+      select: { anchor: n.start + l.length, head: n.start + l.length }
+    };
+  };
+}
+function T(s, a) {
+  const e = /* @__PURE__ */ new Set();
+  for (const t of s.frames) {
+    const n = t.frame.kind;
+    n !== "strong" && n !== "emphasis" && n !== "codeSpan" && n !== "strike" || a < t.start || a > t.end || e.add(n);
+  }
+  return e;
+}
+function A(s, a) {
+  let e = null;
+  for (const r of s.frames)
+    r.frame.kind !== "link" && r.frame.kind !== "image" || a < r.start || a > r.end || (!e || r.end - r.start < e.end - e.start) && (e = r);
+  if (!e) return null;
+  const t = e.frame, n = t.kind === "image" ? t.alt : e.content.map((r) => s.source.slice(r.start, r.end)).join("");
+  return {
+    kind: t.kind,
+    target: t.kind === "image" ? t.src : t.href,
+    label: n,
+    title: t.title,
+    start: e.start,
+    end: e.end
+  };
+}
+function q(s, a, e) {
+  const t = A(s, a);
+  if (!t) return null;
+  const n = e.kind ?? t.kind, r = e.target ?? t.target, i = e.label ?? t.label, l = e.title ?? t.title, c = l ? ` "${l}"` : "", d = `${n === "image" ? "!" : ""}[${i}](${r}${c})`;
+  return d === s.source.slice(t.start, t.end) ? null : {
+    splice: { start: t.start, end: t.end, text: d },
+    select: { anchor: t.start + d.length, head: t.start + d.length }
+  };
+}
+function C(s, a) {
+  const e = A(s, a);
+  return e ? {
+    splice: { start: e.start, end: e.end, text: e.label },
+    select: { anchor: e.start + e.label.length, head: e.start + e.label.length }
+  } : null;
+}
+export {
+  v as blockAt,
+  A as constructAt,
+  B as convertBlock,
+  q as editConstruct,
+  T as marksAt,
+  O as setFenceLanguage,
+  C as unwrapConstruct
+};
+//# sourceMappingURL=convert.js.map

package/dist/lib/markdown/convert.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert.js","sources":["../../../src/lib/markdown/convert.ts"],"sourcesContent":["/* ============================================================================\n   CONVERT — what a block IS, and how to make it something else.\n\n   WHY THE EXISTING COMMANDS ARE NOT ENOUGH. Everything in ./commands.ts\n   TOGGLES: `toggleQuote` adds `> ` or removes it, `setHeading(2)` sets a level\n   or clears one. That is right for a keyboard shortcut, where the user knows\n   what they are looking at and presses the key twice to undo it. It is wrong\n   for a MENU, which shows a list of types and has to SET the one that was\n   picked — \"make this a quote\" must work whether the line is currently a\n   paragraph, a heading, a list item or a fence, and pressing it twice must not\n   turn the quote back into a paragraph.\n\n   So this module is set-semantics over the same string model: read what the\n   block is, reduce it to its plain text, and re-wrap that text as the target.\n   Two steps rather than a matrix, because a matrix of nine kinds against nine\n   kinds is eighty-one behaviours nobody can hold in their head, and the pair of\n   functions below is the same thing with two places to be wrong instead.\n\n   THE UNIT IS THE LINE, EXCEPT WHERE IT CANNOT BE. A fence and a table are\n   multi-line constructs whose halves are meaningless apart — converting the\n   middle three lines of a code block leaves an unterminated fence — so for\n   those the unit is the whole construct. Everywhere else it is the lines the\n   selection touches, which is what a per-line control implies.\n   ========================================================================= */\n\nimport { lineAt } from \"./caret\";\nimport { fenceAround, tableAround, cellsOf, type Command, type Edit } from \"./commands\";\nimport type { FrameRecord } from \"../syntax/markdown/frames\";\nimport type { Projection } from \"./project\";\n\n/** The block kinds a line-type control can offer. */\nexport type BlockKind =\n  | \"paragraph\"\n  | \"heading\"\n  | \"quote\"\n  | \"code\"\n  | \"bullet\"\n  | \"ordered\"\n  | \"task\"\n  | \"table\"\n  | \"rule\";\n\nexport interface BlockInfo {\n  kind: BlockKind;\n  /** 1–6 for a heading, otherwise undefined. */\n  level?: number;\n  /** The info string of a fence, \"\" when it has none. */\n  language?: string;\n  /** Whether a task item is ticked. */\n  checked?: boolean;\n  /** The source span this control operates on. */\n  start: number;\n  end: number;\n}\n\nconst BULLET = /^(\\s*)([-*+])(\\s+)/;\nconst NUMBER = /^(\\s*)(\\d{1,9})([.)])(\\s+)/;\nconst HEADING = /^ {0,3}(#{1,6})(\\s+)/;\nconst QUOTE = /^ {0,3}>\\s?/;\nconst RULE = /^ {0,3}([-*_])(?:[ \\t]*\\1){2,}[ \\t]*$/;\nconst TASK = /^\\[([ xX])\\]\\s?/;\n\n/** Every line of `source`, as spans. */\nfunction allLines(source: string): Array<{ start: number; end: number; text: string }> {\n  const out: Array<{ start: number; end: number; text: string }> = [];\n  let at = 0;\n  for (;;) {\n    const line = lineAt(source, at);\n    out.push({ start: line.start, end: line.end, text: source.slice(line.start, line.end) });\n    if (line.end >= source.length) break;\n    at = line.end + 1;\n  }\n  return out;\n}\n\n/**\n * What the block at `offset` is, and the span a conversion would replace.\n *\n * The span is the whole construct for a fence or a table and the caret's own\n * line otherwise — see the header. A caller with a real selection widens it\n * itself; this answers for a point.\n */\nexport function blockAt(source: string, offset: number): BlockInfo {\n  const fence = fenceAround(source, offset);\n  if (fence) {\n    const open = source.slice(fence.start, lineAt(source, fence.start).end);\n    const language = open.replace(/^ {0,3}(`{3,}|~{3,})/, \"\").trim();\n    return { kind: \"code\", language, start: fence.start, end: fence.end };\n  }\n\n  const table = tableAround(source, offset);\n  if (table) return { kind: \"table\", start: table.start, end: table.end };\n\n  const line = lineAt(source, offset);\n  const text = source.slice(line.start, line.end);\n  const span = { start: line.start, end: line.end };\n\n  if (RULE.test(text)) return { kind: \"rule\", ...span };\n\n  const heading = HEADING.exec(text);\n  if (heading) return { kind: \"heading\", level: heading[1].length, ...span };\n\n  if (QUOTE.test(text)) return { kind: \"quote\", ...span };\n\n  const bullet = BULLET.exec(text);\n  const number = NUMBER.exec(text);\n  if (bullet || number) {\n    const body = text.slice((bullet ?? number)![0].length);\n    const task = TASK.exec(body);\n    if (task) return { kind: \"task\", checked: task[1] !== \" \", ...span };\n    return { kind: bullet ? \"bullet\" : \"ordered\", ...span };\n  }\n\n  return { kind: \"paragraph\", ...span };\n}\n\n/**\n * The plain text of a block, with whatever made it that block removed.\n *\n * Returns one string per line. A table becomes one line per row with its cells\n * joined — there is no lossless answer for \"a table as prose\", and joining is\n * the one that keeps every word the author typed. A rule becomes nothing,\n * because it never held any text to keep.\n */\nfunction plainOf(source: string, info: BlockInfo): string[] {\n  const body = source.slice(info.start, info.end);\n\n  if (info.kind === \"code\") {\n    const fence = fenceAround(source, info.start)!;\n    return source.slice(fence.bodyStart, fence.bodyEnd).split(\"\\n\");\n  }\n\n  if (info.kind === \"table\") {\n    const table = tableAround(source, info.start)!;\n    return allLines(source)\n      .filter((l) => l.start >= table.start && l.end <= table.end)\n      /* The alignment row is markup with no content — it describes the table\n         rather than saying anything, so it does not become a line of prose. */\n      .filter((l) => !/^\\s*\\|?[\\s:|-]+\\|?\\s*$/.test(l.text))\n      .map((l) => cellsOf(l.text).join(\" — \"));\n  }\n\n  if (info.kind === \"rule\") return [\"\"];\n\n  return body.split(\"\\n\").map((line) => {\n    let out = line;\n    out = out.replace(HEADING, \"\");\n    out = out.replace(QUOTE, \"\");\n    const marker = BULLET.exec(out) ?? NUMBER.exec(out);\n    if (marker) out = out.slice(marker[0].length).replace(TASK, \"\");\n    return out.trim();\n  });\n}\n\n/** Wraps plain lines as the target kind. */\nfunction wrapAs(kind: BlockKind, level: number, language: string, lines: string[]): string {\n  const text = lines.length ? lines : [\"\"];\n\n  switch (kind) {\n    case \"paragraph\":\n      return text.join(\"\\n\");\n    case \"heading\":\n      /* A HEADING IS ONE LINE, so several become one. Dropping all but the\n         first would silently delete text the author can see; joining keeps it,\n         and the author can split it again with Enter. */\n      return `${\"#\".repeat(Math.min(6, Math.max(1, level)))} ${text.join(\" \").trim()}`;\n    case \"quote\":\n      return text.map((l) => `> ${l}`.trimEnd()).join(\"\\n\");\n    case \"bullet\":\n      return text.map((l) => `- ${l}`.trimEnd()).join(\"\\n\");\n    case \"ordered\":\n      return text.map((l, i) => `${i + 1}. ${l}`.trimEnd()).join(\"\\n\");\n    case \"task\":\n      return text.map((l) => `- [ ] ${l}`.trimEnd()).join(\"\\n\");\n    case \"code\":\n      return [\"```\" + language, ...text, \"```\"].join(\"\\n\");\n    case \"rule\":\n      return \"---\";\n    case \"table\": {\n      /* One column, one row per line, the first line as the header — the only\n         reading of \"these lines are a table\" that does not invent structure the\n         author never typed. */\n      const [head, ...rest] = text;\n      return [`| ${head} |`, \"| --- |\", ...rest.map((l) => `| ${l} |`)].join(\"\\n\");\n    }\n  }\n}\n\nexport interface ConvertOptions {\n  /** 1–6, for `heading`. Ignored otherwise. */\n  level?: number;\n  /** Info string, for `code`. Ignored otherwise. */\n  language?: string;\n}\n\n/**\n * Converts the block at the selection to `kind`, whatever it is now.\n *\n * SET, NOT TOGGLE: converting a quote to a quote is a no-op rather than an\n * un-quote, because a menu item that undoes itself when the current type is\n * picked is a menu item that punishes confirming what you already have.\n */\nexport function convertBlock(kind: BlockKind, options: ConvertOptions = {}): Command {\n  return (source, selection) => {\n    const from = Math.min(selection.anchor, selection.head);\n    const to = Math.max(selection.anchor, selection.head);\n    const info = blockAt(source, from);\n\n    /* A selection spanning several lines converts all of them — but a fence or\n       a table is one unit and its own span already covers what it owns. */\n    const start = info.kind === \"code\" || info.kind === \"table\" ? info.start : lineAt(source, from).start;\n    const end = info.kind === \"code\" || info.kind === \"table\" ? info.end : lineAt(source, to).end;\n\n    const level = options.level ?? info.level ?? 1;\n    const language = options.language ?? info.language ?? \"\";\n    const plain = plainOf(source, { ...info, start, end });\n    const text = wrapAs(kind, level, language, plain);\n    if (text === source.slice(start, end)) return null;\n\n    /* The caret lands at the end of the converted block's first line, which is\n       where the text the user was looking at now begins. */\n    const firstLine = text.split(\"\\n\")[0];\n    return { splice: { start, end, text }, select: { anchor: start + firstLine.length, head: start + firstLine.length } };\n  };\n}\n\n/**\n * Rewrites a fenced block's info string.\n *\n * Its own command rather than `convertBlock(\"code\", {language})`, because that\n * would rebuild the whole block to change one word — losing nothing, but\n * replacing every line and therefore every DOM node the reconciler had kept.\n */\nexport function setFenceLanguage(language: string): Command {\n  return (source, selection) => {\n    const fence = fenceAround(source, Math.min(selection.anchor, selection.head));\n    if (!fence) return null;\n    const line = lineAt(source, fence.start);\n    const text = source.slice(line.start, line.end);\n    const marker = /^ {0,3}(`{3,}|~{3,})/.exec(text);\n    if (!marker) return null;\n    const next = `${marker[0]}${language}`;\n    if (next === text) return null;\n    return {\n      splice: { start: line.start, end: line.end, text: next },\n      select: { anchor: line.start + next.length, head: line.start + next.length },\n    };\n  };\n}\n\n/* --- Inline marks ----------------------------------------------------------- */\n\n/** The inline mark kinds a toolbar can show as active. */\nexport type InlineMark = \"strong\" | \"emphasis\" | \"codeSpan\" | \"strike\";\n\n/**\n * Every inline mark frame containing `offset`, read from the projection.\n *\n * SAME METHOD AS `constructAt`, for the same reason: the parser has already\n * decided where a `**bold**` run starts and ends, including cases a regex\n * would get wrong — a marker inside a code span, one split across an escaped\n * character. A toolbar asking \"is the caret inside bold\" gets the parser's\n * answer instead of re-deriving it from the source text a second time.\n *\n * Boundaries are INCLUSIVE on both ends, matching `constructAt` — a caret at\n * either edge of `**bold**` still reads as inside it. This is a display\n * nicety (which toolbar buttons light up), not a decision about where\n * `toggleInline` wraps or unwraps, which reasons about the source directly.\n */\nexport function marksAt(projection: Projection, offset: number): Set<InlineMark> {\n  const marks = new Set<InlineMark>();\n  for (const record of projection.frames) {\n    const kind = record.frame.kind;\n    if (kind !== \"strong\" && kind !== \"emphasis\" && kind !== \"codeSpan\" && kind !== \"strike\") continue;\n    if (offset < record.start || offset > record.end) continue;\n    marks.add(kind);\n  }\n  return marks;\n}\n\n/* --- Links and images ------------------------------------------------------ */\n\nexport interface ConstructInfo {\n  kind: \"link\" | \"image\";\n  /** Destination — `href` for a link, `src` for an image. */\n  target: string;\n  /** Label for a link, alt text for an image. */\n  label: string;\n  title?: string;\n  start: number;\n  end: number;\n}\n\n/**\n * The innermost link or image containing `offset`.\n *\n * Read from the PROJECTION rather than by matching brackets, for the reason\n * every other reader in this codebase gives: the parser has already decided\n * what is a link, including the cases a regex gets wrong — a bracket inside a\n * code span, an unbalanced one, a reference definition elsewhere in the file.\n */\nexport function constructAt(projection: Projection, offset: number): ConstructInfo | null {\n  let best: FrameRecord | null = null;\n  for (const record of projection.frames) {\n    if (record.frame.kind !== \"link\" && record.frame.kind !== \"image\") continue;\n    if (offset < record.start || offset > record.end) continue;\n    if (!best || record.end - record.start < best.end - best.start) best = record;\n  }\n  if (!best) return null;\n\n  const frame = best.frame as Extract<typeof best.frame, { kind: \"link\" | \"image\" }>;\n  const label =\n    frame.kind === \"image\"\n      ? frame.alt\n      : best.content.map((r) => projection.source.slice(r.start, r.end)).join(\"\");\n  return {\n    kind: frame.kind,\n    target: frame.kind === \"image\" ? frame.src : frame.href,\n    label,\n    title: frame.title,\n    start: best.start,\n    end: best.end,\n  };\n}\n\nexport interface ConstructPatch {\n  target?: string;\n  label?: string;\n  title?: string;\n  /** Rewrites a link as an image or the other way round. */\n  kind?: \"link\" | \"image\";\n}\n\n/** Rewrites the link or image at `offset` from its parts. */\nexport function editConstruct(projection: Projection, offset: number, patch: ConstructPatch): Edit | null {\n  const found = constructAt(projection, offset);\n  if (!found) return null;\n\n  const kind = patch.kind ?? found.kind;\n  const target = patch.target ?? found.target;\n  const label = patch.label ?? found.label;\n  const title = patch.title ?? found.title;\n  const suffix = title ? ` \"${title}\"` : \"\";\n  const text = `${kind === \"image\" ? \"!\" : \"\"}[${label}](${target}${suffix})`;\n  if (text === projection.source.slice(found.start, found.end)) return null;\n\n  return {\n    splice: { start: found.start, end: found.end, text },\n    select: { anchor: found.start + text.length, head: found.start + text.length },\n  };\n}\n\n/**\n * Replaces a link or image with its own text.\n *\n * The one conversion that removes a construct rather than changing it, and the\n * only way to get rid of a link now that its brackets are markup the caret\n * cannot reach.\n */\nexport function unwrapConstruct(projection: Projection, offset: number): Edit | null {\n  const found = constructAt(projection, offset);\n  if (!found) return null;\n  return {\n    splice: { start: found.start, end: found.end, text: found.label },\n    select: { anchor: found.start + found.label.length, head: found.start + found.label.length },\n  };\n}\n"],"names":["BULLET","NUMBER","HEADING","QUOTE","RULE","TASK","allLines","source","out","at","line","lineAt","blockAt","offset","fence","fenceAround","table","tableAround","text","span","heading","bullet","number","body","task","plainOf","info","l","cellsOf","marker","wrapAs","kind","level","language","lines","head","rest","convertBlock","options","selection","from","to","start","end","plain","firstLine","setFenceLanguage","next","marksAt","projection","marks","record","constructAt","best","frame","label","editConstruct","patch","found","target","title","suffix","unwrapConstruct"],"mappings":"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"}

package/dist/lib/markdown/dom.js

@@ -0,0 +1,89 @@
+const u = "data-md-syntax", l = "data-md";
+function d(t) {
+  switch (t.kind) {
+    case "paragraph":
+      return { tag: "p" };
+    case "heading":
+      return { tag: `h${t.level}` };
+    case "code":
+      return { tag: "pre", attrs: t.language ? { "data-md-lang": t.language } : void 0 };
+    case "codeBody":
+      return { tag: "code" };
+    case "frontmatter":
+      return { tag: "pre", attrs: { "data-md-lang": t.language } };
+    case "quote":
+      return { tag: "blockquote" };
+    case "list":
+      return {
+        tag: t.ordered ? "ol" : "ul",
+        attrs: {
+          ...t.ordered && t.start !== 1 ? { start: String(t.start) } : {},
+          ...t.tight ? {} : { "data-md-loose": "" }
+        }
+      };
+    case "listItem":
+      return {
+        tag: "li",
+        attrs: {
+          /* The SOURCE marker, so the drawn one is the document's own. A CSS
+             counter would renumber a list that starts at 3, and would rewrite
+             the "1. 1. 1." form markdown allows and many people write. */
+          "data-md-marker": t.marker,
+          ...t.checked === null ? {} : { "data-md-checked": String(t.checked) }
+        }
+      };
+    case "rule":
+      return { tag: "div" };
+    case "footnoteDef":
+    case "linkDef":
+      return { tag: "div" };
+    case "table":
+      return { tag: "table" };
+    case "tableRow":
+      return { tag: "tr" };
+    case "tableCell":
+      return {
+        tag: t.header ? "th" : "td",
+        attrs: t.align ? { "data-md-align": t.align } : void 0
+      };
+    case "tableGutter":
+      return { tag: "td" };
+    case "tableDelimiter":
+      return { tag: "tr" };
+    case "inline":
+      return { tag: "span" };
+    case "emphasis":
+      return { tag: "em" };
+    case "strong":
+      return { tag: "strong" };
+    case "strike":
+      return { tag: "del" };
+    case "codeSpan":
+      return { tag: "code" };
+    case "link":
+      return { tag: "span", attrs: { "data-md-href": t.href } };
+    case "autolink":
+      return { tag: "span", attrs: { "data-md-href": t.href } };
+    case "image":
+      return { tag: "span", attrs: { "data-md-src": t.src, "data-md-alt": t.alt } };
+    case "footnoteRef":
+      return { tag: "sup" };
+    case "hardBreak":
+      return { tag: "span" };
+  }
+}
+function o(t, a) {
+  if (t.kind !== a.kind) return !1;
+  const e = d(t), r = d(a);
+  if (e.tag !== r.tag) return !1;
+  const n = e.attrs ?? {}, s = r.attrs ?? {}, g = /* @__PURE__ */ new Set([...Object.keys(n), ...Object.keys(s)]);
+  for (const c of g) if (n[c] !== s[c]) return !1;
+  return !0;
+}
+export {
+  l as FRAME_ATTR,
+  u as SYNTAX_ATTR,
+  o as sameElement,
+  d as tagFor
+};
+//# sourceMappingURL=dom.js.map

package/dist/lib/markdown/dom.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dom.js","sources":["../../../src/lib/markdown/dom.ts"],"sourcesContent":["/* ============================================================================\n   THE PROJECTION AS DOM — what each frame becomes, and why every choice here is\n   forced rather than stylistic.\n\n   THREE CONSTRAINTS DECIDE ALL OF IT.\n\n   1. Every source character must have somewhere LEGAL to live. A table cannot\n      hold loose text between its rows, so a delimiter row gets a real `<tr>`;\n      a thematic rule cannot be an `<hr>`, because `<hr>` is void and its three\n      dashes would have nowhere to go. Anywhere the obvious element cannot hold\n      text, the element is wrong — not the projection.\n\n   2. The container is `white-space: pre-wrap`. Every newline, every space, and\n      every indent in the source is real and renders as itself, so nothing has\n      to synthesise a `<br>` for a hard break or a line for a list indent. This\n      is why the projection can be literal.\n\n   3. Prose is a BARE TEXT NODE, never a wrapper. Only syntax is wrapped, and\n      only because it needs a styling hook to collapse. Wrapping prose would be\n      tidier and is what a naive tile-based renderer does, and it is exactly\n      what makes IME break: the composition holds a reference to one text node,\n      and the fewer reasons there are to replace one, the fewer ways there are\n      to cancel a composition.\n   ========================================================================= */\n\nimport type { Frame } from \"../syntax/markdown/frames\";\n\n/** Marks the wrapper around a run of markup, for the collapse rule. */\nexport const SYNTAX_ATTR = \"data-md-syntax\";\n\n/* THERE IS NO \"ACTIVE\" ATTRIBUTE ANY MORE, and its absence is a decision worth\n   recording rather than a deletion worth forgetting.\n\n   It marked the block the caret was in so that block's markup could be\n   revealed, because a caret cannot be placed inside a zero-size box: Chrome\n   resolves a selection written into `width: 0; overflow: hidden` to the nearest\n   position with real geometry, which is a DIFFERENT source offset than the one\n   asked for. The first browser probe caught that as Enter putting its newline\n   at the end of the paragraph instead of at the caret.\n\n   The markdown is now never shown, so no marker ever has geometry and no offset\n   inside one is ever asked for. The problem is answered by the caret map\n   (./caret-map.ts) refusing to produce such an offset, rather than by making\n   the box big enough to hold it. */\n\n/** Names the frame an element came from, for styling and for the reconciler. */\nexport const FRAME_ATTR = \"data-md\";\n\nexport interface TagSpec {\n  tag: string;\n  /** Attributes the element carries, beyond `data-md`. */\n  attrs?: Record<string, string>;\n}\n\n/**\n * The element a frame becomes.\n *\n * `a` deliberately renders as a `<span>`, NOT an anchor. An anchor inside a\n * contenteditable is a trap: the browser gives it its own selection behaviour,\n * some engines make it draggable, and a click navigates away from the document\n * being edited. The link's appearance is a class; its behaviour belongs to the\n * editor, which knows whether a modifier key was held.\n */\nexport function tagFor(frame: Frame): TagSpec {\n  switch (frame.kind) {\n    case \"paragraph\":\n      return { tag: \"p\" };\n    case \"heading\":\n      return { tag: `h${frame.level}` };\n    case \"code\":\n      /* The `<pre>` holds the fence lines too, which are NOT code — so the\n         `<code>` is the inner `codeBody` frame rather than this one. That is\n         the standard `<pre><code>` pairing, arrived at from the requirement\n         rather than from the convention. */\n      return { tag: \"pre\", attrs: frame.language ? { \"data-md-lang\": frame.language } : undefined };\n    case \"codeBody\":\n      return { tag: \"code\" };\n    case \"frontmatter\":\n      return { tag: \"pre\", attrs: { \"data-md-lang\": frame.language } };\n    case \"quote\":\n      return { tag: \"blockquote\" };\n    case \"list\":\n      return {\n        tag: frame.ordered ? \"ol\" : \"ul\",\n        attrs: {\n          ...(frame.ordered && frame.start !== 1 ? { start: String(frame.start) } : {}),\n          ...(frame.tight ? {} : { \"data-md-loose\": \"\" }),\n        },\n      };\n    case \"listItem\":\n      return {\n        tag: \"li\",\n        attrs: {\n          /* The SOURCE marker, so the drawn one is the document's own. A CSS\n             counter would renumber a list that starts at 3, and would rewrite\n             the \"1. 1. 1.\" form markdown allows and many people write. */\n          \"data-md-marker\": frame.marker,\n          ...(frame.checked === null ? {} : { \"data-md-checked\": String(frame.checked) }),\n        },\n      };\n    case \"rule\":\n      /* Not `<hr>`. A void element cannot hold the three dashes that produced\n         it, and they have to be somewhere — see constraint 1 above. */\n      return { tag: \"div\" };\n    case \"footnoteDef\":\n    case \"linkDef\":\n      return { tag: \"div\" };\n    case \"table\":\n      return { tag: \"table\" };\n    case \"tableRow\":\n      return { tag: \"tr\" };\n    case \"tableCell\":\n      return {\n        tag: frame.header ? \"th\" : \"td\",\n        attrs: frame.align ? { \"data-md-align\": frame.align } : undefined,\n      };\n    case \"tableGutter\":\n      /* A real cell for the pipes and the padding. A `<tr>` cannot hold text —\n         the browser wraps it in an anonymous cell box it will not step a caret\n         into — and the caret contract says every one of those characters is\n         reachable. Hidden, never absent. */\n      return { tag: \"td\" };\n    case \"tableDelimiter\":\n      /* A real row, so the delimiter line's characters sit somewhere a table\n         may legally hold text. It is collapsed by CSS, not by omission. */\n      return { tag: \"tr\" };\n    case \"inline\":\n      return { tag: \"span\" };\n    case \"emphasis\":\n      return { tag: \"em\" };\n    case \"strong\":\n      return { tag: \"strong\" };\n    case \"strike\":\n      return { tag: \"del\" };\n    case \"codeSpan\":\n      return { tag: \"code\" };\n    case \"link\":\n      return { tag: \"span\", attrs: { \"data-md-href\": frame.href } };\n    case \"autolink\":\n      return { tag: \"span\", attrs: { \"data-md-href\": frame.href } };\n    case \"image\":\n      return { tag: \"span\", attrs: { \"data-md-src\": frame.src, \"data-md-alt\": frame.alt } };\n    case \"footnoteRef\":\n      return { tag: \"sup\" };\n    case \"hardBreak\":\n      return { tag: \"span\" };\n  }\n}\n\n/**\n * Whether two frames describe the same element, for reuse during a patch.\n *\n * Compared by TAG and by the attributes that would have to change, not by deep\n * equality of the frame: a heading whose text changed is the same `<h2>` and\n * must keep its identity, while a heading that became an `<h3>` is a different\n * element. Getting this wrong in the permissive direction replaces nodes the\n * caret is inside; getting it wrong in the strict direction is merely slower.\n */\nexport function sameElement(a: Frame, b: Frame): boolean {\n  if (a.kind !== b.kind) return false;\n  const left = tagFor(a);\n  const right = tagFor(b);\n  if (left.tag !== right.tag) return false;\n  const la = left.attrs ?? {};\n  const ra = right.attrs ?? {};\n  const keys = new Set([...Object.keys(la), ...Object.keys(ra)]);\n  for (const key of keys) if (la[key] !== ra[key]) return false;\n  return true;\n}\n"],"names":["SYNTAX_ATTR","FRAME_ATTR","tagFor","frame","sameElement","a","b","left","right","la","ra","keys","key"],"mappings":"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"}

package/dist/lib/markdown/edit.js

@@ -0,0 +1,92 @@
+import { graphemeAfter as S, graphemeBefore as b } from "./caret-map.js";
+const M = /* @__PURE__ */ new Set([
+  "emphasis",
+  "strong",
+  "strike",
+  "codeSpan",
+  "link",
+  "image",
+  "autolink",
+  "footnoteRef"
+]);
+function k(n, a = []) {
+  for (const o of n)
+    o.type === "text" ? a.push(o) : k(o.children, a);
+  return a;
+}
+function B(n, a) {
+  return Math.max(0, Math.min(n.end, a.end) - Math.max(n.start, a.start));
+}
+function w(n, a, o) {
+  const { source: t } = n, e = Math.max(0, Math.min(a, o, t.length)), s = Math.min(t.length, Math.max(a, o));
+  if (e === s) return null;
+  if (e === 0 && s === t.length)
+    return { splice: { start: e, end: s, text: "" }, select: { anchor: 0, head: 0 } };
+  const c = k(n.children), u = new Uint8Array(t.length);
+  for (const r of c)
+    if (!r.syntax)
+      for (let i = r.start; i < r.end; i++) u[i] = 1;
+  let g = 0;
+  for (let r = e; r < s; r++) u[r] && g++;
+  if (!g) return null;
+  const h = [];
+  for (const r of n.frames) {
+    if (!M.has(r.frame.kind)) continue;
+    let i = 0, x = 0;
+    for (const m of r.content)
+      i += m.end - m.start, x += B(m, { start: e, end: s });
+    i > 0 && x === i && h.push(r);
+  }
+  let l = e, f = s;
+  for (const r of h)
+    l = Math.min(l, r.start), f = Math.max(f, r.end);
+  const A = (r) => {
+    if (r >= e && r < s && u[r]) return !0;
+    for (const i of h) if (r >= i.start && r < i.end) return !0;
+    return !1;
+  };
+  let d = "";
+  for (let r = l; r < f; r++) A(r) || (d += t[r]);
+  const p = l + d.length;
+  return { splice: { start: l, end: f, text: d }, select: { anchor: p, head: p } };
+}
+function v(n, a, o) {
+  let t = null;
+  for (const e of n.frames)
+    M.has(e.frame.kind) && (e.content.length || e.start < a || e.end > o || (!t || e.start < t.start) && (t = e));
+  return t;
+}
+function y(n) {
+  return {
+    splice: { start: n.start, end: n.end, text: "" },
+    select: { anchor: n.start, head: n.start }
+  };
+}
+function E(n, a, o) {
+  const { source: t } = n;
+  let e = Math.max(0, Math.min(o, t.length));
+  for (; e > 0 && t[e - 1] !== `
+`; ) e--;
+  let s = e;
+  for (; s < t.length && t[s] !== `
+`; ) s++;
+  if (s === e) return null;
+  for (const c of a.graphemes) if (c.start < s && c.end > e) return null;
+  return { start: e, end: Math.min(t.length, s + 1) };
+}
+function I(n, a, o) {
+  const t = b(a, o), e = v(n, t ? t.end : 0, o);
+  if (e) return y(e);
+  const s = E(n, a, o);
+  return s ? { splice: { ...s, text: "" }, select: { anchor: s.start, head: s.start } } : t ? w(n, t.start, t.end) : null;
+}
+function L(n, a, o) {
+  const t = S(a, o), e = v(n, o, t ? t.start : n.source.length);
+  return e ? y(e) : t ? w(n, t.start, t.end) : null;
+}
+export {
+  w as deleteVisible,
+  L as deleteVisibleAfter,
+  I as deleteVisibleBefore
+};
+//# sourceMappingURL=edit.js.map

package/dist/lib/markdown/edit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit.js","sources":["../../../src/lib/markdown/edit.ts"],"sourcesContent":["/* ============================================================================\n   VISIBLE EDITS — deleting what the user can see, without ever exposing what\n   they cannot.\n\n   THE PROBLEM THIS SOLVES. Under the caret map, the caret only ever stands on a\n   visible position, so a deletion is expressed as \"remove the previous visible\n   character\". But the markers are still real characters sitting in between, and\n   two ways of removing text put them on screen:\n\n     HALF A MARKER    Deleting the source range between two caret stops can cut\n                      a `**` in two. `a**bc**d` with \"c\" selected spans offsets\n                      4 to 7, and 5..7 is the closing marker — deleting the span\n                      leaves `a**bd`, which renders as literal asterisks.\n\n     AN EMPTY ONE     Deleting the last character of `**b**` leaves `****`,\n                      which is not emphasis at all, so every character of it\n                      becomes visible prose.\n\n   So deletion is defined on CONTENT, not on ranges: it removes the visible\n   characters inside the range and leaves every marker alone — except a marker\n   whose construct no longer has any content, which goes with it. Both halves\n   are needed and neither is sufficient.\n\n   IT IS STILL ONE SPLICE. The surviving markers inside the range are re-emitted\n   as the splice's text, so the whole operation stays a single edit: one history\n   entry, one re-projection, one caret to compute. A multi-splice API would have\n   been the obvious shape and would have made undo granularity a per-caller\n   decision, which is exactly the kind of thing that goes wrong quietly.\n   ========================================================================= */\n\nimport type { Frame, FrameRecord } from \"../syntax/markdown/frames\";\nimport type { CaretMap, Span } from \"./caret-map\";\nimport { graphemeAfter, graphemeBefore } from \"./caret-map\";\nimport type { Edit } from \"./commands\";\nimport type { PNode, PText, Projection } from \"./project\";\n\n/* `Edit` and `Splice` are imported rather than redeclared. A second shape for\n   \"a splice and where the caret goes\" would be two things to keep in step for\n   no gain, and the commands already own that shape. */\nexport type { Edit } from \"./commands\";\n\n/**\n * Inline constructs that must not survive losing their content.\n *\n * `inline` is deliberately absent: it is a paragraph's run of prose, and an\n * empty paragraph is an ordinary thing to have. The kinds here are the ones\n * whose markers mean nothing without something between them.\n */\nconst EMPTIABLE = new Set<Frame[\"kind\"]>([\n  \"emphasis\",\n  \"strong\",\n  \"strike\",\n  \"codeSpan\",\n  \"link\",\n  \"image\",\n  \"autolink\",\n  \"footnoteRef\",\n]);\n\nfunction flatten(nodes: readonly PNode[], out: PText[] = []): PText[] {\n  for (const node of nodes) {\n    if (node.type === \"text\") out.push(node);\n    else flatten(node.children, out);\n  }\n  return out;\n}\n\nfunction overlap(a: Span, b: Span): number {\n  return Math.max(0, Math.min(a.end, b.end) - Math.max(a.start, b.start));\n}\n\n/**\n * Removes every visible character in `[from, to)`, and any inline construct\n * that is left with nothing inside it.\n *\n * Returns null when the range holds no visible characters at all, so a caller\n * can tell \"nothing to delete\" from \"deleted nothing\".\n */\nexport function deleteVisible(projection: Projection, from: number, to: number): Edit | null {\n  const { source } = projection;\n  const start = Math.max(0, Math.min(from, to, source.length));\n  const end = Math.min(source.length, Math.max(from, to));\n  if (start === end) return null;\n\n  /* DX-5619: A SELECTION OF THE WHOLE DOCUMENT EMPTIES IT. Everything below\n     removes VISIBLE characters and leaves markers alone, so select-all then\n     Delete left a fence, a `# ` or a list marker behind (and returned null,\n     doing nothing at all, when none of the document was visible). No marker\n     can outlive a document with nothing in it. */\n  if (start === 0 && end === source.length) {\n    return { splice: { start, end, text: \"\" }, select: { anchor: 0, head: 0 } };\n  }\n\n  const runs = flatten(projection.children);\n  const content = new Uint8Array(source.length);\n  for (const run of runs) {\n    if (run.syntax) continue;\n    for (let at = run.start; at < run.end; at++) content[at] = 1;\n  }\n\n  let visible = 0;\n  for (let at = start; at < end; at++) if (content[at]) visible++;\n  if (!visible) return null;\n\n  /* Constructs the deletion empties. Measured against the frame's OWN declared\n     content, which is the parser's answer rather than a guess at where the\n     markers are. */\n  const doomed: FrameRecord[] = [];\n  for (const record of projection.frames) {\n    if (!EMPTIABLE.has(record.frame.kind)) continue;\n    let own = 0;\n    let lost = 0;\n    for (const range of record.content) {\n      own += range.end - range.start;\n      lost += overlap(range, { start, end });\n    }\n    if (own > 0 && lost === own) doomed.push(record);\n  }\n\n  /* The splice has to reach far enough to take the doomed markers with it, and\n     they can lie outside the range the caller asked about — the closing `**` of\n     a construct whose last character was just deleted is always outside it. */\n  let spliceStart = start;\n  let spliceEnd = end;\n  for (const record of doomed) {\n    spliceStart = Math.min(spliceStart, record.start);\n    spliceEnd = Math.max(spliceEnd, record.end);\n  }\n\n  const removed = (at: number): boolean => {\n    if (at >= start && at < end && content[at]) return true;\n    for (const record of doomed) if (at >= record.start && at < record.end) return true;\n    return false;\n  };\n\n  let text = \"\";\n  for (let at = spliceStart; at < spliceEnd; at++) if (!removed(at)) text += source[at];\n\n  /* The caret lands after whatever survived, which is where the deleted text\n     used to be. The surface snaps it to a real stop after re-projecting: an\n     offset that was legal before an edit is not necessarily legal after it. */\n  const caret = spliceStart + text.length;\n  return { splice: { start: spliceStart, end: spliceEnd, text }, select: { anchor: caret, head: caret } };\n}\n\n/**\n * Constructs that are markup end to end: a footnote reference, a hard break.\n *\n * `inline.ts` gives these NO content ranges, which makes them atomic, and atomic\n * is exactly what the delete rules have to know about. Without this, the next\n * visible character after one is whatever follows it, so pressing Delete in\n * front of a footnote reference skipped straight over it and ate the newline\n * beyond. (An image is not one: since DXUI-74 its alt text is its label, edited\n * in place like a link's.)\n */\nfunction atomicIn(projection: Projection, from: number, to: number): FrameRecord | null {\n  let found: FrameRecord | null = null;\n  for (const record of projection.frames) {\n    if (!EMPTIABLE.has(record.frame.kind)) continue;\n    if (record.content.length) continue;\n    if (record.start < from || record.end > to) continue;\n    if (!found || record.start < found.start) found = record;\n  }\n  return found;\n}\n\n/** Removes a construct whole, caret left where it stood. */\nfunction removeSpan(record: FrameRecord): Edit {\n  return {\n    splice: { start: record.start, end: record.end, text: \"\" },\n    select: { anchor: record.start, head: record.start },\n  };\n}\n\n/**\n * The line holding `offset`, when every character of it is markup.\n *\n * THE LAST RESORT, AND IT CLOSES A REAL DEAD END. A table whose cells are all\n * empty is a document with ZERO visible characters — the pipes, the alignment\n * row and the newlines between rows are markup to the last byte. There is no\n * visible character to delete, so backspace had nothing to do and the table\n * could not be removed with the keyboard at all. The probe found it by trying\n * to backspace a mixed document away and stalling with an empty table left.\n *\n * The line must be non-empty: a genuinely blank line is not markup, it is the\n * document's own vertical space, and deleting the line the caret sits at the\n * start of would be a FORWARD deletion wearing backspace's clothes.\n */\nfunction markupOnlyLine(projection: Projection, map: CaretMap, offset: number): Span | null {\n  const { source } = projection;\n  let start = Math.max(0, Math.min(offset, source.length));\n  while (start > 0 && source[start - 1] !== \"\\n\") start--;\n  let end = start;\n  while (end < source.length && source[end] !== \"\\n\") end++;\n  if (end === start) return null;\n  for (const span of map.graphemes) if (span.start < end && span.end > start) return null;\n  return { start, end: Math.min(source.length, end + 1) };\n}\n\n/** Backspace: removes the visible character before `offset`, or an atomic construct. */\nexport function deleteVisibleBefore(projection: Projection, map: CaretMap, offset: number): Edit | null {\n  /* THE ORDER OF THESE THREE IS THE WHOLE RULE, and each position was earned.\n\n     A construct beside the caret goes first: a footnote reference alone on a line\n     satisfies the markup-only test too, and removing the LINE would take the\n     blank line with it when only the reference was asked for.\n\n     The line comes before the character search, because `graphemeBefore` looks\n     through the whole document — on a line that shows nothing it returns a\n     character three rows up, so backspace at the end of an empty table deleted\n     a newline ABOVE the table and left the table standing. A key acts near the\n     caret or it does not act. */\n  const grapheme = graphemeBefore(map, offset);\n\n  const atomic = atomicIn(projection, grapheme ? grapheme.end : 0, offset);\n  if (atomic) return removeSpan(atomic);\n\n  const line = markupOnlyLine(projection, map, offset);\n  if (line) return { splice: { ...line, text: \"\" }, select: { anchor: line.start, head: line.start } };\n\n  if (grapheme) return deleteVisible(projection, grapheme.start, grapheme.end);\n  return null;\n}\n\n/** Forward delete: removes the visible character after `offset`, or an atomic construct. */\nexport function deleteVisibleAfter(projection: Projection, map: CaretMap, offset: number): Edit | null {\n  const grapheme = graphemeAfter(map, offset);\n  const atomic = atomicIn(projection, offset, grapheme ? grapheme.start : projection.source.length);\n  if (atomic) return removeSpan(atomic);\n  if (!grapheme) return null;\n  return deleteVisible(projection, grapheme.start, grapheme.end);\n}\n"],"names":["EMPTIABLE","flatten","nodes","out","node","overlap","a","b","deleteVisible","projection","from","to","source","start","end","runs","content","run","at","visible","doomed","record","own","lost","range","spliceStart","spliceEnd","removed","text","caret","atomicIn","found","removeSpan","markupOnlyLine","map","offset","span","deleteVisibleBefore","grapheme","graphemeBefore","atomic","line","deleteVisibleAfter","graphemeAfter"],"mappings":"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"}

package/dist/lib/markdown/history.js

@@ -0,0 +1,79 @@
+import { substituteAll as r } from "./images.js";
+const h = 500, l = 250;
+class a {
+  entries = [];
+  index = -1;
+  groupMs;
+  limit;
+  now;
+  /** State of the group currently open for merging. */
+  lastAt = 0;
+  lastKind = null;
+  lastEnd = -1;
+  constructor(t, s = {}) {
+    this.groupMs = s.groupMs ?? h, this.limit = s.limit ?? l, this.now = s.now ?? (() => Date.now()), this.entries.push(t), this.index = 0;
+  }
+  get canUndo() {
+    return this.index > 0;
+  }
+  get canRedo() {
+    return this.index < this.entries.length - 1;
+  }
+  /** Entry count, for tests that assert coalescing rather than behaviour. */
+  get size() {
+    return this.entries.length;
+  }
+  /**
+   * Records a state.
+   *
+   * `at` is where the edit happened; adjacency to the previous edit is what
+   * separates "still typing" from "went somewhere else and typed". Passing the
+   * position rather than deriving it from the diff is deliberate — a diff of
+   * two strings finds the shortest edit, which is not always the edit that
+   * happened, and coalescing decisions made from the wrong position are worse
+   * than none.
+   */
+  record(t, s, e) {
+    const i = this.now();
+    this.index < this.entries.length - 1 && (this.entries.length = this.index + 1), this.shouldMerge(s, e, i) ? this.entries[this.index] = { source: t.source, selection: t.selection } : (this.entries.push(t), this.index++, this.entries.length > this.limit && (this.entries.shift(), this.index--)), this.lastAt = i, this.lastKind = s, this.lastEnd = e;
+  }
+  shouldMerge(t, s, e) {
+    return this.index < 0 || t === "compose" || this.lastKind === "compose" || t === "other" || this.lastKind === "other" || t !== this.lastKind || e - this.lastAt > this.groupMs ? !1 : Math.abs(s - this.lastEnd) <= 1;
+  }
+  /** Forces the next edit to open a new group — a selection change, a blur. */
+  break() {
+    this.lastKind = null, this.lastEnd = -1;
+  }
+  /**
+   * Replaces every occurrence of `from` with `to` in EVERY entry, carrying
+   * each entry's selection through the change.
+   *
+   * The upload swap (DX-3134, see `MarkdownSurface.substitute`): a stored
+   * image's object URL must not survive anywhere Ctrl+Z or Ctrl+Y could reach.
+   * The entries are rewritten in place rather than a new one recorded, so the
+   * swap is not itself an undo step and the undo depth is unchanged.
+   */
+  substitute(t, s) {
+    for (let e = 0; e < this.entries.length; e++) {
+      const i = this.entries[e], n = r(i.source, t, s);
+      n && (this.entries[e] = {
+        source: n.source,
+        selection: i.selection && { anchor: n.map(i.selection.anchor), head: n.map(i.selection.head) }
+      });
+    }
+  }
+  /** Whether any entry, reachable by undo or redo, still holds `text`. */
+  includes(t) {
+    return this.entries.some((s) => s.source.includes(t));
+  }
+  undo() {
+    return this.canUndo ? (this.index--, this.break(), this.entries[this.index]) : null;
+  }
+  redo() {
+    return this.canRedo ? (this.index++, this.break(), this.entries[this.index]) : null;
+  }
+}
+export {
+  a as History
+};
+//# sourceMappingURL=history.js.map

package/dist/lib/markdown/history.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"history.js","sources":["../../../src/lib/markdown/history.ts"],"sourcesContent":["/* ============================================================================\n   UNDO — ours, unavoidably.\n\n   MDN is explicit that `execCommand` preserves the browser's native undo buffer\n   and that direct DOM manipulation does not. The moment an editor stops going\n   through `execCommand` it owns undo, so this is not a feature decision; it is\n   entailed by every other decision already made. (Note the same fact is why the\n   `CodeEditor` already in this library goes through `execCommand(\"insertText\")`\n   — that choice is load-bearing, not stylistic.)\n\n   COALESCING IS THE WHOLE DESIGN, and the constants are not guesses. They are\n   what ProseMirror and CodeMirror landed on after years:\n\n     - a new group after 500ms of quiet;\n     - a new group when the edited ranges are not adjacent, because an edit\n       somewhere else is a different thought;\n     - a new group when a composition ends, because an IME commit is one unit\n       however many keystrokes produced it;\n     - typing merges with typing and deletion with deletion, never across.\n\n   Undoing a paragraph the user typed as one breath should take one press. Undo\n   that gives back one character at a time is the most common complaint about\n   hand-rolled editors, and undo that gives back the whole document is the\n   second — both are this table set wrong.\n\n   WHAT IS STORED. Whole snapshots of the source string plus the selection, not\n   inverse patches. That is a deliberate trade: a snapshot of a 100KB document\n   is 100KB, which is nothing next to what it buys — an undo that cannot be\n   wrong. Inverse patches have to be applied in exact reverse order against\n   exactly the state they were computed from, and every editor that has got that\n   wrong has corrupted somebody's document doing it.\n   ========================================================================= */\n\nimport type { SourceSelection } from \"./position\";\nimport { substituteAll } from \"./images\";\n\nexport interface HistoryEntry {\n  source: string;\n  selection: SourceSelection | null;\n}\n\n/** What produced an edit, for deciding whether two of them belong together. */\nexport type EditKind = \"type\" | \"delete\" | \"compose\" | \"other\";\n\nexport interface HistoryOptions {\n  /** Quiet time after which the next edit starts a new group. */\n  groupMs?: number;\n  /** Entries kept. Beyond this the oldest are dropped. */\n  limit?: number;\n  /** Injected so tests are deterministic; never read a clock directly. */\n  now?: () => number;\n}\n\nconst DEFAULT_GROUP_MS = 500;\nconst DEFAULT_LIMIT = 250;\n\nexport class History {\n  private readonly entries: HistoryEntry[] = [];\n  private index = -1;\n\n  private readonly groupMs: number;\n  private readonly limit: number;\n  private readonly now: () => number;\n\n  /** State of the group currently open for merging. */\n  private lastAt = 0;\n  private lastKind: EditKind | null = null;\n  private lastEnd = -1;\n\n  constructor(initial: HistoryEntry, options: HistoryOptions = {}) {\n    this.groupMs = options.groupMs ?? DEFAULT_GROUP_MS;\n    this.limit = options.limit ?? DEFAULT_LIMIT;\n    this.now = options.now ?? (() => Date.now());\n    this.entries.push(initial);\n    this.index = 0;\n  }\n\n  get canUndo(): boolean {\n    return this.index > 0;\n  }\n\n  get canRedo(): boolean {\n    return this.index < this.entries.length - 1;\n  }\n\n  /** Entry count, for tests that assert coalescing rather than behaviour. */\n  get size(): number {\n    return this.entries.length;\n  }\n\n  /**\n   * Records a state.\n   *\n   * `at` is where the edit happened; adjacency to the previous edit is what\n   * separates \"still typing\" from \"went somewhere else and typed\". Passing the\n   * position rather than deriving it from the diff is deliberate — a diff of\n   * two strings finds the shortest edit, which is not always the edit that\n   * happened, and coalescing decisions made from the wrong position are worse\n   * than none.\n   */\n  record(entry: HistoryEntry, kind: EditKind, at: number): void {\n    const time = this.now();\n\n    /* Anything after an undo discards the redo tail — the standard contract,\n       and the one users expect from every text field they have ever used. */\n    if (this.index < this.entries.length - 1) this.entries.length = this.index + 1;\n\n    if (this.shouldMerge(kind, at, time)) {\n      this.entries[this.index] = { source: entry.source, selection: entry.selection };\n    } else {\n      this.entries.push(entry);\n      this.index++;\n      if (this.entries.length > this.limit) {\n        this.entries.shift();\n        this.index--;\n      }\n    }\n\n    this.lastAt = time;\n    this.lastKind = kind;\n    this.lastEnd = at;\n  }\n\n  private shouldMerge(kind: EditKind, at: number, time: number): boolean {\n    if (this.index < 0) return false;\n    /* A composition commit is ONE unit however many keystrokes made it, and it\n       never merges with what came before or after — the IME already decided\n       where its boundaries are, and second-guessing it is how an undo ends up\n       giving back half a character. */\n    if (kind === \"compose\" || this.lastKind === \"compose\") return false;\n    if (kind === \"other\" || this.lastKind === \"other\") return false;\n    if (kind !== this.lastKind) return false;\n    if (time - this.lastAt > this.groupMs) return false;\n    /* Adjacent means \"carried on from where the last edit left off\", within one\n       character either way: typing extends forward, backspace retreats. */\n    return Math.abs(at - this.lastEnd) <= 1;\n  }\n\n  /** Forces the next edit to open a new group — a selection change, a blur. */\n  break(): void {\n    this.lastKind = null;\n    this.lastEnd = -1;\n  }\n\n  /**\n   * Replaces every occurrence of `from` with `to` in EVERY entry, carrying\n   * each entry's selection through the change.\n   *\n   * The upload swap (DX-3134, see `MarkdownSurface.substitute`): a stored\n   * image's object URL must not survive anywhere Ctrl+Z or Ctrl+Y could reach.\n   * The entries are rewritten in place rather than a new one recorded, so the\n   * swap is not itself an undo step and the undo depth is unchanged.\n   */\n  substitute(from: string, to: string): void {\n    for (let i = 0; i < this.entries.length; i++) {\n      const entry = this.entries[i];\n      const swap = substituteAll(entry.source, from, to);\n      if (!swap) continue;\n      this.entries[i] = {\n        source: swap.source,\n        selection: entry.selection && { anchor: swap.map(entry.selection.anchor), head: swap.map(entry.selection.head) },\n      };\n    }\n  }\n\n  /** Whether any entry, reachable by undo or redo, still holds `text`. */\n  includes(text: string): boolean {\n    return this.entries.some((entry) => entry.source.includes(text));\n  }\n\n  undo(): HistoryEntry | null {\n    if (!this.canUndo) return null;\n    this.index--;\n    this.break();\n    return this.entries[this.index];\n  }\n\n  redo(): HistoryEntry | null {\n    if (!this.canRedo) return null;\n    this.index++;\n    this.break();\n    return this.entries[this.index];\n  }\n}\n"],"names":["DEFAULT_GROUP_MS","DEFAULT_LIMIT","History","initial","options","entry","kind","at","time","from","to","i","swap","substituteAll","text"],"mappings":";AAqDA,MAAMA,IAAmB,KACnBC,IAAgB;AAEf,MAAMC,EAAQ;AAAA,EACF,UAA0B,CAAA;AAAA,EACnC,QAAQ;AAAA,EAEC;AAAA,EACA;AAAA,EACA;AAAA;AAAA,EAGT,SAAS;AAAA,EACT,WAA4B;AAAA,EAC5B,UAAU;AAAA,EAElB,YAAYC,GAAuBC,IAA0B,IAAI;AAC/D,SAAK,UAAUA,EAAQ,WAAWJ,GAClC,KAAK,QAAQI,EAAQ,SAASH,GAC9B,KAAK,MAAMG,EAAQ,QAAQ,MAAM,KAAK,QACtC,KAAK,QAAQ,KAAKD,CAAO,GACzB,KAAK,QAAQ;AAAA,EACf;AAAA,EAEA,IAAI,UAAmB;AACrB,WAAO,KAAK,QAAQ;AAAA,EACtB;AAAA,EAEA,IAAI,UAAmB;AACrB,WAAO,KAAK,QAAQ,KAAK,QAAQ,SAAS;AAAA,EAC5C;AAAA;AAAA,EAGA,IAAI,OAAe;AACjB,WAAO,KAAK,QAAQ;AAAA,EACtB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYA,OAAOE,GAAqBC,GAAgBC,GAAkB;AAC5D,UAAMC,IAAO,KAAK,IAAA;AAIlB,IAAI,KAAK,QAAQ,KAAK,QAAQ,SAAS,MAAG,KAAK,QAAQ,SAAS,KAAK,QAAQ,IAEzE,KAAK,YAAYF,GAAMC,GAAIC,CAAI,IACjC,KAAK,QAAQ,KAAK,KAAK,IAAI,EAAE,QAAQH,EAAM,QAAQ,WAAWA,EAAM,UAAA,KAEpE,KAAK,QAAQ,KAAKA,CAAK,GACvB,KAAK,SACD,KAAK,QAAQ,SAAS,KAAK,UAC7B,KAAK,QAAQ,MAAA,GACb,KAAK,WAIT,KAAK,SAASG,GACd,KAAK,WAAWF,GAChB,KAAK,UAAUC;AAAA,EACjB;AAAA,EAEQ,YAAYD,GAAgBC,GAAYC,GAAuB;AASrE,WARI,KAAK,QAAQ,KAKbF,MAAS,aAAa,KAAK,aAAa,aACxCA,MAAS,WAAW,KAAK,aAAa,WACtCA,MAAS,KAAK,YACdE,IAAO,KAAK,SAAS,KAAK,UAAgB,KAGvC,KAAK,IAAID,IAAK,KAAK,OAAO,KAAK;AAAA,EACxC;AAAA;AAAA,EAGA,QAAc;AACZ,SAAK,WAAW,MAChB,KAAK,UAAU;AAAA,EACjB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWA,WAAWE,GAAcC,GAAkB;AACzC,aAASC,IAAI,GAAGA,IAAI,KAAK,QAAQ,QAAQA,KAAK;AAC5C,YAAMN,IAAQ,KAAK,QAAQM,CAAC,GACtBC,IAAOC,EAAcR,EAAM,QAAQI,GAAMC,CAAE;AACjD,MAAKE,MACL,KAAK,QAAQD,CAAC,IAAI;AAAA,QAChB,QAAQC,EAAK;AAAA,QACb,WAAWP,EAAM,aAAa,EAAE,QAAQO,EAAK,IAAIP,EAAM,UAAU,MAAM,GAAG,MAAMO,EAAK,IAAIP,EAAM,UAAU,IAAI,EAAA;AAAA,MAAE;AAAA,IAEnH;AAAA,EACF;AAAA;AAAA,EAGA,SAASS,GAAuB;AAC9B,WAAO,KAAK,QAAQ,KAAK,CAACT,MAAUA,EAAM,OAAO,SAASS,CAAI,CAAC;AAAA,EACjE;AAAA,EAEA,OAA4B;AAC1B,WAAK,KAAK,WACV,KAAK,SACL,KAAK,MAAA,GACE,KAAK,QAAQ,KAAK,KAAK,KAHJ;AAAA,EAI5B;AAAA,EAEA,OAA4B;AAC1B,WAAK,KAAK,WACV,KAAK,SACL,KAAK,MAAA,GACE,KAAK,QAAQ,KAAK,KAAK,KAHJ;AAAA,EAI5B;AACF;"}

package/dist/lib/markdown/hotkeys.js

@@ -0,0 +1,63 @@
+import { toggleBold as n, toggleItalic as s, toggleCode as g, toggleStrike as m, toggleTask as u, smartTab as k, smartShiftTab as h, toggleQuote as p, insertRule as f, deleteRow as y, deleteColumn as b, deleteTable as w, insertLink as C, setHeading as o, adjustHeading as l, toggleList as d, toggleCodeBlock as L, insertRow as c, alignColumn as i } from "./commands.js";
+const R = [
+  /* Inline formatting */
+  { id: "bold", key: "ctrl+b", group: "formatting", command: n },
+  { id: "italic", key: "ctrl+i", group: "formatting", command: s },
+  { id: "inlineCode", key: "ctrl+e", group: "formatting", command: g },
+  { id: "strikethrough", key: "ctrl+shift+s", group: "formatting", command: m },
+  { id: "link", key: "ctrl+k", group: "formatting", command: C() },
+  { id: "attachFile", key: "ctrl+shift+i", group: "formatting", request: "pickFiles" },
+  /* Headings */
+  { id: "paragraph", key: "ctrl+0", group: "headings", command: o(0) },
+  { id: "heading1", key: "ctrl+1", group: "headings", command: o(1) },
+  { id: "heading2", key: "ctrl+2", group: "headings", command: o(2) },
+  { id: "heading3", key: "ctrl+3", group: "headings", command: o(3) },
+  { id: "heading4", key: "ctrl+4", group: "headings", command: o(4) },
+  { id: "heading5", key: "ctrl+5", group: "headings", command: o(5) },
+  { id: "heading6", key: "ctrl+6", group: "headings", command: o(6) },
+  { id: "decreaseHeading", key: "ctrl+shift+comma", group: "headings", command: l(-1) },
+  { id: "increaseHeading", key: "ctrl+shift+period", group: "headings", command: l(1) },
+  /* Lists */
+  { id: "bulletList", key: "ctrl+shift+bracketleft", group: "lists", command: d(!1) },
+  { id: "numberedList", key: "ctrl+shift+bracketright", group: "lists", command: d(!0) },
+  { id: "taskCheckbox", key: "ctrl+shift+x", group: "lists", command: u },
+  // I18N-ALLOW: the chord string "tab" is a key id matched against the registry and never rendered (chordLabel names it from the catalog); the scan reads the lone word as English
+  { id: "indent", key: "tab", group: "lists", command: k },
+  { id: "outdent", key: "shift+tab", group: "lists", command: h },
+  /* Blocks */
+  { id: "codeBlock", key: "ctrl+shift+k", group: "blocks", command: L() },
+  { id: "blockquote", key: "ctrl+shift+q", group: "blocks", command: p },
+  { id: "horizontalRule", key: "ctrl+shift+enter", group: "blocks", command: f },
+  /* Tables */
+  { id: "table", key: "ctrl+alt+shift+t", group: "tables", request: "insertTable" },
+  { id: "rowAbove", key: "ctrl+alt+shift+arrowup", group: "tables", command: c(!1) },
+  { id: "rowBelow", key: "ctrl+alt+shift+arrowdown", group: "tables", command: c(!0) },
+  { id: "columnLeft", key: "ctrl+alt+shift+arrowleft", group: "tables", request: "insertColumnLeft" },
+  { id: "columnRight", key: "ctrl+alt+shift+arrowright", group: "tables", request: "insertColumnRight" },
+  { id: "deleteRow", key: "ctrl+alt+backspace", group: "tables", command: y },
+  { id: "deleteColumn", key: "ctrl+shift+backspace", group: "tables", command: b },
+  { id: "deleteTable", key: "ctrl+alt+shift+backspace", group: "tables", command: w },
+  { id: "alignLeft", key: "ctrl+alt+l", group: "tables", command: i("left") },
+  { id: "alignCenter", key: "ctrl+alt+c", group: "tables", command: i("center") },
+  { id: "alignRight", key: "ctrl+alt+r", group: "tables", command: i("right") }
+];
+function T(t) {
+  const e = [];
+  (t.ctrlKey || t.metaKey) && e.push("ctrl"), t.altKey && e.push("alt"), t.shiftKey && e.push("shift");
+  const r = e.length ? e.join("+") + "+" : "", a = [r + t.key.toLowerCase()];
+  return t.code && a.push(r + t.code.toLowerCase()), a;
+}
+const q = new Map(R.map((t) => [t.key, t]));
+function B(t) {
+  for (const e of T(t)) {
+    const r = q.get(e);
+    if (r) return r;
+  }
+  return null;
+}
+export {
+  R as HOTKEYS,
+  T as chordsOf,
+  B as hotkeyFor
+};
+//# sourceMappingURL=hotkeys.js.map