@latentic/live-markdown 0.3.1 → 0.4.0

package/dist/codemirror/mermaid/mermaidWidget.js

@@ -0,0 +1,142 @@
+import {
+  __publicField
+} from "../../chunk-V6TY7KAL.js";
+import { WidgetType } from "@codemirror/view";
+import {
+  getCachedMermaidSvg,
+  renderMermaidToSvg,
+  warmMermaidPng
+} from "./mermaidRender.js";
+const measuredHeights = /* @__PURE__ */ new Map();
+const MEASURED_CACHE_CAP = 100;
+function rememberHeight(source, height) {
+  if (measuredHeights.size >= MEASURED_CACHE_CAP) {
+    const oldest = measuredHeights.keys().next().value;
+    if (oldest !== void 0) measuredHeights.delete(oldest);
+  }
+  measuredHeights.set(source, height);
+}
+function estimateMermaidHeight(source) {
+  const lines = source === "" ? 1 : source.split("\n").length;
+  return Math.min(520, Math.max(140, 96 + lines * 32));
+}
+const containerSources = /* @__PURE__ */ new WeakMap();
+class MermaidWidget extends WidgetType {
+  constructor(source, selected = false) {
+    super();
+    __publicField(this, "source", source);
+    __publicField(this, "selected", selected);
+  }
+  /** Identity = source + selected. Edits elsewhere shift the fence's position
+   *  but must not tear down the diagram DOM; a selected flip alone updates
+   *  the class in place via {@link updateDOM}. */
+  eq(other) {
+    return other.source === this.source && other.selected === this.selected;
+  }
+  updateDOM(dom) {
+    if (containerSources.get(dom) !== this.source) return false;
+    dom.classList.toggle("cm-mermaid-block--selected", this.selected);
+    return true;
+  }
+  toDOM(view) {
+    const container = document.createElement("div");
+    container.className = "cm-mermaid-block";
+    if (this.selected) container.classList.add("cm-mermaid-block--selected");
+    containerSources.set(container, this.source);
+    container.setAttribute("role", "img");
+    container.setAttribute("aria-label", "Mermaid diagram \u2014 click to select, double-click to edit");
+    container.title = "Click to select \xB7 double-click to edit";
+    container.addEventListener("mousedown", (event) => {
+      event.preventDefault();
+      if (event.detail >= 2) {
+        revealSource(view, container);
+      } else {
+        selectFenceBlock(view, container);
+      }
+    });
+    const cached = getCachedMermaidSvg(this.source);
+    if (cached) {
+      this.fill(container, cached, view);
+    } else {
+      container.classList.add("cm-mermaid-block--pending");
+      container.textContent = "Rendering diagram\u2026";
+      void renderMermaidToSvg(this.source).then((result) => {
+        if (!container.isConnected) return;
+        container.classList.remove("cm-mermaid-block--pending");
+        container.textContent = "";
+        this.fill(container, result, view);
+      });
+    }
+    return container;
+  }
+  fill(container, result, view) {
+    if (result.ok) {
+      container.innerHTML = result.svg;
+      window.setTimeout(() => void warmMermaidPng(this.source), 300);
+    } else {
+      container.classList.add("cm-mermaid-block--error");
+      const title = document.createElement("div");
+      title.className = "cm-mermaid-error__title";
+      title.textContent = "Mermaid couldn't render this diagram \u2014 double-click to edit the source";
+      const message = document.createElement("pre");
+      message.className = "cm-mermaid-error__message";
+      message.textContent = result.message;
+      container.append(title, message);
+    }
+    const edit = document.createElement("span");
+    edit.className = "cm-mermaid-edit";
+    edit.setAttribute("role", "button");
+    edit.setAttribute("aria-label", "Edit diagram source");
+    edit.title = "Edit source";
+    edit.textContent = "Edit";
+    edit.addEventListener("mousedown", (event) => {
+      event.preventDefault();
+      event.stopPropagation();
+      revealSource(view, container);
+    });
+    container.appendChild(edit);
+    view.requestMeasure({
+      read: () => {
+        if (container.isConnected && container.offsetHeight > 0) {
+          rememberHeight(this.source, container.offsetHeight);
+        }
+      }
+    });
+  }
+  /** The widget owns its events (click-to-edit); CM must not also react. */
+  ignoreEvent() {
+    return true;
+  }
+  get estimatedHeight() {
+    return measuredHeights.get(this.source) ?? estimateMermaidHeight(this.source);
+  }
+}
+function revealSource(view, container) {
+  const fenceStart = view.posAtDOM(container);
+  const opener = view.state.doc.lineAt(fenceStart);
+  view.dispatch({
+    selection: { anchor: Math.min(opener.to + 1, view.state.doc.length) }
+  });
+  view.focus();
+}
+function selectFenceBlock(view, container) {
+  const fenceStart = view.posAtDOM(container);
+  const doc = view.state.doc;
+  const opener = doc.lineAt(fenceStart);
+  const markChar = opener.text.trim()[0];
+  const markCount = opener.text.trim().length - opener.text.trim().replace(/^(`+|~+)/, "").length;
+  const closerRe = new RegExp(`^\\s*\\${markChar}{${Math.max(markCount, 3)},}\\s*$`);
+  let end = opener.to;
+  for (let lineNumber = opener.number + 1; lineNumber <= doc.lines; lineNumber += 1) {
+    const line = doc.line(lineNumber);
+    end = line.to;
+    if (closerRe.test(line.text)) break;
+  }
+  view.dispatch({ selection: { anchor: opener.from, head: end } });
+  view.focus();
+}
+export {
+  MermaidWidget,
+  estimateMermaidHeight
+};
+//# sourceMappingURL=mermaidWidget.js.map

package/dist/codemirror/mermaid/mermaidWidget.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/mermaid/mermaidWidget.ts"],"sourcesContent":["/**\n * Mermaid diagram widget — a closed ```mermaid fence rendered as a diagram\n * block. Clicking the diagram moves the caret into the fence, which flips the\n * block back to source (mermaidPlugin owns that swap).\n *\n * Rendering itself (lazy mermaid load, SVG cache, clipboard PNG warm-up) lives\n * in [mermaidRender](./mermaidRender.ts) — this file owns only the widget:\n * measured heights are cached by source so `estimatedHeight` answers with the\n * real height and re-created widgets never shift the scroll position (the\n * #120 contract).\n */\n\nimport { EditorView, WidgetType } from \"@codemirror/view\";\n\nimport {\n  getCachedMermaidSvg,\n  renderMermaidToSvg,\n  warmMermaidPng,\n  type MermaidRenderResult,\n} from \"./mermaidRender\";\n\ntype RenderResult = MermaidRenderResult;\n\nconst measuredHeights = new Map<string, number>();\nconst MEASURED_CACHE_CAP = 100;\n\nfunction rememberHeight(source: string, height: number): void {\n  if (measuredHeights.size >= MEASURED_CACHE_CAP) {\n    const oldest = measuredHeights.keys().next().value;\n    if (oldest !== undefined) measuredHeights.delete(oldest);\n  }\n  measuredHeights.set(source, height);\n}\n\n/** Pre-measure estimate: diagram height doesn't map cleanly onto source\n *  lines, but ~a node-row per line is the right order of magnitude, and the\n *  measured cache replaces the guess after the first real render. */\nexport function estimateMermaidHeight(source: string): number {\n  const lines = source === \"\" ? 1 : source.split(\"\\n\").length;\n  return Math.min(520, Math.max(140, 96 + lines * 32));\n}\n\n/** The rendered source per container, so `updateDOM` can tell a\n *  selection-only flip (toggle a class in place) from a source change\n *  (rebuild + re-render). */\nconst containerSources = new WeakMap<HTMLElement, string>();\n\nexport class MermaidWidget extends WidgetType {\n  constructor(\n    readonly source: string,\n    /** The fence is covered by a (spanning) selection — native selection\n     *  paints nothing over a block widget, so the widget shows its own\n     *  selected state. */\n    readonly selected = false,\n  ) {\n    super();\n  }\n\n  /** Identity = source + selected. Edits elsewhere shift the fence's position\n   *  but must not tear down the diagram DOM; a selected flip alone updates\n   *  the class in place via {@link updateDOM}. */\n  override eq(other: MermaidWidget): boolean {\n    return other.source === this.source && other.selected === this.selected;\n  }\n\n  override updateDOM(dom: HTMLElement): boolean {\n    if (containerSources.get(dom) !== this.source) return false;\n    dom.classList.toggle(\"cm-mermaid-block--selected\", this.selected);\n    return true;\n  }\n\n  override toDOM(view: EditorView): HTMLElement {\n    const container = document.createElement(\"div\");\n    container.className = \"cm-mermaid-block\";\n    if (this.selected) container.classList.add(\"cm-mermaid-block--selected\");\n    containerSources.set(container, this.source);\n    container.setAttribute(\"role\", \"img\");\n    container.setAttribute(\"aria-label\", \"Mermaid diagram — click to select, double-click to edit\");\n    container.title = \"Click to select · double-click to edit\";\n    // A diagram is an OBJECT first: click selects the whole fence (still\n    // rendered — the reveal rule ignores spanning selections), so ⌘C copies\n    // it without ever flashing to source. Editing is the deliberate action:\n    // double-click, or the Edit chip.\n    container.addEventListener(\"mousedown\", (event) => {\n      event.preventDefault();\n      if (event.detail >= 2) {\n        revealSource(view, container);\n      } else {\n        selectFenceBlock(view, container);\n      }\n    });\n\n    const cached = getCachedMermaidSvg(this.source);\n    if (cached) {\n      this.fill(container, cached, view);\n    } else {\n      container.classList.add(\"cm-mermaid-block--pending\");\n      container.textContent = \"Rendering diagram…\";\n      void renderMermaidToSvg(this.source).then((result) => {\n        if (!container.isConnected) return;\n        container.classList.remove(\"cm-mermaid-block--pending\");\n        container.textContent = \"\";\n        this.fill(container, result, view);\n      });\n    }\n    return container;\n  }\n\n  private fill(container: HTMLElement, result: RenderResult, view: EditorView): void {\n    if (result.ok) {\n      container.innerHTML = result.svg;\n      // Rasterise a clipboard PNG in the background — the copy event is\n      // synchronous, so it can only embed diagrams warmed ahead of time.\n      // Deferred off the paint path (NOT requestIdleCallback: WebKit never\n      // runs it while the window is unfocused).\n      window.setTimeout(() => void warmMermaidPng(this.source), 300);\n    } else {\n      container.classList.add(\"cm-mermaid-block--error\");\n      const title = document.createElement(\"div\");\n      title.className = \"cm-mermaid-error__title\";\n      title.textContent = \"Mermaid couldn't render this diagram — double-click to edit the source\";\n      const message = document.createElement(\"pre\");\n      message.className = \"cm-mermaid-error__message\";\n      message.textContent = result.message;\n      container.append(title, message);\n    }\n    // The hover-revealed Edit chip is the pointer path INTO the source\n    // (alongside double-click); a plain click selects the block instead.\n    // Present in the ERROR state too — a broken diagram is exactly where\n    // the edit affordance matters most.\n    const edit = document.createElement(\"span\");\n    edit.className = \"cm-mermaid-edit\";\n    edit.setAttribute(\"role\", \"button\");\n    edit.setAttribute(\"aria-label\", \"Edit diagram source\");\n    edit.title = \"Edit source\";\n    edit.textContent = \"Edit\";\n    edit.addEventListener(\"mousedown\", (event) => {\n      event.preventDefault();\n      event.stopPropagation();\n      revealSource(view, container);\n    });\n    container.appendChild(edit);\n    // Record the real height in a controlled measure pass — never let CM\n    // discover the layout shift mid-scroll.\n    view.requestMeasure({\n      read: () => {\n        if (container.isConnected && container.offsetHeight > 0) {\n          rememberHeight(this.source, container.offsetHeight);\n        }\n      },\n    });\n  }\n\n  /** The widget owns its events (click-to-edit); CM must not also react. */\n  override ignoreEvent(): boolean {\n    return true;\n  }\n\n  override get estimatedHeight(): number {\n    return measuredHeights.get(this.source) ?? estimateMermaidHeight(this.source);\n  }\n}\n\n/** Move the caret onto the fence's first content line (the opener when the\n *  fence is empty) — the plugin sees the selection inside and reveals the\n *  source in the widget's place. */\nfunction revealSource(view: EditorView, container: HTMLElement): void {\n  const fenceStart = view.posAtDOM(container);\n  const opener = view.state.doc.lineAt(fenceStart);\n  view.dispatch({\n    selection: { anchor: Math.min(opener.to + 1, view.state.doc.length) },\n  });\n  view.focus();\n}\n\n/** Select the whole fence as one block. Both endpoints sit ON the fence's\n *  boundaries — not inside — so the diagram stays rendered while selected,\n *  and ⌘C picks up the full fence markdown (which the clipboard enrichment\n *  turns back into the diagram). */\nfunction selectFenceBlock(view: EditorView, container: HTMLElement): void {\n  const fenceStart = view.posAtDOM(container);\n  const doc = view.state.doc;\n  const opener = doc.lineAt(fenceStart);\n  const markChar = opener.text.trim()[0];\n  const markCount = opener.text.trim().length - opener.text.trim().replace(/^(`+|~+)/, \"\").length;\n  const closerRe = new RegExp(`^\\\\s*\\\\${markChar}{${Math.max(markCount, 3)},}\\\\s*$`);\n  let end = opener.to;\n  for (let lineNumber = opener.number + 1; lineNumber <= doc.lines; lineNumber += 1) {\n    const line = doc.line(lineNumber);\n    end = line.to;\n    if (closerRe.test(line.text)) break;\n  }\n  view.dispatch({ selection: { anchor: opener.from, head: end } });\n  view.focus();\n}\n"],"mappings":"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","names":[]}

package/dist/codemirror/selectionLayer.d.ts

@@ -0,0 +1,43 @@
+import { Extension } from '@codemirror/state';
+
+/**
+ * Drawn selection over a virtualized viewport (#166).
+ *
+ * CodeMirror renders only the visible viewport, and the browser's native
+ * `::selection` can only highlight DOM that exists — so with native painting,
+ * a Cmd+A or Shift-extended selection shows highlight only on whatever
+ * happened to be rendered, and scrolling away and back loses it entirely.
+ * This layer paints selection ranges FROM LOGICAL STATE
+ * (`state.selection` × the current viewport), so the highlight is correct at
+ * every scroll position by construction.
+ *
+ * Why not CM6's own `drawSelection()`: its wrapped-line handling reverse-maps
+ * the editor's far-left/right edge through `posAtCoords` per endpoint, and on
+ * lines that start with hidden markers + widgets that probe jitters between
+ * before/after the hidden prefix, flashing between one-piece and three-piece
+ * painting per drag update (#90). The rects here derive only from FORWARD
+ * geometry — `coordsAtPos` of the actual endpoints plus line-block boxes —
+ * with no reverse edge probe anywhere:
+ *
+ *   * endpoints in the same visual row → one rect between their coords;
+ *   * a wrapped or multi-line range → a partial rect for the first row, a
+ *     partial rect for the last row, and ONE full-width rect for everything
+ *     between (which also spans block widgets and hidden rows);
+ *   * a block widget wholly inside a range additionally gets a translucent
+ *     ABOVE-content tint (`cm-selectionWidgetTint`): widgets paint opaque
+ *     backgrounds over a below-content layer, so without it a selected
+ *     table/diagram would show no feedback at all.
+ *
+ * Known coarseness: partial rows of RTL text paint full-width (bidi span
+ * splitting is deliberately not reimplemented here); LTR documents paint
+ * glyph-accurately.
+ *
+ * The native `::selection` stays for the tablev2 cell editors (their own
+ * contenteditable islands) and is made transparent everywhere else — the DOM
+ * selection itself is untouched, so IME, copy, and focus behavior keep
+ * working on the real selection.
+ */
+
+declare const drawnSelection: Extension;
+
+export { drawnSelection };

package/dist/codemirror/selectionLayer.js

@@ -0,0 +1,135 @@
+import {
+  __publicField
+} from "../chunk-V6TY7KAL.js";
+import { Prec } from "@codemirror/state";
+import {
+  BlockType,
+  Direction,
+  EditorView,
+  layer,
+  RectangleMarker
+} from "@codemirror/view";
+function layerBase(view) {
+  const rect = view.scrollDOM.getBoundingClientRect();
+  const left = view.textDirection === Direction.LTR ? rect.left : rect.right - view.scrollDOM.clientWidth * view.scaleX;
+  return {
+    left: left - view.scrollDOM.scrollLeft * view.scaleX,
+    top: rect.top - view.scrollDOM.scrollTop * view.scaleY
+  };
+}
+function contentEdges(view) {
+  const rect = view.contentDOM.getBoundingClientRect();
+  const line = view.contentDOM.querySelector(".cm-line");
+  const style = line ? window.getComputedStyle(line) : null;
+  const padLeft = style ? parseInt(style.paddingLeft) || 0 : 0;
+  const padRight = style ? parseInt(style.paddingRight) || 0 : 0;
+  return { left: rect.left + padLeft, right: rect.right - padRight };
+}
+function isTextBlock(block) {
+  return block.type === BlockType.Text || Array.isArray(block.type);
+}
+class Rect {
+  constructor(left, top, right, bottom) {
+    __publicField(this, "left", left);
+    __publicField(this, "top", top);
+    __publicField(this, "right", right);
+    __publicField(this, "bottom", bottom);
+  }
+}
+function rectsForRange(view, range, edges) {
+  if (range.to <= view.viewport.from || range.from >= view.viewport.to) return [];
+  const from = Math.max(range.from, view.viewport.from);
+  const to = Math.min(range.to, view.viewport.to);
+  const startBlock = view.lineBlockAt(from);
+  const endBlock = view.lineBlockAt(to);
+  const contentTop = view.contentDOM.getBoundingClientRect().top;
+  const startCoords = isTextBlock(startBlock) ? view.coordsAtPos(from, 1) : null;
+  const endCoords = isTextBlock(endBlock) ? view.coordsAtPos(to, -1) : null;
+  const startTop = startCoords ? startCoords.top : contentTop + startBlock.top;
+  const startBottom = startCoords ? startCoords.bottom : contentTop + startBlock.bottom;
+  const endTop = endCoords ? endCoords.top : contentTop + endBlock.top;
+  const endBottom = endCoords ? endCoords.bottom : contentTop + endBlock.bottom;
+  const startLeft = startCoords ? startCoords.left : edges.left;
+  const endRight = endCoords ? endCoords.right : edges.right;
+  if (endTop - startTop < 1) {
+    return [new Rect(startLeft, startTop, Math.max(endRight, startLeft), endBottom)];
+  }
+  const rects = [
+    // Partial first row: selection start to the row's right edge.
+    new Rect(startLeft, startTop, edges.right, startBottom),
+    // Everything between the first and last rows — full width. Wrapped rows
+    // of the endpoint lines, whole middle lines, and block widgets all fall
+    // inside this band, which is what makes the shape probe-free.
+    new Rect(edges.left, startBottom, edges.right, endTop),
+    // Partial last row: the row's left edge to the selection end.
+    new Rect(edges.left, endTop, endRight, endBottom)
+  ];
+  return rects.filter((r) => r.bottom > r.top || r.right > r.left);
+}
+const selectionLayer = layer({
+  above: false,
+  class: "cm-selectionLayer",
+  update: (update) => update.docChanged || update.selectionSet || update.viewportChanged || update.geometryChanged,
+  markers(view) {
+    const base = layerBase(view);
+    const edges = contentEdges(view);
+    const markers = [];
+    for (const range of view.state.selection.ranges) {
+      if (range.empty) continue;
+      for (const rect of rectsForRange(view, range, edges)) {
+        markers.push(
+          new RectangleMarker(
+            "cm-selectionBackground",
+            rect.left - base.left,
+            rect.top - base.top,
+            Math.max(0, rect.right - rect.left),
+            rect.bottom - rect.top
+          )
+        );
+      }
+    }
+    return markers;
+  }
+});
+const widgetTintLayer = layer({
+  above: true,
+  class: "cm-selectionWidgetLayer",
+  update: (update) => update.docChanged || update.selectionSet || update.viewportChanged || update.geometryChanged,
+  markers(view) {
+    const covering = view.state.selection.ranges.filter((r) => !r.empty);
+    if (covering.length === 0) return [];
+    const base = layerBase(view);
+    const edges = contentEdges(view);
+    const contentTop = view.contentDOM.getBoundingClientRect().top;
+    const markers = [];
+    for (const block of view.viewportLineBlocks) {
+      if (isTextBlock(block)) continue;
+      if (!covering.some((r) => r.from <= block.from && r.to >= block.to)) continue;
+      markers.push(
+        new RectangleMarker(
+          "cm-selectionWidgetTint",
+          edges.left - base.left,
+          contentTop + block.top - base.top,
+          Math.max(0, edges.right - edges.left),
+          block.bottom - block.top
+        )
+      );
+    }
+    return markers;
+  }
+});
+const hideNativeSelection = Prec.highest(
+  EditorView.theme({
+    ".cm-content ::selection, .cm-content::selection": {
+      backgroundColor: "transparent"
+    },
+    '.cm-content [contenteditable="plaintext-only"] ::selection, .cm-content [contenteditable="plaintext-only"]::selection': {
+      backgroundColor: "var(--cds-highlight, #d0e2ff)"
+    }
+  })
+);
+const drawnSelection = [selectionLayer, widgetTintLayer, hideNativeSelection];
+export {
+  drawnSelection
+};
+//# sourceMappingURL=selectionLayer.js.map

package/dist/codemirror/selectionLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/codemirror/selectionLayer.ts"],"sourcesContent":["/**\n * Drawn selection over a virtualized viewport (#166).\n *\n * CodeMirror renders only the visible viewport, and the browser's native\n * `::selection` can only highlight DOM that exists — so with native painting,\n * a Cmd+A or Shift-extended selection shows highlight only on whatever\n * happened to be rendered, and scrolling away and back loses it entirely.\n * This layer paints selection ranges FROM LOGICAL STATE\n * (`state.selection` × the current viewport), so the highlight is correct at\n * every scroll position by construction.\n *\n * Why not CM6's own `drawSelection()`: its wrapped-line handling reverse-maps\n * the editor's far-left/right edge through `posAtCoords` per endpoint, and on\n * lines that start with hidden markers + widgets that probe jitters between\n * before/after the hidden prefix, flashing between one-piece and three-piece\n * painting per drag update (#90). The rects here derive only from FORWARD\n * geometry — `coordsAtPos` of the actual endpoints plus line-block boxes —\n * with no reverse edge probe anywhere:\n *\n *   * endpoints in the same visual row → one rect between their coords;\n *   * a wrapped or multi-line range → a partial rect for the first row, a\n *     partial rect for the last row, and ONE full-width rect for everything\n *     between (which also spans block widgets and hidden rows);\n *   * a block widget wholly inside a range additionally gets a translucent\n *     ABOVE-content tint (`cm-selectionWidgetTint`): widgets paint opaque\n *     backgrounds over a below-content layer, so without it a selected\n *     table/diagram would show no feedback at all.\n *\n * Known coarseness: partial rows of RTL text paint full-width (bidi span\n * splitting is deliberately not reimplemented here); LTR documents paint\n * glyph-accurately.\n *\n * The native `::selection` stays for the tablev2 cell editors (their own\n * contenteditable islands) and is made transparent everywhere else — the DOM\n * selection itself is untouched, so IME, copy, and focus behavior keep\n * working on the real selection.\n */\n\nimport { Prec, type Extension, type SelectionRange } from \"@codemirror/state\";\nimport {\n  BlockType,\n  Direction,\n  EditorView,\n  layer,\n  RectangleMarker,\n  type BlockInfo,\n} from \"@codemirror/view\";\n\n/** Client-rect → document-space base, mirroring CM6's own layer arithmetic. */\nfunction layerBase(view: EditorView): { left: number; top: number } {\n  const rect = view.scrollDOM.getBoundingClientRect();\n  const left =\n    view.textDirection === Direction.LTR\n      ? rect.left\n      : rect.right - view.scrollDOM.clientWidth * view.scaleX;\n  return {\n    left: left - view.scrollDOM.scrollLeft * view.scaleX,\n    top: rect.top - view.scrollDOM.scrollTop * view.scaleY,\n  };\n}\n\ninterface ContentEdges {\n  left: number;\n  right: number;\n}\n\n/** The horizontal band text can occupy, in client coordinates. */\nfunction contentEdges(view: EditorView): ContentEdges {\n  const rect = view.contentDOM.getBoundingClientRect();\n  const line = view.contentDOM.querySelector(\".cm-line\");\n  const style = line ? window.getComputedStyle(line) : null;\n  const padLeft = style ? parseInt(style.paddingLeft) || 0 : 0;\n  const padRight = style ? parseInt(style.paddingRight) || 0 : 0;\n  return { left: rect.left + padLeft, right: rect.right - padRight };\n}\n\nfunction isTextBlock(block: BlockInfo): boolean {\n  return block.type === BlockType.Text || Array.isArray(block.type);\n}\n\nclass Rect {\n  constructor(\n    readonly left: number,\n    readonly top: number,\n    readonly right: number,\n    readonly bottom: number,\n  ) {}\n}\n\n/**\n * Selection rectangles for one range, clamped to the viewport. Every rect is\n * derived from forward endpoint geometry; positions whose coords are\n * unavailable (jsdom, or an endpoint inside a replaced range) degrade to the\n * enclosing block's box rather than throwing.\n */\nfunction rectsForRange(view: EditorView, range: SelectionRange, edges: ContentEdges): Rect[] {\n  if (range.to <= view.viewport.from || range.from >= view.viewport.to) return [];\n  const from = Math.max(range.from, view.viewport.from);\n  const to = Math.min(range.to, view.viewport.to);\n  const startBlock = view.lineBlockAt(from);\n  const endBlock = view.lineBlockAt(to);\n  const contentTop = view.contentDOM.getBoundingClientRect().top;\n\n  // A selection endpoint sitting on a widget block has no glyph coords; its\n  // \"row\" is the widget's whole box.\n  const startCoords = isTextBlock(startBlock) ? view.coordsAtPos(from, 1) : null;\n  const endCoords = isTextBlock(endBlock) ? view.coordsAtPos(to, -1) : null;\n  const startTop = startCoords ? startCoords.top : contentTop + startBlock.top;\n  const startBottom = startCoords ? startCoords.bottom : contentTop + startBlock.bottom;\n  const endTop = endCoords ? endCoords.top : contentTop + endBlock.top;\n  const endBottom = endCoords ? endCoords.bottom : contentTop + endBlock.bottom;\n  const startLeft = startCoords ? startCoords.left : edges.left;\n  const endRight = endCoords ? endCoords.right : edges.right;\n\n  // Same visual row: row boxes share their top edge, so the endpoint tops\n  // are equal by construction (adjacent rows differ by a full row height).\n  if (endTop - startTop < 1) {\n    return [new Rect(startLeft, startTop, Math.max(endRight, startLeft), endBottom)];\n  }\n\n  const rects: Rect[] = [\n    // Partial first row: selection start to the row's right edge.\n    new Rect(startLeft, startTop, edges.right, startBottom),\n    // Everything between the first and last rows — full width. Wrapped rows\n    // of the endpoint lines, whole middle lines, and block widgets all fall\n    // inside this band, which is what makes the shape probe-free.\n    new Rect(edges.left, startBottom, edges.right, endTop),\n    // Partial last row: the row's left edge to the selection end.\n    new Rect(edges.left, endTop, endRight, endBottom),\n  ];\n  return rects.filter((r) => r.bottom > r.top || r.right > r.left);\n}\n\nconst selectionLayer = layer({\n  above: false,\n  class: \"cm-selectionLayer\",\n  update: (update) =>\n    update.docChanged || update.selectionSet || update.viewportChanged || update.geometryChanged,\n  markers(view) {\n    const base = layerBase(view);\n    const edges = contentEdges(view);\n    const markers: RectangleMarker[] = [];\n    for (const range of view.state.selection.ranges) {\n      if (range.empty) continue;\n      for (const rect of rectsForRange(view, range, edges)) {\n        markers.push(\n          new RectangleMarker(\n            \"cm-selectionBackground\",\n            rect.left - base.left,\n            rect.top - base.top,\n            Math.max(0, rect.right - rect.left),\n            rect.bottom - rect.top,\n          ),\n        );\n      }\n    }\n    return markers;\n  },\n});\n\n/** Translucent tint ABOVE block widgets wholly covered by a selection — the\n *  below-content band is hidden behind their opaque backgrounds. */\nconst widgetTintLayer = layer({\n  above: true,\n  class: \"cm-selectionWidgetLayer\",\n  update: (update) =>\n    update.docChanged || update.selectionSet || update.viewportChanged || update.geometryChanged,\n  markers(view) {\n    const covering = view.state.selection.ranges.filter((r) => !r.empty);\n    if (covering.length === 0) return [];\n    const base = layerBase(view);\n    const edges = contentEdges(view);\n    const contentTop = view.contentDOM.getBoundingClientRect().top;\n    const markers: RectangleMarker[] = [];\n    for (const block of view.viewportLineBlocks) {\n      if (isTextBlock(block)) continue;\n      if (!covering.some((r) => r.from <= block.from && r.to >= block.to)) continue;\n      markers.push(\n        new RectangleMarker(\n          \"cm-selectionWidgetTint\",\n          edges.left - base.left,\n          contentTop + block.top - base.top,\n          Math.max(0, edges.right - edges.left),\n          block.bottom - block.top,\n        ),\n      );\n    }\n    return markers;\n  },\n});\n\n// The drawn layer replaces the native highlight; the DOM selection itself\n// stays (IME, copy, focus). The tablev2 cell editors are separate\n// contenteditable islands that keep the native paint.\nconst hideNativeSelection = Prec.highest(\n  EditorView.theme({\n    \".cm-content ::selection, .cm-content::selection\": {\n      backgroundColor: \"transparent\",\n    },\n    '.cm-content [contenteditable=\"plaintext-only\"] ::selection, .cm-content [contenteditable=\"plaintext-only\"]::selection':\n      {\n        backgroundColor: \"var(--cds-highlight, #d0e2ff)\",\n      },\n  }),\n);\n\nexport const drawnSelection: Extension = [selectionLayer, widgetTintLayer, hideNativeSelection];\n"],"mappings":"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","names":[]}

package/dist/codemirror/table/cellDividerWidget.d.ts

@@ -0,0 +1,9 @@
+import { WidgetType, EditorView } from '@codemirror/view';
+
+declare class CellDividerWidget extends WidgetType {
+    eq(_other: CellDividerWidget): boolean;
+    toDOM(_view: EditorView): HTMLElement;
+    ignoreEvent(): boolean;
+}
+
+export { CellDividerWidget };

package/dist/codemirror/table/cellDividerWidget.js

@@ -0,0 +1,19 @@
+import "../../chunk-V6TY7KAL.js";
+import { WidgetType } from "@codemirror/view";
+class CellDividerWidget extends WidgetType {
+  eq(_other) {
+    return true;
+  }
+  toDOM(_view) {
+    const span = document.createElement("span");
+    span.className = "cm-table-divider";
+    return span;
+  }
+  ignoreEvent() {
+    return false;
+  }
+}
+export {
+  CellDividerWidget
+};
+//# sourceMappingURL=cellDividerWidget.js.map

package/dist/codemirror/table/cellDividerWidget.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/table/cellDividerWidget.ts"],"sourcesContent":["import { EditorView, WidgetType } from \"@codemirror/view\";\n\n\nexport class CellDividerWidget extends WidgetType {\n  override eq(_other: CellDividerWidget): boolean {\n    return true;\n  }\n  override toDOM(_view: EditorView): HTMLElement {\n    const span = document.createElement(\"span\");\n    span.className = \"cm-table-divider\";\n    return span;\n  }\n  override ignoreEvent(): boolean {\n    return false;\n  }\n}\n"],"mappings":";AAAA,SAAqB,kBAAkB;AAGhC,MAAM,0BAA0B,WAAW;AAAA,EACvC,GAAG,QAAoC;AAC9C,WAAO;AAAA,EACT;AAAA,EACS,MAAM,OAAgC;AAC7C,UAAM,OAAO,SAAS,cAAc,MAAM;AAC1C,SAAK,YAAY;AACjB,WAAO;AAAA,EACT;AAAA,EACS,cAAuB;AAC9B,WAAO;AAAA,EACT;AACF;","names":[]}

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

