@50arms/ui 0.0.0-stage → 35.1.0

package/dist/lib/markdown/input.js

@@ -0,0 +1,210 @@
+import { sourceOffsetAt as E } from "./position.js";
+import { resolveKey as A } from "./keys.js";
+import { hotkeyFor as C } from "./hotkeys.js";
+import { nearestStop as S } from "./caret-map.js";
+import { htmlFragmentToMarkdown as P } from "./paste.js";
+import { sanitizeHref as R } from "../syntax/markdown/render.js";
+const K = /* @__PURE__ */ new Set([
+  "insertText",
+  "insertReplacementText",
+  "insertFromPaste",
+  "insertFromPasteAsQuotation",
+  "insertFromDrop",
+  "insertFromYank",
+  "insertTranspose",
+  "insertLink"
+]), I = /* @__PURE__ */ new Set([
+  "deleteContent",
+  "deleteContentBackward",
+  "deleteContentForward",
+  "deleteWordBackward",
+  "deleteWordForward",
+  "deleteSoftLineBackward",
+  "deleteSoftLineForward",
+  "deleteEntireSoftLine",
+  "deleteHardLineBackward",
+  "deleteHardLineForward",
+  "deleteByDrag",
+  "deleteByCut"
+]);
+function Y(t, r = {}) {
+  const o = t.root, n = (e) => {
+    const a = e.inputType;
+    if (!e.cancelable) return;
+    if (a === "historyUndo") {
+      e.preventDefault(), t.undo();
+      return;
+    }
+    if (a === "historyRedo") {
+      e.preventDefault(), t.redo();
+      return;
+    }
+    const d = O(o, e) ?? M(t);
+    if (!d) return;
+    const c = t.getSelection(), u = c !== null && c.anchor === c.head ? c : null, p = (h, D, b = u ?? { anchor: d.start, head: d.end }) => {
+      const k = A(
+        { source: t.getSource(), projection: t.getProjection(), map: t.getCaretMap() },
+        b,
+        h
+      );
+      return k ? (t.apply(k.splice, k.select, D), !0) : !1;
+    };
+    if (K.has(a)) {
+      e.preventDefault();
+      const h = H(e);
+      if (h === null) {
+        r.onUnhandled?.(a);
+        return;
+      }
+      p({ kind: "insert", text: h }, "type");
+      return;
+    }
+    if (I.has(a)) {
+      e.preventDefault(), p(
+        { kind: a === "deleteContentBackward" || a === "deleteWordBackward" ? "backspace" : "delete" },
+        "delete",
+        (a === "deleteContentBackward" || a === "deleteContentForward" || a === "deleteContent") && u ? u : { anchor: d.start, head: d.end }
+      );
+      return;
+    }
+    if (a === "insertParagraph" || a === "insertLineBreak") {
+      e.preventDefault(), p({ kind: a === "insertParagraph" ? "enter" : "lineBreak" }, "type");
+      return;
+    }
+    e.preventDefault(), r.onUnhandled?.(a);
+  }, i = /* @__PURE__ */ new Set([
+    "ArrowLeft",
+    "ArrowRight",
+    "ArrowUp",
+    "ArrowDown",
+    "Home",
+    "End",
+    "PageUp",
+    "PageDown"
+  ]), s = () => t.breakUndoGroup(), f = (e) => {
+    if (!e.ctrlKey && !e.metaKey) return;
+    const c = e.target?.closest?.("[data-md-href]")?.getAttribute("data-md-href");
+    if (!c) return;
+    const u = R(c);
+    u && (e.preventDefault(), o.ownerDocument.defaultView?.open(u, "_blank", "noopener,noreferrer"));
+  }, l = (e) => {
+    const a = C(e);
+    if (a?.request) {
+      r.onRequest && (e.preventDefault(), r.onRequest(a.request));
+      return;
+    }
+    if (a?.command) {
+      const u = t.getSelection(), p = u ? a.command(t.getSource(), u) : null;
+      p && (e.preventDefault(), t.breakUndoGroup(), t.apply(p.splice, p.select, "other"));
+      return;
+    }
+    if (i.has(e.key)) {
+      t.breakUndoGroup(), (e.key === "ArrowLeft" || e.key === "ArrowRight") && !e.ctrlKey && !e.altKey && !e.metaKey ? t.moveCaret(e.key === "ArrowRight" ? 1 : -1, e.shiftKey) && e.preventDefault() : (e.key === "Home" || e.key === "End") && !e.ctrlKey && !e.altKey && !e.metaKey && t.moveToLineEdge(e.key === "Home" ? "start" : "end", e.shiftKey) && e.preventDefault();
+      return;
+    }
+    const d = e.ctrlKey || e.metaKey, c = e.key.toLowerCase();
+    if (d && c === "z" && !e.shiftKey) {
+      e.preventDefault(), t.undo();
+      return;
+    }
+    d && (c === "z" && e.shiftKey || c === "y") && (e.preventDefault(), t.redo());
+  }, m = o.ownerDocument, g = () => {
+    const a = m.getSelection()?.anchorNode;
+    !a || !o.contains(a) || t.snapCaret();
+  }, y = r.files ? x(t, r.files) : () => {
+  };
+  return o.addEventListener("beforeinput", n), o.addEventListener("pointerdown", s), o.addEventListener("click", f), o.addEventListener("keydown", l), m.addEventListener("selectionchange", g), () => {
+    y(), o.removeEventListener("beforeinput", n), o.removeEventListener("pointerdown", s), o.removeEventListener("click", f), o.removeEventListener("keydown", l), m.removeEventListener("selectionchange", g);
+  };
+}
+const L = "data-md-drop-target";
+function T(t, r) {
+  return t ? Array.from(t.files).filter((o) => r(o.type)) : [];
+}
+function F(t, r) {
+  return t ? Array.from(t.items).some((o) => o.kind === "file" && r(o.type)) : !1;
+}
+function B(t, r) {
+  const o = new Set(r.map((i) => i.name)), n = t.split(/\r?\n/).map((i) => i.trim()).filter(Boolean);
+  return n.length > 0 && n.every((i) => o.has(i) || o.has(i.split(/[\\/]/).pop() ?? ""));
+}
+function w(t) {
+  return !!t && Array.from(t.types).includes("Files");
+}
+function N(t, r, o) {
+  const n = t.root.ownerDocument;
+  let i = null, s = 0;
+  if (typeof n.caretPositionFromPoint == "function") {
+    const l = n.caretPositionFromPoint(r, o);
+    l && (i = l.offsetNode, s = l.offset);
+  } else if (typeof n.caretRangeFromPoint == "function") {
+    const l = n.caretRangeFromPoint(r, o);
+    l && (i = l.startContainer, s = l.startOffset);
+  }
+  if (!i || !t.root.contains(i)) return null;
+  const f = E(t.root, i, s);
+  return f === null ? null : S(t.getCaretMap(), f);
+}
+function x(t, { accepts: r, receive: o }) {
+  const n = t.root;
+  let i = 0;
+  const s = (e) => {
+    e ? n.setAttribute(L, "") : n.removeAttribute(L);
+  }, f = (e) => {
+    if (!n.isContentEditable) return;
+    const a = e.clipboardData, d = T(a, r);
+    if (!d.length) return;
+    const c = a.getData("text/plain");
+    c.length && !B(c, d) || (e.preventDefault(), o(d, t.getSelection()));
+  }, l = (e) => {
+    !n.isContentEditable || !w(e.dataTransfer) || (i++, s(F(e.dataTransfer, r)));
+  }, m = (e) => {
+    !n.isContentEditable || !w(e.dataTransfer) || (e.preventDefault(), e.dataTransfer.dropEffect = F(e.dataTransfer, r) ? "copy" : "none");
+  }, g = (e) => {
+    w(e.dataTransfer) && (i = Math.max(0, i - 1), i === 0 && s(!1));
+  }, y = (e) => {
+    if (!n.isContentEditable || !w(e.dataTransfer)) return;
+    e.preventDefault(), i = 0, s(!1);
+    const a = T(e.dataTransfer, r);
+    if (!a.length) return;
+    const d = N(t, e.clientX, e.clientY);
+    o(a, d === null ? null : { anchor: d, head: d });
+  };
+  return n.addEventListener("paste", f), n.addEventListener("dragenter", l), n.addEventListener("dragover", m), n.addEventListener("dragleave", g), n.addEventListener("drop", y), () => {
+    n.removeEventListener("paste", f), n.removeEventListener("dragenter", l), n.removeEventListener("dragover", m), n.removeEventListener("dragleave", g), n.removeEventListener("drop", y), s(!1);
+  };
+}
+function O(t, r) {
+  const o = typeof r.getTargetRanges == "function" ? r.getTargetRanges() : [];
+  if (!o.length) return null;
+  let n = Number.POSITIVE_INFINITY, i = Number.NEGATIVE_INFINITY;
+  for (const s of o) {
+    const f = E(t, s.startContainer, s.startOffset), l = E(t, s.endContainer, s.endOffset);
+    if (f === null || l === null) return null;
+    n = Math.min(n, f, l), i = Math.max(i, f, l);
+  }
+  return Number.isFinite(n) ? { start: n, end: i } : null;
+}
+function M(t) {
+  const r = t.getSelection();
+  return r ? { start: Math.min(r.anchor, r.head), end: Math.max(r.anchor, r.head) } : null;
+}
+function H(t) {
+  if (typeof t.data == "string") return t.data;
+  const r = t.dataTransfer;
+  if (!r) return null;
+  const o = r.getData("text/plain"), n = r.getData("text/html");
+  if (n && n.trim().length) {
+    const i = P(
+      n,
+      (s) => new DOMParser().parseFromString(s, "text/html")
+    );
+    if (i && i !== o) return i;
+  }
+  return o.length ? o : null;
+}
+export {
+  L as DROP_TARGET_ATTR,
+  Y as attachInput
+};
+//# sourceMappingURL=input.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"input.js","sources":["../../../src/lib/markdown/input.ts"],"sourcesContent":["/* ============================================================================\n   INPUT — `beforeinput`, never `keydown`; intents, never keystrokes.\n\n   THE SINGLE CHOICE THIS FILE IS ABOUT. Most text entry is not a key press.\n   Android's keyboard sends no meaningful `keydown` at all — `keyCode` is 229\n   for everything — and swipe typing inserts a whole word at once. Paste,\n   drag-and-drop and autofill have no keystroke. Dictation, the emoji picker,\n   autocorrect and spellcheck \"replace with\" all arrive as `beforeinput` with no\n   key. An editor whose handler is keydown-shaped is wrong on every one of them,\n   the first time a real person uses it.\n\n   `beforeinput` reports the INTENT — `insertText`, `deleteContentBackward`,\n   `insertFromPaste`, `historyUndo` — uniformly, for every source, and it is\n   cancellable. There are 44 inputType values across insert, delete, format and\n   history; every one is a case to handle or to deliberately fall through.\n\n   THREE RULES THAT ARE NOT NEGOTIABLE.\n\n   1. BIND NATIVELY, NEVER React's `onBeforeInput`. React's synthetic event is\n      not the native one: no `inputType`, no `getTargetRanges()`. It works in\n      desktop Chrome and silently loses every autocorrect, dictation and IME\n      path — which makes it the cheapest catastrophic mistake available here,\n      and there is a source sweep against it.\n\n   2. USE `getTargetRanges()`, NOT THE SELECTION. For a backspace the browser\n      has already worked out what one \"character\" means — a grapheme cluster, a\n      flag emoji, a Hangul syllable — and the answer is in the target range.\n      Recomputing it from the selection is how an editor eats half an emoji.\n\n   3. CANCEL WHAT IS CANCELLABLE, INCLUDING WHAT WE DO NOT HANDLE. An\n      unhandled `formatBold` left to the browser wraps the selection in a `<b>`\n      the projection has no idea about. Cancelling and ignoring is a no-op;\n      letting it through is a DOM this editor can no longer map.\n\n   WHAT CANNOT BE CANCELLED falls to the surface's mutation-observation repair,\n   and that is a requirement rather than a safety net: Chrome on Android reports\n   `cancelable: true` on `deleteContentBackward` and deletes anyway,\n   `insertCompositionText` is non-cancelable by spec, and iOS dictation fires no\n   composition events at all.\n   ========================================================================= */\n\nimport { sourceOffsetAt, type SourceSelection } from \"./position\";\nimport { resolveKey, type KeyIntent } from \"./keys\";\nimport type { EditKind } from \"./history\";\nimport { hotkeyFor, type EditorRequest } from \"./hotkeys\";\nimport { nearestStop } from \"./caret-map\";\nimport { htmlFragmentToMarkdown } from \"./paste\";\nimport { sanitizeHref } from \"../syntax/markdown/render\";\nimport type { MarkdownSurface } from \"./surface\";\n\n/** Insert intents whose payload is `data` or the DataTransfer's plain text. */\nconst INSERTS = new Set([\n  \"insertText\",\n  \"insertReplacementText\",\n  \"insertFromPaste\",\n  \"insertFromPasteAsQuotation\",\n  \"insertFromDrop\",\n  \"insertFromYank\",\n  \"insertTranspose\",\n  \"insertLink\",\n]);\n\n/** Delete intents. The extent always comes from `getTargetRanges()`. */\nconst DELETES = new Set([\n  \"deleteContent\",\n  \"deleteContentBackward\",\n  \"deleteContentForward\",\n  \"deleteWordBackward\",\n  \"deleteWordForward\",\n  \"deleteSoftLineBackward\",\n  \"deleteSoftLineForward\",\n  \"deleteEntireSoftLine\",\n  \"deleteHardLineBackward\",\n  \"deleteHardLineForward\",\n  \"deleteByDrag\",\n  \"deleteByCut\",\n]);\n\nexport interface InputOptions {\n  /**\n   * Called for an intent this layer cancelled but did not act on.\n   *\n   * Not a warning to be silenced — it is the list of what phase 4 owes. An\n   * editor that quietly ignores `formatBold` looks like one where Ctrl+B is\n   * broken, and this is how that gets noticed before a user reports it.\n   */\n  onUnhandled?: (inputType: string) => void;\n  /**\n   * Receives the files of a paste or a drop, and where they go (DX-3134, DXUI-74).\n   *\n   * `accepts` says from a MIME type alone whether the editor takes that file (a drag only exposes the type, never\n   * the file, until it is dropped). `receive` gets the accepted files and `at`: the caret for a paste and the drop\n   * point for a drop, already on a caret stop. Without this option files are not handled here at all, and a paste\n   * or drop behaves exactly as it always did.\n   */\n  files?: {\n    accepts: (mimeType: string) => boolean;\n    receive: (files: File[], at: SourceSelection | null) => void;\n  };\n  /**\n   * Receives a hotkey that asks the EDITOR to do something rather than making\n   * an edit — the Attach-file chord opening a file picker (DX-3134). A\n   * request with no receiver lets the key fall through, like a command that\n   * declined.\n   */\n  onRequest?: (request: EditorRequest) => void;\n}\n\n/**\n * Binds the input layer to a surface. Returns the unbind function.\n */\nexport function attachInput(surface: MarkdownSurface, options: InputOptions = {}): () => void {\n  const root = surface.root;\n\n  const onBeforeInput = (event: InputEvent) => {\n    const type = event.inputType;\n\n    /* Not cancellable: let the DOM change and let the surface repair from it.\n       This is the Android and IME path, and it is the majority path there. */\n    if (!event.cancelable) return;\n\n    if (type === \"historyUndo\") {\n      event.preventDefault();\n      surface.undo();\n      return;\n    }\n    if (type === \"historyRedo\") {\n      event.preventDefault();\n      surface.redo();\n      return;\n    }\n\n    const target = targetRange(root, event) ?? selectionRange(surface);\n    if (!target) return;\n\n    /* EVERY DECISION BELOW BELONGS TO `keys.ts`, and this function's whole job\n       is to say which intent arrived. That split is what lets the keystroke\n       tests drive the real logic without a DOM — before it, the only way to\n       assert \"Backspace here produces exactly this markdown\" was to\n       re-implement this dispatch in the test and assert against the copy. */\n    /* A COLLAPSED CARET IS THE MODEL'S TO LOCATE, not the browser's.\n       `getTargetRanges()` and the raw DOM selection both report a position in\n       the tree, and a caret stop can have no text node of its own — the place\n       after the marker of an empty list item is inside a zero-width span, so the\n       surface writes it into the newline before it and the browser reads back an\n       offset one group away. Typing then landed BEFORE the marker and turned\n       `- one\\n- ` into `- one\\ntwo- `. `getSelection()` puts it back through the\n       same map that produced it. A real range is still the browser's. */\n    const caret = surface.getSelection();\n    const collapsed = caret !== null && caret.anchor === caret.head ? caret : null;\n\n    const press = (intent: KeyIntent, kind: EditKind, over = collapsed ?? { anchor: target.start, head: target.end }): boolean => {\n      const edit = resolveKey(\n        { source: surface.getSource(), projection: surface.getProjection(), map: surface.getCaretMap() },\n        over,\n        intent,\n      );\n      if (!edit) return false;\n      surface.apply(edit.splice, edit.select, kind);\n      return true;\n    };\n\n    if (INSERTS.has(type)) {\n      event.preventDefault();\n      const text = insertedText(event);\n      if (text === null) {\n        options.onUnhandled?.(type);\n        return;\n      }\n      press({ kind: \"insert\", text }, \"type\");\n      return;\n    }\n\n    if (DELETES.has(type)) {\n      event.preventDefault();\n      /* THE SELECTION DECIDES WHETHER THIS IS A CARET OR A RANGE, not the\n         target range — and that inverts rule 2 of this file's header for the\n         one-character deletes.\n\n         `getTargetRanges()` answers \"what would the browser delete\", and for a\n         collapsed caret it answers with the previous SOURCE character, which\n         under always-hidden markup is routinely one asterisk of a `**` or the\n         newline above a list item. Reading that as a range made every backspace\n         at a construct's edge a no-op: a one-character range over pure markup\n         holds nothing visible to delete. The probe caught it as thirteen\n         constructs where the key did nothing at all.\n\n         The browser's extent is still exactly right for a real selection, and\n         still right for word- and line-wise deletes, where it knows where a\n         word ends and we do not. What it cannot know is what one VISIBLE\n         character means here, so that case is ours. */\n      const backward = type === \"deleteContentBackward\" || type === \"deleteWordBackward\";\n      /* Word- and line-wise deletes keep the browser's extent: it knows where a\n         word ends and this layer does not. Only the one-character deletes are\n         ours, because only they depend on what one VISIBLE character means. */\n      const single = type === \"deleteContentBackward\" || type === \"deleteContentForward\" || type === \"deleteContent\";\n      press(\n        { kind: backward ? \"backspace\" : \"delete\" },\n        \"delete\",\n        single && collapsed ? collapsed : { anchor: target.start, head: target.end },\n      );\n      return;\n    }\n\n    if (type === \"insertParagraph\" || type === \"insertLineBreak\") {\n      event.preventDefault();\n      press({ kind: type === \"insertParagraph\" ? \"enter\" : \"lineBreak\" }, \"type\");\n      return;\n    }\n\n    /* Everything else — the sixteen `format*` intents above all. Cancelled so\n       the browser cannot put markup into the projection, and reported so the\n       gap is visible rather than mysterious. */\n    event.preventDefault();\n    options.onUnhandled?.(type);\n  };\n\n  /* An edit after the caret was deliberately moved is a different thought, so\n     it starts a new undo group however soon it arrives. This is the coalescing\n     rule a timer cannot express, and it is bound to the two things that\n     actually move a caret on purpose — a click and a navigation key.\n     Not `selectionchange`: that also fires for the surface's OWN caret\n     restore after every edit, which would break the group on every keystroke\n     and leave undo giving text back one character at a time. */\n  const NAVIGATION = new Set([\n    \"ArrowLeft\",\n    \"ArrowRight\",\n    \"ArrowUp\",\n    \"ArrowDown\",\n    \"Home\",\n    \"End\",\n    \"PageUp\",\n    \"PageDown\",\n  ]);\n  const onPointerDown = () => surface.breakUndoGroup();\n\n  /**\n   * A modifier-click opens a link.\n   *\n   * Links render as SPANS, not anchors — an anchor inside a contenteditable is\n   * a trap: the browser gives it its own selection behaviour, some engines make\n   * it draggable, and a plain click navigates away from the document being\n   * edited. So the appearance is a class and the behaviour is this, which means\n   * a plain click still puts the caret in the link's text where an author needs\n   * it, and Ctrl (or Cmd) opens.\n   *\n   * `noopener` is not optional: without it the opened page gets a handle on\n   * this one through `window.opener` and can navigate it anywhere.\n   */\n  const onClick = (event: MouseEvent) => {\n    if (!event.ctrlKey && !event.metaKey) return;\n    const target = event.target as HTMLElement | null;\n    const anchor = target?.closest?.(\"[data-md-href]\");\n    const href = anchor?.getAttribute(\"data-md-href\");\n    if (!href) return;\n    const safe = sanitizeHref(href);\n    if (!safe) return;\n    event.preventDefault();\n    // I18N-ALLOW: window.open target and feature tokens\n    root.ownerDocument.defaultView?.open(safe, \"_blank\", \"noopener,noreferrer\");\n  };\n  const onKeyDown = (event: KeyboardEvent) => {\n    /* THE TABLE IS CONSULTED FIRST, because four of its chords ARE arrow keys —\n       `ctrl+alt+shift+ArrowUp` inserts a table row. Letting the navigation\n       branch below claim every arrow would have made those four silently\n       inert, which is the shape of bug nobody reports because nobody knew the\n       key existed. */\n    const hotkey = hotkeyFor(event);\n    if (hotkey?.request) {\n      if (options.onRequest) {\n        event.preventDefault();\n        options.onRequest(hotkey.request);\n      }\n      return;\n    }\n    if (hotkey?.command) {\n      const selection = surface.getSelection();\n      const edit = selection ? hotkey.command(surface.getSource(), selection) : null;\n      if (edit) {\n        event.preventDefault();\n        /* Every authoring command is its own undo step: merging \"make this a\n           heading\" into the typing before it means one Ctrl+Z takes back both. */\n        surface.breakUndoGroup();\n        surface.apply(edit.splice, edit.select, \"other\");\n      }\n      /* A command that DECLINED lets the key fall through, which is what makes\n         Tab leave the editor everywhere except inside a list. */\n      return;\n    }\n\n    if (NAVIGATION.has(event.key)) {\n      surface.breakUndoGroup();\n      /* HORIZONTAL MOVEMENT AND LINE-EDGE MOVEMENT ARE OURS; vertical and\n         word-wise movement are the browser's. The split is not arbitrary: one\n         source offset can be two DOM points — the end of one node and the\n         start of the next — and across a table-cell boundary the browser\n         visits both, so a plain Right appears to stall. Rule 1 of the caret\n         contract says Left moves back exactly one character always, and the\n         only way to mean that is to move in the model. Ctrl/Alt variants fall\n         through, because word-wise (and, for Home/End, whole-document)\n         movement depends on layout and locale and reimplementing it is how\n         editors lose a decade.\n\n         Home/End used to be on the browser's side of this split too, on the\n         theory that they are as native as vertical movement. SG-799 found\n         that theory wrong: a block's leading markup renders as a zero-size\n         `inline-block` (`styles/markdown.css`), which is an ATOMIC box to\n         Chromium's own line navigation, and a real Chromium probe caught\n         native End landing the browser's selection INSIDE that leading box —\n         the same on-screen point the caret already stood at — instead of at\n         the line's true end, on every block with a leading marker. Home had\n         the identical exposure and simply hadn't been caught: `lineStartStop`\n         already existed in `caret-map.ts` for it and was never called from\n         here. Both are now computed in the model and written directly, same\n         as ArrowLeft/ArrowRight already were. */\n      if ((event.key === \"ArrowLeft\" || event.key === \"ArrowRight\") && !event.ctrlKey && !event.altKey && !event.metaKey) {\n        if (surface.moveCaret(event.key === \"ArrowRight\" ? 1 : -1, event.shiftKey)) event.preventDefault();\n      } else if ((event.key === \"Home\" || event.key === \"End\") && !event.ctrlKey && !event.altKey && !event.metaKey) {\n        if (surface.moveToLineEdge(event.key === \"Home\" ? \"start\" : \"end\", event.shiftKey)) event.preventDefault();\n      }\n      return;\n    }\n\n    /* UNDO IS BOUND HERE AS WELL AS AT `historyUndo`, and the browser probe is\n       why. Chrome only fires the `historyUndo` intent when its OWN undo stack\n       has something in it — and this editor cancels every cancellable input, so\n       that stack is permanently empty and Ctrl+Z produced no event at all.\n       Two sources for one intent, not a fallback chain: the keymap is what a\n       keyboard user hits, and `historyUndo` is what arrives from an Edit menu,\n       a trackpad gesture, or a phone's shake-to-undo. Neither covers the other.\n       Both land on the same model-level history. */\n    const accel = event.ctrlKey || event.metaKey;\n    const key = event.key.toLowerCase();\n    if (accel && key === \"z\" && !event.shiftKey) {\n      event.preventDefault();\n      surface.undo();\n      return;\n    }\n    if (accel && ((key === \"z\" && event.shiftKey) || key === \"y\")) {\n      event.preventDefault();\n      surface.redo();\n    }\n  };\n\n  /* THE REVEAL FOLLOWS THE CARET. Rule 2 of the caret contract: markup is\n     revealed for the caret's own line, and the caret moves without the document\n     changing — arrow keys, clicks, drags. `selectionchange` is a DOCUMENT\n     event, never an element one, and it is the only signal for a caret the\n     browser moved on its own.\n\n     It fires for the surface's own caret restore too, which is why this only\n     ever touches ATTRIBUTES: re-projecting here would put a patch on the end of\n     every keystroke, and every patch is a chance to disturb a caret that was\n     already exactly where it belonged. */\n  const document = root.ownerDocument;\n  const onSelectionChange = () => {\n    const selection = document.getSelection();\n    const node = selection?.anchorNode;\n    if (!node || !root.contains(node)) return;\n    surface.snapCaret();\n  };\n\n  const unbindFiles = options.files ? attachFiles(surface, options.files) : () => {};\n\n  root.addEventListener(\"beforeinput\", onBeforeInput as EventListener);\n  root.addEventListener(\"pointerdown\", onPointerDown);\n  root.addEventListener(\"click\", onClick);\n  root.addEventListener(\"keydown\", onKeyDown);\n  document.addEventListener(\"selectionchange\", onSelectionChange);\n  return () => {\n    unbindFiles();\n    root.removeEventListener(\"beforeinput\", onBeforeInput as EventListener);\n    root.removeEventListener(\"pointerdown\", onPointerDown);\n    root.removeEventListener(\"click\", onClick);\n    root.removeEventListener(\"keydown\", onKeyDown);\n    document.removeEventListener(\"selectionchange\", onSelectionChange);\n  };\n}\n\n/* --- Files: paste and drop ------------------------------------------------- */\n\n/** Marks the surface while files it takes are dragged over it, for the affordance. */\nexport const DROP_TARGET_ATTR = \"data-md-drop-target\";\n\n/** The files a DataTransfer carries that `accepts` takes, in the order it lists them. */\nfunction acceptedFilesOf(transfer: DataTransfer | null, accepts: (mimeType: string) => boolean): File[] {\n  if (!transfer) return [];\n  return Array.from(transfer.files).filter((file) => accepts(file.type));\n}\n\n/**\n * Whether a drag carries at least one file `accepts` takes.\n *\n * Read from `items`, not `files`: during `dragenter`/`dragover` the browser\n * keeps the files themselves protected and `files` is empty, while each item's\n * `kind` and MIME `type` are already readable.\n */\nfunction dragHasAccepted(transfer: DataTransfer | null, accepts: (mimeType: string) => boolean): boolean {\n  if (!transfer) return false;\n  return Array.from(transfer.items).some((item) => item.kind === \"file\" && accepts(item.type));\n}\n\n/**\n * Whether a clipboard's plain text is nothing but the NAMES of its files.\n *\n * Copying a file in a desktop file manager (Finder does this) puts the file on\n * the clipboard AND its name as plain text. That text is a label for the file,\n * not content the author wrote — pasting \"photo.png\" instead of the photo is\n * the wrong reading of it. Anything more than the names, and text wins as\n * usual.\n */\nfunction namesOnly(plain: string, files: readonly File[]): boolean {\n  const names = new Set(files.map((file) => file.name));\n  const lines = plain.split(/\\r?\\n/).map((line) => line.trim()).filter(Boolean);\n  return lines.length > 0 && lines.every((line) => names.has(line) || names.has(line.split(/[\\\\/]/).pop() ?? \"\"));\n}\n\n/** Whether a drag carries files at all — of any kind. */\nfunction dragHasFiles(transfer: DataTransfer | null): boolean {\n  return !!transfer && Array.from(transfer.types).includes(\"Files\");\n}\n\n/**\n * The source offset under a viewport point, snapped to a caret stop — where a\n * drop lands.\n *\n * `caretPositionFromPoint` is the standard and `caretRangeFromPoint` the\n * WebKit spelling of the same question; Safari shipped only the latter until\n * 2024, so both are asked for by feature detection, never as a fallback for a\n * wrong answer. A point that resolves outside this surface returns null.\n */\nfunction offsetAtPoint(surface: MarkdownSurface, x: number, y: number): number | null {\n  const doc = surface.root.ownerDocument as Document & {\n    caretPositionFromPoint?: (x: number, y: number) => { offsetNode: Node; offset: number } | null;\n    caretRangeFromPoint?: (x: number, y: number) => Range | null;\n  };\n  let node: Node | null = null;\n  let offset = 0;\n  if (typeof doc.caretPositionFromPoint === \"function\") {\n    const position = doc.caretPositionFromPoint(x, y);\n    if (position) {\n      node = position.offsetNode;\n      offset = position.offset;\n    }\n  } else if (typeof doc.caretRangeFromPoint === \"function\") {\n    const range = doc.caretRangeFromPoint(x, y);\n    if (range) {\n      node = range.startContainer;\n      offset = range.startOffset;\n    }\n  }\n  if (!node || !surface.root.contains(node)) return null;\n  const at = sourceOffsetAt(surface.root, node, offset);\n  return at === null ? null : nearestStop(surface.getCaretMap(), at);\n}\n\n/**\n * Binds paste and drop of FILES. Returns the unbind function.\n *\n * NATIVE `paste` / `drop` EVENTS, NOT `beforeinput`, and that is not a\n * contradiction of this file's header. `beforeinput` carries intents that have\n * TEXT; whether a browser fires `insertFromPaste` at all for a clipboard\n * holding only a file — and whether its `dataTransfer` exposes the file — is\n * not something the spec pins down. `ClipboardEvent.clipboardData` and\n * `DragEvent.dataTransfer` are where every engine puts the files, and\n * cancelling either event cancels the `beforeinput` that would follow, so one\n * gesture can never be inserted twice. Before DX-3134 a file-only paste reached\n * `beforeinput`, was cancelled there, found no text, and vanished.\n *\n * TEXT WINS WHEN THERE IS TEXT. Copying from a word processor or a spreadsheet\n * puts plain text, HTML AND a picture of the selection on the clipboard; the\n * author meant the text, and that paste must behave exactly as it did before.\n * Files are taken only when the clipboard has no plain text — a screenshot, or\n * \"Copy image\" in a browser — or when its text is just the files' own names\n * (a file copied in a file manager; see `namesOnly`).\n *\n * A DROP IS THE OTHER WAY ROUND, deliberately: a drag carrying files is always\n * the files, because no application drags a file and means its text.\n */\nfunction attachFiles(surface: MarkdownSurface, { accepts, receive }: NonNullable<InputOptions[\"files\"]>): () => void {\n  const root = surface.root;\n  /* Enter and leave fire for every CHILD the pointer crosses, so a boolean\n     would flicker off at the first inline element. A depth counter reads true\n     for as long as the pointer is anywhere inside. */\n  let depth = 0;\n  const setTarget = (on: boolean) => {\n    if (on) root.setAttribute(DROP_TARGET_ATTR, \"\");\n    else root.removeAttribute(DROP_TARGET_ATTR);\n  };\n\n  const onPaste = (event: ClipboardEvent) => {\n    if (!root.isContentEditable) return;\n    const transfer = event.clipboardData;\n    const files = acceptedFilesOf(transfer, accepts);\n    if (!files.length) return;\n    const plain = transfer!.getData(\"text/plain\");\n    if (plain.length && !namesOnly(plain, files)) return;\n    event.preventDefault();\n    receive(files, surface.getSelection());\n  };\n\n  const onDragEnter = (event: DragEvent) => {\n    if (!root.isContentEditable || !dragHasFiles(event.dataTransfer)) return;\n    depth++;\n    setTarget(dragHasAccepted(event.dataTransfer, accepts));\n  };\n\n  const onDragOver = (event: DragEvent) => {\n    if (!root.isContentEditable || !dragHasFiles(event.dataTransfer)) return;\n    /* A FILE DRAG IS ALWAYS OURS once it is over the surface, images or not.\n       Left to the browser, a file dropped on a page may be OPENED — the tab\n       navigates to it and takes the unsaved document with it. Accepting the\n       drag here is what stops that; the drop below ignores what is not\n       accepted. A TEXT drag has no \"Files\" type and never reaches this line, so\n       moving text around the document works exactly as it did. */\n    event.preventDefault();\n    event.dataTransfer!.dropEffect = dragHasAccepted(event.dataTransfer, accepts) ? \"copy\" : \"none\";\n  };\n\n  const onDragLeave = (event: DragEvent) => {\n    if (!dragHasFiles(event.dataTransfer)) return;\n    depth = Math.max(0, depth - 1);\n    if (depth === 0) setTarget(false);\n  };\n\n  const onDrop = (event: DragEvent) => {\n    if (!root.isContentEditable || !dragHasFiles(event.dataTransfer)) return;\n    event.preventDefault();\n    depth = 0;\n    setTarget(false);\n    const files = acceptedFilesOf(event.dataTransfer, accepts);\n    if (!files.length) return;\n    const at = offsetAtPoint(surface, event.clientX, event.clientY);\n    receive(files, at === null ? null : { anchor: at, head: at });\n  };\n\n  root.addEventListener(\"paste\", onPaste);\n  root.addEventListener(\"dragenter\", onDragEnter);\n  root.addEventListener(\"dragover\", onDragOver);\n  root.addEventListener(\"dragleave\", onDragLeave);\n  root.addEventListener(\"drop\", onDrop);\n  return () => {\n    root.removeEventListener(\"paste\", onPaste);\n    root.removeEventListener(\"dragenter\", onDragEnter);\n    root.removeEventListener(\"dragover\", onDragOver);\n    root.removeEventListener(\"dragleave\", onDragLeave);\n    root.removeEventListener(\"drop\", onDrop);\n    setTarget(false);\n  };\n}\n\n/* --- Ranges --------------------------------------------------------------- */\n\ninterface Extent {\n  start: number;\n  end: number;\n}\n\n/**\n * The source extent the browser says it intends to change.\n *\n * Returns null when the ranges point into nodes this editor did not build —\n * which happens for real, mid-composition and after a drop — so the caller\n * falls back to the selection rather than acting on a guessed number.\n */\nfunction targetRange(root: HTMLElement, event: InputEvent): Extent | null {\n  const ranges = typeof event.getTargetRanges === \"function\" ? event.getTargetRanges() : [];\n  if (!ranges.length) return null;\n\n  let start = Number.POSITIVE_INFINITY;\n  let end = Number.NEGATIVE_INFINITY;\n  for (const range of ranges) {\n    const from = sourceOffsetAt(root, range.startContainer, range.startOffset);\n    const to = sourceOffsetAt(root, range.endContainer, range.endOffset);\n    if (from === null || to === null) return null;\n    start = Math.min(start, from, to);\n    end = Math.max(end, from, to);\n  }\n  return Number.isFinite(start) ? { start, end } : null;\n}\n\nfunction selectionRange(surface: MarkdownSurface): Extent | null {\n  const selection: SourceSelection | null = surface.getSelection();\n  if (!selection) return null;\n  return { start: Math.min(selection.anchor, selection.head), end: Math.max(selection.anchor, selection.head) };\n}\n\n/**\n * The text an insert intent carries.\n *\n * `data` for typing; the DataTransfer for paste and drop.\n *\n * RICH HTML BECOMES MARKDOWN, and this is the ONLY place in the editor where an\n * HTML-to-markdown conversion happens. ARCH-1 struck the document-wide one and\n * that stands: a document serializer runs on every edit over text the user did\n * not touch, which is what reformats a whole file because someone fixed a typo.\n * This runs once, on bytes from outside the document, at the user's request.\n *\n * PLAIN TEXT WINS WHEN IT IS ALL THERE IS, and also when the HTML is just the\n * plain text wrapped in a `<div>` — which is what a plain-text copy looks like\n * from most applications, and converting it would escape characters the user\n * typed deliberately.\n */\nfunction insertedText(event: InputEvent): string | null {\n  if (typeof event.data === \"string\") return event.data;\n  const transfer = event.dataTransfer;\n  if (!transfer) return null;\n\n  const plain = transfer.getData(\"text/plain\");\n  const html = transfer.getData(\"text/html\");\n  if (html && html.trim().length) {\n    const markdown = htmlFragmentToMarkdown(html, (source) =>\n      new DOMParser().parseFromString(source, \"text/html\"),\n    );\n    /* If the conversion produced the plain text back, prefer the plain text:\n       it carries no escapes, and the two agreeing means there was no markup to\n       preserve in the first place. */\n    if (markdown && markdown !== plain) return markdown;\n  }\n  return plain.length ? plain : null;\n}\n"],"names":["INSERTS","DELETES","attachInput","surface","options","root","onBeforeInput","event","type","target","targetRange","selectionRange","caret","collapsed","press","intent","kind","over","edit","resolveKey","text","insertedText","NAVIGATION","onPointerDown","onClick","href","safe","sanitizeHref","onKeyDown","hotkey","hotkeyFor","selection","accel","key","document","onSelectionChange","node","unbindFiles","attachFiles","DROP_TARGET_ATTR","acceptedFilesOf","transfer","accepts","file","dragHasAccepted","item","namesOnly","plain","files","names","lines","line","dragHasFiles","offsetAtPoint","x","y","doc","offset","position","range","at","sourceOffsetAt","nearestStop","receive","depth","setTarget","on","onPaste","onDragEnter","onDragOver","onDragLeave","onDrop","ranges","start","end","from","to","html","markdown","htmlFragmentToMarkdown","source"],"mappings":"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"}

