@50arms/ui 0.0.0-stage → 35.2.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"hotkeys.js","sources":["../../../src/lib/markdown/hotkeys.ts"],"sourcesContent":["/* ============================================================================\n   THE HOTKEY TABLE — data, not code.\n\n   Ported from danx-ui's `hotkeyDefinitions`, which is the point: it is the\n   accumulated result of somebody using their editor, and re-deriving a keymap\n   from first principles would throw that away to arrive somewhere worse. What\n   changed is the OTHER side of each row — every action is now a pure command\n   over the source string rather than a call into a DOM-mutating composable, so\n   the whole table is testable without a browser.\n\n   TWO ROWS ARE MISSING, deliberately: highlight and underline. Neither is\n   CommonMark or GFM, and this parser is strict about that (see ./commands.ts\n   for the argument). A key that writes characters the renderer shows as literal\n   text is worse than a key that does nothing.\n\n   HELP IS PART OF THE CONTRACT, not a nicety. WCAG 2.1.2's advisement clause is\n   normative: an editor may own Tab, but an UNDOCUMENTED escape is a failure\n   even when the escape exists. `id` (whose description the provider holds) and\n   `group` are what the help surface renders, so a key that cannot be described\n   cannot be added.\n   ========================================================================= */\n\nimport {\n  adjustHeading,\n  alignColumn,\n  deleteColumn,\n  deleteRow,\n  deleteTable,\n  insertLink,\n  insertRow,\n  insertRule,\n  setHeading,\n  smartShiftTab,\n  smartTab,\n  toggleBold,\n  toggleCode,\n  toggleCodeBlock,\n  toggleItalic,\n  toggleList,\n  toggleQuote,\n  toggleStrike,\n  toggleTask,\n  type Command,\n} from \"./commands\";\n\nexport type HotkeyGroup = \"formatting\" | \"headings\" | \"lists\" | \"blocks\" | \"tables\";\n\n/**\n * What a row does, in the words of no language: the help surface looks the row's\n * description up under this id in the active `UiLocaleProvider`'s strings\n * (`markdownEditor.hotkeys`), so the table holds chords and commands only.\n */\nexport type HotkeyId =\n  | \"bold\" | \"italic\" | \"inlineCode\" | \"strikethrough\" | \"link\" | \"attachFile\"\n  | \"paragraph\" | \"heading1\" | \"heading2\" | \"heading3\" | \"heading4\" | \"heading5\" | \"heading6\"\n  | \"decreaseHeading\" | \"increaseHeading\"\n  | \"bulletList\" | \"numberedList\" | \"taskCheckbox\" | \"indent\" | \"outdent\"\n  | \"codeBlock\" | \"blockquote\" | \"horizontalRule\"\n  | \"table\" | \"rowAbove\" | \"rowBelow\" | \"columnLeft\" | \"columnRight\" | \"deleteRow\" | \"deleteColumn\" | \"deleteTable\"\n  | \"alignLeft\" | \"alignCenter\" | \"alignRight\";\n\n/**\n * Something only the editor itself can do, because it is not a function of the\n * source (DX-3134).\n *\n * Attaching a file means choosing it first, which needs a file picker —\n * a browser dialog, not a splice. The row that used to insert an empty `![]()`\n * (a construct with nothing to show, which rendered as nothing) now asks the\n * editor for the picker instead, and the chosen files go through the same\n * pipeline as a paste or a drop.\n */\nexport type EditorRequest = \"pickFiles\" | \"insertTable\" | \"insertColumnLeft\" | \"insertColumnRight\";\n\ninterface HotkeyBase {\n  id: HotkeyId;\n  /**\n   * The chord this matches: lower-case, modifiers first, in the order ctrl,\n   * alt, shift.\n   *\n   * PUNCTUATION IS SPELLED BY PHYSICAL KEY (`bracketleft`, `comma`), not by the\n   * character it produces. The browser probe found why: with Shift held, the\n   * `[` key reports `event.key === \"{\"`, so a table keyed on `[` never matched\n   * and Ctrl+Shift+[ was silently inert. `event.code` is the same regardless of\n   * which character the modifier produced.\n   */\n  key: string;\n  group: HotkeyGroup;\n}\n\n/** A chord, and EITHER the pure edit it makes OR the editor request it raises. */\ntype HotkeyAction = { command: Command; request?: never } | { request: EditorRequest; command?: never };\nexport type Hotkey = HotkeyBase & HotkeyAction;\n\nexport const HOTKEYS: readonly Hotkey[] = [\n  /* Inline formatting */\n  { id: \"bold\", key: \"ctrl+b\", group: \"formatting\", command: toggleBold },\n  { id: \"italic\", key: \"ctrl+i\", group: \"formatting\", command: toggleItalic },\n  { id: \"inlineCode\", key: \"ctrl+e\", group: \"formatting\", command: toggleCode },\n  { id: \"strikethrough\", key: \"ctrl+shift+s\", group: \"formatting\", command: toggleStrike },\n  { id: \"link\", key: \"ctrl+k\", group: \"formatting\", command: insertLink() },\n  { id: \"attachFile\", key: \"ctrl+shift+i\", group: \"formatting\", request: \"pickFiles\" },\n\n  /* Headings */\n  { id: \"paragraph\", key: \"ctrl+0\", group: \"headings\", command: setHeading(0) },\n  { id: \"heading1\", key: \"ctrl+1\", group: \"headings\", command: setHeading(1) },\n  { id: \"heading2\", key: \"ctrl+2\", group: \"headings\", command: setHeading(2) },\n  { id: \"heading3\", key: \"ctrl+3\", group: \"headings\", command: setHeading(3) },\n  { id: \"heading4\", key: \"ctrl+4\", group: \"headings\", command: setHeading(4) },\n  { id: \"heading5\", key: \"ctrl+5\", group: \"headings\", command: setHeading(5) },\n  { id: \"heading6\", key: \"ctrl+6\", group: \"headings\", command: setHeading(6) },\n  { id: \"decreaseHeading\", key: \"ctrl+shift+comma\", group: \"headings\", command: adjustHeading(-1) },\n  { id: \"increaseHeading\", key: \"ctrl+shift+period\", group: \"headings\", command: adjustHeading(1) },\n\n  /* Lists */\n  { id: \"bulletList\", key: \"ctrl+shift+bracketleft\", group: \"lists\", command: toggleList(false) },\n  { id: \"numberedList\", key: \"ctrl+shift+bracketright\", group: \"lists\", command: toggleList(true) },\n  { id: \"taskCheckbox\", key: \"ctrl+shift+x\", group: \"lists\", command: toggleTask },\n  // 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\n  { id: \"indent\", key: \"tab\", group: \"lists\", command: smartTab },\n  { id: \"outdent\", key: \"shift+tab\", group: \"lists\", command: smartShiftTab },\n\n  /* Blocks */\n  { id: \"codeBlock\", key: \"ctrl+shift+k\", group: \"blocks\", command: toggleCodeBlock() },\n  { id: \"blockquote\", key: \"ctrl+shift+q\", group: \"blocks\", command: toggleQuote },\n  { id: \"horizontalRule\", key: \"ctrl+shift+enter\", group: \"blocks\", command: insertRule },\n\n  /* Tables */\n  { id: \"table\", key: \"ctrl+alt+shift+t\", group: \"tables\", request: \"insertTable\" },\n  { id: \"rowAbove\", key: \"ctrl+alt+shift+arrowup\", group: \"tables\", command: insertRow(false) },\n  { id: \"rowBelow\", key: \"ctrl+alt+shift+arrowdown\", group: \"tables\", command: insertRow(true) },\n  { id: \"columnLeft\", key: \"ctrl+alt+shift+arrowleft\", group: \"tables\", request: \"insertColumnLeft\" },\n  { id: \"columnRight\", key: \"ctrl+alt+shift+arrowright\", group: \"tables\", request: \"insertColumnRight\" },\n  { id: \"deleteRow\", key: \"ctrl+alt+backspace\", group: \"tables\", command: deleteRow },\n  { id: \"deleteColumn\", key: \"ctrl+shift+backspace\", group: \"tables\", command: deleteColumn },\n  { id: \"deleteTable\", key: \"ctrl+alt+shift+backspace\", group: \"tables\", command: deleteTable },\n  { id: \"alignLeft\", key: \"ctrl+alt+l\", group: \"tables\", command: alignColumn(\"left\") },\n  { id: \"alignCenter\", key: \"ctrl+alt+c\", group: \"tables\", command: alignColumn(\"center\") },\n  { id: \"alignRight\", key: \"ctrl+alt+r\", group: \"tables\", command: alignColumn(\"right\") },\n];\n\n/**\n * The chords a key event could be, most specific first.\n *\n * TWO SPELLINGS, because neither alone is enough. The CHARACTER spelling is\n * what a letter or digit chord needs — Ctrl+B is the letter B whatever key\n * produced it. The PHYSICAL spelling is what punctuation needs: with Shift\n * held, the `[` key reports `event.key === \"{\"`, so a table keyed on the\n * character never matches and the chord is silently inert. The browser probe\n * found exactly that: Ctrl+Shift+[ did nothing at all, and nothing in the unit\n * suite could have seen it, because the commands themselves were correct.\n *\n * Modifiers in a FIXED order, because `ctrl+shift+s` and `shift+ctrl+s` are the\n * same chord and a table keyed on free-form strings silently misses one of\n * them. `metaKey` folds into `ctrl` so one table serves macOS, where the\n * platform convention is Command for every one of these.\n */\nexport function chordsOf(event: KeyboardEvent): string[] {\n  const parts: string[] = [];\n  // I18N-ALLOW: modifier id of a hotkey chord, matched against the registry\n  if (event.ctrlKey || event.metaKey) parts.push(\"ctrl\");\n  // I18N-ALLOW: modifier id of a hotkey chord, matched against the registry\n  if (event.altKey) parts.push(\"alt\");\n  // I18N-ALLOW: modifier id of a hotkey chord, matched against the registry\n  if (event.shiftKey) parts.push(\"shift\");\n  const prefix = parts.length ? parts.join(\"+\") + \"+\" : \"\";\n  const chords = [prefix + event.key.toLowerCase()];\n  if (event.code) chords.push(prefix + event.code.toLowerCase());\n  return chords;\n}\n\nconst BY_CHORD = new Map(HOTKEYS.map((hotkey) => [hotkey.key, hotkey]));\n\nexport function hotkeyFor(event: KeyboardEvent): Hotkey | null {\n  for (const chord of chordsOf(event)) {\n    const found = BY_CHORD.get(chord);\n    if (found) return found;\n  }\n  return null;\n}\n"],"names":["HOTKEYS","toggleBold","toggleItalic","toggleCode","toggleStrike","insertLink","setHeading","adjustHeading","toggleList","toggleTask","smartTab","smartShiftTab","toggleCodeBlock","toggleQuote","insertRule","insertRow","deleteRow","deleteColumn","deleteTable","alignColumn","chordsOf","event","parts","prefix","chords","BY_CHORD","hotkey","hotkeyFor","chord","found"],"mappings":"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"}