@@ -0,0 +1,5 @@
+export { ArmedTable, armedTable, armedTableField, setArmedTable, tableArmedHighlight } from './tableArmed.js';
+export { tableField } from './tableField.js';
+export { addColumnAfter, addColumnBefore, addRowAbove, addRowBelow, deleteColumn, deleteRow, deleteTable } from './tableEditCommands.js';
+import '@codemirror/state';
+import '@codemirror/view';

package/dist/codemirror/table/index.js

@@ -0,0 +1,4 @@
+export * from "./tableArmed.js";
+export * from "./tableField.js";
+export * from "./tableEditCommands.js";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/table/index.ts"],"sourcesContent":["/**\n * GFM tables, v1: the pipe-source model, the atomic block widget StateField,\n * and the editing/navigation commands. `tablev2/` (the in-cell editing\n * surfaces) bridges into these by concrete module path.\n */\nexport * from \"./tableArmed\";\nexport * from \"./tableField\";\nexport * from \"./tableEditCommands\";\n"],"mappings":"AAKA,cAAc;AACd,cAAc;AACd,cAAc;","names":[]}

package/dist/codemirror/table/tableArmed.d.ts

@@ -0,0 +1,27 @@
+import * as _codemirror_state from '@codemirror/state';
+import { EditorState, StateField } from '@codemirror/state';
+import { ViewPlugin, EditorView, ViewUpdate } from '@codemirror/view';
+
+/** Which edge of a table the caret is parked against. `"end"` is the trailing
+ *  edge (a Backspace from the line below); `"start"` is the leading edge (a
+ *  Delete from the line above). The edge decides where the green line is drawn
+ *  — under the table or over it. */
+interface ArmedTable {
+    from: number;
+    edge: "start" | "end";
+}
+/** Arm (with an `ArmedTable`) or disarm (with null) the two-step table delete.
+ *  Dispatched by the delete normalizer when its first press parks the caret. */
+declare const setArmedTable: _codemirror_state.StateEffectType<ArmedTable | null>;
+/** The armed table, or null. Set only by `setArmedTable`; cleared by any cursor
+ *  move or document edit, so navigating onto a table edge never arms it. */
+declare const armedTableField: StateField<ArmedTable | null>;
+declare function armedTable(state: EditorState): ArmedTable | null;
+declare class TableArmedHighlighter {
+    constructor(view: EditorView);
+    update(update: ViewUpdate): void;
+    private sync;
+}
+declare const tableArmedHighlight: ViewPlugin<TableArmedHighlighter, undefined>;
+
+export { type ArmedTable, armedTable, armedTableField, setArmedTable, tableArmedHighlight };