package/dist/lib/markdown/keys.js

@@ -0,0 +1,37 @@
+import { smartShiftTab as p, smartTab as u, smartEnter as h, backspaceBlockPrefix as f } from "./commands.js";
+import { deleteVisible as c, deleteVisibleAfter as d, deleteVisibleBefore as m } from "./edit.js";
+const l = (e) => ({
+  start: Math.min(e.anchor, e.head),
+  end: Math.max(e.anchor, e.head)
+}), o = (e, a, n) => ({
+  splice: { start: e, end: a, text: n },
+  select: { anchor: e + n.length, head: e + n.length }
+});
+function j(e, a, n) {
+  const { start: r, end: s } = l(a), t = r === s;
+  switch (n.kind) {
+    case "insert":
+      return o(r, s, n.text);
+    case "backspace": {
+      if (!t) return c(e.projection, r, s);
+      const i = f(e.source, a);
+      return i || m(e.projection, e.map, r);
+    }
+    case "delete":
+      return t ? d(e.projection, e.map, r) : c(e.projection, r, s);
+    case "enter":
+      return h(e.source, a) ?? o(r, s, `
+`);
+    case "lineBreak":
+      return o(r, s, `
+`);
+    case "tab":
+      return u(e.source, a);
+    case "shiftTab":
+      return p(e.source, a);
+  }
+}
+export {
+  j as resolveKey
+};
+//# sourceMappingURL=keys.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"keys.js","sources":["../../../src/lib/markdown/keys.ts"],"sourcesContent":["/* ============================================================================\n   KEYS — what a keystroke does to the source, as a pure function.\n\n   WHY THIS IS ITS OWN MODULE. The behaviour a user actually notices is\n   \"I pressed Backspace and the document became this\", and until now that\n   sentence had nowhere to live: the decisions were spread across the\n   `beforeinput` handler, so the only way to test them was to drive a real DOM,\n   and the only way to test them CHEAPLY was to re-implement the dispatch in the\n   test — which tests a copy of the logic rather than the logic.\n\n   So the dispatch moved here, and `input.ts` became the adapter that turns a\n   browser event into one of these intents. The tests drive exactly the code the\n   editor runs, with no DOM and no duplication.\n\n   THE INTENTS ARE NOT KEYSTROKES. `input.ts` still binds `beforeinput` and\n   still reads `inputType`, for all the reasons its own header gives — Android\n   sends no meaningful keydown, dictation and paste have no key at all. What\n   arrives here is the intent that survived that translation, which is why\n   `insert` carries text rather than a key name.\n   ========================================================================= */\n\nimport type { CaretMap } from \"./caret-map\";\nimport { backspaceBlockPrefix, smartEnter, smartShiftTab, smartTab } from \"./commands\";\nimport { deleteVisible, deleteVisibleAfter, deleteVisibleBefore, type Edit } from \"./edit\";\nimport type { SourceSelection } from \"./position\";\nimport type { Projection } from \"./project\";\n\nexport type KeyIntent =\n  | { kind: \"insert\"; text: string }\n  | { kind: \"backspace\" }\n  | { kind: \"delete\" }\n  | { kind: \"enter\" }\n  | { kind: \"lineBreak\" }\n  | { kind: \"tab\" }\n  | { kind: \"shiftTab\" };\n\n/** Everything a decision needs, and nothing it does not. */\nexport interface KeyContext {\n  source: string;\n  projection: Projection;\n  map: CaretMap;\n}\n\nconst span = (selection: SourceSelection) => ({\n  start: Math.min(selection.anchor, selection.head),\n  end: Math.max(selection.anchor, selection.head),\n});\n\n/** A plain splice, with the caret left where the inserted text ends. */\nconst plain = (start: number, end: number, text: string): Edit => ({\n  splice: { start, end, text },\n  select: { anchor: start + text.length, head: start + text.length },\n});\n\n/**\n * The edit a keystroke produces, or null to let the caller decline the key.\n *\n * Null is a real answer and not a failure: Tab outside a list declines so focus\n * can leave the editor, which is what makes the WCAG 2.1.2 keyboard trap not\n * happen in the first place.\n */\nexport function resolveKey(ctx: KeyContext, selection: SourceSelection, intent: KeyIntent): Edit | null {\n  const { start, end } = span(selection);\n  const collapsed = start === end;\n\n  switch (intent.kind) {\n    case \"insert\":\n      return plain(start, end, intent.text);\n\n    case \"backspace\": {\n      if (!collapsed) return deleteVisible(ctx.projection, start, end);\n      /* THE BLOCK RULE COMES FIRST, and it has to: at a block's content start\n         the previous visible character is the newline above, so the fallback\n         would merge a list item into the line before it and print its marker\n         as prose. This is the only way to remove markup that is never shown. */\n      const prefix = backspaceBlockPrefix(ctx.source, selection);\n      if (prefix) return prefix;\n      return deleteVisibleBefore(ctx.projection, ctx.map, start);\n    }\n\n    case \"delete\": {\n      if (!collapsed) return deleteVisible(ctx.projection, start, end);\n      return deleteVisibleAfter(ctx.projection, ctx.map, start);\n    }\n\n    case \"enter\":\n      return smartEnter(ctx.source, selection) ?? plain(start, end, \"\\n\");\n\n    case \"lineBreak\":\n      /* Shift+Enter means \"a line break, not a new block\", so it stays literal\n         while plain Enter carries the block structure onto the next line. */\n      return plain(start, end, \"\\n\");\n\n    case \"tab\":\n      return smartTab(ctx.source, selection);\n\n    case \"shiftTab\":\n      return smartShiftTab(ctx.source, selection);\n  }\n}\n"],"names":["span","selection","plain","start","end","text","resolveKey","ctx","intent","collapsed","deleteVisible","prefix","backspaceBlockPrefix","deleteVisibleBefore","deleteVisibleAfter","smartEnter","smartTab","smartShiftTab"],"mappings":";;AA2CA,MAAMA,IAAO,CAACC,OAAgC;AAAA,EAC5C,OAAO,KAAK,IAAIA,EAAU,QAAQA,EAAU,IAAI;AAAA,EAChD,KAAK,KAAK,IAAIA,EAAU,QAAQA,EAAU,IAAI;AAChD,IAGMC,IAAQ,CAACC,GAAeC,GAAaC,OAAwB;AAAA,EACjE,QAAQ,EAAE,OAAAF,GAAO,KAAAC,GAAK,MAAAC,EAAA;AAAA,EACtB,QAAQ,EAAE,QAAQF,IAAQE,EAAK,QAAQ,MAAMF,IAAQE,EAAK,OAAA;AAC5D;AASO,SAASC,EAAWC,GAAiBN,GAA4BO,GAAgC;AACtG,QAAM,EAAE,OAAAL,GAAO,KAAAC,MAAQJ,EAAKC,CAAS,GAC/BQ,IAAYN,MAAUC;AAE5B,UAAQI,EAAO,MAAA;AAAA,IACb,KAAK;AACH,aAAON,EAAMC,GAAOC,GAAKI,EAAO,IAAI;AAAA,IAEtC,KAAK,aAAa;AAChB,UAAI,CAACC,EAAW,QAAOC,EAAcH,EAAI,YAAYJ,GAAOC,CAAG;AAK/D,YAAMO,IAASC,EAAqBL,EAAI,QAAQN,CAAS;AACzD,aAAIU,KACGE,EAAoBN,EAAI,YAAYA,EAAI,KAAKJ,CAAK;AAAA,IAC3D;AAAA,IAEA,KAAK;AACH,aAAKM,IACEK,EAAmBP,EAAI,YAAYA,EAAI,KAAKJ,CAAK,IADjCO,EAAcH,EAAI,YAAYJ,GAAOC,CAAG;AAAA,IAIjE,KAAK;AACH,aAAOW,EAAWR,EAAI,QAAQN,CAAS,KAAKC,EAAMC,GAAOC,GAAK;AAAA,CAAI;AAAA,IAEpE,KAAK;AAGH,aAAOF,EAAMC,GAAOC,GAAK;AAAA,CAAI;AAAA,IAE/B,KAAK;AACH,aAAOY,EAAST,EAAI,QAAQN,CAAS;AAAA,IAEvC,KAAK;AACH,aAAOgB,EAAcV,EAAI,QAAQN,CAAS;AAAA,EAAA;AAEhD;"}