package/dist/lib/markdown/image-pipeline.js

@@ -0,0 +1,236 @@
+import { nearestStop as y } from "./caret-map.js";
+import { nextReferenceNumber as k } from "./attachments.js";
+import { referenceMarkdown as U, enclosingCode as E, findUnstoredImages as L, markdownDestination as R, reshapeForCodeBoundary as S, isUnstoredImageSrc as M, sanitizeImageSrc as F } from "./images.js";
+import { sanitizeHref as P } from "../syntax/markdown/render.js";
+const b = 300;
+function j(c) {
+  const t = (c instanceof Error ? c.message : void 0)?.trim();
+  if (t)
+    return t.length > b ? `${t.slice(0, b - 1)}…` : t;
+}
+const I = {
+  createObjectURL: (c) => URL.createObjectURL(c),
+  revokeObjectURL: (c) => URL.revokeObjectURL(c),
+  preload: (c) => {
+    const e = new Image();
+    return e.src = c, e.decode();
+  },
+  preloadTimeoutMs: 1e4
+};
+class A {
+  constructor(e) {
+    this.options = e, this.env = { ...I, ...e.environment };
+  }
+  options;
+  surface = null;
+  entries = /* @__PURE__ */ new Map();
+  /** Where each stored URL came from: the object URL that held its place in the document until its upload finished. */
+  origins = /* @__PURE__ */ new Map();
+  env;
+  last = null;
+  revision = 0;
+  disposed = !1;
+  /**
+   * What the strip knows about an object URL this editor minted, or null for
+   * anything else. An arrow property so it can be handed around before the
+   * surface exists.
+   */
+  resolve = (e) => {
+    const t = this.entries.get(e.trim());
+    return t ? { file: t.file, state: t.state, message: t.message } : null;
+  };
+  /**
+   * A name for a file that does not change when its upload finishes: the object URL it was first written under,
+   * or the URL itself for a file that was never swapped. A tile keyed or opened on it survives the swap.
+   */
+  identity = (e) => {
+    const t = e.trim();
+    return this.origins.get(t) ?? t;
+  };
+  /** Whether a file of this MIME type is a picture `uploadImage` stores. */
+  isPicture(e) {
+    if (!e.startsWith("image/")) return !1;
+    const t = this.options.imageTypes();
+    return t === void 0 || t.includes(e);
+  }
+  /**
+   * Whether the editor takes a file of this MIME type: a picture it stores, or any file once `uploadFile` is set.
+   * Read by paste, drop and the picker, so all three agree.
+   */
+  accepts = (e) => this.isPicture(e) || this.options.uploadFile() !== null;
+  /** Connects the surface this pipeline edits, and reports the first snapshot. */
+  attach(e) {
+    this.surface = e, this.sync();
+  }
+  /**
+   * THE pipeline: every file that enters the editor comes through here -
+   * paste, drop and the file picker alike.
+   *
+   * `at` is where the references go: the caret for a paste or a pick, the drop
+   * point for a drop. With none (an editor that was never focused), they go at
+   * the end of the document - never at offset 0 in front of whatever the
+   * author wrote first. A file the editor does not take (`accepts`) is ignored;
+   * the picker's `accept` is a hint the user can override, not a guarantee.
+   *
+   * Returns the object URLs it inserted, in order.
+   */
+  insert(e, t) {
+    const r = this.requireSurface(), s = e.filter((l) => this.accepts(l.type));
+    if (!s.length) return [];
+    const i = s.map((l) => {
+      const o = this.isPicture(l.type), p = this.env.createObjectURL(l), v = o ? this.options.uploadImage() : this.options.uploadFile();
+      return this.entries.set(p, { file: l, picture: o, state: v ? "uploading" : "local", controller: null }), p;
+    }), a = r.getSource(), u = k(a, { isFileUrl: this.options.isFileUrl() });
+    let n = "";
+    s.forEach((l, o) => {
+      const p = `${this.options.kindWord(l)} ${u + o}`, v = this.entries.get(i[o]).picture ? "image" : "link";
+      n += (n ? " " : "") + U(v, i[o], p);
+    });
+    const f = t ?? r.getSelection() ?? { anchor: a.length, head: a.length }, g = r.getCaretMap();
+    let d = y(g, Math.min(f.anchor, f.head)), m = y(g, Math.max(f.anchor, f.head));
+    const h = E(r.getProjection(), d);
+    if (h && (d = m = y(g, h.end), h.block && (n = S(a, d, n))), !h?.block) {
+      const l = r.getProjection().frames.filter((o) => o.frame.kind === "image" || o.frame.kind === "link");
+      l.some((o) => o.end === d) ? n = ` ${n}` : !h && d > 0 && !/[\s(\[{]/.test(a[d - 1]) && (n = ` ${n}`), l.some((o) => o.start === m) && (n = `${n} `);
+    }
+    const w = d + n.length;
+    r.breakUndoGroup(), r.apply({ start: d, end: m, text: n }, { anchor: w, head: w }, "other"), r.breakUndoGroup();
+    for (const l of i) {
+      const o = this.uploaderFor(this.entries.get(l));
+      o && this.upload(l, o);
+    }
+    return this.sync(), i;
+  }
+  /**
+   * Uploads a failed file again, with the SAME File it was inserted with.
+   *
+   * With no uploader configured any more, the file becomes local-only rather
+   * than staying "failed" - the honest state for something nothing can store.
+   */
+  retry(e) {
+    const t = e.trim(), r = this.entries.get(t);
+    if (!r || r.state !== "failed") return;
+    const s = this.uploaderFor(r);
+    s ? this.upload(t, s) : (r.state = "local", r.message = void 0), this.changed();
+  }
+  /**
+   * Starts uploading every local-only file once an uploader exists.
+   *
+   * The component calls this when an uploader changes: a file pasted before an
+   * app's storage provider mounted should not stay unsaveable when the storage
+   * it needed arrives a moment later.
+   */
+  uploaderChanged() {
+    const e = this.requireSurface().getSource();
+    let t = !1;
+    for (const [r, s] of this.entries) {
+      if (s.state !== "local" || !e.includes(r)) continue;
+      const i = this.uploaderFor(s);
+      i && (this.upload(r, i), t = !0);
+    }
+    t && this.changed();
+  }
+  /**
+   * Recomputes the snapshot from the CURRENT document, and releases object
+   * URLs nothing can reach any more. Called after every change to the source.
+   *
+   * THE COUNTS COME FROM `findUnstoredImages`, the same exported function a
+   * consumer's save path calls - one detection source, never a second opinion
+   * the two could disagree on (DX-3134).
+   *
+   * AN OBJECT URL IS RELEASED WHEN ITS FILE IS GONE AND SETTLED: not in the
+   * document, not in any undo or redo entry (Ctrl+Z could bring it back), and
+   * not mid-upload (the upload will swap it wherever it still is). Revoking one
+   * any earlier turns an undo into a broken file; never revoking leaks the
+   * file's bytes for the life of the page.
+   */
+  sync() {
+    const e = this.surface;
+    if (!e || this.disposed) return;
+    const t = e.getSource();
+    for (const [a, u] of this.entries)
+      u.controller || t.includes(a) || e.remembers(a) || this.release(a);
+    const r = L(t), s = {
+      uploading: 0,
+      failed: 0,
+      unstored: r.length,
+      local: 0,
+      revision: this.revision
+    };
+    for (const a of r) {
+      const n = this.entries.get(a.src.trim())?.state ?? "foreign";
+      n === "uploading" ? s.uploading++ : n === "local" ? s.local++ : s.failed++;
+    }
+    const i = this.last;
+    i && i.uploading === s.uploading && i.failed === s.failed && i.unstored === s.unstored && i.local === s.local && i.revision === s.revision || (this.last = s, this.options.onChange(s));
+  }
+  /**
+   * Stops everything: aborts every upload in flight and releases every object
+   * URL. The editor is going away, so nothing it minted can be drawn anywhere
+   * again - no other editor will render another's `blob:`.
+   */
+  dispose() {
+    this.disposed = !0, this.origins.clear();
+    for (const e of [...this.entries.keys()]) this.release(e);
+    this.surface = null;
+  }
+  /* --- Internals ---------------------------------------------------------- */
+  uploaderFor(e) {
+    return e.picture ? this.options.uploadImage() : this.options.uploadFile();
+  }
+  async upload(e, t) {
+    const r = this.entries.get(e);
+    if (!r) return;
+    const s = new AbortController();
+    r.state = "uploading", r.controller = s, r.message = void 0;
+    let i;
+    try {
+      const u = await t(r.file, { signal: s.signal });
+      i = O(u, r.picture);
+    } catch (u) {
+      if (s.signal.aborted) return;
+      r.state = "failed", r.controller = null, r.message = j(u), console.error(`[MarkdownEditor] upload failed for "${r.file.name}":`, u), this.changed();
+      return;
+    }
+    if (r.picture && await this.settled(this.env.preload(i), s.signal), s.signal.aborted || !this.surface) return;
+    r.controller = null;
+    const a = R(i);
+    this.surface.substitute(e, a), this.origins.set(a, e), this.sync();
+  }
+  /**
+   * Resolves when `work` settles, `preloadTimeoutMs` passes, or `signal`
+   * aborts - never rejects. Every timer and listener is cleaned up.
+   */
+  settled(e, t) {
+    return new Promise((r) => {
+      const s = () => {
+        clearTimeout(i), t.removeEventListener("abort", s), r();
+      }, i = setTimeout(s, this.env.preloadTimeoutMs);
+      t.addEventListener("abort", s), e.then(s, s);
+    });
+  }
+  release(e) {
+    const t = this.entries.get(e);
+    t && (t.controller?.abort(), this.entries.delete(e), this.env.revokeObjectURL(e));
+  }
+  /** A file's state moved: re-report, so its tile redraws. */
+  changed() {
+    !this.surface || this.disposed || (this.revision++, this.sync());
+  }
+  requireSurface() {
+    if (!this.surface) throw new Error("ImagePipeline: attach(surface) before using it");
+    return this.surface;
+  }
+}
+function O(c, e) {
+  const t = c?.url;
+  if (typeof t != "string" || !t.trim())
+    throw new Error("the uploader resolved without a `url` string");
+  if (M(t) || !(e ? F(t) : P(t)))
+    throw new Error(`the uploader resolved with a URL a stored file cannot have: ${t.slice(0, 80)}`);
+  return t.trim();
+}
+export {
+  A as ImagePipeline
+};
+//# sourceMappingURL=image-pipeline.js.map

package/dist/lib/markdown/image-pipeline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-pipeline.js","sources":["../../../src/lib/markdown/image-pipeline.ts"],"sourcesContent":["/* ============================================================================\n   THE FILE PIPELINE - one path from a File to a stored, named reference in the document.\n\n   DX-3134, DXUI-74. Three gestures put a file into the editor: pasting one,\n   dropping one, and choosing one with the toolbar's Attach file button (or its\n   chord). They all end here, in `insert`, and nowhere else - PLN-10 R-2's \"one\n   pipeline, no parallel paths\" is the reason there is one method and not three\n   that agree.\n\n   WHAT `insert` DOES, in order:\n     1. mints an object URL for each file, so the reference exists NOW, before a\n        single byte has left the machine;\n     2. writes `![Image 1](blob:...)` (a picture) or `[PDF 2](blob:...)` (any\n        other file) at the caret (or the drop point) as ONE ordinary edit -\n        undoable, like typing it would be;\n     3. hands each file to the consumer's uploader, and on success swaps the\n        object URL for the stored one through `MarkdownSurface.substitute`,\n        which rewrites the document AND its undo history, so no later undo can\n        bring back a URL that no longer means anything.\n\n   THE REGISTRY is the set of object URLs this editor minted, with the File\n   each came from. It is what the attachment strip reads for a tile's picture\n   and state, and what makes Retry possible: the original File is kept until\n   the file is stored, or gone and settled.\n\n   NO REACT HERE, like the rest of this directory. The component supplies the\n   uploaders and listens for state; everything that decides anything is plain\n   code that a test can drive with a fake uploader and a fake URL factory.\n   ========================================================================= */\n\nimport { nearestStop } from \"./caret-map\";\nimport { nextReferenceNumber } from \"./attachments\";\nimport {\n  enclosingCode,\n  findUnstoredImages,\n  isUnstoredImageSrc,\n  markdownDestination,\n  referenceMarkdown,\n  reshapeForCodeBoundary,\n  sanitizeImageSrc,\n} from \"./images\";\nimport { sanitizeHref } from \"../syntax/markdown/render\";\nimport type { SourceSelection } from \"./position\";\nimport type { MarkdownSurface } from \"./surface\";\n\n/**\n * Stores one file and says where it now lives. The same contract serves a picture (`uploadImage`) and any\n * other file (`uploadFile`).\n *\n * `signal` aborts when the editor unmounts; an uploader that ignores it still\n * works, its result is simply discarded. The returned `url` must be one an\n * `<img>` may load (`http(s)`, a relative URL, or `data:image/*` -\n * `sanitizeImageSrc`) and never another `blob:`; anything else is reported\n * as a failed upload rather than written into the document.\n */\nexport type ImageUploader = (file: File, options: { signal: AbortSignal }) => Promise<{ url: string }>;\n\n/**\n * What the consumer needs to decide whether it may save (PLN-10 R-1).\n *\n * Counts REFERENCES IN THE CURRENT DOCUMENT to a file not stored yet, one per construct - the same unit\n * `findUnstoredImages` returns, so `unstored === findUnstoredImages(value).length`\n * always. `uploading` are being stored, `failed` cannot be stored without the\n * author acting (a rejected upload, or a `blob:` this editor did not mint), and\n * `unstored` is every file not stored yet - `uploading + failed` plus those\n * with no storage configured. `unstored > 0` means the value must not be saved.\n */\nexport interface ImageUploadState {\n  uploading: number;\n  failed: number;\n  unstored: number;\n}\n\n/** The editor's own view: the public counts, plus what its chrome needs. */\nexport interface ImagePipelineSnapshot extends ImageUploadState {\n  /** Files that cannot be stored because there is no uploader. */\n  local: number;\n  /** Bumps whenever a file's state moves, so a tile redraws even when the counts above do not change. */\n  revision: number;\n}\n\n/** What the pipeline knows about one object URL it minted: the strip's source for a tile's picture and state. */\nexport interface LocalFileInfo {\n  file: File;\n  state: \"uploading\" | \"failed\" | \"local\";\n  /** The rejection's own text, present only when `state === \"failed\"` and the uploader threw an `Error`. */\n  message?: string;\n}\n\n/**\n * The longest an uploader's rejection message is kept, in characters.\n *\n * A message this long has already said what it needs to; anything past this\n * is defensive against an uploader that throws its whole response body (a\n * stack trace, an HTML error page) rather than a short reason, which would\n * otherwise blow out the tile's detail line.\n */\nconst MAX_UPLOAD_ERROR_MESSAGE_LENGTH = 300;\n\n/**\n * The rejection's own text, trimmed and length-capped - or undefined when the\n * uploader threw something with no usable message (not an `Error`, or an\n * `Error` with empty/whitespace-only `.message`). Never throws.\n */\nfunction errorMessage(error: unknown): string | undefined {\n  const raw = error instanceof Error ? error.message : undefined;\n  const trimmed = raw?.trim();\n  if (!trimmed) return undefined;\n  return trimmed.length > MAX_UPLOAD_ERROR_MESSAGE_LENGTH\n    ? `${trimmed.slice(0, MAX_UPLOAD_ERROR_MESSAGE_LENGTH - 1)}…`\n    : trimmed;\n}\n\n/**\n * The browser facilities the pipeline touches, injectable so a test never\n * needs a real object URL or a real network.\n */\nexport interface ImagePipelineEnvironment {\n  createObjectURL: (file: File) => string;\n  revokeObjectURL: (url: string) => void;\n  /**\n   * Settles once `url` has loaded or failed to. The swap waits for it so the\n   * stored picture is already in the cache when it replaces the local one -\n   * otherwise the tile blinks empty for as long as the download takes.\n   */\n  preload: (url: string) => Promise<unknown>;\n  /**\n   * The longest the swap waits for `preload`. A stored URL whose download\n   * stalls would otherwise hold a file that IS stored in \"uploading\" for\n   * ever - save disabled, page-leave guarded - for want of a cache warm-up.\n   */\n  preloadTimeoutMs: number;\n}\n\nexport interface ImagePipelineOptions {\n  /** The picture uploader in force right now, or null when there is no storage for pictures. */\n  uploadImage: () => ImageUploader | null;\n  /** The uploader for any other file, or null: then a file that is not a picture is ignored. */\n  uploadFile: () => ImageUploader | null;\n  /** The picture types `uploadImage` stores, or undefined for every `image/*`. A picture outside them goes to `uploadFile` as a link. */\n  imageTypes: () => readonly string[] | undefined;\n  /** Whether a link's destination is a file the app stores or a file this editor minted; numbering counts only those. */\n  isFileUrl: () => (url: string) => boolean;\n  /** The word a file's reference name starts with (\"Image\", \"PDF\"), from the library's strings. */\n  kindWord: (file: File) => string;\n  /** Called whenever the snapshot changes, and once when attached. */\n  onChange: (snapshot: ImagePipelineSnapshot) => void;\n  environment?: Partial<ImagePipelineEnvironment>;\n}\n\ninterface Entry {\n  file: File;\n  /** A picture is written as an image construct and stored by `uploadImage`; any other file as a link by `uploadFile`. */\n  picture: boolean;\n  state: LocalFileInfo[\"state\"];\n  /** The in-flight upload's controller; null whenever nothing is in flight. */\n  controller: AbortController | null;\n  /** Set on a rejection (DX-3146); stale once a fresh attempt starts. */\n  message?: string;\n}\n\nconst browserEnvironment: ImagePipelineEnvironment = {\n  createObjectURL: (file) => URL.createObjectURL(file),\n  revokeObjectURL: (url) => URL.revokeObjectURL(url),\n  preload: (url) => {\n    const image = new Image();\n    image.src = url;\n    return image.decode();\n  },\n  preloadTimeoutMs: 10_000,\n};\n\nexport class ImagePipeline {\n  private surface: MarkdownSurface | null = null;\n  private readonly entries = new Map<string, Entry>();\n  /** Where each stored URL came from: the object URL that held its place in the document until its upload finished. */\n  private readonly origins = new Map<string, string>();\n  private readonly env: ImagePipelineEnvironment;\n  private last: ImagePipelineSnapshot | null = null;\n  private revision = 0;\n  private disposed = false;\n\n  constructor(private readonly options: ImagePipelineOptions) {\n    this.env = { ...browserEnvironment, ...options.environment };\n  }\n\n  /**\n   * What the strip knows about an object URL this editor minted, or null for\n   * anything else. An arrow property so it can be handed around before the\n   * surface exists.\n   */\n  readonly resolve = (src: string): LocalFileInfo | null => {\n    const entry = this.entries.get(src.trim());\n    return entry ? { file: entry.file, state: entry.state, message: entry.message } : null;\n  };\n\n  /**\n   * A name for a file that does not change when its upload finishes: the object URL it was first written under,\n   * or the URL itself for a file that was never swapped. A tile keyed or opened on it survives the swap.\n   */\n  readonly identity = (src: string): string => {\n    const url = src.trim();\n    return this.origins.get(url) ?? url;\n  };\n\n  /** Whether a file of this MIME type is a picture `uploadImage` stores. */\n  private isPicture(mimeType: string): boolean {\n    if (!mimeType.startsWith(\"image/\")) return false;\n    const types = this.options.imageTypes();\n    return types === undefined || types.includes(mimeType);\n  }\n\n  /**\n   * Whether the editor takes a file of this MIME type: a picture it stores, or any file once `uploadFile` is set.\n   * Read by paste, drop and the picker, so all three agree.\n   */\n  readonly accepts = (mimeType: string): boolean => this.isPicture(mimeType) || this.options.uploadFile() !== null;\n\n  /** Connects the surface this pipeline edits, and reports the first snapshot. */\n  attach(surface: MarkdownSurface): void {\n    this.surface = surface;\n    this.sync();\n  }\n\n  /**\n   * THE pipeline: every file that enters the editor comes through here -\n   * paste, drop and the file picker alike.\n   *\n   * `at` is where the references go: the caret for a paste or a pick, the drop\n   * point for a drop. With none (an editor that was never focused), they go at\n   * the end of the document - never at offset 0 in front of whatever the\n   * author wrote first. A file the editor does not take (`accepts`) is ignored;\n   * the picker's `accept` is a hint the user can override, not a guarantee.\n   *\n   * Returns the object URLs it inserted, in order.\n   */\n  insert(files: readonly File[], at: SourceSelection | null): string[] {\n    const surface = this.requireSurface();\n    const taken = files.filter((file) => this.accepts(file.type));\n    if (!taken.length) return [];\n\n    /* Registered BEFORE the edit, so the very first render of the new\n       construct already finds it in the registry. */\n    const urls = taken.map((file) => {\n      const picture = this.isPicture(file.type);\n      const url = this.env.createObjectURL(file);\n      const uploader = picture ? this.options.uploadImage() : this.options.uploadFile();\n      this.entries.set(url, { file, picture, state: uploader ? \"uploading\" : \"local\", controller: null });\n      return url;\n    });\n\n    /* A SPACE BETWEEN SEVERAL REFERENCES, never a newline: this may be a table\n       cell or a heading, where a newline would end the construct the author\n       is standing in. Each file takes the next number after the document's own,\n       counted once: a batch landing in a place the document does not read as a\n       reference (an unclosed fence) would otherwise number every file alike. */\n    const source = surface.getSource();\n    const first = nextReferenceNumber(source, { isFileUrl: this.options.isFileUrl() });\n    let text = \"\";\n    taken.forEach((file, i) => {\n      const name = `${this.options.kindWord(file)} ${first + i}`;\n      const kind = this.entries.get(urls[i])!.picture ? \"image\" : \"link\";\n      text += (text ? \" \" : \"\") + referenceMarkdown(kind, urls[i], name);\n    });\n    const where = at ?? surface.getSelection() ?? { anchor: source.length, head: source.length };\n    const map = surface.getCaretMap();\n    let start = nearestStop(map, Math.min(where.anchor, where.head));\n    let end = nearestStop(map, Math.max(where.anchor, where.head));\n\n    /* DX-3140: code is never inline-parsed - a fenced or indented block embeds\n       its body raw, and a span's content is literal text by definition - so a\n       `![name](blob:...)` written inside either is inert forever: no frame,\n       nothing in the strip, and `findUnstoredImages` (which walks the same\n       frames) never counts it, so no warning ever fires and a dead local\n       address sits in the saved text. Landing just past the enclosing\n       construct instead keeps the paste/drop/pick and never loses it: a\n       block gets its own paragraph (`reshapeForCodeBoundary`); a SPAN gets no\n       reshaping at all - DELIBERATE (code review round 2): it is an ordinary\n       same-line insertion at the redirected offset, exactly like landing\n       anywhere else in this pipeline, so whatever immediately follows the\n       span (more prose, or nothing) is abutted with no space invented - the\n       same as typing would leave it, and not a second formatting policy only\n       code spans get. */\n    const enclosing = enclosingCode(surface.getProjection(), start);\n    if (enclosing) {\n      /* Snapped FIRST, and `start` (never `enclosing.end` again below) is\n         what decides the reshape too - the two must never be able to\n         disagree about where the text is actually landing (DX-3140 code\n         review, round 1). */\n      start = end = nearestStop(map, enclosing.end);\n      if (enclosing.block) text = reshapeForCodeBoundary(source, start, text);\n    }\n    /* A reference never runs into the reference beside it: `[PDF 1]` and `![Image 2]` written back to back would read as\n       one word, so a space goes between them (a block boundary already separates them with its own newlines). */\n    if (!enclosing?.block) {\n      const references = surface.getProjection().frames.filter((record) => record.frame.kind === \"image\" || record.frame.kind === \"link\");\n      if (references.some((record) => record.end === start)) text = ` ${text}`;\n      /* A reference inserted straight after a word would read `DX-6551.Image 1`: plain prose gets a space before it\n         when the character before is not whitespace. Never at a line start (that character is a newline), after an\n         opening bracket, or past a code span (`enclosing`, deliberate above); the neighbouring-reference case above\n         has already added its own. */\n      else if (!enclosing && start > 0 && !/[\\s(\\[{]/.test(source[start - 1])) text = ` ${text}`;\n      if (references.some((record) => record.start === end)) text = `${text} `;\n    }\n    const caret = start + text.length;\n\n    /* One undo step of its own: \"put these files here\" is a different\n       thought from the typing on either side of it. */\n    surface.breakUndoGroup();\n    surface.apply({ start, end, text }, { anchor: caret, head: caret }, \"other\");\n    surface.breakUndoGroup();\n\n    for (const url of urls) {\n      const uploader = this.uploaderFor(this.entries.get(url)!);\n      if (uploader) void this.upload(url, uploader);\n    }\n    this.sync();\n    return urls;\n  }\n\n  /**\n   * Uploads a failed file again, with the SAME File it was inserted with.\n   *\n   * With no uploader configured any more, the file becomes local-only rather\n   * than staying \"failed\" - the honest state for something nothing can store.\n   */\n  retry(src: string): void {\n    const url = src.trim();\n    const entry = this.entries.get(url);\n    if (!entry || entry.state !== \"failed\") return;\n    const uploader = this.uploaderFor(entry);\n    if (uploader) void this.upload(url, uploader);\n    else {\n      entry.state = \"local\";\n      entry.message = undefined;\n    }\n    this.changed();\n  }\n\n  /**\n   * Starts uploading every local-only file once an uploader exists.\n   *\n   * The component calls this when an uploader changes: a file pasted before an\n   * app's storage provider mounted should not stay unsaveable when the storage\n   * it needed arrives a moment later.\n   */\n  uploaderChanged(): void {\n    const source = this.requireSurface().getSource();\n    let started = false;\n    for (const [url, entry] of this.entries) {\n      /* Only files in the document - one that survives only in the undo\n         history is not the author's file right now, and storing it would\n         leave an orphan object behind for nothing. */\n      if (entry.state !== \"local\" || !source.includes(url)) continue;\n      const uploader = this.uploaderFor(entry);\n      if (!uploader) continue;\n      void this.upload(url, uploader);\n      started = true;\n    }\n    if (started) this.changed();\n  }\n\n  /**\n   * Recomputes the snapshot from the CURRENT document, and releases object\n   * URLs nothing can reach any more. Called after every change to the source.\n   *\n   * THE COUNTS COME FROM `findUnstoredImages`, the same exported function a\n   * consumer's save path calls - one detection source, never a second opinion\n   * the two could disagree on (DX-3134).\n   *\n   * AN OBJECT URL IS RELEASED WHEN ITS FILE IS GONE AND SETTLED: not in the\n   * document, not in any undo or redo entry (Ctrl+Z could bring it back), and\n   * not mid-upload (the upload will swap it wherever it still is). Revoking one\n   * any earlier turns an undo into a broken file; never revoking leaks the\n   * file's bytes for the life of the page.\n   */\n  sync(): void {\n    const surface = this.surface;\n    if (!surface || this.disposed) return;\n    const source = surface.getSource();\n\n    for (const [url, entry] of this.entries) {\n      if (entry.controller || source.includes(url) || surface.remembers(url)) continue;\n      this.release(url);\n    }\n\n    /* ONE COUNT PER REFERENCE IN THE DOCUMENT - every construct\n       `findUnstoredImages` returns, so `unstored` is always exactly\n       `findUnstoredImages(value).length` and a consumer's own submit-time\n       check can never disagree with the editor's (DX-3134). A file pasted\n       and then copied within the document is two references, and counts as two. */\n    const unstored = findUnstoredImages(source);\n    const snapshot: ImagePipelineSnapshot = {\n      uploading: 0,\n      failed: 0,\n      unstored: unstored.length,\n      local: 0,\n      revision: this.revision,\n    };\n    for (const reference of unstored) {\n      const entry = this.entries.get(reference.src.trim());\n      // I18N-ALLOW: file state token compared against the pipeline states\n      const state = entry?.state ?? \"foreign\";\n      if (state === \"uploading\") snapshot.uploading++;\n      else if (state === \"local\") snapshot.local++;\n      /* A `blob:` this editor did not mint is as unsaveable as a rejected\n         upload and cannot be retried - it counts as failed. */\n      else snapshot.failed++;\n    }\n\n    const last = this.last;\n    if (\n      last &&\n      last.uploading === snapshot.uploading &&\n      last.failed === snapshot.failed &&\n      last.unstored === snapshot.unstored &&\n      last.local === snapshot.local &&\n      last.revision === snapshot.revision\n    ) {\n      return;\n    }\n    this.last = snapshot;\n    this.options.onChange(snapshot);\n  }\n\n  /**\n   * Stops everything: aborts every upload in flight and releases every object\n   * URL. The editor is going away, so nothing it minted can be drawn anywhere\n   * again - no other editor will render another's `blob:`.\n   */\n  dispose(): void {\n    this.disposed = true;\n    this.origins.clear();\n    for (const url of [...this.entries.keys()]) this.release(url);\n    this.surface = null;\n  }\n\n  /* --- Internals ---------------------------------------------------------- */\n\n  private uploaderFor(entry: Entry): ImageUploader | null {\n    return entry.picture ? this.options.uploadImage() : this.options.uploadFile();\n  }\n\n  private async upload(url: string, uploader: ImageUploader): Promise<void> {\n    const entry = this.entries.get(url);\n    if (!entry) return;\n    const controller = new AbortController();\n    entry.state = \"uploading\";\n    entry.controller = controller;\n    /* Cleared at the START of every attempt, not just overwritten at the end\n       (code review, DX-3146): a previous rejection's message must never be\n       readable off an entry that is not currently \"failed\". */\n    entry.message = undefined;\n\n    let stored: string;\n    try {\n      const result = await uploader(entry.file, { signal: controller.signal });\n      stored = usableStoredUrl(result, entry.picture);\n    } catch (error) {\n      if (controller.signal.aborted) return;\n      entry.state = \"failed\";\n      entry.controller = null;\n      /* Carried onto the entry (DX-3146) so the tile can say WHY, not just\n         THAT - the one thing a bare \"failed\" could never say. */\n      entry.message = errorMessage(error);\n      /* Loud on purpose: a rejected upload is shown on its tile, and the\n         reason is the one thing the tile may truncate. */\n      console.error(`[MarkdownEditor] upload failed for \"${entry.file.name}\":`, error);\n      this.changed();\n      return;\n    }\n\n    /* The swap waits for a stored picture to be in the cache - or for the\n       time limit, or for the editor going away, whichever comes first. The\n       preload SETTLING is the point, not its outcome: a URL that will not load\n       is still the URL the upload returned, and it goes into the document\n       regardless. The wait only decides WHEN, never WHETHER. Another file has\n       no picture to warm up. */\n    if (entry.picture) await this.settled(this.env.preload(stored), controller.signal);\n    if (controller.signal.aborted || !this.surface) return;\n\n    /* Settled from here on: `sync` releases the object URL the moment no\n       document or history entry names it - at once normally, or at\n       `compositionend` when the surface had to queue the swap. */\n    entry.controller = null;\n    /* Recorded in the spelling the text now holds: that is the URL a row, a rename or a remove reads back. */\n    const written = markdownDestination(stored);\n    this.surface.substitute(url, written);\n    this.origins.set(written, url);\n    this.sync();\n  }\n\n  /**\n   * Resolves when `work` settles, `preloadTimeoutMs` passes, or `signal`\n   * aborts - never rejects. Every timer and listener is cleaned up.\n   */\n  private settled(work: Promise<unknown>, signal: AbortSignal): Promise<void> {\n    return new Promise((resolve) => {\n      const done = () => {\n        clearTimeout(timer);\n        signal.removeEventListener(\"abort\", done);\n        resolve();\n      };\n      const timer = setTimeout(done, this.env.preloadTimeoutMs);\n      signal.addEventListener(\"abort\", done);\n      work.then(done, done);\n    });\n  }\n\n  private release(url: string): void {\n    const entry = this.entries.get(url);\n    if (!entry) return;\n    entry.controller?.abort();\n    this.entries.delete(url);\n    this.env.revokeObjectURL(url);\n  }\n\n  /** A file's state moved: re-report, so its tile redraws. */\n  private changed(): void {\n    if (!this.surface || this.disposed) return;\n    this.revision++;\n    this.sync();\n  }\n\n  private requireSurface(): MarkdownSurface {\n    if (!this.surface) throw new Error(\"ImagePipeline: attach(surface) before using it\");\n    return this.surface;\n  }\n}\n\n/**\n * The URL an uploader resolved with, if it is one the document may hold.\n *\n * Throws - which the caller reports as a FAILED upload - for anything an\n * `<img>` in this editor would refuse, and for another `blob:`: writing either\n * into the document would swap a reference that works for one that does not,\n * and call it stored.\n */\nfunction usableStoredUrl(result: unknown, picture: boolean): string {\n  const url = (result as { url?: unknown } | null)?.url;\n  if (typeof url !== \"string\" || !url.trim()) {\n    throw new Error(\"the uploader resolved without a `url` string\");\n  }\n  if (isUnstoredImageSrc(url) || !(picture ? sanitizeImageSrc(url) : sanitizeHref(url))) {\n    throw new Error(`the uploader resolved with a URL a stored file cannot have: ${url.slice(0, 80)}`);\n  }\n  return url.trim();\n}\n"],"names":["MAX_UPLOAD_ERROR_MESSAGE_LENGTH","errorMessage","error","trimmed","browserEnvironment","file","url","image","ImagePipeline","options","src","entry","mimeType","types","surface","files","at","taken","urls","picture","uploader","source","first","nextReferenceNumber","text","i","name","kind","referenceMarkdown","where","map","start","nearestStop","end","enclosing","enclosingCode","reshapeForCodeBoundary","references","record","caret","started","unstored","findUnstoredImages","snapshot","reference","state","last","controller","stored","result","usableStoredUrl","written","markdownDestination","work","signal","resolve","done","timer","isUnstoredImageSrc","sanitizeImageSrc","sanitizeHref"],"mappings":";;;;AAiGA,MAAMA,IAAkC;AAOxC,SAASC,EAAaC,GAAoC;AAExD,QAAMC,KADMD,aAAiB,QAAQA,EAAM,UAAU,SAChC,KAAA;AACrB,MAAKC;AACL,WAAOA,EAAQ,SAASH,IACpB,GAAGG,EAAQ,MAAM,GAAGH,IAAkC,CAAC,CAAC,MACxDG;AACN;AAkDA,MAAMC,IAA+C;AAAA,EACnD,iBAAiB,CAACC,MAAS,IAAI,gBAAgBA,CAAI;AAAA,EACnD,iBAAiB,CAACC,MAAQ,IAAI,gBAAgBA,CAAG;AAAA,EACjD,SAAS,CAACA,MAAQ;AAChB,UAAMC,IAAQ,IAAI,MAAA;AAClB,WAAAA,EAAM,MAAMD,GACLC,EAAM,OAAA;AAAA,EACf;AAAA,EACA,kBAAkB;AACpB;AAEO,MAAMC,EAAc;AAAA,EAUzB,YAA6BC,GAA+B;AAA/B,SAAA,UAAAA,GAC3B,KAAK,MAAM,EAAE,GAAGL,GAAoB,GAAGK,EAAQ,YAAA;AAAA,EACjD;AAAA,EAF6B;AAAA,EATrB,UAAkC;AAAA,EACzB,8BAAc,IAAA;AAAA;AAAA,EAEd,8BAAc,IAAA;AAAA,EACd;AAAA,EACT,OAAqC;AAAA,EACrC,WAAW;AAAA,EACX,WAAW;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWV,UAAU,CAACC,MAAsC;AACxD,UAAMC,IAAQ,KAAK,QAAQ,IAAID,EAAI,MAAM;AACzC,WAAOC,IAAQ,EAAE,MAAMA,EAAM,MAAM,OAAOA,EAAM,OAAO,SAASA,EAAM,QAAA,IAAY;AAAA,EACpF;AAAA;AAAA;AAAA;AAAA;AAAA,EAMS,WAAW,CAACD,MAAwB;AAC3C,UAAMJ,IAAMI,EAAI,KAAA;AAChB,WAAO,KAAK,QAAQ,IAAIJ,CAAG,KAAKA;AAAA,EAClC;AAAA;AAAA,EAGQ,UAAUM,GAA2B;AAC3C,QAAI,CAACA,EAAS,WAAW,QAAQ,EAAG,QAAO;AAC3C,UAAMC,IAAQ,KAAK,QAAQ,WAAA;AAC3B,WAAOA,MAAU,UAAaA,EAAM,SAASD,CAAQ;AAAA,EACvD;AAAA;AAAA;AAAA;AAAA;AAAA,EAMS,UAAU,CAACA,MAA8B,KAAK,UAAUA,CAAQ,KAAK,KAAK,QAAQ,WAAA,MAAiB;AAAA;AAAA,EAG5G,OAAOE,GAAgC;AACrC,SAAK,UAAUA,GACf,KAAK,KAAA;AAAA,EACP;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcA,OAAOC,GAAwBC,GAAsC;AACnE,UAAMF,IAAU,KAAK,eAAA,GACfG,IAAQF,EAAM,OAAO,CAACV,MAAS,KAAK,QAAQA,EAAK,IAAI,CAAC;AAC5D,QAAI,CAACY,EAAM,OAAQ,QAAO,CAAA;AAI1B,UAAMC,IAAOD,EAAM,IAAI,CAACZ,MAAS;AAC/B,YAAMc,IAAU,KAAK,UAAUd,EAAK,IAAI,GAClCC,IAAM,KAAK,IAAI,gBAAgBD,CAAI,GACnCe,IAAWD,IAAU,KAAK,QAAQ,gBAAgB,KAAK,QAAQ,WAAA;AACrE,kBAAK,QAAQ,IAAIb,GAAK,EAAE,MAAAD,GAAM,SAAAc,GAAS,OAAOC,IAAW,cAAc,SAAS,YAAY,KAAA,CAAM,GAC3Fd;AAAA,IACT,CAAC,GAOKe,IAASP,EAAQ,UAAA,GACjBQ,IAAQC,EAAoBF,GAAQ,EAAE,WAAW,KAAK,QAAQ,UAAA,GAAa;AACjF,QAAIG,IAAO;AACX,IAAAP,EAAM,QAAQ,CAACZ,GAAMoB,MAAM;AACzB,YAAMC,IAAO,GAAG,KAAK,QAAQ,SAASrB,CAAI,CAAC,IAAIiB,IAAQG,CAAC,IAClDE,IAAO,KAAK,QAAQ,IAAIT,EAAKO,CAAC,CAAC,EAAG,UAAU,UAAU;AAC5D,MAAAD,MAASA,IAAO,MAAM,MAAMI,EAAkBD,GAAMT,EAAKO,CAAC,GAAGC,CAAI;AAAA,IACnE,CAAC;AACD,UAAMG,IAAQb,KAAMF,EAAQ,aAAA,KAAkB,EAAE,QAAQO,EAAO,QAAQ,MAAMA,EAAO,OAAA,GAC9ES,IAAMhB,EAAQ,YAAA;AACpB,QAAIiB,IAAQC,EAAYF,GAAK,KAAK,IAAID,EAAM,QAAQA,EAAM,IAAI,CAAC,GAC3DI,IAAMD,EAAYF,GAAK,KAAK,IAAID,EAAM,QAAQA,EAAM,IAAI,CAAC;AAgB7D,UAAMK,IAAYC,EAAcrB,EAAQ,cAAA,GAAiBiB,CAAK;AAW9D,QAVIG,MAKFH,IAAQE,IAAMD,EAAYF,GAAKI,EAAU,GAAG,GACxCA,EAAU,UAAOV,IAAOY,EAAuBf,GAAQU,GAAOP,CAAI,KAIpE,CAACU,GAAW,OAAO;AACrB,YAAMG,IAAavB,EAAQ,cAAA,EAAgB,OAAO,OAAO,CAACwB,MAAWA,EAAO,MAAM,SAAS,WAAWA,EAAO,MAAM,SAAS,MAAM;AAClI,MAAID,EAAW,KAAK,CAACC,MAAWA,EAAO,QAAQP,CAAK,IAAGP,IAAO,IAAIA,CAAI,KAK7D,CAACU,KAAaH,IAAQ,KAAK,CAAC,WAAW,KAAKV,EAAOU,IAAQ,CAAC,CAAC,MAAGP,IAAO,IAAIA,CAAI,KACpFa,EAAW,KAAK,CAACC,MAAWA,EAAO,UAAUL,CAAG,MAAGT,IAAO,GAAGA,CAAI;AAAA,IACvE;AACA,UAAMe,IAAQR,IAAQP,EAAK;AAI3B,IAAAV,EAAQ,eAAA,GACRA,EAAQ,MAAM,EAAE,OAAAiB,GAAO,KAAAE,GAAK,MAAAT,EAAA,GAAQ,EAAE,QAAQe,GAAO,MAAMA,EAAA,GAAS,OAAO,GAC3EzB,EAAQ,eAAA;AAER,eAAWR,KAAOY,GAAM;AACtB,YAAME,IAAW,KAAK,YAAY,KAAK,QAAQ,IAAId,CAAG,CAAE;AACxD,MAAIc,KAAe,KAAK,OAAOd,GAAKc,CAAQ;AAAA,IAC9C;AACA,gBAAK,KAAA,GACEF;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,MAAMR,GAAmB;AACvB,UAAMJ,IAAMI,EAAI,KAAA,GACVC,IAAQ,KAAK,QAAQ,IAAIL,CAAG;AAClC,QAAI,CAACK,KAASA,EAAM,UAAU,SAAU;AACxC,UAAMS,IAAW,KAAK,YAAYT,CAAK;AACvC,IAAIS,IAAe,KAAK,OAAOd,GAAKc,CAAQ,KAE1CT,EAAM,QAAQ,SACdA,EAAM,UAAU,SAElB,KAAK,QAAA;AAAA,EACP;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,kBAAwB;AACtB,UAAMU,IAAS,KAAK,eAAA,EAAiB,UAAA;AACrC,QAAImB,IAAU;AACd,eAAW,CAAClC,GAAKK,CAAK,KAAK,KAAK,SAAS;AAIvC,UAAIA,EAAM,UAAU,WAAW,CAACU,EAAO,SAASf,CAAG,EAAG;AACtD,YAAMc,IAAW,KAAK,YAAYT,CAAK;AACvC,MAAKS,MACA,KAAK,OAAOd,GAAKc,CAAQ,GAC9BoB,IAAU;AAAA,IACZ;AACA,IAAIA,UAAc,QAAA;AAAA,EACpB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAgBA,OAAa;AACX,UAAM1B,IAAU,KAAK;AACrB,QAAI,CAACA,KAAW,KAAK,SAAU;AAC/B,UAAMO,IAASP,EAAQ,UAAA;AAEvB,eAAW,CAACR,GAAKK,CAAK,KAAK,KAAK;AAC9B,MAAIA,EAAM,cAAcU,EAAO,SAASf,CAAG,KAAKQ,EAAQ,UAAUR,CAAG,KACrE,KAAK,QAAQA,CAAG;AAQlB,UAAMmC,IAAWC,EAAmBrB,CAAM,GACpCsB,IAAkC;AAAA,MACtC,WAAW;AAAA,MACX,QAAQ;AAAA,MACR,UAAUF,EAAS;AAAA,MACnB,OAAO;AAAA,MACP,UAAU,KAAK;AAAA,IAAA;AAEjB,eAAWG,KAAaH,GAAU;AAGhC,YAAMI,IAFQ,KAAK,QAAQ,IAAID,EAAU,IAAI,MAAM,GAE9B,SAAS;AAC9B,MAAIC,MAAU,cAAaF,EAAS,cAC3BE,MAAU,UAASF,EAAS,UAGhCA,EAAS;AAAA,IAChB;AAEA,UAAMG,IAAO,KAAK;AAClB,IACEA,KACAA,EAAK,cAAcH,EAAS,aAC5BG,EAAK,WAAWH,EAAS,UACzBG,EAAK,aAAaH,EAAS,YAC3BG,EAAK,UAAUH,EAAS,SACxBG,EAAK,aAAaH,EAAS,aAI7B,KAAK,OAAOA,GACZ,KAAK,QAAQ,SAASA,CAAQ;AAAA,EAChC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,UAAgB;AACd,SAAK,WAAW,IAChB,KAAK,QAAQ,MAAA;AACb,eAAWrC,KAAO,CAAC,GAAG,KAAK,QAAQ,MAAM,EAAG,MAAK,QAAQA,CAAG;AAC5D,SAAK,UAAU;AAAA,EACjB;AAAA;AAAA,EAIQ,YAAYK,GAAoC;AACtD,WAAOA,EAAM,UAAU,KAAK,QAAQ,gBAAgB,KAAK,QAAQ,WAAA;AAAA,EACnE;AAAA,EAEA,MAAc,OAAOL,GAAac,GAAwC;AACxE,UAAMT,IAAQ,KAAK,QAAQ,IAAIL,CAAG;AAClC,QAAI,CAACK,EAAO;AACZ,UAAMoC,IAAa,IAAI,gBAAA;AACvB,IAAApC,EAAM,QAAQ,aACdA,EAAM,aAAaoC,GAInBpC,EAAM,UAAU;AAEhB,QAAIqC;AACJ,QAAI;AACF,YAAMC,IAAS,MAAM7B,EAAST,EAAM,MAAM,EAAE,QAAQoC,EAAW,QAAQ;AACvE,MAAAC,IAASE,EAAgBD,GAAQtC,EAAM,OAAO;AAAA,IAChD,SAAST,GAAO;AACd,UAAI6C,EAAW,OAAO,QAAS;AAC/B,MAAApC,EAAM,QAAQ,UACdA,EAAM,aAAa,MAGnBA,EAAM,UAAUV,EAAaC,CAAK,GAGlC,QAAQ,MAAM,uCAAuCS,EAAM,KAAK,IAAI,MAAMT,CAAK,GAC/E,KAAK,QAAA;AACL;AAAA,IACF;AASA,QADIS,EAAM,WAAS,MAAM,KAAK,QAAQ,KAAK,IAAI,QAAQqC,CAAM,GAAGD,EAAW,MAAM,GAC7EA,EAAW,OAAO,WAAW,CAAC,KAAK,QAAS;AAKhD,IAAApC,EAAM,aAAa;AAEnB,UAAMwC,IAAUC,EAAoBJ,CAAM;AAC1C,SAAK,QAAQ,WAAW1C,GAAK6C,CAAO,GACpC,KAAK,QAAQ,IAAIA,GAAS7C,CAAG,GAC7B,KAAK,KAAA;AAAA,EACP;AAAA;AAAA;AAAA;AAAA;AAAA,EAMQ,QAAQ+C,GAAwBC,GAAoC;AAC1E,WAAO,IAAI,QAAQ,CAACC,MAAY;AAC9B,YAAMC,IAAO,MAAM;AACjB,qBAAaC,CAAK,GAClBH,EAAO,oBAAoB,SAASE,CAAI,GACxCD,EAAA;AAAA,MACF,GACME,IAAQ,WAAWD,GAAM,KAAK,IAAI,gBAAgB;AACxD,MAAAF,EAAO,iBAAiB,SAASE,CAAI,GACrCH,EAAK,KAAKG,GAAMA,CAAI;AAAA,IACtB,CAAC;AAAA,EACH;AAAA,EAEQ,QAAQlD,GAAmB;AACjC,UAAMK,IAAQ,KAAK,QAAQ,IAAIL,CAAG;AAClC,IAAKK,MACLA,EAAM,YAAY,MAAA,GAClB,KAAK,QAAQ,OAAOL,CAAG,GACvB,KAAK,IAAI,gBAAgBA,CAAG;AAAA,EAC9B;AAAA;AAAA,EAGQ,UAAgB;AACtB,IAAI,CAAC,KAAK,WAAW,KAAK,aAC1B,KAAK,YACL,KAAK,KAAA;AAAA,EACP;AAAA,EAEQ,iBAAkC;AACxC,QAAI,CAAC,KAAK,QAAS,OAAM,IAAI,MAAM,gDAAgD;AACnF,WAAO,KAAK;AAAA,EACd;AACF;AAUA,SAAS4C,EAAgBD,GAAiB9B,GAA0B;AAClE,QAAMb,IAAO2C,GAAqC;AAClD,MAAI,OAAO3C,KAAQ,YAAY,CAACA,EAAI;AAClC,UAAM,IAAI,MAAM,8CAA8C;AAEhE,MAAIoD,EAAmBpD,CAAG,KAAK,EAAEa,IAAUwC,EAAiBrD,CAAG,IAAIsD,EAAatD,CAAG;AACjF,UAAM,IAAI,MAAM,+DAA+DA,EAAI,MAAM,GAAG,EAAE,CAAC,EAAE;AAEnG,SAAOA,EAAI,KAAA;AACb;"}

package/dist/lib/markdown/images.js

@@ -0,0 +1,85 @@
+import { project as f } from "./project.js";
+import { sanitizeHref as u } from "../syntax/markdown/render.js";
+const d = /^\s*blob:/i;
+function l(e) {
+  return d.test(e);
+}
+function k(e) {
+  if (!/blob:/i.test(e)) return [];
+  const t = [];
+  for (const n of f(e).frames) {
+    const r = n.frame;
+    r.kind === "image" ? l(r.src) && t.push({ src: r.src, alt: r.alt, start: n.start, end: n.end }) : r.kind === "link" && l(r.href) && t.push({ src: r.href, alt: g(e, n.content), start: n.start, end: n.end });
+  }
+  return t.sort((n, r) => n.start - r.start);
+}
+function g(e, t) {
+  return t.map((n) => e.slice(n.start, n.end)).join("").replace(/\\([!-/:-@[-`{-~])/g, "$1");
+}
+function S(e) {
+  const t = u(e);
+  if (t) return /^(mailto|tel|ftp):/i.test(t) ? null : t;
+  const n = e.trim();
+  return /^data:image[/](png|jpe?g|gif|webp|avif|svg[+]xml)[;,]/i.test(n) ? n : null;
+}
+const p = /[\\[\]*_`<>|!]/g;
+function h(e) {
+  return e.trim().replace(/[\s()<>\\]/g, (t) => `%${t.charCodeAt(0).toString(16).toUpperCase().padStart(2, "0")}`);
+}
+function m(e) {
+  return e.replace(p, "\\$&");
+}
+function C(e, t, n) {
+  return `${e === "image" ? "!" : ""}[${m(n)}](${h(t)})`;
+}
+function A(e, t, n) {
+  if (!t.length) throw new Error("substituteAll: cannot substitute an empty string");
+  const r = [];
+  for (let s = e.indexOf(t); s !== -1; s = e.indexOf(t, s + t.length)) r.push(s);
+  if (!r.length) return null;
+  const i = n.length - t.length;
+  return {
+    source: e.split(t).join(n),
+    map: (s) => {
+      let c = s;
+      for (let o = 0; o < r.length; o++) {
+        const a = r[o];
+        if (s < a + 1) break;
+        if (s < a + t.length) return a + o * i + n.length;
+        c += i;
+      }
+      return c;
+    }
+  };
+}
+function I(e, t) {
+  let n = null;
+  for (const r of e.frames) {
+    const i = r.frame.kind;
+    i !== "code" && i !== "codeSpan" || t < r.start || t > r.end || (!n || r.end - r.start > n.end - n.start) && (n = { start: r.start, end: r.end, block: i === "code" });
+  }
+  return n;
+}
+function j(e, t, n) {
+  const r = e[t - 1] === `
+`, i = t >= e.length || e[t] === `
+`;
+  return `${r ? `
+` : `
+
+`}${n}${i ? "" : `
+`}`;
+}
+export {
+  I as enclosingCode,
+  m as escapeReferenceName,
+  k as findUnstoredImages,
+  l as isUnstoredImageSrc,
+  h as markdownDestination,
+  g as referenceLabel,
+  C as referenceMarkdown,
+  j as reshapeForCodeBoundary,
+  S as sanitizeImageSrc,
+  A as substituteAll
+};
+//# sourceMappingURL=images.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"images.js","sources":["../../../src/lib/markdown/images.ts"],"sourcesContent":["/* ============================================================================\n   IMAGES — the pure half of putting a picture into a document.\n\n   DX-3134. Everything here is a function of strings: which images in a\n   document are not stored yet, how an image is spelled, and how one URL is\n   swapped for another without moving anything else. No DOM, no React, no\n   clock, for the reason every module in this directory gives — the pieces a\n   consumer has to trust (above all `findUnstoredImages`, which gates their\n   save button) must be testable with nothing but a string.\n\n   WHAT \"UNSTORED\" MEANS, and why it is a URL scheme rather than a registry\n   lookup. An image the editor has not finished storing is written into the\n   document with an object URL (`blob:`), and an object URL is, by definition,\n   a handle into ONE page's memory: it cannot be fetched by the server, by\n   another tab, or by this tab after a reload. So a `blob:` src in a saved\n   value is a broken image for every reader, whoever minted it — which makes\n   the scheme alone the complete, dependency-free answer to \"may this value be\n   saved\", and lets a consumer ask it at submit time with no editor in hand.\n   ========================================================================= */\n\nimport { project, type Projection } from \"./project\";\nimport { sanitizeHref } from \"../syntax/markdown/render\";\n\n/**\n * A reference to a file that exists only in this page's memory: an image `![name](blob:...)` or a link\n * `[name](blob:...)` (DXUI-74 - a file the editor stores is a named reference, whatever its kind).\n */\nexport interface UnstoredImage {\n  /** The `blob:` URL exactly as the source spells it. */\n  src: string;\n  /** The reference name: the bracket text. */\n  alt: string;\n  /** The whole `![name](src)` or `[name](src)` construct, as source offsets. */\n  start: number;\n  end: number;\n}\n\nconst UNSTORED_SRC = /^\\s*blob:/i;\n\n/** Whether an image src names a picture that has not been stored anywhere. */\nexport function isUnstoredImageSrc(src: string): boolean {\n  return UNSTORED_SRC.test(src);\n}\n\n/**\n * Every image and link in `markdown` whose destination is a `blob:` URL, in source order.\n *\n * THE SINGLE DETECTION SOURCE. The editor's own warning strip, its\n * `onImageUploadStateChange` counts and its `beforeunload` guard all read this\n * function, and it is exported so a consumer's save path can re-check the\n * exact value it is about to persist with the same answer (DX-3134, PLN-10\n * \"Pending-state event\").\n *\n * Read from the PARSER, not with a regex, for the reason `constructAt` gives:\n * the parser has already decided what is an image, including the cases a\n * pattern gets wrong — a `![x](blob:…)` inside a code span is prose, not a\n * picture, and saving it loses nothing.\n */\nexport function findUnstoredImages(markdown: string): UnstoredImage[] {\n  /* The overwhelmingly common document holds no object URL at all, and this\n     runs on every edit — so the parse is only paid for when there is anything\n     for it to find. */\n  if (!/blob:/i.test(markdown)) return [];\n  const found: UnstoredImage[] = [];\n  for (const record of project(markdown).frames) {\n    const frame = record.frame;\n    if (frame.kind === \"image\") {\n      if (isUnstoredImageSrc(frame.src)) found.push({ src: frame.src, alt: frame.alt, start: record.start, end: record.end });\n    } else if (frame.kind === \"link\" && isUnstoredImageSrc(frame.href)) {\n      found.push({ src: frame.href, alt: referenceLabel(markdown, record.content), start: record.start, end: record.end });\n    }\n  }\n  return found.sort((a, b) => a.start - b.start);\n}\n\n/**\n * The bracket text of a link or image as the person reads it: the source slice with markdown backslash escapes\n * undone (`Bob \\[final\\]\\!` reads `Bob [final]!`). It is the inverse of `escapeReferenceName`, so a rename that\n * is read back and saved again never grows backslashes.\n */\nexport function referenceLabel(source: string, content: readonly { start: number; end: number }[]): string {\n  return content.map((range) => source.slice(range.start, range.end)).join(\"\").replace(/\\\\([!-/:-@[-`{-~])/g, \"$1\");\n}\n\n/* --- What an image src may be ----------------------------------------------- */\n\n/**\n * What a stored file's URL may be, and what a tile's `<img>` may load.\n *\n * `sanitizeHref` allows only `http(s)`, `mailto`, `tel` and `ftp`, because a link is something a person\n * clicks and `data:text/html` is a working attack. That rule is not loosened: this only narrows it to\n * `http(s)` and relative URLs, since the other three name nothing to load, and adds `data:image/*`, how an\n * inline avatar, an icon or a pasted screenshot is written. That narrow addition is safe because an SVG\n * loaded through `<img>` has scripting disabled by specification. `blob:` is refused here and stays\n * refused: an object URL is only rendered when the editor that minted it vouches for it.\n */\nexport function sanitizeImageSrc(src: string): string | null {\n  const linked = sanitizeHref(src);\n  if (linked) return /^(mailto|tel|ftp):/i.test(linked) ? null : linked;\n  const clean = src.trim();\n  return /^data:image[/](png|jpe?g|gif|webp|avif|svg[+]xml)[;,]/i.test(clean) ? clean : null;\n}\n\n/* --- Spelling a reference --------------------------------------------------- */\n\n/**\n * Characters that would change what the alt text MEANS if written bare.\n *\n * A file called `[draft] *final*.png` is an ordinary file name and, unescaped,\n * an image whose alt closes early and whose remaining text turns into\n * emphasis. `|` is here because an image inserted into a table cell would\n * otherwise end the cell.\n */\nconst ALT_SPECIAL = /[\\\\[\\]*_`<>|!]/g;\n\n/**\n * A URL written so the destination parses as exactly that URL.\n *\n * Whitespace ends a destination, an unbalanced parenthesis ends the construct,\n * and a backslash before punctuation is an escape markdown would consume — so\n * all of them are percent-encoded, which is the same URL to every server and\n * the only spelling that survives being written into markdown.\n */\nexport function markdownDestination(url: string): string {\n  return url.trim().replace(/[\\s()<>\\\\]/g, (ch) => `%${ch.charCodeAt(0).toString(16).toUpperCase().padStart(2, \"0\")}`);\n}\n\n/** `name` written so it reads back as exactly that bracket text. */\nexport function escapeReferenceName(name: string): string {\n  return name.replace(ALT_SPECIAL, \"\\\\$&\");\n}\n\n/** `![name](src)` for a picture, `[name](src)` for any other file, with both halves escaped so they read back as themselves. */\nexport function referenceMarkdown(kind: \"image\" | \"link\", src: string, name: string): string {\n  return `${kind === \"image\" ? \"!\" : \"\"}[${escapeReferenceName(name)}](${markdownDestination(src)})`;\n}\n\n/* --- Swapping one URL for another ----------------------------------------- */\n\n/** The result of replacing every occurrence of one string with another. */\nexport interface Substitution {\n  source: string;\n  /** Carries an offset in the old source to the same place in the new one. */\n  map: (offset: number) => number;\n}\n\n/**\n * Replaces EVERY occurrence of `from` in `source` with `to`, or returns null\n * when there is none.\n *\n * A PLAIN TEXT REPLACEMENT, deliberately, and only safe because of what `from`\n * is: an object URL this editor minted, which embeds a random UUID and was\n * never typed by anyone. Every occurrence of it is that image, whatever\n * construct holds it now — including one the author has since turned into a\n * link, which a parser-driven swap would leave pointing at a dead handle in\n * the saved value (DX-3134).\n *\n * `map` is what lets the caret survive the swap: offsets before an occurrence\n * stay, offsets after one shift by the length change, and an offset that was\n * INSIDE a replaced URL lands at the end of its replacement.\n */\nexport function substituteAll(source: string, from: string, to: string): Substitution | null {\n  if (!from.length) throw new Error(\"substituteAll: cannot substitute an empty string\");\n  const hits: number[] = [];\n  for (let at = source.indexOf(from); at !== -1; at = source.indexOf(from, at + from.length)) hits.push(at);\n  if (!hits.length) return null;\n\n  const delta = to.length - from.length;\n  return {\n    source: source.split(from).join(to),\n    map: (offset) => {\n      let shifted = offset;\n      for (let i = 0; i < hits.length; i++) {\n        const start = hits[i];\n        if (offset < start + 1) break;\n        if (offset < start + from.length) return start + i * delta + to.length;\n        shifted += delta;\n      }\n      return shifted;\n    },\n  };\n}\n\n/* --- Never landing an image inside code (DX-3140) -------------------------- */\n\n/** The innermost code construct containing an offset — see `enclosingCode`. */\nexport interface CodeConstruct {\n  end: number;\n  block: boolean;\n}\n\n/**\n * The innermost code construct — fenced block, indented block, or inline span\n * — containing `offset`, or null when `offset` sits in ordinary prose.\n *\n * DX-3140: read from the PROJECTION, the same source `marksAt`/`constructAt`\n * in `convert.ts` use, rather than re-deriving fence syntax with a second\n * regex — `blockAt`'s own `fenceAround` regex only ever recognises a FENCED\n * block, so it would miss an indented one entirely, and every code kind here\n * (fenced, indented, span) shares exactly one frame shape either way: the\n * parser has already decided the boundary in every case a hand-rolled pattern\n * gets wrong. Boundaries are inclusive on both ends, matching `marksAt` — a\n * caret at either edge still reads as inside. When several code frames\n * contain `offset` (a nested case the grammar does not produce today), the\n * outermost one wins, so the image lands past all of them, not between two.\n *\n * SHARED, not private to the image pipeline: `insertImage` below is public\n * API (`src/index.ts`), so a consumer calling it directly with a selection\n * inside a code construct is exactly as able to write dead `![](…)` text into\n * code as a paste ever was — the ONE check has to live somewhere both paths\n * reach, not be re-derived per caller.\n */\nexport function enclosingCode(projection: Projection, offset: number): CodeConstruct | null {\n  let found: { start: number; end: number; block: boolean } | null = null;\n  for (const record of projection.frames) {\n    const kind = record.frame.kind;\n    if (kind !== \"code\" && kind !== \"codeSpan\") continue;\n    if (offset < record.start || offset > record.end) continue;\n    if (!found || record.end - record.start > found.end - found.start) {\n      found = { start: record.start, end: record.end, block: kind === \"code\" };\n    }\n  }\n  return found;\n}\n\n/**\n * The text to actually write at `at` when it sits at the boundary of a code\n * BLOCK (fenced or indented) — reshaped so it lands cleanly outside it.\n *\n * CALLERS MUST PASS THE SAME `at` THEY ACTUALLY SPLICE AT, and nothing else —\n * this was a real bug (DX-3140 code review, round 1): reading the boundary\n * characters from `enclosingCode`'s raw `end` while splicing at a DIFFERENT,\n * caret-map-snapped offset meant the two could disagree, most detectably when\n * `nearestStop` ever moved the insertion point off `end`. There being exactly\n * ONE offset in this function's signature makes that class of drift\n * impossible to reintroduce by construction, rather than by convention.\n *\n * A BLOCK FRAME ALREADY OWNS ITS OWN TRAILING NEWLINE, when one exists (`at`\n * sits at the START of the next line, not at the fence's last backtick) — so\n * blindly prefixing \"\\n\\n\" would stack a THIRD newline on top of the one\n * already there, splitting the image from the code by a full extra blank\n * line no author asked for. Reading what is already on each side of `at` and\n * adding only what is missing keeps it to exactly one blank line before the\n * image, and puts it on its own line after, whatever originally followed the\n * block (nothing, a line right away, or an existing blank line of its own).\n *\n * A SPAN NEEDS NO RESHAPING — it just continues the line it was on — so this\n * is only ever called for `enclosingCode(...).block === true`.\n */\nexport function reshapeForCodeBoundary(source: string, at: number, text: string): string {\n  const before = source[at - 1] === \"\\n\";\n  const afterIsNewlineOrEnd = at >= source.length || source[at] === \"\\n\";\n  return `${before ? \"\\n\" : \"\\n\\n\"}${text}${afterIsNewlineOrEnd ? \"\" : \"\\n\"}`;\n}\n"],"names":["UNSTORED_SRC","isUnstoredImageSrc","src","findUnstoredImages","markdown","found","record","project","frame","referenceLabel","a","b","source","content","range","sanitizeImageSrc","linked","sanitizeHref","clean","ALT_SPECIAL","markdownDestination","url","ch","escapeReferenceName","name","referenceMarkdown","kind","substituteAll","from","to","hits","at","delta","offset","shifted","i","start","enclosingCode","projection","reshapeForCodeBoundary","text","before","afterIsNewlineOrEnd"],"mappings":";;AAqCA,MAAMA,IAAe;AAGd,SAASC,EAAmBC,GAAsB;AACvD,SAAOF,EAAa,KAAKE,CAAG;AAC9B;AAgBO,SAASC,EAAmBC,GAAmC;AAIpE,MAAI,CAAC,SAAS,KAAKA,CAAQ,UAAU,CAAA;AACrC,QAAMC,IAAyB,CAAA;AAC/B,aAAWC,KAAUC,EAAQH,CAAQ,EAAE,QAAQ;AAC7C,UAAMI,IAAQF,EAAO;AACrB,IAAIE,EAAM,SAAS,UACbP,EAAmBO,EAAM,GAAG,KAAGH,EAAM,KAAK,EAAE,KAAKG,EAAM,KAAK,KAAKA,EAAM,KAAK,OAAOF,EAAO,OAAO,KAAKA,EAAO,KAAK,IAC7GE,EAAM,SAAS,UAAUP,EAAmBO,EAAM,IAAI,KAC/DH,EAAM,KAAK,EAAE,KAAKG,EAAM,MAAM,KAAKC,EAAeL,GAAUE,EAAO,OAAO,GAAG,OAAOA,EAAO,OAAO,KAAKA,EAAO,KAAK;AAAA,EAEvH;AACA,SAAOD,EAAM,KAAK,CAACK,GAAGC,MAAMD,EAAE,QAAQC,EAAE,KAAK;AAC/C;AAOO,SAASF,EAAeG,GAAgBC,GAA4D;AACzG,SAAOA,EAAQ,IAAI,CAACC,MAAUF,EAAO,MAAME,EAAM,OAAOA,EAAM,GAAG,CAAC,EAAE,KAAK,EAAE,EAAE,QAAQ,uBAAuB,IAAI;AAClH;AAcO,SAASC,EAAiBb,GAA4B;AAC3D,QAAMc,IAASC,EAAaf,CAAG;AAC/B,MAAIc,EAAQ,QAAO,sBAAsB,KAAKA,CAAM,IAAI,OAAOA;AAC/D,QAAME,IAAQhB,EAAI,KAAA;AAClB,SAAO,yDAAyD,KAAKgB,CAAK,IAAIA,IAAQ;AACxF;AAYA,MAAMC,IAAc;AAUb,SAASC,EAAoBC,GAAqB;AACvD,SAAOA,EAAI,OAAO,QAAQ,eAAe,CAACC,MAAO,IAAIA,EAAG,WAAW,CAAC,EAAE,SAAS,EAAE,EAAE,YAAA,EAAc,SAAS,GAAG,GAAG,CAAC,EAAE;AACrH;AAGO,SAASC,EAAoBC,GAAsB;AACxD,SAAOA,EAAK,QAAQL,GAAa,MAAM;AACzC;AAGO,SAASM,EAAkBC,GAAwBxB,GAAasB,GAAsB;AAC3F,SAAO,GAAGE,MAAS,UAAU,MAAM,EAAE,IAAIH,EAAoBC,CAAI,CAAC,KAAKJ,EAAoBlB,CAAG,CAAC;AACjG;AA0BO,SAASyB,EAAcf,GAAgBgB,GAAcC,GAAiC;AAC3F,MAAI,CAACD,EAAK,OAAQ,OAAM,IAAI,MAAM,kDAAkD;AACpF,QAAME,IAAiB,CAAA;AACvB,WAASC,IAAKnB,EAAO,QAAQgB,CAAI,GAAGG,MAAO,IAAIA,IAAKnB,EAAO,QAAQgB,GAAMG,IAAKH,EAAK,MAAM,EAAG,CAAAE,EAAK,KAAKC,CAAE;AACxG,MAAI,CAACD,EAAK,OAAQ,QAAO;AAEzB,QAAME,IAAQH,EAAG,SAASD,EAAK;AAC/B,SAAO;AAAA,IACL,QAAQhB,EAAO,MAAMgB,CAAI,EAAE,KAAKC,CAAE;AAAA,IAClC,KAAK,CAACI,MAAW;AACf,UAAIC,IAAUD;AACd,eAASE,IAAI,GAAGA,IAAIL,EAAK,QAAQK,KAAK;AACpC,cAAMC,IAAQN,EAAKK,CAAC;AACpB,YAAIF,IAASG,IAAQ,EAAG;AACxB,YAAIH,IAASG,IAAQR,EAAK,eAAeQ,IAAQD,IAAIH,IAAQH,EAAG;AAChE,QAAAK,KAAWF;AAAA,MACb;AACA,aAAOE;AAAA,IACT;AAAA,EAAA;AAEJ;AA+BO,SAASG,EAAcC,GAAwBL,GAAsC;AAC1F,MAAI5B,IAA+D;AACnE,aAAWC,KAAUgC,EAAW,QAAQ;AACtC,UAAMZ,IAAOpB,EAAO,MAAM;AAC1B,IAAIoB,MAAS,UAAUA,MAAS,cAC5BO,IAAS3B,EAAO,SAAS2B,IAAS3B,EAAO,QACzC,CAACD,KAASC,EAAO,MAAMA,EAAO,QAAQD,EAAM,MAAMA,EAAM,WAC1DA,IAAQ,EAAE,OAAOC,EAAO,OAAO,KAAKA,EAAO,KAAK,OAAOoB,MAAS,OAAA;AAAA,EAEpE;AACA,SAAOrB;AACT;AA0BO,SAASkC,EAAuB3B,GAAgBmB,GAAYS,GAAsB;AACvF,QAAMC,IAAS7B,EAAOmB,IAAK,CAAC,MAAM;AAAA,GAC5BW,IAAsBX,KAAMnB,EAAO,UAAUA,EAAOmB,CAAE,MAAM;AAAA;AAClE,SAAO,GAAGU,IAAS;AAAA,IAAO;AAAA;AAAA,CAAM,GAAGD,CAAI,GAAGE,IAAsB,KAAK;AAAA,CAAI;AAC3E;"}