package/dist/codemirror/table/tableArmed.js

@@ -0,0 +1,43 @@
+import "../../chunk-V6TY7KAL.js";
+import { StateEffect, StateField } from "@codemirror/state";
+import { ViewPlugin } from "@codemirror/view";
+const setArmedTable = StateEffect.define();
+const armedTableField = StateField.define({
+  create: () => null,
+  update(value, tr) {
+    for (const effect of tr.effects) if (effect.is(setArmedTable)) return effect.value;
+    if (tr.selection || tr.docChanged) return null;
+    return value;
+  }
+});
+function armedTable(state) {
+  return state.field(armedTableField, false) ?? null;
+}
+class TableArmedHighlighter {
+  constructor(view) {
+    this.sync(view);
+  }
+  update(update) {
+    if (update.selectionSet || update.docChanged || update.viewportChanged) {
+      this.sync(update.view);
+    }
+  }
+  sync(view) {
+    const armed = armedTable(view.state);
+    view.dom.classList.toggle("cm-table-arming", armed !== null);
+    for (const wrap of view.dom.querySelectorAll(".cm-table-wrap")) {
+      const isArmed = armed !== null && Number(wrap.dataset.tableFrom) === armed.from;
+      wrap.classList.toggle("cm-table-armed", isArmed);
+      if (armed && isArmed) wrap.dataset.armedEdge = armed.edge;
+      else delete wrap.dataset.armedEdge;
+    }
+  }
+}
+const tableArmedHighlight = ViewPlugin.fromClass(TableArmedHighlighter);
+export {
+  armedTable,
+  armedTableField,
+  setArmedTable,
+  tableArmedHighlight
+};
+//# sourceMappingURL=tableArmed.js.map