package/dist/lib/markdown/paste.js

@@ -0,0 +1,180 @@
+function p(n) {
+  return n.replace(/([\\`*_[\]<>])/g, "\\$1");
+}
+function u(n, t) {
+  return n.getAttribute(t) ?? "";
+}
+function w(n, t) {
+  const r = t(n).body;
+  return r ? i(r, "").trim().replace(/\n{3,}/g, `
+
+`) : "";
+}
+function i(n, t) {
+  let e = "";
+  for (let r = n.firstChild; r; r = r.nextSibling) e += d(r, t);
+  return e;
+}
+function d(n, t) {
+  if (n.nodeType === 3)
+    return p(n.data.replace(/\s+/g, " "));
+  if (n.nodeType !== 1) return "";
+  const e = n, r = e.tagName.toLowerCase(), s = () => i(e, t);
+  switch (r) {
+    case "br":
+      return `
+`;
+    case "hr":
+      return `
+
+---
+
+`;
+    case "p":
+    case "div":
+      return `
+
+${s()}
+
+`;
+    case "h1":
+    case "h2":
+    case "h3":
+    case "h4":
+    case "h5":
+    case "h6":
+      return `
+
+${"#".repeat(Number(r[1]))} ${s()}
+
+`;
+    /* AN INLINE TAG WRAPPING BLOCKS IS A CONTAINER, not emphasis. Google Docs
+       puts the entire clipboard payload inside
+       `<b style="font-weight:normal" id="docs-internal-guid-…">`, and taking
+       that literally bolds the whole paste and puts the markers on their own
+       lines around it. If it holds a paragraph, it is not a mark. */
+    case "strong":
+    case "b":
+      return h(e) ? s() : `**${s()}**`;
+    case "em":
+    case "i":
+      return h(e) ? s() : `*${s()}*`;
+    case "del":
+    case "s":
+    case "strike":
+      return h(e) ? s() : `~~${s()}~~`;
+    case "code":
+      return e.parentElement?.tagName.toLowerCase() === "pre" ? e.textContent ?? "" : g(e.textContent ?? "");
+    case "pre":
+      return `
+
+\`\`\`
+${(e.textContent ?? "").replace(/\n+$/, "")}
+\`\`\`
+
+`;
+    case "blockquote":
+      return `
+
+${i(e, t).trim().replace(/\n{3,}/g, `
+
+`).split(`
+`).map((o) => `> ${o}`).join(`
+`)}
+
+`;
+    case "a": {
+      const o = u(e, "href"), c = s();
+      return o ? `[${c}](${o})` : c;
+    }
+    case "img": {
+      const o = u(e, "src"), c = u(e, "alt");
+      return o ? `![${c}](${o})` : "";
+    }
+    case "ul":
+    case "ol":
+      return `
+
+${b(e, t, r === "ol")}
+
+`;
+    case "li":
+      return `
+${t}- ${s().trim()}`;
+    case "table":
+      return `
+
+${y(e)}
+
+`;
+    case "script":
+    case "style":
+    case "head":
+      return "";
+    case "span":
+      return m(e, s());
+    default:
+      return s();
+  }
+}
+function m(n, t) {
+  const e = u(n, "style").toLowerCase();
+  if (!e) return t;
+  let r = t;
+  /text-decoration[^;]*line-through/.test(e) && (r = `~~${r}~~`), /font-style\s*:\s*italic/.test(e) && (r = `*${r}*`);
+  const s = /font-weight\s*:\s*([a-z0-9]+)/.exec(e);
+  if (s) {
+    const o = s[1];
+    (o === "bold" || o === "bolder" || Number(o) >= 600) && (r = `**${r}**`);
+  }
+  return r;
+}
+const $ = /* @__PURE__ */ new Set(["p", "div", "h1", "h2", "h3", "h4", "h5", "h6", "ul", "ol", "li", "table", "blockquote", "pre", "hr"]);
+function h(n) {
+  for (let t = n.firstChild; t; t = t.nextSibling)
+    if (t.nodeType === 1 && $.has(t.tagName.toLowerCase())) return !0;
+  return !1;
+}
+function g(n) {
+  const t = (n.match(/`+/g) ?? []).reduce((s, o) => Math.max(s, o.length), 0), e = "`".repeat(t + 1), r = n.startsWith("`") || n.endsWith("`") ? " " : "";
+  return `${e}${r}${n}${r}${e}`;
+}
+function b(n, t, e) {
+  const r = [];
+  let s = Number(n.getAttribute("start") ?? "1") || 1;
+  for (let o = n.firstChild; o; o = o.nextSibling) {
+    if (o.nodeType !== 1 || o.tagName.toLowerCase() !== "li") continue;
+    const c = e ? `${s++}. ` : "- ", l = t + " ".repeat(c.length), a = i(o, "").trim().replace(/\n{2,}/g, `
+`);
+    r.push(`${t}${c}${a.split(`
+`).join(`
+${l}`)}`);
+  }
+  return r.join(`
+`);
+}
+function y(n) {
+  const t = [];
+  for (const l of Array.from(n.querySelectorAll("tr"))) {
+    const a = Array.from(l.querySelectorAll("th, td")).map(
+      (f) => (
+        /* A pipe inside a cell would end the cell, and a newline would end the
+           row — both have to go, and there is no escape for the second. */
+        i(f, "").replace(/\|/g, "\\|").replace(/\s*\n\s*/g, " ").trim()
+      )
+    );
+    a.length && t.push(a);
+  }
+  if (!t.length) return "";
+  const e = Math.max(...t.map((l) => l.length)), r = (l) => {
+    const a = l.slice(0, e);
+    for (; a.length < e; ) a.push("");
+    return `| ${a.join(" | ")} |`;
+  }, s = n.querySelector("th") !== null, o = s ? t[0] : Array.from({ length: e }, () => ""), c = s ? t.slice(1) : t;
+  return [r(o), `| ${Array.from({ length: e }, () => "---").join(" | ")} |`, ...c.map(r)].join(`
+`);
+}
+export {
+  w as htmlFragmentToMarkdown
+};
+//# sourceMappingURL=paste.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"paste.js","sources":["../../../src/lib/markdown/paste.ts"],"sourcesContent":["/* ============================================================================\n   PASTE — the ONE place HTML becomes markdown, and it is a fragment.\n\n   ARCH-1 struck the document-wide `htmlToMarkdown` — 407 lines, the largest new\n   module on NEXT-4's mapping — because a DOM-to-markdown leg is lossy by nature\n   and every serializer disaster in the research belongs to it. That decision\n   stands and this does not weaken it. The difference is total:\n\n     - A document serializer runs on EVERY EDIT, over text the user did not\n       touch. That is what reformats a whole file because someone fixed a typo,\n       and it is what made Obsidian's version-control users revolt.\n     - This runs ONCE, on bytes that came from OUTSIDE the document, at the\n       user's explicit request. There is no \"unchanged region\" to preserve\n       because none of it was ever in the document.\n\n   Pasting rich HTML as its literal source would be worse than either. So the\n   conversion exists, scoped as tightly as it can be, and it is allowed to be\n   imperfect in a way the document model is not.\n\n   WHAT IS DELIBERATELY NOT HERE: any dependency on the projection, the surface\n   or the DOM the editor owns. It takes an HTML string, parses it in an inert\n   document, and returns markdown.\n   ========================================================================= */\n\n/** Characters that would change a document's meaning if pasted raw. */\nfunction escapeText(text: string): string {\n  /* Only the characters that START something. Escaping every punctuation mark\n     is what makes pasted prose unreadable in source view, and CommonMark only\n     gives these meaning at a position where they could open a construct. */\n  return text.replace(/([\\\\`*_[\\]<>])/g, \"\\\\$1\");\n}\n\nfunction attr(element: Element, name: string): string {\n  return element.getAttribute(name) ?? \"\";\n}\n\n/**\n * Converts one pasted HTML fragment to markdown.\n *\n * `parser` is injected so this stays testable and so it never reaches for a\n * global — the editor passes its own document, and a test passes whatever it\n * has. A module that grabs `window` is a module that cannot be tested without\n * one.\n */\nexport function htmlFragmentToMarkdown(html: string, parse: (html: string) => Document): string {\n  const document = parse(html);\n  const body = document.body;\n  if (!body) return \"\";\n  const out = convertChildren(body, \"\").trim();\n  /* Collapse runs of three or more newlines: nested block elements each add\n     their own separation, and the result is never meant to be a blank page. */\n  return out.replace(/\\n{3,}/g, \"\\n\\n\");\n}\n\nfunction convertChildren(node: Node, indent: string): string {\n  let out = \"\";\n  for (let child = node.firstChild; child; child = child.nextSibling) out += convert(child, indent);\n  return out;\n}\n\nfunction convert(node: Node, indent: string): string {\n  if (node.nodeType === 3) {\n    /* Whitespace between block elements is layout, not content — HTML collapses\n       it and so must this, or every paste arrives with the source's own\n       indentation baked into the prose. */\n    return escapeText((node as Text).data.replace(/\\s+/g, \" \"));\n  }\n  if (node.nodeType !== 1) return \"\";\n\n  const element = node as Element;\n  const tag = element.tagName.toLowerCase();\n  const inner = () => convertChildren(element, indent);\n\n  switch (tag) {\n    case \"br\":\n      return \"\\n\";\n    case \"hr\":\n      return \"\\n\\n---\\n\\n\";\n    case \"p\":\n    case \"div\":\n      return `\\n\\n${inner()}\\n\\n`;\n    case \"h1\":\n    case \"h2\":\n    case \"h3\":\n    case \"h4\":\n    case \"h5\":\n    case \"h6\":\n      return `\\n\\n${\"#\".repeat(Number(tag[1]))} ${inner()}\\n\\n`;\n    /* AN INLINE TAG WRAPPING BLOCKS IS A CONTAINER, not emphasis. Google Docs\n       puts the entire clipboard payload inside\n       `<b style=\"font-weight:normal\" id=\"docs-internal-guid-…\">`, and taking\n       that literally bolds the whole paste and puts the markers on their own\n       lines around it. If it holds a paragraph, it is not a mark. */\n    case \"strong\":\n    case \"b\":\n      return wrapsBlocks(element) ? inner() : `**${inner()}**`;\n    case \"em\":\n    case \"i\":\n      return wrapsBlocks(element) ? inner() : `*${inner()}*`;\n    case \"del\":\n    case \"s\":\n    case \"strike\":\n      return wrapsBlocks(element) ? inner() : `~~${inner()}~~`;\n    case \"code\":\n      /* Inside a `<pre>` the parent handles the fence; a bare `<code>` is a\n         span. Backticks in the content need a longer fence, which is the one\n         piece of CommonMark subtlety worth honouring here. */\n      if (element.parentElement?.tagName.toLowerCase() === \"pre\") return element.textContent ?? \"\";\n      return spanCode(element.textContent ?? \"\");\n    case \"pre\": {\n      const text = element.textContent ?? \"\";\n      return `\\n\\n\\`\\`\\`\\n${text.replace(/\\n+$/, \"\")}\\n\\`\\`\\`\\n\\n`;\n    }\n    case \"blockquote\":\n      return `\\n\\n${convertChildren(element, indent)\n        .trim()\n        /* Collapsed BEFORE prefixing: each inner block contributes its own\n           blank lines, and prefixing first turns three of them into three\n           `> ` lines — which is a quote with holes in it. */\n        .replace(/\\n{3,}/g, \"\\n\\n\")\n        .split(\"\\n\")\n        .map((line) => `> ${line}`)\n        .join(\"\\n\")}\\n\\n`;\n    case \"a\": {\n      const href = attr(element, \"href\");\n      const label = inner();\n      return href ? `[${label}](${href})` : label;\n    }\n    case \"img\": {\n      const src = attr(element, \"src\");\n      const alt = attr(element, \"alt\");\n      return src ? `![${alt}](${src})` : \"\";\n    }\n    case \"ul\":\n    case \"ol\":\n      return `\\n\\n${listItems(element, indent, tag === \"ol\")}\\n\\n`;\n    case \"li\":\n      /* Reached only for a stray `<li>` outside a list; the list case handles\n         the normal one, because only it knows the numbering. */\n      return `\\n${indent}- ${inner().trim()}`;\n    case \"table\":\n      return `\\n\\n${convertTable(element)}\\n\\n`;\n    case \"script\":\n    case \"style\":\n    case \"head\":\n      /* Never their text. A pasted `<style>` block would arrive as a paragraph\n         of CSS, which is the least useful possible reading of it. */\n      return \"\";\n    case \"span\":\n      /* GOOGLE DOCS AND WORD DO NOT EMIT `<strong>`. Docs spells bold as\n         `<span style=\"font-weight:700\">` and italic as `font-style:italic`, so\n         reading only the semantic tags loses every mark in a paste from the two\n         applications people paste from most. This is a heuristic and it is the\n         standard one; it fires only on an explicit inline style. */\n      return styled(element, inner());\n    default:\n      return inner();\n  }\n}\n\n/** Marks a span carries as inline CSS rather than as tags. */\nfunction styled(element: Element, inner: string): string {\n  const style = attr(element, \"style\").toLowerCase();\n  if (!style) return inner;\n  let out = inner;\n  if (/text-decoration[^;]*line-through/.test(style)) out = `~~${out}~~`;\n  if (/font-style\\s*:\\s*italic/.test(style)) out = `*${out}*`;\n  /* `font-weight: normal` is how Docs marks its OWN wrapper as not-bold, so a\n     numeric threshold is not enough on its own — the keyword has to lose. */\n  const weight = /font-weight\\s*:\\s*([a-z0-9]+)/.exec(style);\n  if (weight) {\n    const value = weight[1];\n    const bold = value === \"bold\" || value === \"bolder\" || Number(value) >= 600;\n    if (bold) out = `**${out}**`;\n  }\n  return out;\n}\n\nconst BLOCK_TAGS = new Set([\"p\", \"div\", \"h1\", \"h2\", \"h3\", \"h4\", \"h5\", \"h6\", \"ul\", \"ol\", \"li\", \"table\", \"blockquote\", \"pre\", \"hr\"]);\n\n/** Whether an inline tag is really being used as a container. */\nfunction wrapsBlocks(element: Element): boolean {\n  for (let child = element.firstChild; child; child = child.nextSibling) {\n    if (child.nodeType === 1 && BLOCK_TAGS.has((child as Element).tagName.toLowerCase())) return true;\n  }\n  return false;\n}\n\nfunction spanCode(text: string): string {\n  const longest = (text.match(/`+/g) ?? []).reduce((max, run) => Math.max(max, run.length), 0);\n  const fence = \"`\".repeat(longest + 1);\n  const pad = text.startsWith(\"`\") || text.endsWith(\"`\") ? \" \" : \"\";\n  return `${fence}${pad}${text}${pad}${fence}`;\n}\n\nfunction listItems(list: Element, indent: string, ordered: boolean): string {\n  const items: string[] = [];\n  let index = Number(list.getAttribute(\"start\") ?? \"1\") || 1;\n  for (let child = list.firstChild; child; child = child.nextSibling) {\n    if (child.nodeType !== 1 || (child as Element).tagName.toLowerCase() !== \"li\") continue;\n    const marker = ordered ? `${index++}. ` : \"- \";\n    const nested = indent + \" \".repeat(marker.length);\n    /* Converted at NO indent, then indented once by the join below. Passing\n       `nested` down as well double-indents every nested list — a two-level list\n       came out four spaces deep, which markdown reads as a code block. */\n    const body = convertChildren(child as Element, \"\").trim().replace(/\\n{2,}/g, \"\\n\");\n    /* Continuation lines line up under the marker, which is what makes a nested\n       list a nested list rather than a new one. */\n    items.push(`${indent}${marker}${body.split(\"\\n\").join(`\\n${nested}`)}`);\n  }\n  return items.join(\"\\n\");\n}\n\nfunction convertTable(table: Element): string {\n  const rows: string[][] = [];\n  for (const row of Array.from(table.querySelectorAll(\"tr\"))) {\n    const cells = Array.from(row.querySelectorAll(\"th, td\")).map((cell) =>\n      /* A pipe inside a cell would end the cell, and a newline would end the\n         row — both have to go, and there is no escape for the second. */\n      convertChildren(cell, \"\").replace(/\\|/g, \"\\\\|\").replace(/\\s*\\n\\s*/g, \" \").trim(),\n    );\n    if (cells.length) rows.push(cells);\n  }\n  if (!rows.length) return \"\";\n\n  const width = Math.max(...rows.map((row) => row.length));\n  const pad = (row: string[]) => {\n    const copy = row.slice(0, width);\n    while (copy.length < width) copy.push(\"\");\n    return `| ${copy.join(\" | \")} |`;\n  };\n  const hasHeader = table.querySelector(\"th\") !== null;\n  const header = hasHeader ? rows[0] : Array.from({ length: width }, () => \"\");\n  const body = hasHeader ? rows.slice(1) : rows;\n  return [pad(header), `| ${Array.from({ length: width }, () => \"---\").join(\" | \")} |`, ...body.map(pad)].join(\"\\n\");\n}\n"],"names":["escapeText","text","attr","element","name","htmlFragmentToMarkdown","html","parse","body","convertChildren","node","indent","out","child","convert","tag","inner","wrapsBlocks","spanCode","line","href","label","src","alt","listItems","convertTable","styled","style","weight","value","BLOCK_TAGS","longest","max","run","fence","pad","list","ordered","items","index","marker","nested","table","rows","row","cells","cell","width","copy","hasHeader","header"],"mappings":"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"}