package/dist/codemirror/table/tableArmed.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/table/tableArmed.ts"],"sourcesContent":["/**\n * Visible \"armed for deletion\" state for the two-step table delete.\n *\n * The first Backspace/Delete next to a table parks the caret at the table's\n * edge instead of editing its hidden source (see deleteNormalizer), and records\n * that intent here via `setArmedTable`. While armed, this plugin outlines the\n * table and draws a green \"cursor behind the table\" line at the parked edge —\n * the cue that the next press removes it (Zettlr's affordance) — and the theme\n * hides the real caret.\n *\n * Arming is EXPLICIT, not inferred from the caret resting at an edge: ordinary\n * navigation lands the caret on a table edge too, and that must not arm\n * anything or hide the cursor. Any later move or edit disarms.\n */\n\nimport { StateEffect, StateField, type EditorState } from \"@codemirror/state\";\nimport { EditorView, ViewPlugin, type ViewUpdate } from \"@codemirror/view\";\n\n/** Which edge of a table the caret is parked against. `\"end\"` is the trailing\n *  edge (a Backspace from the line below); `\"start\"` is the leading edge (a\n *  Delete from the line above). The edge decides where the green line is drawn\n *  — under the table or over it. */\nexport interface ArmedTable {\n  from: number;\n  edge: \"start\" | \"end\";\n}\n\n/** Arm (with an `ArmedTable`) or disarm (with null) the two-step table delete.\n *  Dispatched by the delete normalizer when its first press parks the caret. */\nexport const setArmedTable = StateEffect.define<ArmedTable | null>();\n\n/** The armed table, or null. Set only by `setArmedTable`; cleared by any cursor\n *  move or document edit, so navigating onto a table edge never arms it. */\nexport const armedTableField = StateField.define<ArmedTable | null>({\n  create: () => null,\n  update(value, tr) {\n    for (const effect of tr.effects) if (effect.is(setArmedTable)) return effect.value;\n    if (tr.selection || tr.docChanged) return null;\n    return value;\n  },\n});\n\nexport function armedTable(state: EditorState): ArmedTable | null {\n  return state.field(armedTableField, false) ?? null;\n}\n\nclass TableArmedHighlighter {\n  constructor(view: EditorView) {\n    this.sync(view);\n  }\n\n  update(update: ViewUpdate): void {\n    if (update.selectionSet || update.docChanged || update.viewportChanged) {\n      this.sync(update.view);\n    }\n  }\n\n  private sync(view: EditorView): void {\n    const armed = armedTable(view.state);\n    // Root class lets the theme hide the parked caret — it would otherwise blink\n    // on the blank line just past the table (table.to is a block boundary CM\n    // paints below the widget), competing with the outline + green edge line.\n    view.dom.classList.toggle(\"cm-table-arming\", armed !== null);\n    for (const wrap of view.dom.querySelectorAll<HTMLElement>(\".cm-table-wrap\")) {\n      const isArmed = armed !== null && Number(wrap.dataset.tableFrom) === armed.from;\n      wrap.classList.toggle(\"cm-table-armed\", isArmed);\n      if (armed && isArmed) wrap.dataset.armedEdge = armed.edge;\n      else delete wrap.dataset.armedEdge;\n    }\n  }\n}\n\nexport const tableArmedHighlight = ViewPlugin.fromClass(TableArmedHighlighter);\n"],"mappings":";AAeA,SAAS,aAAa,kBAAoC;AAC1D,SAAqB,kBAAmC;AAajD,MAAM,gBAAgB,YAAY,OAA0B;AAI5D,MAAM,kBAAkB,WAAW,OAA0B;AAAA,EAClE,QAAQ,MAAM;AAAA,EACd,OAAO,OAAO,IAAI;AAChB,eAAW,UAAU,GAAG,QAAS,KAAI,OAAO,GAAG,aAAa,EAAG,QAAO,OAAO;AAC7E,QAAI,GAAG,aAAa,GAAG,WAAY,QAAO;AAC1C,WAAO;AAAA,EACT;AACF,CAAC;AAEM,SAAS,WAAW,OAAuC;AAChE,SAAO,MAAM,MAAM,iBAAiB,KAAK,KAAK;AAChD;AAEA,MAAM,sBAAsB;AAAA,EAC1B,YAAY,MAAkB;AAC5B,SAAK,KAAK,IAAI;AAAA,EAChB;AAAA,EAEA,OAAO,QAA0B;AAC/B,QAAI,OAAO,gBAAgB,OAAO,cAAc,OAAO,iBAAiB;AACtE,WAAK,KAAK,OAAO,IAAI;AAAA,IACvB;AAAA,EACF;AAAA,EAEQ,KAAK,MAAwB;AACnC,UAAM,QAAQ,WAAW,KAAK,KAAK;AAInC,SAAK,IAAI,UAAU,OAAO,mBAAmB,UAAU,IAAI;AAC3D,eAAW,QAAQ,KAAK,IAAI,iBAA8B,gBAAgB,GAAG;AAC3E,YAAM,UAAU,UAAU,QAAQ,OAAO,KAAK,QAAQ,SAAS,MAAM,MAAM;AAC3E,WAAK,UAAU,OAAO,kBAAkB,OAAO;AAC/C,UAAI,SAAS,QAAS,MAAK,QAAQ,YAAY,MAAM;AAAA,UAChD,QAAO,KAAK,QAAQ;AAAA,IAC3B;AAAA,EACF;AACF;AAEO,MAAM,sBAAsB,WAAW,UAAU,qBAAqB;","names":[]}

package/dist/codemirror/table/tableCell.d.ts

@@ -0,0 +1,19 @@
+import { InlineScanRule } from '../core/inlineScan.js';
+import '@codemirror/state';
+
+/**
+ * Renders a table cell's inline HTML into safe DOM.
+ *
+ * The string is pre-rendered by {@link renderInlineCell} (markdown markup →
+ * `<span>`s carrying the editor's `.cm-*` mark classes) and may also carry
+ * literal inline HTML from the source — most commonly `<br>` to stack several
+ * lines in one cell — so it can't go in as `textContent`. It's sanitized through
+ * DOMPurify with an inline-only allow-list: emphasis, code, links, and `<br>`
+ * pass through; block, script, and event-handler markup is stripped. `class` is
+ * allowed (CSS classes are inert — no XSS surface) so the mark styling survives;
+ * DOMPurify also neutralises unsafe `href` schemes (e.g. `javascript:`).
+ */
+
+declare function renderCellInto(el: HTMLElement, source: string, rules: readonly InlineScanRule[]): void;
+
+export { renderCellInto };

package/dist/codemirror/table/tableCell.js

@@ -0,0 +1,15 @@
+import "../../chunk-V6TY7KAL.js";
+import DOMPurify from "dompurify";
+const CELL_SANITIZE_CONFIG = {
+  ALLOWED_TAGS: ["br", "b", "strong", "i", "em", "code", "sub", "sup", "del", "s", "u", "span", "a"],
+  ALLOWED_ATTR: ["href", "class"],
+  RETURN_TRUSTED_TYPE: false
+};
+function renderCellInto(el, source, rules) {
+  el.innerHTML = DOMPurify.sanitize(source, CELL_SANITIZE_CONFIG);
+  for (const rule of rules) rule.hydrate?.(el);
+}
+export {
+  renderCellInto
+};
+//# sourceMappingURL=tableCell.js.map

package/dist/codemirror/table/tableCell.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/table/tableCell.ts"],"sourcesContent":["/**\n * Renders a table cell's inline HTML into safe DOM.\n *\n * The string is pre-rendered by {@link renderInlineCell} (markdown markup →\n * `<span>`s carrying the editor's `.cm-*` mark classes) and may also carry\n * literal inline HTML from the source — most commonly `<br>` to stack several\n * lines in one cell — so it can't go in as `textContent`. It's sanitized through\n * DOMPurify with an inline-only allow-list: emphasis, code, links, and `<br>`\n * pass through; block, script, and event-handler markup is stripped. `class` is\n * allowed (CSS classes are inert — no XSS surface) so the mark styling survives;\n * DOMPurify also neutralises unsafe `href` schemes (e.g. `javascript:`).\n */\n\nimport DOMPurify from \"dompurify\";\n\nimport { type InlineScanRule } from \"../core/inlineScan\";\n\nconst CELL_SANITIZE_CONFIG = {\n  ALLOWED_TAGS: [\"br\", \"b\", \"strong\", \"i\", \"em\", \"code\", \"sub\", \"sup\", \"del\", \"s\", \"u\", \"span\", \"a\"],\n  ALLOWED_ATTR: [\"href\", \"class\"],\n  RETURN_TRUSTED_TYPE: false,\n};\n\nexport function renderCellInto(\n  el: HTMLElement,\n  source: string,\n  rules: readonly InlineScanRule[],\n): void {\n  el.innerHTML = DOMPurify.sanitize(source, CELL_SANITIZE_CONFIG) as unknown as string;\n  // Only after sanitising: a hydrate generates trusted DOM (KaTeX) from the\n  // inert text left in the element it replaces.\n  for (const rule of rules) rule.hydrate?.(el);\n}\n"],"mappings":";AAaA,OAAO,eAAe;AAItB,MAAM,uBAAuB;AAAA,EAC3B,cAAc,CAAC,MAAM,KAAK,UAAU,KAAK,MAAM,QAAQ,OAAO,OAAO,OAAO,KAAK,KAAK,QAAQ,GAAG;AAAA,EACjG,cAAc,CAAC,QAAQ,OAAO;AAAA,EAC9B,qBAAqB;AACvB;AAEO,SAAS,eACd,IACA,QACA,OACM;AACN,KAAG,YAAY,UAAU,SAAS,QAAQ,oBAAoB;AAG9D,aAAW,QAAQ,MAAO,MAAK,UAAU,EAAE;AAC7C;","names":[]}

package/dist/codemirror/table/tableCellNav.d.ts

@@ -0,0 +1,51 @@
+import { TableModel, TableCellData } from './tableModel.js';
+import '@codemirror/state';
+
+/**
+ * Pure geometry for moving the caret between table cells. A table is rendered as
+ * one atomic block whose cells are edited in per-cell subviews; navigation maps
+ * a (row, col) + direction to the next cell or to an exit out of the table. Row 0
+ * is the header; the `| --- |` delimiter row is not navigable. Kept pure (no
+ * EditorView) so the step math is unit-testable; mounting lives in
+ * {@link mountCellSubview}.
+ */
+/** Navigable rows: the header plus every body row. */
+declare function rowCount(model: TableModel): number;
+/** The cell at (row, col) — row 0 is the header — or null when out of range. */
+declare function cellAt(model: TableModel, row: number, col: number): TableCellData;
+/** The (row, col) of the cell whose source starts at `from`, or null. */
+declare function positionOf(model: TableModel, from: number): {
+    row: number;
+    col: number;
+} | null;
+type NavDir = "next" | "prev" | "up" | "down";
+type ExitEdge = "above" | "below" | "before" | "after";
+type NavTarget = {
+    kind: "cell";
+    row: number;
+    col: number;
+} | {
+    kind: "exit";
+    edge: ExitEdge;
+};
+/**
+ * Where `dir` moves from (row, col): an adjacent cell, or an exit edge when it
+ * leaves the table. `next`/`prev` (Tab / shift-Tab, or Left/Right at a cell's
+ * text edge) wrap across rows in reading order; `up`/`down` stay in the column.
+ */
+declare function stepCell(model: TableModel, row: number, col: number, dir: NavDir): NavTarget;
+/** {@link stepCell} on bare grid dimensions — the tablev2 bridge has the
+ *  dimensions but no model object. Single home for the step math. */
+declare function stepGrid(rows: number, cols: number, row: number, col: number, dir: NavDir): NavTarget;
+/**
+ * Where the caret lands when leaving the table at `edge`. The table is one atomic
+ * block spanning [from, to]: a caret at `from` is shoved forward past the whole
+ * block by CodeMirror, and a caret at `to` stays on the block's last (hidden) row
+ * — either boundary keeps the caret on the grid, so a stray arrow press is then
+ * needed to clear it. Stepping one position outward reaches the real neighbouring
+ * line: `from - 1` ends the line above, `to + 1` starts the line below (the blank
+ * line a GFM table is separated by). Both are clamped to the document.
+ */
+declare function exitCaretPos(edge: ExitEdge, from: number, to: number, docLength: number): number;
+
+export { type ExitEdge, type NavDir, type NavTarget, cellAt, exitCaretPos, positionOf, rowCount, stepCell, stepGrid };