@vscode/markdown-editor 0.0.2-0

package/dist/index.js

@@ -0,0 +1,4274 @@
+import { parse as en, preprocess as tn, postprocess as nn } from "micromark";
+import { math as sn } from "micromark-extension-math";
+import { gfmTable as rn } from "micromark-extension-gfm-table";
+import { gfmTaskListItem as on } from "micromark-extension-gfm-task-list-item";
+import { gfmStrikethrough as cn } from "micromark-extension-gfm-strikethrough";
+import { o as G, d as A, D as te, t as ln, r as an, a as Z } from "./runOnChange-owE1SMC0.js";
+import Nt from "katex";
+class _ {
+  constructor(e, t) {
+    if (this.start = e, this.endExclusive = t, e > t)
+      throw new Error(`Invalid range: [${e}, ${t})`);
+  }
+  static fromTo(e, t) {
+    return new _(e, t);
+  }
+  static ofLength(e) {
+    return new _(0, e);
+  }
+  static ofStartAndLength(e, t) {
+    return new _(e, e + t);
+  }
+  static emptyAt(e) {
+    return new _(e, e);
+  }
+  get isEmpty() {
+    return this.start === this.endExclusive;
+  }
+  get length() {
+    return this.endExclusive - this.start;
+  }
+  delta(e) {
+    return new _(this.start + e, this.endExclusive + e);
+  }
+  deltaStart(e) {
+    return new _(this.start + e, this.endExclusive);
+  }
+  deltaEnd(e) {
+    return new _(this.start, this.endExclusive + e);
+  }
+  contains(e) {
+    return this.start <= e && e < this.endExclusive;
+  }
+  containsRange(e) {
+    return this.start <= e.start && e.endExclusive <= this.endExclusive;
+  }
+  intersects(e) {
+    return Math.max(this.start, e.start) < Math.min(this.endExclusive, e.endExclusive);
+  }
+  intersectsOrTouches(e) {
+    return Math.max(this.start, e.start) <= Math.min(this.endExclusive, e.endExclusive);
+  }
+  intersect(e) {
+    const t = Math.max(this.start, e.start), s = Math.min(this.endExclusive, e.endExclusive);
+    if (t <= s)
+      return new _(t, s);
+  }
+  join(e) {
+    return new _(
+      Math.min(this.start, e.start),
+      Math.max(this.endExclusive, e.endExclusive)
+    );
+  }
+  isBefore(e) {
+    return this.endExclusive <= e.start;
+  }
+  isAfter(e) {
+    return this.start >= e.endExclusive;
+  }
+  substring(e) {
+    return e.substring(this.start, this.endExclusive);
+  }
+  slice(e) {
+    return e.slice(this.start, this.endExclusive);
+  }
+  equals(e) {
+    return this.start === e.start && this.endExclusive === e.endExclusive;
+  }
+  toString() {
+    return `[${this.start}, ${this.endExclusive})`;
+  }
+}
+class V {
+  constructor(e, t) {
+    this.replaceRange = e, this.newText = t;
+  }
+  static insert(e, t) {
+    return new V(_.emptyAt(e), t);
+  }
+  static replace(e, t) {
+    return new V(e, t);
+  }
+  static delete(e) {
+    return new V(e, "");
+  }
+  get isEmpty() {
+    return this.replaceRange.isEmpty && this.newText.length === 0;
+  }
+  equals(e) {
+    return this.replaceRange.equals(e.replaceRange) && this.newText === e.newText;
+  }
+  toString() {
+    return `${this.replaceRange} -> ${JSON.stringify(this.newText)}`;
+  }
+}
+class y {
+  static empty = new y([]);
+  static single(e) {
+    return new y([e]);
+  }
+  static replace(e, t) {
+    return new y([V.replace(e, t)]);
+  }
+  static insert(e, t) {
+    return new y([V.insert(e, t)]);
+  }
+  static delete(e) {
+    return new y([V.delete(e)]);
+  }
+  replacements;
+  constructor(e) {
+    let t = -1;
+    for (const s of e) {
+      if (s.replaceRange.start < t)
+        throw new Error(
+          `Edits must be disjoint and sorted. Found ${s} after ${t}`
+        );
+      t = s.replaceRange.endExclusive;
+    }
+    this.replacements = e;
+  }
+  get isEmpty() {
+    return this.replacements.length === 0;
+  }
+  apply(e) {
+    const t = [];
+    let s = 0;
+    for (const i of this.replacements)
+      t.push(e.substring(s, i.replaceRange.start)), t.push(i.newText), s = i.replaceRange.endExclusive;
+    return t.push(e.substring(s)), t.join("");
+  }
+  inverse(e) {
+    const t = [];
+    let s = 0;
+    for (const i of this.replacements) {
+      const r = e.substring(i.replaceRange.start, i.replaceRange.endExclusive);
+      t.push(
+        V.replace(
+          _.ofStartAndLength(i.replaceRange.start + s, i.newText.length),
+          r
+        )
+      ), s += i.newText.length - i.replaceRange.length;
+    }
+    return new y(t);
+  }
+  equals(e) {
+    if (this.replacements.length !== e.replacements.length)
+      return !1;
+    for (let t = 0; t < this.replacements.length; t++)
+      if (!this.replacements[t].equals(e.replacements[t]))
+        return !1;
+    return !0;
+  }
+  mapOffset(e) {
+    let t = 0;
+    for (const s of this.replacements) {
+      if (s.replaceRange.start > e)
+        break;
+      if (s.replaceRange.endExclusive <= e)
+        t += s.newText.length - s.replaceRange.length;
+      else
+        return s.replaceRange.start + t + s.newText.length;
+    }
+    return e + t;
+  }
+  toString() {
+    return `[${this.replacements.map((e) => e.toString()).join(", ")}]`;
+  }
+}
+class Ie {
+  constructor(e, t) {
+    if (this.replaceRange = e, this.newLength = t, t < 0)
+      throw new Error(`newLength must be non-negative, got ${t}`);
+  }
+  static replace(e, t) {
+    return new Ie(e, t);
+  }
+  get lengthDelta() {
+    return this.newLength - this.replaceRange.length;
+  }
+  equals(e) {
+    return this.replaceRange.equals(e.replaceRange) && this.newLength === e.newLength;
+  }
+  toString() {
+    return `${this.replaceRange} -> +${this.newLength}`;
+  }
+}
+class J {
+  static empty = new J([]);
+  static single(e) {
+    return new J([e]);
+  }
+  static replace(e, t) {
+    return new J([Ie.replace(e, t)]);
+  }
+  replacements;
+  constructor(e) {
+    let t = -1;
+    for (const s of e) {
+      if (s.replaceRange.start < t)
+        throw new Error(`Edits must be disjoint and sorted. Found ${s} after end ${t}`);
+      t = s.replaceRange.endExclusive;
+    }
+    this.replacements = e;
+  }
+  get isEmpty() {
+    return this.replacements.length === 0;
+  }
+  equals(e) {
+    if (this.replacements.length !== e.replacements.length)
+      return !1;
+    for (let t = 0; t < this.replacements.length; t++)
+      if (!this.replacements[t].equals(e.replacements[t]))
+        return !1;
+    return !0;
+  }
+  toString() {
+    return this.isEmpty ? "LengthEdit.empty" : this.replacements.join(", ");
+  }
+}
+class Oe {
+  constructor(e) {
+    this.value = e;
+  }
+  get length() {
+    return this.value.length;
+  }
+  substring(e) {
+    return e.substring(this.value);
+  }
+  toString() {
+    return this.value;
+  }
+}
+class x {
+  constructor(e, t) {
+    this.anchor = e, this.active = t;
+  }
+  static collapsed(e) {
+    return new x(e, e);
+  }
+  get isCollapsed() {
+    return this.anchor === this.active;
+  }
+  get isForward() {
+    return this.active >= this.anchor;
+  }
+  get range() {
+    return this.isForward ? new _(this.anchor, this.active) : new _(this.active, this.anchor);
+  }
+  collapseToActive() {
+    return x.collapsed(this.active);
+  }
+  withActive(e) {
+    return new x(this.anchor, e);
+  }
+}
+class ee {
+  constructor(e, t) {
+    this.x = e, this.y = t;
+  }
+  static ZERO = new ee(0, 0);
+  translate(e, t) {
+    return new ee(this.x + e, this.y + t);
+  }
+}
+class R {
+  constructor(e, t, s, i) {
+    this.x = e, this.y = t, this.width = s, this.height = i;
+  }
+  static EMPTY = new R(0, 0, 0, 0);
+  static fromPointPoint(e, t, s, i) {
+    return new R(e, t, s - e, i - t);
+  }
+  static fromPointSize(e, t, s, i) {
+    return new R(e, t, s, i);
+  }
+  get left() {
+    return this.x;
+  }
+  get top() {
+    return this.y;
+  }
+  get right() {
+    return this.x + this.width;
+  }
+  get bottom() {
+    return this.y + this.height;
+  }
+  get topLeft() {
+    return new ee(this.x, this.y);
+  }
+  containsX(e) {
+    return e >= this.left && e < this.right;
+  }
+  containsY(e) {
+    return e >= this.top && e < this.bottom;
+  }
+  containsPoint(e) {
+    return this.containsX(e.x) && this.containsY(e.y);
+  }
+  /** Same y/height, zero-width band at `x = this.left`. Useful for caret rects derived from a line. */
+  withZeroWidthAt(e) {
+    return new R(e, this.y, 0, this.height);
+  }
+  translate(e, t) {
+    return new R(this.x + e, this.y + t, this.width, this.height);
+  }
+}
+function It(n, e) {
+  if (e <= 0)
+    return 0;
+  let t = e - 1;
+  for (; t > 0 && /\s/.test(n[t]); )
+    t--;
+  if (t >= 0 && /\w/.test(n[t]))
+    for (; t > 0 && /\w/.test(n[t - 1]); )
+      t--;
+  else if (t >= 0)
+    for (; t > 0 && !/\w/.test(n[t - 1]) && !/\s/.test(n[t - 1]); )
+      t--;
+  return t;
+}
+function Bt(n, e) {
+  const t = n.length;
+  if (e >= t)
+    return t;
+  let s = e;
+  for (; s < t && /\s/.test(n[s]); )
+    s++;
+  if (s < t && /\w/.test(n[s]))
+    for (; s < t && /\w/.test(n[s]); )
+      s++;
+  else if (s < t)
+    for (; s < t && !/\w/.test(n[s]) && !/\s/.test(n[s]); )
+      s++;
+  return s;
+}
+function hn(n, e) {
+  if (e >= n.length)
+    return { start: n.length, end: n.length };
+  const t = n[e];
+  if (/\w/.test(t)) {
+    let r = e, o = e;
+    for (; r > 0 && /\w/.test(n[r - 1]); )
+      r--;
+    for (; o < n.length && /\w/.test(n[o]); )
+      o++;
+    return { start: r, end: o };
+  }
+  if (/\s/.test(t)) {
+    let r = e, o = e;
+    for (; r > 0 && /\s/.test(n[r - 1]); )
+      r--;
+    for (; o < n.length && /\s/.test(n[o]); )
+      o++;
+    return { start: r, end: o };
+  }
+  let s = e, i = e;
+  for (; s > 0 && !/\w/.test(n[s - 1]) && !/\s/.test(n[s - 1]); )
+    s--;
+  for (; i < n.length && !/\w/.test(n[i]) && !/\s/.test(n[i]); )
+    i++;
+  return { start: s, end: i };
+}
+let un = 1;
+class E {
+  /**
+   * A stable identity. Every node has one: it is minted on construction and
+   * carried across edits by reconciliation, so a node that survives an edit
+   * (even with changed content) keeps the same id.
+   */
+  id = un++;
+  _length = -1;
+  get length() {
+    if (this._length < 0) {
+      let e = 0;
+      for (const t of this.children)
+        e += t.length;
+      this._length = e;
+    }
+    return this._length;
+  }
+  /**
+   * True when `other` has the same content. Containers compare children *by
+   * identity* (`===`): bottom-up reconciliation substitutes reused old
+   * instances into the fresh tree first, so equal children already share
+   * instances — keeping this O(children), not O(subtree). Leaves have no
+   * children, so {@link _localEquals} is their whole comparison.
+   */
+  structurallyEqual(e) {
+    if (this === e)
+      return !0;
+    if (this.kind !== e.kind || this.length !== e.length || !this._localEquals(e))
+      return !1;
+    const t = this.children, s = e.children;
+    if (t.length !== s.length)
+      return !1;
+    for (let i = 0; i < t.length; i++)
+      if (t[i] !== s[i])
+        return !1;
+    return !0;
+  }
+  /** Compares only this node's own scalar fields (kind/length already match). */
+  _localEquals(e) {
+    return !0;
+  }
+  /**
+   * A copy of this node that adopts `id`. Reconciliation uses this to carry an
+   * old identity onto a node whose content changed. Nodes are immutable value
+   * holders, so a shallow prototype copy with `id` overridden is sound.
+   */
+  cloneWithId(e) {
+    const t = Object.create(Object.getPrototypeOf(this));
+    return Object.assign(t, this), t.id = e, t;
+  }
+}
+const dn = [];
+function O(n, e) {
+  let t;
+  for (let s = 0; s < e.length; s++) {
+    const i = n.get(e[s]);
+    i && i !== e[s] && ((t ??= e.slice())[s] = i);
+  }
+  return t ?? e;
+}
+function P(n, e) {
+  const t = n.get(e);
+  return t && t !== e ? t : e;
+}
+class Ee extends E {
+  get children() {
+    return dn;
+  }
+  get length() {
+    return this.content.length;
+  }
+  mapChildren() {
+    return this;
+  }
+}
+class ve extends Ee {
+  constructor(e) {
+    super(), this.content = e;
+  }
+  kind = "text";
+  _localEquals(e) {
+    return this.content === e.content;
+  }
+}
+class k extends Ee {
+  constructor(e, t) {
+    super(), this.markerKind = e, this.content = t;
+  }
+  kind = "marker";
+  _localEquals(e) {
+    return this.markerKind === e.markerKind && this.content === e.content;
+  }
+}
+class N extends Ee {
+  constructor(e, t) {
+    super(), this.content = e, this.glueKind = t;
+  }
+  kind = "glue";
+  _localEquals(e) {
+    return this.content === e.content && this.glueKind === e.glueKind;
+  }
+}
+class ne extends E {
+  constructor(e) {
+    super(), this.content = e;
+  }
+  kind = "thematicBreak";
+  get children() {
+    return this.content;
+  }
+  get marker() {
+    return le(this.content, "content");
+  }
+  mapChildren(e) {
+    return new ne(O(e, this.content));
+  }
+}
+function le(n, e) {
+  return n.find((t) => t instanceof k && t.markerKind === e);
+}
+class Be extends E {
+  constructor(e, t, s) {
+    super(), this.openMarker = e, this.content = t, this.closeMarker = s;
+  }
+  kind = "strong";
+  get children() {
+    return [this.openMarker, ...this.content, this.closeMarker];
+  }
+  mapChildren(e) {
+    return new Be(P(e, this.openMarker), O(e, this.content), P(e, this.closeMarker));
+  }
+}
+class Re extends E {
+  constructor(e, t, s) {
+    super(), this.openMarker = e, this.content = t, this.closeMarker = s;
+  }
+  kind = "emphasis";
+  get children() {
+    return [this.openMarker, ...this.content, this.closeMarker];
+  }
+  mapChildren(e) {
+    return new Re(P(e, this.openMarker), O(e, this.content), P(e, this.closeMarker));
+  }
+}
+class De extends E {
+  constructor(e, t, s) {
+    super(), this.openMarker = e, this.content = t, this.closeMarker = s;
+  }
+  kind = "strikethrough";
+  get children() {
+    return [this.openMarker, ...this.content, this.closeMarker];
+  }
+  mapChildren(e) {
+    return new De(P(e, this.openMarker), O(e, this.content), P(e, this.closeMarker));
+  }
+}
+class Ae extends E {
+  constructor(e) {
+    super(), this.content = e;
+  }
+  kind = "inlineCode";
+  get children() {
+    return this.content;
+  }
+  mapChildren(e) {
+    return new Ae(O(e, this.content));
+  }
+}
+class $e extends E {
+  constructor(e) {
+    super(), this.content = e;
+  }
+  kind = "inlineMath";
+  get children() {
+    return this.content;
+  }
+  mapChildren(e) {
+    return new $e(O(e, this.content));
+  }
+}
+class fe extends E {
+  constructor(e, t) {
+    super(), this.url = e, this.content = t;
+  }
+  kind = "link";
+  get children() {
+    return this.content;
+  }
+  mapChildren(e) {
+    return new fe(this.url, O(e, this.content));
+  }
+  _localEquals(e) {
+    return this.url === e.url;
+  }
+}
+class ge extends E {
+  constructor(e, t, s) {
+    super(), this.alt = e, this.url = t, this.content = s;
+  }
+  kind = "image";
+  get children() {
+    return this.content;
+  }
+  mapChildren(e) {
+    return new ge(this.alt, this.url, O(e, this.content));
+  }
+  _localEquals(e) {
+    return this.alt === e.alt && this.url === e.url;
+  }
+}
+class U extends E {
+  constructor(e, t, s) {
+    super(), this.level = e, this.marker = t, this.content = s;
+  }
+  kind = "heading";
+  get children() {
+    return [this.marker, ...this.content];
+  }
+  mapChildren(e) {
+    return new U(this.level, P(e, this.marker), O(e, this.content));
+  }
+  _localEquals(e) {
+    return this.level === e.level;
+  }
+}
+class z extends E {
+  constructor(e) {
+    super(), this.content = e;
+  }
+  kind = "paragraph";
+  get children() {
+    return this.content;
+  }
+  mapChildren(e) {
+    return new z(O(e, this.content));
+  }
+}
+class K extends E {
+  constructor(e, t) {
+    super(), this.language = e, this.content = t;
+  }
+  kind = "codeBlock";
+  _previous;
+  _contentEdit;
+  get children() {
+    return this.content;
+  }
+  get openFence() {
+    return le(this.content, "openFence");
+  }
+  get closeFence() {
+    return le(this.content, "closeFence");
+  }
+  get code() {
+    return le(this.content, "content");
+  }
+  /** Relative start offset of the {@link code} marker within this block. */
+  get codeOffset() {
+    let e = 0;
+    for (const t of this.content) {
+      if (t.kind === "marker" && t.markerKind === "content")
+        return e;
+      e += t.length;
+    }
+    return e;
+  }
+  mapChildren(e) {
+    return new K(this.language, O(e, this.content));
+  }
+  _localEquals(e) {
+    return this.language === e.language;
+  }
+  /**
+   * A copy of this block carrying an incremental link to `previous`:
+   * `contentEdit` (in the block's *content* coordinates) turns `previous`'s
+   * content into this one. Uses a weak reference so the previous tree can be
+   * garbage-collected.
+   */
+  withCodeDiff(e, t) {
+    const s = this.cloneWithId(this.id);
+    return s._previous = new WeakRef(e), s._contentEdit = t, s;
+  }
+  /**
+   * When this block was incrementally derived from `previous` (same
+   * fences/language, edit entirely within the content), returns the
+   * content-coordinate edit; otherwise `undefined`.
+   */
+  getDiff(e) {
+    if (this._contentEdit && this._previous?.deref() === e)
+      return { stringEdit: this._contentEdit };
+  }
+}
+class se extends E {
+  constructor(e) {
+    super(), this.content = e;
+  }
+  kind = "mathBlock";
+  get children() {
+    return this.content;
+  }
+  get code() {
+    return le(this.content, "content");
+  }
+  mapChildren(e) {
+    return new se(O(e, this.content));
+  }
+}
+class pe extends E {
+  constructor(e) {
+    super(), this.content = e;
+  }
+  kind = "blockQuote";
+  get children() {
+    return this.content;
+  }
+  get blocks() {
+    return this.content.filter(Ve);
+  }
+  mapChildren(e) {
+    return new pe(O(e, this.content));
+  }
+}
+class H extends E {
+  constructor(e, t) {
+    super(), this.ordered = e, this.content = t;
+  }
+  kind = "list";
+  get children() {
+    return this.content;
+  }
+  get items() {
+    return this.content.filter((e) => e instanceof $);
+  }
+  mapChildren(e) {
+    return new H(this.ordered, O(e, this.content));
+  }
+  _localEquals(e) {
+    return this.ordered === e.ordered;
+  }
+}
+class $ extends E {
+  constructor(e, t, s, i) {
+    super(), this.marker = e, this.content = t, this.checked = s, this.leadingTrivia = i;
+  }
+  kind = "listItem";
+  get children() {
+    return this.leadingTrivia ? [this.leadingTrivia, this.marker, ...this.content] : [this.marker, ...this.content];
+  }
+  get blocks() {
+    return this.content.filter(Ve);
+  }
+  mapChildren(e) {
+    return new $(
+      P(e, this.marker),
+      O(e, this.content),
+      this.checked,
+      this.leadingTrivia ? P(e, this.leadingTrivia) : void 0
+    );
+  }
+  _localEquals(e) {
+    return this.checked === e.checked;
+  }
+}
+class me extends E {
+  constructor(e) {
+    super(), this.content = e;
+  }
+  kind = "table";
+  get children() {
+    return this.content;
+  }
+  get _rows() {
+    return this.content.filter((e) => e instanceof he);
+  }
+  get headerRow() {
+    return this._rows[0];
+  }
+  get delimiterRow() {
+    return this._rows[1];
+  }
+  get bodyRows() {
+    return this._rows.slice(2);
+  }
+  mapChildren(e) {
+    return new me(O(e, this.content));
+  }
+}
+class he extends E {
+  constructor(e) {
+    super(), this.content = e;
+  }
+  kind = "tableRow";
+  get children() {
+    return this.content;
+  }
+  get cells() {
+    return this.content.filter((e) => e instanceof ue);
+  }
+  mapChildren(e) {
+    return new he(O(e, this.content));
+  }
+}
+class ue extends E {
+  constructor(e) {
+    super(), this.content = e;
+  }
+  kind = "tableCell";
+  get children() {
+    return this.content;
+  }
+  mapChildren(e) {
+    return new ue(O(e, this.content));
+  }
+}
+class Fe extends E {
+  constructor(e) {
+    super(), this.content = e;
+  }
+  kind = "document";
+  get children() {
+    return this.content;
+  }
+  get blocks() {
+    return this.content.filter(Ve);
+  }
+  mapChildren(e) {
+    return new Fe(O(e, this.content));
+  }
+}
+function Ve(n) {
+  return n instanceof U || n instanceof z || n instanceof K || n instanceof se || n instanceof ne || n instanceof pe || n instanceof H || n instanceof me;
+}
+function fn(n, e) {
+  if (n.id === e.id)
+    return 0;
+  let t = 0;
+  for (const s of n.children) {
+    const i = fn(s, e);
+    if (i !== void 0)
+      return t + i;
+    t += s.length;
+  }
+}
+const gn = /\[[ xX]\]/;
+function Si(n) {
+  if (n.checked === void 0)
+    return;
+  const e = gn.exec(Rt(n));
+  if (e)
+    return _.ofStartAndLength(e.index, e[0].length);
+}
+function Rt(n) {
+  if (n instanceof Ee)
+    return n.content;
+  let e = "";
+  for (const t of n.children)
+    e += Rt(t);
+  return e;
+}
+function pn(n) {
+  const e = en({ extensions: [sn(), rn(), on(), cn()] }), t = tn()(n, void 0, !0);
+  return nn(e.document().write(t)).map(([i, r]) => ({
+    type: i,
+    tokenType: r.type,
+    startOffset: r.start.offset,
+    endOffset: r.end.offset
+  }));
+}
+function mn(n) {
+  return new wn(pn(n), n).build();
+}
+function Ue(n) {
+  const e = [];
+  for (let t = 0; t < n.length; t++) {
+    const s = n[t], i = n[t + 1];
+    if (s instanceof N && s.glueKind === "indent") {
+      if (i instanceof H) {
+        const o = i.content.findIndex((c) => c instanceof $);
+        if (o >= 0) {
+          const c = i.content.map((l, a) => a === o ? Ye(l, s) : l);
+          e.push(new H(i.ordered, c)), t++;
+          continue;
+        }
+      } else if (i instanceof $) {
+        e.push(Ye(i, s)), t++;
+        continue;
+      }
+      const r = e[e.length - 1];
+      if (r instanceof N && r.glueKind === void 0) {
+        e[e.length - 1] = new N(r.content + s.content);
+        continue;
+      }
+      e.push(new N(s.content));
+      continue;
+    }
+    e.push(s);
+  }
+  return e;
+}
+function Ye(n, e) {
+  return new $(n.marker, n.content, n.checked, e);
+}
+function ke(n) {
+  const e = [];
+  for (let t = 0; t < n.length; t++) {
+    const s = n[t];
+    if (s instanceof N && s.glueKind === void 0) {
+      const i = e[e.length - 1], r = n[t + 1], o = i instanceof z && r instanceof z, c = new N(s.content, o ? "blockBreak" : "blockGap"), l = i !== void 0 ? Dt(i, c) : void 0;
+      l ? e[e.length - 1] = l : e.push(c);
+      continue;
+    }
+    e.push(s);
+  }
+  return e;
+}
+function Dt(n, e) {
+  switch (n.kind) {
+    case "paragraph":
+      return new z([...n.content, e]);
+    case "heading": {
+      const t = n;
+      return new U(t.level, t.marker, [...t.content, e]);
+    }
+    case "codeBlock": {
+      const t = n;
+      return new K(t.language, [...t.content, e]);
+    }
+    case "mathBlock":
+      return new se([...n.content, e]);
+    case "thematicBreak":
+      return new ne([...n.content, e]);
+    case "table":
+      return new me([...n.content, e]);
+    case "blockQuote":
+      return new pe(Me(n.content, e));
+    case "list": {
+      const t = n;
+      return new H(t.ordered, Me(t.content, e));
+    }
+    case "listItem": {
+      const t = n;
+      return new $(t.marker, Me(t.content, e), t.checked, t.leadingTrivia);
+    }
+    default:
+      return;
+  }
+}
+function Me(n, e) {
+  const t = n[n.length - 1], s = t !== void 0 ? Dt(t, e) : void 0;
+  if (s) {
+    const i = n.slice();
+    return i[i.length - 1] = s, i;
+  }
+  return [...n, e];
+}
+function _n(n) {
+  return n.some((e) => !(e instanceof N)) ? n : [new z(n)];
+}
+class C {
+  constructor(e, t) {
+    this._parentStart = e, this._source = t;
+  }
+  _entries = [];
+  add(e, t) {
+    this._entries.push({ node: e, start: t });
+  }
+  build(e, t) {
+    this._entries.sort((c, l) => c.start - l.start);
+    const s = [];
+    let i = this._parentStart;
+    const r = this._parentStart + e, o = (c, l) => {
+      const a = this._source.substring(c, l), h = t ? null : /\n[^\S\n]+$/.exec(a);
+      if (!h) {
+        s.push(new N(a, t));
+        return;
+      }
+      const g = a.slice(h.index + 1);
+      s.push(new N(a.slice(0, a.length - g.length))), s.push(new N(g, "indent"));
+    };
+    for (const { node: c, start: l } of this._entries)
+      c.length !== 0 && (l > i && o(i, l), s.push(c), i = l + c.length);
+    return i < r && o(i, r), s;
+  }
+}
+class wn {
+  constructor(e, t) {
+    this._events = e, this._source = t;
+  }
+  _idx = 0;
+  _checkChecked;
+  build() {
+    const e = new C(0, this._source);
+    for (; this._idx < this._events.length; ) {
+      const t = this._events[this._idx];
+      if (t.type === "enter") {
+        const s = t.startOffset, i = this._tryParseBlock();
+        i ? e.add(i, s) : this._idx++;
+      } else
+        this._idx++;
+    }
+    return new Fe(_n(ke(e.build(this._source.length))));
+  }
+  _tryParseBlock() {
+    switch (this._events[this._idx].tokenType) {
+      case "atxHeading":
+        return this._parseHeading();
+      case "paragraph":
+        return this._parseParagraph();
+      case "codeFenced":
+        return this._parseCodeFenced();
+      case "mathFlow":
+        return this._parseMathFlow();
+      case "thematicBreak":
+        return this._parseThematicBreak();
+      case "blockQuote":
+        return this._parseBlockQuote();
+      case "listUnordered":
+      case "listOrdered":
+        return this._parseList();
+      case "table":
+        return this._parseTable();
+      default:
+        return;
+    }
+  }
+  _parseHeading() {
+    const e = this._consume("enter", "atxHeading");
+    let t = 1, s = e.startOffset, i = e.startOffset;
+    const r = [];
+    for (; this._notExit("atxHeading"); ) {
+      const h = this._events[this._idx];
+      if (h.type === "enter" && h.tokenType === "atxHeadingSequence") {
+        const g = this._consume("enter", "atxHeadingSequence"), u = this._consume("exit", "atxHeadingSequence");
+        i === e.startOffset && (t = Math.min(6, Math.max(1, u.endOffset - g.startOffset)), s = g.startOffset, i = u.endOffset);
+      } else h.type === "enter" && h.tokenType === "atxHeadingText" ? (this._consume("enter", "atxHeadingText"), this._parseInlines(r, "atxHeadingText"), this._consume("exit", "atxHeadingText")) : this._idx++;
+    }
+    const o = this._consume("exit", "atxHeading");
+    i > s && r.length > 0 && (i = r[0].start);
+    const c = new k("headingMarker", this._source.substring(e.startOffset, i)), l = new C(i, this._source);
+    for (const h of r)
+      l.add(h.node, h.start);
+    const a = l.build(o.endOffset - i);
+    return new U(t, c, a);
+  }
+  _parseParagraph() {
+    const e = this._consume("enter", "paragraph"), t = [];
+    for (; this._notExit("paragraph"); )
+      this._parseInlineEvent(t);
+    const s = this._consume("exit", "paragraph"), i = new C(e.startOffset, this._source);
+    for (const r of t)
+      i.add(r.node, r.start);
+    return new z(i.build(s.endOffset - e.startOffset));
+  }
+  _parseCodeFenced() {
+    const e = this._consume("enter", "codeFenced");
+    let t = "";
+    const s = new C(e.startOffset, this._source);
+    let i = !1, r, o;
+    for (; this._notExit("codeFenced"); ) {
+      const l = this._events[this._idx];
+      if (l.type === "enter" && l.tokenType === "codeFencedFence") {
+        const a = this._consume("enter", "codeFencedFence");
+        for (; this._notExit("codeFencedFence"); ) {
+          const g = this._events[this._idx];
+          if (g.type === "enter" && g.tokenType === "codeFencedFenceInfo") {
+            for (this._consume("enter", "codeFencedFenceInfo"); this._notExit("codeFencedFenceInfo"); ) {
+              const u = this._events[this._idx];
+              u.tokenType === "data" && (t = this._source.substring(u.startOffset, u.endOffset)), this._idx++;
+            }
+            this._consume("exit", "codeFencedFenceInfo");
+          } else
+            this._idx++;
+        }
+        const h = this._consume("exit", "codeFencedFence");
+        s.add(new k(
+          i ? "closeFence" : "openFence",
+          this._source.substring(a.startOffset, h.endOffset)
+        ), a.startOffset), i = !0;
+      } else l.tokenType === "codeFlowValue" || l.tokenType === "lineEnding" ? (r === void 0 && (r = l.startOffset), o = l.endOffset, this._idx++) : this._idx++;
+    }
+    const c = this._consume("exit", "codeFenced");
+    return r !== void 0 && s.add(new k("content", this._source.substring(r, o)), r), new K(t, s.build(c.endOffset - e.startOffset));
+  }
+  _parseMathFlow() {
+    const e = this._consume("enter", "mathFlow"), t = new C(e.startOffset, this._source);
+    let s = !1, i, r;
+    for (; this._notExit("mathFlow"); ) {
+      const c = this._events[this._idx];
+      if (c.type === "enter" && c.tokenType === "mathFlowFence") {
+        const l = this._consume("enter", "mathFlowFence");
+        for (; this._notExit("mathFlowFence"); )
+          this._idx++;
+        const a = this._consume("exit", "mathFlowFence");
+        t.add(new k(
+          s ? "closeFence" : "openFence",
+          this._source.substring(l.startOffset, a.endOffset)
+        ), l.startOffset), s = !0;
+      } else c.tokenType === "mathFlowValue" || c.tokenType === "lineEnding" ? (i === void 0 && (i = c.startOffset), r = c.endOffset, this._idx++) : this._idx++;
+    }
+    const o = this._consume("exit", "mathFlow");
+    return i !== void 0 && t.add(new k("content", this._source.substring(i, r)), i), new se(t.build(o.endOffset - e.startOffset));
+  }
+  _parseThematicBreak() {
+    const e = this._consume("enter", "thematicBreak");
+    for (; this._notExit("thematicBreak"); )
+      this._idx++;
+    const t = this._consume("exit", "thematicBreak"), s = new k("content", this._source.substring(e.startOffset, t.endOffset));
+    return new ne([s]);
+  }
+  _parseBlockQuote() {
+    const e = this._consume("enter", "blockQuote"), t = new C(e.startOffset, this._source);
+    let s = !1;
+    for (; this._notExit("blockQuote"); ) {
+      const r = this._events[this._idx];
+      if (r.type === "enter" && r.tokenType === "blockQuotePrefix") {
+        const o = this._consume("enter", "blockQuotePrefix");
+        for (; this._notExit("blockQuotePrefix"); )
+          this._idx++;
+        const c = this._consume("exit", "blockQuotePrefix");
+        s || t.add(new k("blockQuoteMarker", this._source.substring(o.startOffset, c.endOffset)), o.startOffset);
+      } else if (r.type === "enter") {
+        const o = r.startOffset, c = this._tryParseBlock();
+        c ? (t.add(c, o), s = !0) : this._idx++;
+      } else
+        this._idx++;
+    }
+    const i = this._consume("exit", "blockQuote");
+    return new pe(ke(t.build(i.endOffset - e.startOffset)));
+  }
+  _parseList() {
+    const e = this._events[this._idx].tokenType, t = e === "listOrdered", s = this._consume("enter", e), i = new C(s.startOffset, this._source);
+    let r, o, c, l, a, h;
+    const g = () => {
+      if (r === void 0 || o === void 0 || l === void 0)
+        return;
+      const d = new k("listItemMarker", this._source.substring(o, c)), f = h ?? c, p = l.build(f - c);
+      i.add(new $(d, ke(Ue(p)), a), r);
+    };
+    for (; this._notExit(e); ) {
+      const d = this._events[this._idx];
+      if (d.type === "enter" && d.tokenType === "listItemPrefix") {
+        for (g(), this._consume("enter", "listItemPrefix"), r = d.startOffset, o = d.startOffset, a = void 0, h = void 0, this._checkChecked = void 0; this._notExit("listItemPrefix"); )
+          this._idx++;
+        c = this._events[this._idx].endOffset, this._consume("exit", "listItemPrefix"), l = new C(c, this._source);
+      } else if (d.type === "enter") {
+        const f = d.startOffset, p = this._tryParseBlock();
+        p && l ? (l.add(p, f), h = f + p.length, a === void 0 && this._checkChecked !== void 0 && (a = this._checkChecked)) : p || this._idx++;
+      } else
+        this._idx++;
+    }
+    g();
+    const u = this._consume("exit", e);
+    return new H(t, ke(Ue(i.build(u.endOffset - s.startOffset))));
+  }
+  _parseTable() {
+    const e = this._consume("enter", "table"), t = new C(e.startOffset, this._source);
+    let s = 0;
+    for (; this._notExit("table"); ) {
+      const r = this._events[this._idx];
+      if (r.type === "enter" && r.tokenType === "tableHead") {
+        for (this._consume("enter", "tableHead"); this._notExit("tableHead"); ) {
+          const o = this._events[this._idx];
+          if (o.type === "enter" && o.tokenType === "tableRow") {
+            const c = this._parseTableRow("tableHeader");
+            s = c.cells.length, t.add(c, o.startOffset);
+          } else if (o.type === "enter" && o.tokenType === "tableDelimiterRow") {
+            const c = o.startOffset;
+            for (; this._notExit("tableDelimiterRow"); )
+              this._idx++;
+            const l = this._events[this._idx].endOffset;
+            this._idx++, t.add(this._buildDelimiterRow(c, l, s), c);
+          } else
+            this._idx++;
+        }
+        this._consume("exit", "tableHead");
+      } else if (r.type === "enter" && r.tokenType === "tableBody") {
+        for (this._consume("enter", "tableBody"); this._notExit("tableBody"); ) {
+          const o = this._events[this._idx];
+          o.type === "enter" && o.tokenType === "tableRow" ? t.add(this._parseTableRow("tableData"), o.startOffset) : this._idx++;
+        }
+        this._consume("exit", "tableBody");
+      } else
+        this._idx++;
+    }
+    const i = this._consume("exit", "table");
+    return new me(t.build(i.endOffset - e.startOffset));
+  }
+  _buildDelimiterRow(e, t, s) {
+    const i = this._source.substring(e, t), r = [];
+    for (let a = 0; a < i.length; a++)
+      i[a] === "|" && r.push(a);
+    const o = [], c = Math.max(1, s);
+    if (i[0] === "|")
+      for (let a = 0; a < c && a < r.length; a++)
+        o.push(r[a]);
+    else {
+      o.push(0);
+      for (let a = 0; a < c - 1 && a < r.length; a++)
+        o.push(r[a]);
+    }
+    const l = new C(e, this._source);
+    for (let a = 0; a < o.length; a++) {
+      const h = o[a], g = a + 1 < o.length ? o[a + 1] : i.length, u = new C(e + h, this._source), d = i.substring(h, g);
+      a === o.length - 1 && d.length > 1 && d.endsWith("|") ? (u.add(new k("tableDelimiter", d.slice(0, -1)), e + h), u.add(new k("tableDelimiterClose", "|"), e + h + d.length - 1)) : u.add(new k("tableDelimiter", d), e + h), l.add(new ue(u.build(g - h)), e + h);
+    }
+    return new he(l.build(t - e));
+  }
+  _parseTableRow(e) {
+    const t = this._consume("enter", "tableRow"), s = new C(t.startOffset, this._source);
+    for (; this._notExit("tableRow"); ) {
+      const r = this._events[this._idx];
+      if (r.type === "enter" && r.tokenType === e) {
+        const o = this._consume("enter", e), c = [];
+        for (; this._notExit(e); ) {
+          const h = this._events[this._idx];
+          if (h.type === "enter" && h.tokenType === "tableContent") {
+            for (this._consume("enter", "tableContent"); this._notExit("tableContent"); )
+              this._parseInlineEvent(c);
+            this._consume("exit", "tableContent");
+          } else
+            this._idx++;
+        }
+        const l = this._consume("exit", e), a = new C(o.startOffset, this._source);
+        for (const h of c)
+          a.add(h.node, h.start);
+        s.add(new ue(a.build(l.endOffset - o.startOffset, "tableCellGlue")), o.startOffset);
+      } else
+        this._idx++;
+    }
+    const i = this._consume("exit", "tableRow");
+    return new he(s.build(i.endOffset - t.startOffset));
+  }
+  _parseInlines(e, t) {
+    for (; this._idx < this._events.length; ) {
+      const s = this._events[this._idx];
+      if (s.type === "exit" && s.tokenType === t)
+        return;
+      this._parseInlineEvent(e);
+    }
+  }
+  _parseInlineEvent(e) {
+    const t = this._events[this._idx];
+    if (t.type === "enter")
+      switch (t.tokenType) {
+        case "strongSequence":
+        case "emphasisSequence":
+          this._parseEmphasisOrStrong(e);
+          return;
+        case "codeText":
+          e.push(this._parseInlineCode());
+          return;
+        case "mathText":
+          e.push(this._parseInlineMath());
+          return;
+        case "link":
+          e.push(this._parseLink());
+          return;
+        case "image":
+          e.push(this._parseImage());
+          return;
+        case "strikethrough":
+          e.push(this._parseStrikethrough());
+          return;
+        case "hardBreakTrailing":
+        case "hardBreakEscape":
+          e.push(this._parseHardBreak());
+          return;
+      }
+    t.type === "exit" && (t.tokenType === "data" || t.tokenType === "codeTextData") && e.push({ node: new ve(this._source.substring(t.startOffset, t.endOffset)), start: t.startOffset }), t.type === "exit" && t.tokenType === "taskListCheckValueChecked" ? this._checkChecked = !0 : t.type === "exit" && t.tokenType === "taskListCheckValueUnchecked" && (this._checkChecked = !1), this._idx++;
+  }
+  /**
+   * A GFM hard line break — either two-or-more trailing spaces
+   * (`hardBreakTrailing`) or a backslash (`hardBreakEscape`) — followed by the
+   * line ending it forces. Both halves are absorbed into a single
+   * `hardBreak` marker, so the node *is* the whole break: a bare `lineEnding`
+   * (a soft break) is never matched here and stays glue that collapses to a
+   * space. Whether the line ending breaks is thus micromark's call, not ours.
+   */
+  _parseHardBreak() {
+    const e = this._events[this._idx], t = e.tokenType;
+    for (this._consume("enter", t); this._notExit(t); )
+      this._idx++;
+    let s = this._consume("exit", t).endOffset;
+    const i = this._events[this._idx];
+    return i && i.type === "enter" && i.tokenType === "lineEnding" && (this._consume("enter", "lineEnding"), s = this._consume("exit", "lineEnding").endOffset), { node: new k("hardBreak", this._source.substring(e.startOffset, s)), start: e.startOffset };
+  }
+  _parseEmphasisOrStrong(e) {
+    const t = this._events[this._idx].tokenType, s = t === "strongSequence", i = this._consume("enter", t), r = this._consume("exit", t), o = [];
+    for (; this._idx < this._events.length; ) {
+      const c = this._events[this._idx];
+      if (c.type === "enter" && c.tokenType === t) {
+        const l = this._consume("enter", t), a = this._consume("exit", t), h = new k("openMarker", this._source.substring(i.startOffset, r.endOffset)), g = new k("closeMarker", this._source.substring(l.startOffset, a.endOffset)), u = new C(r.endOffset, this._source);
+        for (const p of o)
+          u.add(p.node, p.start);
+        const d = u.build(l.startOffset - r.endOffset), f = s ? new Be(h, d, g) : new Re(h, d, g);
+        e.push({ node: f, start: i.startOffset });
+        return;
+      }
+      this._parseInlineEvent(o);
+    }
+    e.push({ node: new ve(this._source.substring(i.startOffset, r.endOffset)), start: i.startOffset });
+  }
+  _parseInlineCode() {
+    const e = this._consume("enter", "codeText"), t = new C(e.startOffset, this._source);
+    let s = !1, i, r;
+    for (; this._notExit("codeText"); ) {
+      const c = this._events[this._idx];
+      c.type === "enter" && c.tokenType === "codeTextSequence" ? (t.add(new k(s ? "closeMarker" : "openMarker", this._source.substring(c.startOffset, c.endOffset)), c.startOffset), s = !0) : c.type === "enter" && c.tokenType === "codeTextData" && (i === void 0 && (i = c.startOffset), r = c.endOffset), this._idx++;
+    }
+    const o = this._consume("exit", "codeText");
+    return i !== void 0 && t.add(new k("content", this._source.substring(i, r)), i), { node: new Ae(t.build(o.endOffset - e.startOffset)), start: e.startOffset };
+  }
+  _parseInlineMath() {
+    const e = this._consume("enter", "mathText"), t = new C(e.startOffset, this._source);
+    let s = !1, i, r;
+    for (; this._notExit("mathText"); ) {
+      const c = this._events[this._idx];
+      c.type === "enter" && c.tokenType === "mathTextSequence" ? (t.add(new k(s ? "closeMarker" : "openMarker", this._source.substring(c.startOffset, c.endOffset)), c.startOffset), s = !0) : c.type === "enter" && c.tokenType === "mathTextData" && (i === void 0 && (i = c.startOffset), r = c.endOffset), this._idx++;
+    }
+    const o = this._consume("exit", "mathText");
+    return i !== void 0 && t.add(new k("content", this._source.substring(i, r)), i), { node: new $e(t.build(o.endOffset - e.startOffset)), start: e.startOffset };
+  }
+  _parseStrikethrough() {
+    const e = this._consume("enter", "strikethrough");
+    let t, s, i = e.startOffset, r = e.startOffset;
+    const o = [];
+    for (; this._notExit("strikethrough"); ) {
+      const a = this._events[this._idx];
+      if (a.type === "enter" && a.tokenType === "strikethroughSequence") {
+        const h = this._source.substring(a.startOffset, a.endOffset);
+        t ? (s = new k("closeMarker", h), r = a.startOffset) : (t = new k("openMarker", h), i = a.endOffset), this._idx++;
+      } else a.type === "enter" && a.tokenType === "strikethroughText" ? (this._consume("enter", "strikethroughText"), this._parseInlines(o, "strikethroughText"), this._consume("exit", "strikethroughText")) : this._idx++;
+    }
+    this._consume("exit", "strikethrough");
+    const c = new C(i, this._source);
+    for (const a of o)
+      c.add(a.node, a.start);
+    const l = c.build(r - i);
+    return { node: new De(t, l, s), start: e.startOffset };
+  }
+  _parseLink() {
+    const e = this._consume("enter", "link"), t = new C(e.startOffset, this._source), s = [];
+    let i = "", r = !1;
+    for (; this._notExit("link"); ) {
+      const c = this._events[this._idx];
+      if (c.type === "enter" && c.tokenType === "label") {
+        for (this._consume("enter", "label"); this._notExit("label"); ) {
+          const l = this._events[this._idx];
+          if (l.type === "enter" && l.tokenType === "labelMarker")
+            t.add(new k(r ? "closeBracket" : "openBracket", this._source.substring(l.startOffset, l.endOffset)), l.startOffset), r = !0;
+          else if (l.type === "enter" && l.tokenType === "labelText") {
+            this._consume("enter", "labelText"), this._parseInlines(s, "labelText"), this._consume("exit", "labelText");
+            continue;
+          }
+          this._idx++;
+        }
+        this._consume("exit", "label");
+      } else if (c.type === "enter" && c.tokenType === "resource") {
+        this._consume("enter", "resource");
+        let l = !1;
+        for (; this._notExit("resource"); ) {
+          const a = this._events[this._idx];
+          a.type === "enter" && a.tokenType === "resourceMarker" ? (t.add(new k(l ? "closeParen" : "openParen", this._source.substring(a.startOffset, a.endOffset)), a.startOffset), l = !0) : a.type === "enter" && a.tokenType === "resourceDestinationString" && (i = this._source.substring(a.startOffset, a.endOffset), t.add(new k("url", i), a.startOffset)), this._idx++;
+        }
+        this._consume("exit", "resource");
+      } else
+        this._idx++;
+    }
+    const o = this._consume("exit", "link");
+    for (const c of s)
+      t.add(c.node, c.start);
+    return { node: new fe(i, t.build(o.endOffset - e.startOffset)), start: e.startOffset };
+  }
+  _parseImage() {
+    const e = this._consume("enter", "image"), t = new C(e.startOffset, this._source);
+    let s = "", i = "", r = !1;
+    for (; this._notExit("image"); ) {
+      const c = this._events[this._idx];
+      if (c.type === "enter" && c.tokenType === "label") {
+        for (this._consume("enter", "label"); this._notExit("label"); ) {
+          const l = this._events[this._idx];
+          l.type === "enter" && l.tokenType === "labelImageMarker" ? t.add(new k("bangBracket", this._source.substring(l.startOffset, l.endOffset)), l.startOffset) : l.type === "enter" && l.tokenType === "labelMarker" ? (t.add(new k(r ? "closeBracket" : "openBracket", this._source.substring(l.startOffset, l.endOffset)), l.startOffset), r = !0) : l.type === "enter" && l.tokenType === "labelText" && (s = this._source.substring(l.startOffset, l.endOffset)), this._idx++;
+        }
+        this._consume("exit", "label");
+      } else if (c.type === "enter" && c.tokenType === "resource") {
+        this._consume("enter", "resource");
+        let l = !1;
+        for (; this._notExit("resource"); ) {
+          const a = this._events[this._idx];
+          a.type === "enter" && a.tokenType === "resourceMarker" ? (t.add(new k(l ? "closeParen" : "openParen", this._source.substring(a.startOffset, a.endOffset)), a.startOffset), l = !0) : a.type === "enter" && a.tokenType === "resourceDestinationString" && (i = this._source.substring(a.startOffset, a.endOffset)), this._idx++;
+        }
+        this._consume("exit", "resource");
+      } else
+        this._idx++;
+    }
+    const o = this._consume("exit", "image");
+    return { node: new ge(s, i, t.build(o.endOffset - e.startOffset)), start: e.startOffset };
+  }
+  _notExit(e) {
+    if (this._idx >= this._events.length)
+      return !1;
+    const t = this._events[this._idx];
+    return !(t.type === "exit" && t.tokenType === e);
+  }
+  _consume(e, t) {
+    const s = this._events[this._idx];
+    if (!s || s.type !== e || s.tokenType !== t)
+      throw new Error(`Expected ${e}:${t} at ${this._idx}, got ${s?.type}:${s?.tokenType}`);
+    return this._idx++, s;
+  }
+}
+class kn {
+  constructor(e) {
+    this._edit = e;
+  }
+  /**
+   * The original range corresponding to `mod`, or `undefined` if `mod`
+   * overlaps any replaced/inserted text (i.e. is not provably unchanged).
+   */
+  getOriginalRange(e) {
+    let t = 0;
+    for (const s of this._edit.replacements) {
+      const i = s.replaceRange.start + t;
+      if (i >= e.endExclusive)
+        break;
+      const r = i + s.newText.length;
+      if (Math.max(i, e.start) < Math.min(r, e.endExclusive))
+        return;
+      t += s.newText.length - s.replaceRange.length;
+    }
+    return e.delta(-t);
+  }
+  /** The original offset for `mod`, or `undefined` if it falls inside inserted text. */
+  getOriginalOffset(e) {
+    let t = 0;
+    for (const s of this._edit.replacements) {
+      const i = s.replaceRange.start + t;
+      if (e < i)
+        break;
+      if (e < i + s.newText.length)
+        return;
+      t += s.newText.length - s.replaceRange.length;
+    }
+    return e - t;
+  }
+}
+class xn {
+  _byRange = /* @__PURE__ */ new Map();
+  _byId = /* @__PURE__ */ new Map();
+  constructor(e) {
+    this._walk(e, 0);
+  }
+  _walk(e, t) {
+    const s = `${t}:${t + e.length}`;
+    let i = this._byRange.get(s);
+    i || (i = [], this._byRange.set(s, i)), i.push(e), this._byId.set(`${t}:${e.kind}`, e);
+    let r = t;
+    for (const o of e.children)
+      this._walk(o, r), r += o.length;
+  }
+  /** The old node spanning exactly `range` with the given `kind`, if any. */
+  lookupExact(e, t) {
+    return this._byRange.get(`${e.start}:${e.endExclusive}`)?.find((s) => s.kind === t);
+  }
+  /** The old node that began at `originalStart` with the given `kind`. */
+  lookupId(e, t) {
+    return this._byId.get(`${e}:${t}`);
+  }
+}
+function At(n, e, t, s, i) {
+  let r, o = e;
+  for (const g of n.children) {
+    const u = At(g, o, t, s, i);
+    u !== g && (r ??= /* @__PURE__ */ new Map()).set(g, u), o += g.length;
+  }
+  let c = r ? n.mapChildren(r) : n;
+  const l = t.getOriginalRange(_.ofStartAndLength(e, n.length));
+  if (l) {
+    const g = s.lookupExact(l, c.kind);
+    if (g && c.structurallyEqual(g))
+      return g;
+  }
+  const a = t.getOriginalOffset(e), h = a !== void 0 ? s.lookupId(a, c.kind) : void 0;
+  if (h && h.id !== c.id && (c = c.cloneWithId(h.id)), c instanceof K && h instanceof K && a !== void 0) {
+    const g = vn(c, h, a, i);
+    if (g)
+      return g;
+  }
+  return c;
+}
+function vn(n, e, t, s) {
+  const i = e.code, r = n.code;
+  if (!i || !r || n.language !== e.language || n.openFence?.content !== e.openFence?.content || n.closeFence?.content !== e.closeFence?.content)
+    return;
+  const o = t + e.codeOffset, c = o + i.length;
+  if (!bn(s, o, c))
+    return;
+  const l = yn(s, -o);
+  if (l.apply(i.content) === r.content)
+    return n.withCodeDiff(e, l);
+}
+function bn(n, e, t) {
+  for (const s of n.replacements)
+    if (s.replaceRange.start < e || s.replaceRange.endExclusive > t)
+      return !1;
+  return !0;
+}
+function yn(n, e) {
+  return new y(n.replacements.map((t) => V.replace(t.replaceRange.delta(e), t.newText)));
+}
+function En(n, e, t) {
+  return At(n, 0, new kn(t), new xn(e), t);
+}
+function Cn(n, e, t) {
+  const s = mn(n);
+  return !e || !t ? s : En(s, e, t);
+}
+class On {
+  parse(e, t, s) {
+    return Cn(e.value, t, s);
+  }
+}
+function Mn(n, e, t = 0) {
+  if (n.children.length === 0) {
+    const r = $t(e.substring(t, t + n.length));
+    if (n instanceof ve || n instanceof N)
+      return r;
+    const o = n instanceof k ? n.markerKind : n.kind;
+    return `<${o}${Je(n)}>${r}</${o}>`;
+  }
+  let s = "", i = t;
+  for (const r of n.children)
+    s += Mn(r, e, i), i += r.length;
+  return `<${n.kind}${Je(n)}>${s}</${n.kind}>`;
+}
+function Je(n) {
+  const e = {};
+  return n instanceof U ? e.level = String(n.level) : n instanceof H ? e.ordered = String(n.ordered) : n instanceof K ? n.language && (e.language = n.language) : n instanceof fe ? e.url = n.url : n instanceof ge ? (e.alt = n.alt, e.url = n.url) : n instanceof $ && n.checked !== void 0 && (e.checked = String(n.checked)), Object.entries(e).map(([t, s]) => ` ${t}="${$t(s)}"`).join("");
+}
+function $t(n) {
+  return n.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function Tn(n) {
+  return n instanceof ve ? `text ${JSON.stringify(n.content)}` : n instanceof N ? `glue${n.glueKind ? `(${n.glueKind})` : ""} ${JSON.stringify(n.content)}` : n instanceof k ? `marker(${n.markerKind}) ${JSON.stringify(n.content)}` : n instanceof ne ? `thematicBreak ${JSON.stringify(n.content)}` : n instanceof U ? `heading(level=${n.level})` : n instanceof H ? `list(ordered=${n.ordered})` : n instanceof $ ? n.checked === void 0 ? "listItem" : `listItem(checked=${n.checked})` : n instanceof K ? `codeBlock(language=${JSON.stringify(n.language)})` : n instanceof se ? "mathBlock" : n instanceof fe ? `link(url=${JSON.stringify(n.url)})` : n instanceof ge ? `image(alt=${JSON.stringify(n.alt)}, url=${JSON.stringify(n.url)})` : n.kind;
+}
+const Ze = /* @__PURE__ */ new WeakMap();
+let Sn = 0;
+function Ln(n) {
+  let e = Ze.get(n);
+  return e === void 0 && (e = Sn++, Ze.set(n, e)), e;
+}
+function Li(n, e) {
+  let t = 0;
+  function s(i) {
+    const r = t, o = i.children;
+    let c;
+    return o.length === 0 ? t += i.length : c = o.map(s), { label: `${Tn(i)}  #${Ln(i)} nid=${i.id}`, range: [r, t], children: c };
+  }
+  return { $fileExtension: "ast.w", source: e, root: s(n) };
+}
+const Nn = Symbol("NO_ACTIVE_BLOCKS");
+class Ni {
+  _parser = new On();
+  /**
+   * The most recent edit applied to {@link sourceText}, used by
+   * {@link document} to let the parser link incrementally edited code
+   * blocks. Only trusted when it exactly bridges the previous and current
+   * source text (see {@link document}).
+   */
+  _pendingEdit;
+  sourceText = G(this, new Oe(""));
+  /**
+   * The current selection, or `undefined` when the editor has no caret
+   * (e.g. an inactive/unfocused rendering).
+   */
+  selection = G(this, x.collapsed(0));
+  /**
+   * Forces the rendered active-block set. `undefined` (the default)
+   * derives the set from the current selection range (see
+   * {@link activeBlocks}). The sentinel {@link NO_ACTIVE_BLOCKS} forces
+   * "no active block" — useful in fixtures that always want the
+   * collapsed/inactive rendering.
+   */
+  activeBlocksOverride = G(this, void 0);
+  cursorOffset = A(
+    this,
+    (e) => e.readObservable(this.selection)?.active
+  );
+  /**
+   * The parsed document. Threads the previous document into the parser so
+   * unchanged blocks keep their object identity across reparses (see
+   * {@link MarkdownParser.parse}). Writing `previous` inside the compute is
+   * a safe optimization: `derived` only recomputes when `sourceText`
+   * changes, and the result is structurally identical to a full reparse.
+   */
+  document = (() => {
+    let e, t;
+    return A(this, (s) => {
+      const i = s.readObservable(this.sourceText), r = this._pendingEdit, o = r && r.baseText === t && r.newText === i.value ? r.edit : void 0, c = this._parser.parse(i, e, o);
+      return e = c, t = i.value, c;
+    });
+  })();
+  /**
+   * Block that contains the cursor (selection's active end). Used by
+   * cursor navigation to know which block's marker ranges count as
+   * visible. Unaffected by {@link activeBlocksOverride} because
+   * navigation is independent of rendering.
+   */
+  activeBlock = A(this, (e) => {
+    const t = e.readObservable(this.document), s = e.readObservable(this.cursorOffset);
+    if (s !== void 0)
+      return Ft(t, s);
+  });
+  /**
+   * All blocks whose source range intersects the current selection.
+   * The rendering side uses this to decide which blocks render in
+   * their expanded (markers-visible) form. When the selection is
+   * collapsed this is a one-element set holding {@link activeBlock}.
+   */
+  activeBlocks = A(this, (e) => {
+    const t = e.readObservable(this.activeBlocksOverride);
+    if (t === Nn)
+      return /* @__PURE__ */ new Set();
+    if (t !== void 0)
+      return new Set(t);
+    const s = e.readObservable(this.document), i = e.readObservable(this.selection);
+    return i === void 0 ? /* @__PURE__ */ new Set() : new Set(In(s, i.range.start, i.range.endExclusive));
+  });
+  applyEdit(e) {
+    const t = this.sourceText.get(), s = new Oe(e.apply(t.value)), i = this.selection.get() ?? x.collapsed(0), r = e.mapOffset(i.active);
+    this._pendingEdit = { baseText: t.value, newText: s.value, edit: e }, this.sourceText.set(s, void 0), this.selection.set(x.collapsed(r), void 0);
+  }
+  applyEditForSelection(e) {
+    const t = this.sourceText.get(), s = new Oe(e.apply(t.value)), i = this.selection.get() ?? x.collapsed(0), r = e.mapOffset(i.range.endExclusive);
+    this._pendingEdit = { baseText: t.value, newText: s.value, edit: e }, this.sourceText.set(s, void 0), this.selection.set(x.collapsed(r), void 0);
+  }
+}
+function Ft(n, e) {
+  let t = 0, s;
+  for (const i of n.children) {
+    const r = t + i.length;
+    if (n.blocks.includes(i)) {
+      if (t <= e && e < r)
+        return i;
+      r === e && (s = i);
+    }
+    t = r;
+  }
+  return s;
+}
+function In(n, e, t) {
+  if (e === t) {
+    const r = Ft(n, e);
+    return r ? [r] : [];
+  }
+  const s = [];
+  let i = 0;
+  for (const r of n.children) {
+    const o = i + r.length;
+    n.blocks.includes(r) && i < t && o > e && s.push(r), i = o;
+  }
+  return s;
+}
+class _e {
+  constructor(e) {
+    this.lines = e;
+  }
+  static EMPTY = new _e([]);
+  static measure(e) {
+    return An(e);
+  }
+  get lineCount() {
+    return this.lines.length;
+  }
+  get isEmpty() {
+    return this.lines.length === 0;
+  }
+  lineRect(e) {
+    return this.lines[e].rect;
+  }
+  // ---- SourceOffset → ... -------------------------------------------
+  /**
+   * Line whose runs cover the offset, or the nearest line by source
+   * distance if no run covers it.
+   *
+   * An offset that is only a run's *trailing* boundary (`offset ===
+   * endExclusive`) — most notably the source offset just past a
+   * line-breaking `\n`, which a zero-width run reports as its end on the line
+   * it terminates — belongs to the START of the NEXT line instead. Preferring
+   * the line that actually *starts* the offset makes the caret advance past a
+   * newline to the next line rather than collapsing onto the previous line's
+   * end (which would render two distinct offsets at the same caret position).
+   * The first such trailing-boundary line is remembered as a fallback for the
+   * document's very last offset, where no later line starts it.
+   */
+  lineIndexOfOffset(e) {
+    let t = -1;
+    for (let r = 0; r < this.lines.length; r++) {
+      const o = this.lines[r].offsetMembership(e);
+      if (o === "covers")
+        return r;
+      o === "end" && t < 0 && (t = r);
+    }
+    if (t >= 0)
+      return t;
+    let s = 0, i = 1 / 0;
+    for (let r = 0; r < this.lines.length; r++) {
+      const o = this.lines[r].sourceDistanceTo(e);
+      o < i && (i = o, s = r);
+    }
+    return s;
+  }
+  /**
+   * x of the caret position before `offset`, on the line returned by
+   * {@link lineIndexOfOffset}. Returns `0` when the map is empty.
+   */
+  xAtOffset(e) {
+    return this.lines.length === 0 ? 0 : this.lines[this.lineIndexOfOffset(e)].xAtOffset(e);
+  }
+  // ---- Point2D → ... -------------------------------------------------
+  /**
+   * Line whose vertical band contains `y`, clamped to the first/last
+   * line when `y` is outside the document.
+   */
+  lineIndexAtY(e) {
+    if (this.lines.length === 0)
+      return 0;
+    for (let t = 0; t < this.lines.length; t++)
+      if (e < this.lines[t].rect.bottom)
+        return t;
+    return this.lines.length - 1;
+  }
+  /**
+   * Snap a 2D point to the nearest source offset. Uses `y` to pick a
+   * line, then `x` to pick an offset within it. Up/down navigation
+   * uses {@link offsetInLineAtX} directly to preserve desired column.
+   */
+  offsetAtPoint(e) {
+    return this.offsetInLineAtX(this.lineIndexAtY(e.y), e.x);
+  }
+  /** Snap `x` to the nearest offset on a specific line. */
+  offsetInLineAtX(e, t) {
+    return e < 0 || e >= this.lines.length ? 0 : this.lines[e].offsetAtX(t);
+  }
+}
+class Bn {
+  constructor(e, t) {
+    this.rect = e, this.runs = t;
+  }
+  containsOffset(e) {
+    for (const t of this.runs)
+      if (t.containsOffset(e))
+        return !0;
+    return !1;
+  }
+  /**
+   * How `offset` relates to this line's runs:
+   *   - `'covers'`: a run starts at or strictly contains the offset
+   *     (`start <= offset < endExclusive`) — the caret belongs on this line.
+   *   - `'end'`: the offset is only some run's trailing boundary
+   *     (`offset === endExclusive`) with no run covering it — a line-break
+   *     boundary the caret should leave for the next line.
+   *   - `'none'`: no run touches the offset.
+   */
+  offsetMembership(e) {
+    let t = !1;
+    for (const s of this.runs) {
+      if (e >= s.sourceStart && e < s.sourceEndExclusive)
+        return "covers";
+      e === s.sourceEndExclusive && (t = !0);
+    }
+    return t ? "end" : "none";
+  }
+  /**
+   * Min `|offset - r|` over offsets `r` in any of this line's runs. Used
+   * to pick the nearest line when no run actually covers the offset.
+   */
+  sourceDistanceTo(e) {
+    let t = 1 / 0;
+    for (const s of this.runs) {
+      const i = s.sourceDistanceTo(e);
+      i < t && (t = i);
+    }
+    return t;
+  }
+  /**
+   * x of the caret position before `offset` on this line. When `offset`
+   * is past all runs (trailing whitespace / blank line), returns the
+   * right edge of the last run; when before all runs, returns the left
+   * edge of the first run.
+   */
+  xAtOffset(e) {
+    for (const s of this.runs)
+      if (s.containsOffset(e))
+        return s.xAtOffset(e);
+    const t = this.runs[0];
+    return e <= t.sourceStart ? t.rect.left : this.runs[this.runs.length - 1].rect.right;
+  }
+  /**
+   * Snap `x` to the nearest offset on this line. If `x` falls inside a
+   * run, the offset is interpolated by character fraction; otherwise it
+   * snaps to the closer edge of the nearest run.
+   */
+  offsetAtX(e) {
+    if (this.runs.length === 0)
+      return 0;
+    let t = this.runs[0], s = 1 / 0;
+    for (const i of this.runs) {
+      if (i.rect.containsX(e) || e === i.rect.right)
+        return i.offsetAtX(e);
+      const r = Math.min(Math.abs(e - i.rect.left), Math.abs(e - i.rect.right));
+      r < s && (s = r, t = i);
+    }
+    return e <= t.rect.left ? t.sourceRange.start : t.sourceRange.endExclusive;
+  }
+}
+class Le {
+  constructor(e, t, s) {
+    this.sourceRange = e, this.rect = t, this.source = s;
+  }
+  get sourceStart() {
+    return this.sourceRange.start;
+  }
+  get sourceEndExclusive() {
+    return this.sourceRange.endExclusive;
+  }
+  get sourceLength() {
+    return this.sourceRange.length;
+  }
+  containsOffset(e) {
+    return e >= this.sourceStart && e <= this.sourceEndExclusive;
+  }
+  sourceDistanceTo(e) {
+    return e < this.sourceStart ? this.sourceStart - e : e > this.sourceEndExclusive ? e - this.sourceEndExclusive : 0;
+  }
+  xAtOffset(e) {
+    if (this.sourceLength === 0)
+      return this.rect.left;
+    if (this.source)
+      return Rn(this.source.textNode, this.source.textNodeStart + (e - this.sourceStart), this.rect.left);
+    const t = (e - this.sourceStart) / this.sourceLength;
+    return this.rect.left + t * this.rect.width;
+  }
+  offsetAtX(e) {
+    if (this.rect.width <= 0)
+      return this.sourceStart;
+    if (this.source) {
+      const s = Dn(this.source.textNode, this.source.textNodeStart, this.source.textNodeStart + this.sourceLength, e);
+      return this.sourceStart + (s - this.source.textNodeStart);
+    }
+    const t = (e - this.rect.left) / this.rect.width;
+    return this.sourceStart + Math.round(t * this.sourceLength);
+  }
+}
+function Rn(n, e, t) {
+  if (e <= 0)
+    return t;
+  const s = document.createRange();
+  s.setStart(n, e - 1), s.setEnd(n, e);
+  const i = s.getBoundingClientRect();
+  return i.width === 0 && i.height === 0 ? t : i.right;
+}
+function Dn(n, e, t, s) {
+  const i = document.createRange();
+  let r = e, o = 1 / 0;
+  for (let c = e; c < t; c++) {
+    i.setStart(n, c), i.setEnd(n, c + 1);
+    const l = i.getBoundingClientRect();
+    if (l.width === 0 && l.height === 0)
+      continue;
+    const a = (l.left + l.right) / 2, h = Math.abs(s - l.left), g = Math.abs(s - l.right);
+    if (h < o && (o = h, r = c), g < o && (o = g, r = c + 1), s >= l.left && s <= l.right)
+      return s < a ? c : c + 1;
+  }
+  return r;
+}
+function An(n) {
+  const e = [];
+  for (const a of n) {
+    const h = e.length;
+    a.viewNode.forEachTextLeaf(a.absoluteStart, (g, u) => {
+      const d = g.dom;
+      if (d.length === 0)
+        return;
+      const f = document.createRange();
+      f.selectNodeContents(d);
+      const p = f.getClientRects();
+      if (p.length === 0)
+        return;
+      const m = Fn(d);
+      if (p.length === 1)
+        e.push(new Le(
+          _.fromTo(u, u + d.length),
+          et(p[0], m),
+          { textNode: d, textNodeStart: 0 }
+        ));
+      else {
+        const w = $n(d, p);
+        for (let v = 0; v < p.length; v++) {
+          const I = v === 0 ? 0 : w[v - 1], X = v < w.length ? w[v] : d.length;
+          e.push(new Le(
+            _.fromTo(u + I, u + X),
+            et(p[v], m),
+            { textNode: d, textNodeStart: I }
+          ));
+        }
+      }
+    }), e.length === h && Vn(e, a.viewNode, a.absoluteStart);
+  }
+  e.sort((a, h) => a.rect.y - h.rect.y || a.rect.x - h.rect.x);
+  const t = [];
+  let s = [], i = -1 / 0, r = 0, o = 1 / 0, c = -1 / 0;
+  const l = () => {
+    s.length !== 0 && t.push(new Bn(
+      R.fromPointPoint(o, i, c, i + r),
+      s
+    ));
+  };
+  for (const a of e) {
+    const h = a.rect, g = Math.min(i + r, h.y + h.height) - Math.max(i, h.y);
+    s.length > 0 && g > Math.min(r, h.height) / 2 ? (s.push(a), r = Math.max(r, h.y + h.height - i), o = Math.min(o, h.left), c = Math.max(c, h.right)) : (l(), s = [a], i = h.y, r = h.height, o = h.left, c = h.right);
+  }
+  return l(), new _e(t);
+}
+function $n(n, e) {
+  const t = [], s = document.createRange();
+  for (let i = 0; i < e.length - 1; i++) {
+    const r = e[i + 1].y;
+    let o = i === 0 ? 0 : t[i - 1], c = n.length;
+    for (; o < c; ) {
+      const l = o + c >>> 1;
+      s.setStart(n, l), s.setEnd(n, Math.min(l + 1, n.length)), s.getBoundingClientRect().y < r - 1 ? o = l + 1 : c = l;
+    }
+    t.push(o);
+  }
+  return t;
+}
+function Fn(n) {
+  const e = n.parentElement;
+  if (!e)
+    return 0;
+  const t = getComputedStyle(e);
+  let s = parseFloat(t.lineHeight);
+  return isFinite(s) || (s = parseFloat(t.fontSize) * 1.2), s;
+}
+function et(n, e) {
+  if (e <= n.height)
+    return R.fromPointSize(n.x, n.y, n.width, n.height);
+  const t = (e - n.height) / 2;
+  return R.fromPointSize(n.x, n.y - t, n.width, e);
+}
+function Vn(n, e, t) {
+  const s = e.dom;
+  if (s.nodeType !== 1)
+    return;
+  const i = s.getBoundingClientRect();
+  i.width === 0 && i.height === 0 || n.push(new Le(
+    _.fromTo(t, t + e.sourceLength),
+    R.fromPointSize(i.x, i.y, i.width, i.height)
+  ));
+}
+class Pn {
+  measurements = G(this, []);
+  /**
+   * Concatenated visual line map across all mounted blocks. Lines are
+   * left in DOM (client-coordinate) y order — each per-block map already
+   * uses absolute client coordinates from `getClientRects()`, so the
+   * concatenation is well-formed without re-sorting.
+   */
+  visualLineMap = A(this, (e) => {
+    const s = e.readObservable(this.measurements).flatMap((i) => i.visualLineMap?.lines ?? []);
+    return new _e(s);
+  });
+}
+function Vt(n, e, t, s) {
+  let i = s === "right" ? t + 1 : t - 1, r = 0;
+  for (const o of n.children) {
+    if (n.blocks.includes(o)) {
+      const l = o, a = Kn(l, l === e, t - r);
+      i = Hn(i, r, a, s);
+    }
+    r += o.length;
+  }
+  return s === "right" ? Math.min(i, n.length) : Math.max(i, 0);
+}
+function Kn(n, e, t) {
+  if (!e)
+    return qn(n);
+  if (n.kind === "list") {
+    const s = Pt(n, t);
+    return Wn(n, s);
+  }
+  return [];
+}
+function Hn(n, e, t, s) {
+  if (s === "right")
+    for (const i of t) {
+      const r = n - e;
+      (i.contains(r) || i.start === r) && (n = e + i.endExclusive);
+    }
+  else
+    for (let i = t.length - 1; i >= 0; i--) {
+      const r = t[i], o = n - e;
+      (r.contains(o) || r.endExclusive === o) && (n = e + r.start);
+    }
+  return n;
+}
+function Pt(n, e) {
+  let t = 0, s;
+  for (let i = 0; i < n.children.length; i++) {
+    const r = n.children[i], o = t + r.length, c = n.items.indexOf(r);
+    if (c >= 0) {
+      if (t <= e && e < o)
+        return c;
+      o === e && (s = c);
+    }
+    t = o;
+  }
+  return s;
+}
+function Wn(n, e) {
+  const t = [];
+  let s = 0;
+  for (const i of n.children) {
+    const r = n.items.indexOf(i);
+    if (r >= 0 && r !== e) {
+      const o = n.items[r];
+      Pe(o, s, t);
+    }
+    s += i.length;
+  }
+  return t.sort((i, r) => i.start - r.start), t;
+}
+function qn(n) {
+  const e = [];
+  return Pe(n, 0, e), e.sort((t, s) => t.start - s.start), e;
+}
+function Pe(n, e, t) {
+  if (n.children.length === 0) {
+    n instanceof k && t.push(_.ofStartAndLength(e, n.length));
+    return;
+  }
+  switch (n.kind) {
+    case "codeBlock":
+    case "mathBlock": {
+      let i = e;
+      for (const r of n.children)
+        r instanceof k && (r.markerKind === "openFence" || r.markerKind === "closeFence") && t.push(_.ofStartAndLength(i, r.length)), i += r.length;
+      return;
+    }
+    case "inlineCode":
+    case "inlineMath": {
+      let i = e;
+      for (const r of n.children)
+        r instanceof k && (r.markerKind === "openMarker" || r.markerKind === "closeMarker") && t.push(_.ofStartAndLength(i, r.length)), i += r.length;
+      return;
+    }
+    case "thematicBreak":
+      return;
+    case "image": {
+      t.push(_.ofStartAndLength(e, n.length));
+      return;
+    }
+  }
+  let s = e;
+  for (const i of n.children)
+    Pe(i, s, t), s += i.length;
+}
+const jn = (n) => n.selection.isCollapsed ? Math.min(n.selection.active + 1, n.text.length) : n.selection.range.endExclusive, Gn = (n) => n.selection.isCollapsed ? Math.max(n.selection.active - 1, 0) : n.selection.range.start, zn = (n) => Math.min(n.selection.active + 1, n.text.length), Xn = (n) => Math.max(n.selection.active - 1, 0), Qn = (n) => Bt(n.text, n.selection.active), tt = (n) => It(n.text, n.selection.active), Un = (n) => n.text.lastIndexOf(`
+`, n.selection.active - 1) + 1, Yn = (n) => {
+  const e = n.text.indexOf(`
+`, n.selection.active);
+  return e === -1 ? n.text.length : e;
+}, Jn = () => 0, Zn = (n) => n.text.length, nt = (n) => {
+  const e = n.lineMap.lineIndexOfOffset(n.selection.active), t = n.desiredColumn ?? n.lineMap.xAtOffset(n.selection.active);
+  return e >= n.lineMap.lineCount - 1 ? { offset: n.selection.active, desiredColumn: t } : { offset: n.lineMap.offsetInLineAtX(e + 1, t), desiredColumn: t };
+}, st = (n) => {
+  const e = n.lineMap.lineIndexOfOffset(n.selection.active), t = n.desiredColumn ?? n.lineMap.xAtOffset(n.selection.active);
+  return e <= 0 ? { offset: n.selection.active, desiredColumn: t } : { offset: n.lineMap.offsetInLineAtX(e - 1, t), desiredColumn: t };
+}, it = (n) => {
+  const e = n.selection;
+  if (!e.isCollapsed)
+    return {
+      edit: y.delete(e.range),
+      selection: x.collapsed(e.range.start)
+    };
+  if (e.active === 0)
+    return;
+  const t = new _(Vt(n.document, n.activeBlock, e.active, "left"), e.active);
+  return {
+    edit: y.delete(t),
+    selection: x.collapsed(t.start)
+  };
+}, es = (n) => {
+  const e = n.selection;
+  if (!e.isCollapsed)
+    return {
+      edit: y.delete(e.range),
+      selection: x.collapsed(e.range.start)
+    };
+  if (e.active >= n.text.length)
+    return;
+  const t = new _(e.active, Vt(n.document, n.activeBlock, e.active, "right"));
+  return {
+    edit: y.delete(t),
+    selection: x.collapsed(t.start)
+  };
+}, ts = (n) => {
+  const e = n.selection;
+  if (!e.isCollapsed)
+    return {
+      edit: y.delete(e.range),
+      selection: x.collapsed(e.range.start)
+    };
+  if (e.active === 0)
+    return;
+  const t = It(n.text, e.active), s = new _(t, e.active);
+  return {
+    edit: y.delete(s),
+    selection: x.collapsed(t)
+  };
+}, ns = (n) => {
+  const e = n.selection;
+  if (!e.isCollapsed)
+    return {
+      edit: y.delete(e.range),
+      selection: x.collapsed(e.range.start)
+    };
+  if (e.active >= n.text.length)
+    return;
+  const t = Bt(n.text, e.active), s = new _(e.active, t);
+  return {
+    edit: y.delete(s),
+    selection: x.collapsed(e.active)
+  };
+};
+function ss(n) {
+  return (e) => {
+    const t = y.replace(e.selection.range, n), s = e.selection.range.start + n.length;
+    return {
+      edit: t,
+      selection: x.collapsed(s)
+    };
+  };
+}
+const is = (n) => {
+  const e = y.replace(n.selection.range, `
+
+`), t = n.selection.range.start + 2;
+  return {
+    edit: e,
+    selection: x.collapsed(t)
+  };
+}, rs = (n) => {
+  const e = y.replace(n.selection.range, `
+`), t = n.selection.range.start + 1;
+  return {
+    edit: e,
+    selection: x.collapsed(t)
+  };
+}, os = (n) => {
+  const e = n.selection.range.start;
+  let t = 0;
+  for (; t < 2 && n.text[e - 1 - t] === " "; )
+    t++;
+  const i = " ".repeat(2 - t) + `
+`, r = y.replace(n.selection.range, i), o = e + i.length;
+  return {
+    edit: r,
+    selection: x.collapsed(o)
+  };
+}, cs = (n) => new x(0, n.text.length), ls = (n, e) => {
+  const t = hn(n.text, e);
+  return new x(t.start, t.end);
+};
+function as(n, e) {
+  return new x(e.start, e.endExclusive);
+}
+const rt = /* @__PURE__ */ new WeakMap(), Te = /* @__PURE__ */ new WeakMap();
+class ie extends te {
+  constructor(e, t, s = hs) {
+    super(), this.ast = e, this.dom = t, this._children = s, rt.set(t, this);
+    for (const i of s)
+      Te.set(i, this);
+  }
+  _children;
+  /** This node's view children (a mirror of `ast.children`). */
+  get children() {
+    return this._children;
+  }
+  /**
+   * Replace this node's children in place, disposing the old ones and
+   * re-pointing the new ones' parent to this node. The node value is still
+   * conceptually immutable with respect to its `ast`/`dom` *identity*; this
+   * is used only when a node patches its own DOM subtree in place (a code
+   * block re-tokenising on a highlighter recolour), where the source-mapping
+   * leaves must follow the new DOM text nodes without rebuilding the node
+   * itself.
+   */
+  _replaceChildren(e) {
+    for (const t of this._children)
+      t.dispose();
+    this._children = e;
+    for (const t of e)
+      Te.set(t, this);
+  }
+  dispose() {
+    for (const e of this._children)
+      e.dispose();
+  }
+  /**
+   * The number of source characters this node spans. Defaults to the length
+   * of its {@link ast}; a synthetic leaf that subdivides one ast node (a
+   * decorated-whitespace character, a code-block token span) shares that ast
+   * for identity but overrides this with the length of its own slice, so the
+   * renderer never has to fabricate an AST node just to carry a length.
+   */
+  get sourceLength() {
+    return this.ast.length;
+  }
+  /**
+   * The DOM node a parent mounts for this child. It is {@link dom} for almost
+   * everything; a marker is the exception — its `dom` is the inner Text node
+   * (so source ↔ DOM mapping lands on it) while the node it mounts is the
+   * wrapping `<span>`.
+   */
+  get mountNode() {
+    return this.dom;
+  }
+  /** The view node that rendered this node's parent, or `undefined` for a root. */
+  get parent() {
+    return Te.get(this);
+  }
+  /**
+   * Closest view node owning `domNode`: the node itself if registered, else
+   * the nearest registered ancestor. Returns `undefined` if the DOM node is
+   * outside any view tree.
+   */
+  static forDom(e) {
+    for (let t = e; t; t = t.parentNode) {
+      const s = rt.get(t);
+      if (s)
+        return s;
+    }
+  }
+  /**
+   * This node's start offset within its parent's local source space: the sum
+   * of the `ast.length` of the siblings before it. Polymorphic via
+   * {@link _localOffsetOfChild} so a parent whose children do not map
+   * linearly (e.g. it hides or reorders some) can override how its children
+   * are placed.
+   */
+  localOffsetInParent() {
+    const e = this.parent;
+    return e ? e._localOffsetOfChild(this) : 0;
+  }
+  /** Start offset of `child` within this node's local source space. */
+  _localOffsetOfChild(e) {
+    let t = 0;
+    for (const s of this.children) {
+      if (s === e)
+        return t;
+      t += s.sourceLength;
+    }
+    return t;
+  }
+  /**
+   * Map a DOM hit that lands on THIS node's own representation into a source
+   * range in this node's local space `[0, ast.length)`. Polymorphic: a text
+   * leaf maps the caret offset 1:1; an element-only node (KaTeX math, `<hr>`,
+   * an image, a hidden marker) has no internal text mapping and snaps to its
+   * start by default — subclasses may override (e.g. to snap to the nearer
+   * edge by x).
+   */
+  getLocalSourceRange(e) {
+    return this.dom === e.node && this.dom.nodeType === 3 ? _.emptyAt(Math.max(0, Math.min(e.offset, this.sourceLength))) : _.emptyAt(0);
+  }
+  /**
+   * DOM hit (any node + offset within it) → source offset relative to THIS
+   * node, or `undefined` when the hit is outside this node's subtree. Enters
+   * the tree at the closest owning view node ({@link forDom}), maps the hit
+   * into that node's local space ({@link getLocalSourceRange}), then lifts the
+   * range up the parent chain — adding each node's {@link localOffsetInParent} —
+   * until it reaches this node.
+   */
+  resolveSource(e) {
+    let t = ie.forDom(e.node);
+    if (!t)
+      return;
+    let s = t.getLocalSourceRange(e);
+    for (; t !== this; ) {
+      const i = t.parent;
+      if (!i)
+        return;
+      s = s.delta(t.localOffsetInParent()), t = i;
+    }
+    return s.start;
+  }
+  /**
+   * Source offset → DOM position. `nodeOffset` is the absolute source
+   * offset of THIS node's start. Returns a position into a DOM Text node,
+   * descending into children based on accumulated lengths.
+   */
+  sourceToDom(e, t = 0) {
+    if (e < t || e > t + this.sourceLength)
+      return;
+    if (this.children.length === 0)
+      return this.dom.nodeType === 3 ? { node: this.dom, offset: e - t } : void 0;
+    let s = t;
+    for (const i of this.children) {
+      const r = s + i.sourceLength;
+      if (e >= s && e <= r) {
+        const o = i.sourceToDom(e, s);
+        if (o)
+          return o;
+      }
+      s = r;
+    }
+  }
+  /** Visit every text-bearing leaf in this subtree with its absolute offset. */
+  forEachTextLeaf(e, t) {
+    if (this.children.length === 0) {
+      this.dom.nodeType === 3 && t(this, e);
+      return;
+    }
+    let s = e;
+    for (const i of this.children)
+      i.forEachTextLeaf(s, t), s += i.sourceLength;
+  }
+}
+const hs = [];
+class M extends ie {
+  constructor(e, t, s) {
+    super(e.ast, t, s), this.data = e;
+  }
+  get block() {
+    return this.data.ast;
+  }
+  get element() {
+    return this.dom;
+  }
+  /**
+   * Whether this already-built node can stand in for `data` unchanged. The
+   * builder preserves view-data identity for any subtree whose ast and
+   * selection-derived flags are unchanged (see `buildDocumentViewData`), so a
+   * single identity check captures "nothing in my subtree changed" — and its
+   * whole subtree, and any session it owns, are kept as-is.
+   */
+  canReuse(e) {
+    return this.data === e;
+  }
+  /**
+   * Called by the view after this block is mounted and measured, with the
+   * block's rendered height in px. The default is a no-op; subclasses whose
+   * active/inactive renderings have different intrinsic heights (e.g. a math
+   * block) override this to remember a height to reserve across the toggle.
+   */
+  recordMeasuredHeight(e) {
+  }
+}
+function re(n, e, t) {
+  if (t instanceof M) {
+    if (t.canReuse(n))
+      return t;
+  } else if (t?.ast === n.ast)
+    return t;
+  switch (n.kind) {
+    case "text":
+      return gs(n, S(t, He));
+    case "marker":
+      return n.ast.markerKind === "hardBreak" ? new lt(n, S(t, lt)) : new ct(n, S(t, ct));
+    case "glue":
+      return new be(n, S(t, be));
+    case "heading":
+      return new at(n, e, S(t, at));
+    case "paragraph":
+      return new F(n, "p", "md-block md-paragraph", e, j(t));
+    case "codeBlock":
+      return new We(n, e, t);
+    case "mathBlock":
+      return new dt(n, e, S(t, dt));
+    case "thematicBreak":
+      return new ht(n, e, S(t, ht));
+    case "blockQuote":
+      return new F(n, "blockquote", "md-block md-blockquote", e, j(t));
+    case "list":
+      return new ft(n, e, S(t, ft));
+    case "listItem":
+      return new gt(n, e, S(t, gt));
+    case "table":
+      return new F(n, "table", "md-block md-table", e, j(t));
+    case "tableRow":
+      return new pt(n, e, S(t, pt));
+    case "tableCell":
+      return new F(n, "td", "", e, j(t));
+    case "strong":
+      return new F(n, "strong", "", e, j(t));
+    case "emphasis":
+      return new F(n, "em", "", e, j(t));
+    case "strikethrough":
+      return new F(n, "del", "", e, j(t));
+    case "inlineCode":
+      return new mt(n, e, S(t, mt));
+    case "inlineMath":
+      return new _t(n, e, S(t, _t));
+    case "link":
+      return new wt(n, e, S(t, wt));
+    case "image":
+      return new kt(n, e, S(t, kt));
+    case "document":
+      return new F(n, "div", "", e, j(t));
+  }
+}
+function S(n, e) {
+  return n instanceof e ? n : void 0;
+}
+function j(n) {
+  return n instanceof F ? n : void 0;
+}
+function W(n, e, t, s) {
+  const { paired: i, unused: r } = qe(e, t ?? T), o = e.map((c) => s(c, i.get(c)));
+  for (const c of r)
+    c.dispose();
+  return us(n, o), o;
+}
+function us(n, e) {
+  ae(n, e.map((t) => t.mountNode));
+}
+function ae(n, e) {
+  let t = n.firstChild, s = 0;
+  for (; s < e.length && t === e[s]; s++)
+    t = t.nextSibling;
+  if (!(s === e.length && t === null)) {
+    for (; s < e.length; s++) {
+      const i = e[s];
+      t === i ? t = i.nextSibling : n.insertBefore(i, t);
+    }
+    for (; t; ) {
+      const i = t;
+      t = t.nextSibling, n.removeChild(i);
+    }
+  }
+}
+function Y(n) {
+  return (e, t) => re(e, n, t);
+}
+function Kt(n) {
+  return (e, t) => e.kind === "marker" && e.ast.markerKind === "content" ? new He(e, document.createTextNode(e.ast.content)) : re(e, n, t);
+}
+const T = [];
+function ds(n) {
+  return "content" in n ? n.content : fs;
+}
+const fs = [];
+function gs(n, e) {
+  const t = n.ast.content, s = {
+    leftBoundary: n.leftWordBoundary,
+    rightBoundary: n.rightWordBoundary,
+    decorateNewline: !0
+  };
+  if (n.showWhitespace && Wt(t, s)) {
+    const o = document.createElement("span");
+    o.className = "md-text";
+    const c = Ke(o, t, s, n.ast);
+    return new M(n, o, c);
+  }
+  const i = e?.dom, r = i instanceof globalThis.Text && i.data === t ? i : document.createTextNode(t);
+  return new He(n, r);
+}
+function ot(n) {
+  return n === " " || n === "	" || n === `
+` || n === "\r";
+}
+const ps = { leftBoundary: !1, rightBoundary: !1, decorateNewline: !1 };
+function ms(n, e, t) {
+  const s = e > 0 ? !ot(n[e - 1]) : t.leftBoundary, i = e < n.length - 1 ? !ot(n[e + 1]) : t.rightBoundary;
+  return s && i;
+}
+function Ht(n, e, t) {
+  const s = n[e];
+  if (s === "	")
+    return "md-ws-tab";
+  if (s === `
+` || s === "\r")
+    return t.decorateNewline ? "md-ws-newline" : void 0;
+  if (s === " " && !ms(n, e, t))
+    return "md-ws-space";
+}
+function Wt(n, e) {
+  for (let t = 0; t < n.length; t++)
+    if (Ht(n, t, e) !== void 0)
+      return !0;
+  return !1;
+}
+function _s(n, e) {
+  const t = [];
+  let s = -1;
+  const i = (c) => {
+    s >= 0 && (t.push({ text: n.slice(s, c), cls: void 0 }), s = -1);
+  }, r = e.breakGlyphClass ? n.indexOf(`
+`) : -1, o = e.newlineGlyph ? n.lastIndexOf(`
+`) : -1;
+  for (let c = 0; c < n.length; c++) {
+    const l = n[c];
+    if (e.newlineGlyph && (l === `
+` || l === "\r")) {
+      const h = c === r;
+      if (c !== o || h) {
+        i(c), t.push({ text: l, cls: h ? e.breakGlyphClass : "md-ws-newline-glyph", display: "↵" });
+        continue;
+      }
+    }
+    const a = e.newlineGlyph && (l === `
+` || l === "\r") ? void 0 : Ht(n, c, e);
+    if (a === void 0) {
+      s < 0 && (s = c);
+      continue;
+    }
+    i(c), t.push({ text: l, cls: a });
+  }
+  return i(n.length), t;
+}
+function Ke(n, e, t, s) {
+  const i = [];
+  for (const r of _s(e, t)) {
+    const o = document.createTextNode(r.display ?? r.text);
+    if (r.cls) {
+      const c = document.createElement("span");
+      c.className = r.cls, c.appendChild(o), n.appendChild(c);
+    } else
+      n.appendChild(o);
+    i.push(new Q(s, o, T, r.text.length));
+  }
+  return i;
+}
+class He extends M {
+  constructor(e, t) {
+    super(e, t, T);
+  }
+}
+class Q extends ie {
+  _sourceLength;
+  constructor(e, t, s = T, i = e.length) {
+    super(e, t, s), this._sourceLength = i;
+  }
+  get sourceLength() {
+    return this._sourceLength;
+  }
+}
+class ct extends M {
+  _span;
+  constructor(e, t) {
+    const s = e.ast, i = `md-marker md-marker-${s.markerKind}`, r = t && t.dom instanceof globalThis.Text && t.dom.data === s.content, o = r ? t._span : document.createElement("span");
+    o.className = e.visible ? i : `${i} md-marker-hidden`;
+    const c = r ? t.dom : document.createTextNode(s.content);
+    r || o.appendChild(c), super(e, c, T), this._span = o;
+  }
+  get mountNode() {
+    return this._span;
+  }
+}
+class be extends M {
+  _span;
+  constructor(e, t) {
+    const s = be._build(e, t);
+    super(e, s.dom, s.children), this._span = s.span;
+  }
+  get mountNode() {
+    return this._span;
+  }
+  static _build(e, t) {
+    const s = e.ast, i = s.glueKind ? `md-glue md-glue-${s.glueKind}` : "md-glue", r = s.glueKind === "blockBreak", o = {
+      leftBoundary: !1,
+      rightBoundary: !1,
+      decorateNewline: e.decorateNewline,
+      // A blank-line `↵` glyph only belongs where the gap is hosted at the end
+      // of a block's last line (inline flow, `decorateNewline`). The hostless
+      // document-level gap (trailing a leaf thematic break, or leading the
+      // first block) sits between block-level siblings where the break is
+      // already visible, so it draws no glyph and simply collapses — making
+      // e.g. `---\n\n…` and `---\n…` render identically.
+      newlineGlyph: (s.glueKind === "blockGap" || r) && e.decorateNewline,
+      breakGlyphClass: r ? "md-ws-blockbreak-glyph" : void 0
+    };
+    if (e.visible && Wt(s.content, o)) {
+      const g = document.createElement("span");
+      g.className = i;
+      const u = Ke(g, s.content, o, s);
+      return { span: g, dom: g, children: u };
+    }
+    const l = t && t.dom instanceof globalThis.Text && t.dom.data === s.content && t.children.length === 0, a = l ? t._span : document.createElement("span");
+    a.className = e.visible ? i : `${i} md-glue-hidden`;
+    const h = l ? t.dom : document.createTextNode(s.content);
+    return l || a.appendChild(h), { span: a, dom: h, children: T };
+  }
+}
+class lt extends M {
+  _span;
+  constructor(e, t) {
+    const s = e.ast.content, i = document.createElement("span");
+    i.className = "md-hardbreak";
+    const r = document.createElement("span");
+    r.className = e.visible ? "md-hardbreak-src" : "md-hardbreak-src md-hardbreak-src-hidden";
+    const o = e.visible ? Ke(r, s, ps, e.ast) : ws(r, s, e.ast);
+    i.appendChild(r), i.appendChild(document.createElement("br")), super(e, i, o), this._span = i;
+  }
+  get mountNode() {
+    return this._span;
+  }
+}
+function ws(n, e, t) {
+  const s = document.createTextNode(e);
+  return n.appendChild(s), [new Q(t, s)];
+}
+class F extends M {
+  constructor(e, t, s, i, r) {
+    const o = r?.element ?? document.createElement(t);
+    !r && s && (o.className = s);
+    const c = W(o, ds(e), r?.children, Y(i));
+    super(e, o, c);
+  }
+}
+class at extends M {
+  constructor(e, t, s) {
+    const i = s && s.element.tagName === `H${e.ast.level}`, r = i ? s.element : document.createElement(`h${e.ast.level}`);
+    i || (r.className = "md-block md-heading");
+    const o = W(r, e.content, s?.children, Y(t));
+    super(e, r, o);
+  }
+}
+class ht extends M {
+  constructor(e, t, s) {
+    if (e.showMarkup) {
+      const r = s?.dom instanceof HTMLDivElement ? s : void 0, o = r?.element ?? document.createElement("div");
+      r || (o.className = "md-block md-thematic-break-source");
+      const c = W(o, e.content, r?.children, Y(t));
+      super(e, o, c);
+      return;
+    }
+    const i = document.createElement("hr");
+    i.className = "md-block md-thematic-break", super(e, i, T);
+  }
+}
+class We extends M {
+  _session;
+  /**
+   * Subscription that re-tokenises the rendered `<code>` in place whenever the
+   * session advances its {@link ISyntaxHighlighterDocument.snapshot} *without*
+   * a source edit (an async grammar finishing, a live recolour). It is tied to
+   * this node's lifetime, but like {@link _session} it must be disposed
+   * manually: a node reused as `previous` for a rebuild is never `dispose`d
+   * (see {@link reconcileDomChildren}), so the rebuilding constructor disposes
+   * its predecessor's subscription explicitly.
+   */
+  _snapshotSub;
+  constructor(e, t, s) {
+    const i = e.ast, r = i.code?.content ?? "", o = !e.showMarkup && i.language && t?.renderCustomCodeBlock ? t.renderCustomCodeBlock(i.language, r) ?? void 0 : void 0, c = t?.syntaxHighlighter, l = s instanceof We ? s : void 0;
+    let a;
+    if (!o && c && i.language) {
+      if (l?._session && i === l.ast)
+        a = l._session, l._session = void 0;
+      else if (l?._session) {
+        const f = i.getDiff(l.ast);
+        f && (a = l._session, l._session = void 0, ln((p) => a.update(f.stringEdit, p)));
+      }
+      a || (a = c.create(i.language, r));
+    }
+    l?._session && (l._session.dispose(), l._session = void 0), l?._snapshotSub?.dispose(), l && (l._snapshotSub = void 0);
+    const h = a ? a.snapshot.get().getTokens(_.ofLength(r.length)).tokens : void 0;
+    let g, u, d;
+    if (o)
+      o.classList.add("md-block", "md-code-block"), g = o, u = T;
+    else {
+      const f = document.createElement("pre");
+      f.className = "md-block md-code-block";
+      const p = [];
+      for (const m of e.content)
+        if (m.ast === i.code) {
+          const w = document.createElement("code");
+          i.language && (w.className = `language-${CSS.escape(i.language)}`);
+          const v = ks(i.code, r, w, h);
+          v instanceof qt && (d = v), p.push(v), f.appendChild(w);
+        } else {
+          const w = re(m, t, void 0);
+          f.appendChild(w.mountNode), p.push(w);
+        }
+      g = f, u = p;
+    }
+    super(e, g, u), this._session = a, a && d && (this._snapshotSub = an(a.snapshot, () => {
+      const f = a.snapshot.get();
+      d.refresh(r, f.getTokens(_.ofLength(r.length)).tokens);
+    }));
+  }
+  dispose() {
+    this._snapshotSub?.dispose(), this._snapshotSub = void 0, this._session?.dispose(), this._session = void 0, super.dispose();
+  }
+}
+function ks(n, e, t, s) {
+  if (!s) {
+    const i = document.createTextNode(e);
+    return t.appendChild(i), new Q(n, i);
+  }
+  return new qt(n, t, e, s);
+}
+class qt extends ie {
+  constructor(e, t, s, i) {
+    super(e, t, ut(e, t, s, i));
+  }
+  /** Re-render the token spans for a new colouring, in place. */
+  refresh(e, t) {
+    const s = this.dom;
+    s.replaceChildren(), this._replaceChildren(ut(this.ast, s, e, t));
+  }
+}
+function ut(n, e, t, s) {
+  const i = [];
+  let r = 0;
+  for (const o of s) {
+    const c = t.slice(r, r + o.length);
+    r += o.length;
+    const l = document.createTextNode(c);
+    if (o.className) {
+      const a = document.createElement("span");
+      for (const h of o.className.split("."))
+        h && a.classList.add(`tok-${h}`);
+      a.appendChild(l), e.appendChild(a);
+    } else
+      e.appendChild(l);
+    i.push(new Q(n, l, T, c.length));
+  }
+  return i;
+}
+function jt(n) {
+  let e = 0;
+  for (const t of n) {
+    if (t.kind === "marker" && t.markerKind === "content")
+      return e;
+    e += t.length;
+  }
+  return e;
+}
+function Gt(n, e, t) {
+  const s = e.filter((c) => c.length > 0 && c.start >= 0 && c.start + c.length <= t).slice().sort((c, l) => c.start - l.start), i = [];
+  let r = 0;
+  const o = (c) => {
+    c > 0 && i.push(new Q(n, document.createTextNode(""), T, c));
+  };
+  for (const c of s)
+    c.start < r || (o(c.start - r), i.push(new Q(n, c.dom, T, c.length)), r = c.start + c.length);
+  return o(t - r), i;
+}
+class dt extends M {
+  /**
+   * The rendered (inactive, KaTeX) height in px, measured after mount and
+   * carried forward across rebuilds via `previous`. When the block becomes
+   * active (source markers shown) this height is reserved as a `min-height`
+   * so the editor does not collapse below the rendered size, keeping the
+   * surrounding layout stable as the caret enters and leaves the block.
+   */
+  _renderedHeight;
+  constructor(e, t, s) {
+    const i = e.ast, r = s?._renderedHeight;
+    if (e.showMarkup) {
+      const a = document.createElement("pre");
+      a.className = "md-block md-math-block", r !== void 0 && (a.style.boxSizing = "border-box", a.style.minHeight = `${r}px`);
+      const h = [];
+      for (const g of e.content)
+        if (g.ast === i.code) {
+          const u = document.createElement("code"), d = document.createTextNode(i.code.content);
+          u.appendChild(d), a.appendChild(u), h.push(new Q(i.code, d));
+        } else {
+          const u = re(g, t, void 0);
+          a.appendChild(u.mountNode), h.push(u);
+        }
+      super(e, a, h), this._renderedHeight = r;
+      return;
+    }
+    const o = i.code?.content ?? "", c = t?.renderMath?.({
+      latex: o,
+      displayMode: !0,
+      className: "md-block md-math-block",
+      nodeLength: i.length,
+      contentStart: jt(i.content)
+    });
+    if (c) {
+      super(e, c.dom, Gt(i, c.segments, i.length)), this._renderedHeight = r;
+      return;
+    }
+    const l = document.createElement("div");
+    l.className = "md-block md-math-block";
+    try {
+      Nt.render(o, l, { displayMode: !0, throwOnError: !1 });
+    } catch {
+      l.textContent = o;
+    }
+    super(e, l, T), this._renderedHeight = r;
+  }
+  recordMeasuredHeight(e) {
+    this.data.showMarkup || (this._renderedHeight = e);
+  }
+}
+class ft extends M {
+  constructor(e, t, s) {
+    const i = e.ast.ordered ? "ol" : "ul", r = s && s.element.tagName === i.toUpperCase(), o = r ? s.element : document.createElement(i);
+    r || (o.className = "md-block md-list");
+    const c = W(o, e.content, s?.children, Y(t));
+    super(e, o, c);
+  }
+}
+class gt extends M {
+  constructor(e, t, s) {
+    const i = e.ast, r = document.createElement("li");
+    e.isActive && r.classList.add("md-list-item-active"), i.checked !== void 0 && r.classList.add("md-task-list-item"), e.isActive || r.classList.add("md-markers-hidden"), r.style.setProperty("--md-list-level", String(e.level));
+    const o = xs(r, e.content, s, t);
+    if (!e.isActive && i.checked !== void 0) {
+      const c = document.createElement("input");
+      c.type = "checkbox", c.checked = i.checked, c.className = "md-checkbox";
+      const l = t?.onToggleCheckbox;
+      if (l) {
+        const a = i.checked;
+        c.addEventListener("mousedown", (h) => {
+          h.stopPropagation(), h.preventDefault(), l(i, !a);
+        });
+      } else
+        c.disabled = !0;
+      r.insertBefore(c, r.firstChild);
+    }
+    super(e, r, o);
+  }
+}
+function xs(n, e, t, s) {
+  const { paired: i, unused: r } = qe(e, t?.children ?? T), o = e.map((h) => re(h, s, i.get(h)));
+  for (const h of r)
+    h.dispose();
+  if (!(e.length >= 2 && e[0].kind === "glue" && e[0].ast.glueKind === "indent" && e[1].kind === "marker" && e[1].ast.markerKind === "listItemMarker"))
+    return ae(n, o.map((h) => h.mountNode)), o;
+  const l = n.firstElementChild, a = l && l.classList.contains("md-list-gutter") ? l : document.createElement("span");
+  return a.className = "md-list-gutter", ae(a, [o[0].mountNode, o[1].mountNode]), ae(n, [a, ...o.slice(2).map((h) => h.mountNode)]), o;
+}
+class pt extends M {
+  constructor(e, t, s) {
+    const i = s?.element ?? document.createElement("tr");
+    e.isDelimiter && i.classList.add("md-table-delimiter-row");
+    const r = W(i, e.content, s?.children, Y(t));
+    e.isDelimiter || e.content.forEach((o, c) => {
+      o.kind === "tableCell" && o.isActive && r[c].element.classList.add("md-table-cell-active");
+    }), super(e, i, r);
+  }
+}
+class mt extends M {
+  constructor(e, t, s) {
+    const i = s?.element ?? document.createElement("code"), r = W(i, e.content, s?.children, Kt(t));
+    super(e, i, r);
+  }
+}
+class _t extends M {
+  constructor(e, t, s) {
+    if (e.showMarkup) {
+      const l = document.createElement("span");
+      l.className = "md-inline-math";
+      const a = W(l, e.content, s?.children, Kt(t));
+      super(e, l, a);
+      return;
+    }
+    const r = e.content.find(
+      (l) => l.kind === "marker" && l.ast.markerKind === "content"
+    )?.ast.content ?? "", o = t?.renderMath?.({
+      latex: r,
+      displayMode: !1,
+      className: "md-inline-math",
+      nodeLength: e.ast.length,
+      contentStart: jt(e.ast.content)
+    });
+    if (o) {
+      super(e, o.dom, Gt(e.ast, o.segments, e.ast.length));
+      return;
+    }
+    const c = document.createElement("span");
+    c.className = "md-inline-math";
+    try {
+      Nt.render(r, c, { throwOnError: !1 });
+    } catch {
+      c.textContent = r;
+    }
+    super(e, c, T);
+  }
+}
+class wt extends M {
+  constructor(e, t, s) {
+    const i = s?.element ?? document.createElement("a");
+    zt(e.ast.url) ? (i.href = e.ast.url, i.dataset.mdUrl = e.ast.url) : (i.removeAttribute("href"), delete i.dataset.mdUrl), s || i.addEventListener("mousedown", (o) => {
+      const c = i.dataset.mdUrl;
+      !c || i.closest(".md-block-active") !== null && !(o.ctrlKey || o.metaKey) || (o.preventDefault(), o.stopPropagation(), t?.onOpenLink ? t.onOpenLink(c, o) : window.open(c, "_blank", "noopener"));
+    });
+    const r = W(i, e.content, s?.children, Y(t));
+    super(e, i, r);
+  }
+}
+class kt extends M {
+  constructor(e, t, s) {
+    const i = e.ast;
+    if (e.showMarkup) {
+      const o = document.createElement("span");
+      o.className = "md-image-source";
+      const c = W(o, e.content, s?.children, Y(t));
+      super(e, o, c);
+      return;
+    }
+    const r = document.createElement("img");
+    zt(i.url) && (r.src = i.url), r.alt = i.alt, super(e, r, T);
+  }
+}
+function qe(n, e) {
+  const t = /* @__PURE__ */ new Map();
+  for (const i of e)
+    t.set(i.ast.id, i);
+  const s = /* @__PURE__ */ new Map();
+  for (const i of n) {
+    const r = t.get(i.ast.id);
+    r && (s.set(i, r), t.delete(i.ast.id));
+  }
+  return { paired: s, unused: [...t.values()] };
+}
+function zt(n) {
+  return !n.trim().toLowerCase().startsWith("javascript:");
+}
+class je extends ie {
+  constructor(e, t, s, i) {
+    super(e, t, i), this.blocks = s;
+  }
+  static create(e, t, s) {
+    const i = s?.contentDomNode ?? document.createElement("div"), r = new Map(
+      e.children.filter((u) => u.kind === "block").map((u) => [u.view, u.isActive])
+    ), o = s?.children, c = e.children.map((u) => u.view), { paired: l, unused: a } = qe(c, o ?? vs), h = c.map((u, d) => {
+      const f = l.get(u), p = re(u, t, f);
+      if (e.children[d].kind === "block") {
+        const m = r.get(u);
+        m !== void 0 && (p.element.classList.toggle("md-block-active", m), p.element.classList.toggle("md-markers-hidden", !m));
+      }
+      return p;
+    });
+    for (const u of a)
+      u.dispose();
+    ae(i, h.map((u) => u.mountNode));
+    const g = [];
+    return e.children.forEach((u, d) => {
+      u.kind === "block" && g.push({ node: h[d], absoluteStart: u.absoluteStart });
+    }), new je(e.ast, i, g, h);
+  }
+  /** The stable content element this document mounts its children into. */
+  get contentDomNode() {
+    return this.dom;
+  }
+}
+const vs = [];
+function bs(n) {
+  const e = document;
+  if (e.caretPositionFromPoint) {
+    const s = e.caretPositionFromPoint(n.x, n.y);
+    return s ? { node: s.offsetNode, offset: s.offset } : void 0;
+  }
+  const t = e.caretRangeFromPoint?.(n.x, n.y);
+  if (t)
+    return { node: t.startContainer, offset: t.startOffset };
+}
+class ys {
+  constructor(e, t, s) {
+    this.ast = e, this.blocks = t, this.children = s;
+  }
+  kind = "document";
+}
+class Es {
+  constructor(e, t) {
+    this.ast = e, this.content = t;
+  }
+  kind = "heading";
+}
+class Cs {
+  constructor(e, t) {
+    this.ast = e, this.content = t;
+  }
+  kind = "paragraph";
+}
+class Os {
+  constructor(e, t, s) {
+    this.ast = e, this.showMarkup = t, this.content = s;
+  }
+  kind = "codeBlock";
+}
+class Ms {
+  constructor(e, t, s) {
+    this.ast = e, this.showMarkup = t, this.content = s;
+  }
+  kind = "mathBlock";
+}
+class Ts {
+  constructor(e, t) {
+    this.ast = e, this.content = t;
+  }
+  kind = "blockQuote";
+}
+class Ss {
+  constructor(e, t) {
+    this.ast = e, this.content = t;
+  }
+  kind = "list";
+}
+class Ls {
+  constructor(e, t) {
+    this.ast = e, this.content = t;
+  }
+  kind = "table";
+}
+class Ns {
+  constructor(e, t) {
+    this.ast = e, this.content = t;
+  }
+  kind = "strong";
+}
+class Is {
+  constructor(e, t) {
+    this.ast = e, this.content = t;
+  }
+  kind = "emphasis";
+}
+class Bs {
+  constructor(e, t) {
+    this.ast = e, this.content = t;
+  }
+  kind = "strikethrough";
+}
+class Rs {
+  constructor(e, t) {
+    this.ast = e, this.content = t;
+  }
+  kind = "inlineCode";
+}
+class Ds {
+  constructor(e, t, s) {
+    this.ast = e, this.showMarkup = t, this.content = s;
+  }
+  kind = "inlineMath";
+}
+class As {
+  constructor(e, t) {
+    this.ast = e, this.content = t;
+  }
+  kind = "link";
+}
+class $s {
+  constructor(e, t, s) {
+    this.ast = e, this.showMarkup = t, this.content = s;
+  }
+  kind = "image";
+}
+class Fs {
+  constructor(e, t, s, i) {
+    this.ast = e, this.isActive = t, this.content = s, this.level = i;
+  }
+  kind = "listItem";
+}
+class Vs {
+  constructor(e, t, s) {
+    this.ast = e, this.isDelimiter = t, this.content = s;
+  }
+  kind = "tableRow";
+}
+class Ps {
+  constructor(e, t, s, i) {
+    this.ast = e, this.isActive = t, this.showTableGlue = s, this.content = i;
+  }
+  kind = "tableCell";
+}
+class Ks {
+  /**
+   * Whether non-obvious whitespace in this text is revealed (block is active).
+   * `leftWordBoundary`/`rightWordBoundary` say whether the inline sibling on
+   * that side ends/starts with visible word content (e.g. inline code, a link,
+   * emphasis); a single space touching such a sibling is obvious and stays
+   * undecorated, just like a space between two words within this leaf.
+   */
+  constructor(e, t, s = !1, i = !1) {
+    this.ast = e, this.showWhitespace = t, this.leftWordBoundary = s, this.rightWordBoundary = i;
+  }
+  kind = "text";
+}
+class Hs {
+  constructor(e, t, s) {
+    this.ast = e, this.showMarkup = t, this.content = s;
+  }
+  kind = "thematicBreak";
+}
+class Ws {
+  constructor(e, t) {
+    this.ast = e, this.visible = t;
+  }
+  kind = "marker";
+}
+class Xt {
+  constructor(e, t, s) {
+    this.ast = e, this.visible = t, this.decorateNewline = s;
+  }
+  kind = "glue";
+}
+const qs = { showMarkup: !1, showTableGlue: !1, selectionInNode: void 0 };
+function B(n) {
+  return n.inlineFlow ? n : { ...n, inlineFlow: !0 };
+}
+function Qt(n, e, t, s) {
+  const i = /* @__PURE__ */ new Map();
+  if (s)
+    for (const u of s.children)
+      i.set(u.view.ast, u);
+  const r = n.content, o = new Set(n.blocks), c = (u) => u >= 0 && u < r.length && o.has(r[u]), l = (u) => c(u) && e.has(r[u]), a = [], h = [];
+  let g = 0;
+  for (let u = 0; u < r.length; u++) {
+    const d = r[u];
+    if (o.has(d)) {
+      const f = d, p = e.has(f), m = i.get(f);
+      let w;
+      if (!p)
+        w = m && !m.isActive ? m.view : vt(f, qs, m?.view);
+      else {
+        const v = t ? new _(
+          Math.max(0, t.start - g),
+          Math.min(f.length, t.endExclusive - g)
+        ) : void 0;
+        w = vt(f, { showMarkup: !0, showTableGlue: !1, selectionInNode: v }, m?.view);
+      }
+      a.push({ ast: f, absoluteStart: g, isActive: p, view: w }), h.push({ absoluteStart: g, isActive: p, view: w, kind: "block" });
+    } else if (d instanceof N && (d.glueKind === "blockGap" || d.glueKind === "blockBreak")) {
+      const f = xt(c, l, r.length, u, -1), p = f || xt(c, l, r.length, u, 1), m = i.get(d), w = b(m?.view, new Xt(d, p, f));
+      h.push({ absoluteStart: g, isActive: p, view: w, kind: "glue" });
+    }
+    g += d.length;
+  }
+  return new ys(n, a, h);
+}
+function xt(n, e, t, s, i) {
+  for (let r = s + i; r >= 0 && r < t; r += i)
+    if (n(r))
+      return e(r);
+  return !1;
+}
+function vt(n, e, t) {
+  return oe(n, e, t);
+}
+function oe(n, e, t, s) {
+  const i = n;
+  switch (i.kind) {
+    case "text":
+      return b(t, new Ks(i, e.showMarkup, s?.left ?? !1, s?.right ?? !1));
+    // The trailing gap the parser absorbs into the break is inline flow, so its
+    // revealed newlines get the `↵` glyph (each its own width) — without it the
+    // raw `\n`s are zero-width and the caret can't tell them apart.
+    case "thematicBreak":
+      return b(t, new Hs(i, e.showMarkup, L(i.children, B(e), t)));
+    case "marker":
+      return b(t, new Ws(i, zs(i.markerKind, e)));
+    case "glue":
+      return b(t, new Xt(i, Xs(i.glueKind, e), e.inlineFlow ?? !1));
+    case "heading":
+      return b(t, new Es(i, L(i.children, B(e), t)));
+    case "paragraph":
+      return b(t, new Cs(i, L(i.children, B(e), t)));
+    case "codeBlock":
+      return b(t, new Os(i, e.showMarkup, L(i.children, e, t)));
+    case "mathBlock":
+      return b(t, new Ms(i, e.showMarkup, L(i.children, e, t)));
+    case "blockQuote":
+      return b(t, new Ts(i, L(i.children, e, t)));
+    case "list":
+      return b(t, Qs(i, e, t));
+    case "listItem":
+      return b(t, Ut(i, e, t));
+    case "table":
+      return b(t, Us(i, e, t));
+    case "tableRow":
+      return b(t, Yt(i, e, !1, t));
+    case "tableCell":
+      return b(t, Jt(i, e.showMarkup, e.showTableGlue, e.selectionInNode, t));
+    case "strong":
+      return b(t, new Ns(i, L(i.children, B(e), t)));
+    case "emphasis":
+      return b(t, new Is(i, L(i.children, B(e), t)));
+    case "strikethrough":
+      return b(t, new Bs(i, L(i.children, B(e), t)));
+    case "inlineCode":
+      return b(t, new Rs(i, L(i.children, B(e), t)));
+    case "inlineMath":
+      return b(t, new Ds(i, e.showMarkup, L(i.children, B(e), t)));
+    case "link":
+      return b(t, new As(i, L(i.children, B(e), t)));
+    case "image":
+      return b(t, new $s(i, e.showMarkup, L(i.children, B(e), t)));
+    case "document":
+      return Qt(i, /* @__PURE__ */ new Set(), _.ofLength(0), void 0);
+  }
+}
+function Ne(n) {
+  return n.kind === "document" ? n.blocks.map((e) => e.view) : "content" in n ? n.content : js;
+}
+const js = [];
+function we(n) {
+  if (!n)
+    return;
+  const e = /* @__PURE__ */ new Map();
+  for (const t of Ne(n))
+    e.set(t.ast, t);
+  return e;
+}
+function b(n, e) {
+  if (n && n.kind === e.kind && n.ast === e.ast && Gs(n, e)) {
+    const t = Ne(n), s = Ne(e);
+    if (t.length === s.length && t.every((i, r) => i === s[r]))
+      return n;
+  }
+  return e;
+}
+function Gs(n, e) {
+  switch (n.kind) {
+    case "text":
+      return n.showWhitespace === e.showWhitespace && n.leftWordBoundary === e.leftWordBoundary && n.rightWordBoundary === e.rightWordBoundary;
+    case "marker":
+      return n.visible === e.visible;
+    case "glue":
+      return n.visible === e.visible && n.decorateNewline === e.decorateNewline;
+    case "thematicBreak":
+      return n.showMarkup === e.showMarkup;
+    case "codeBlock":
+      return n.showMarkup === e.showMarkup;
+    case "mathBlock":
+      return n.showMarkup === e.showMarkup;
+    case "inlineMath":
+      return n.showMarkup === e.showMarkup;
+    case "image":
+      return n.showMarkup === e.showMarkup;
+    case "listItem":
+      return n.isActive === e.isActive;
+    case "tableCell": {
+      const t = e;
+      return n.isActive === t.isActive && n.showTableGlue === t.showTableGlue;
+    }
+    case "tableRow":
+      return n.isDelimiter === e.isDelimiter;
+    default:
+      return !0;
+  }
+}
+function L(n, e, t) {
+  const s = we(t);
+  return n.map((i, r) => {
+    const o = i.kind === "text" ? {
+      left: r > 0 && bt(n[r - 1], "end"),
+      right: r < n.length - 1 && bt(n[r + 1], "start")
+    } : void 0;
+    return oe(i, e, s?.get(i), o);
+  });
+}
+function bt(n, e) {
+  switch (n.kind) {
+    case "text": {
+      const t = n.content, s = e === "end" ? t[t.length - 1] : t[0];
+      return s !== void 0 && s !== " " && s !== "	" && s !== `
+` && s !== "\r";
+    }
+    case "inlineCode":
+    case "inlineMath":
+    case "link":
+    case "image":
+    case "strong":
+    case "emphasis":
+    case "strikethrough":
+      return !0;
+    default:
+      return !1;
+  }
+}
+function zs(n, e) {
+  return e.showMarkup || n === "tableCellGlue" && e.showTableGlue;
+}
+function Xs(n, e) {
+  return e.showMarkup || n === "tableCellGlue" && e.showTableGlue;
+}
+function Qs(n, e, t) {
+  const s = we(t), i = Ys(n, e), r = new Set(n.items), o = (e.listLevel ?? 0) + 1, c = [];
+  let l = 0;
+  for (const a of n.children) {
+    if (r.has(a)) {
+      const h = a, g = i.has(n.items.indexOf(h)), u = {
+        showMarkup: g,
+        showTableGlue: !1,
+        selectionInNode: g && e.selectionInNode ? e.selectionInNode.delta(-l) : void 0,
+        listLevel: o
+      };
+      c.push(b(s?.get(h), Ut(h, u, s?.get(h))));
+    } else
+      c.push(oe(a, e, s?.get(a)));
+    l += a.length;
+  }
+  return new Ss(n, c);
+}
+function Ut(n, e, t) {
+  const s = we(t), i = [];
+  let r = 0;
+  for (const o of n.children) {
+    const c = e.selectionInNode ? { ...e, selectionInNode: e.selectionInNode.delta(-r) } : e;
+    i.push(oe(o, c, s?.get(o))), r += o.length;
+  }
+  return new Fs(n, e.showMarkup, i, e.listLevel ?? 1);
+}
+function Us(n, e, t) {
+  const s = we(t), i = e.showMarkup, r = n.delimiterRow, o = new Set(
+    [n.headerRow, n.delimiterRow, ...n.bodyRows].filter((a) => a !== void 0)
+  ), c = [];
+  let l = 0;
+  for (const a of n.children) {
+    if (o.has(a)) {
+      const h = a, g = h === r, u = {
+        showMarkup: i,
+        showTableGlue: i,
+        selectionInNode: !g && i && e.selectionInNode ? e.selectionInNode.delta(-l) : void 0
+      };
+      c.push(b(s?.get(h), Yt(h, u, g, s?.get(h))));
+    } else
+      c.push(oe(a, e, s?.get(a)));
+    l += a.length;
+  }
+  return new Ls(n, c);
+}
+function Yt(n, e, t, s) {
+  const i = we(s), r = e.showMarkup, o = t ? void 0 : Js(n, e), c = new Set(n.cells), l = [];
+  let a = 0;
+  for (const h of n.children) {
+    if (c.has(h)) {
+      const g = h, u = t ? r : o.has(n.cells.indexOf(g)), d = u && e.selectionInNode ? e.selectionInNode.delta(-a) : void 0;
+      l.push(Jt(g, u, r, d, i?.get(g)));
+    } else
+      l.push(oe(h, e, i?.get(h)));
+    a += h.length;
+  }
+  return new Vs(n, t, l);
+}
+function Jt(n, e, t, s, i) {
+  const r = { showMarkup: e, showTableGlue: t, selectionInNode: s };
+  return new Ps(n, e, t, L(n.children, B(r), i));
+}
+const ye = /* @__PURE__ */ new Set();
+function Ys(n, e) {
+  if (!e.showMarkup || !e.selectionInNode)
+    return ye;
+  const t = e.selectionInNode;
+  if (t.isEmpty) {
+    const r = Pt(n, t.start);
+    return r === void 0 ? ye : /* @__PURE__ */ new Set([r]);
+  }
+  const s = /* @__PURE__ */ new Set();
+  let i = 0;
+  for (const r of n.children) {
+    const o = n.items.indexOf(r);
+    o >= 0 && i < t.endExclusive && i + r.length > t.start && s.add(o), i += r.length;
+  }
+  return s;
+}
+function Js(n, e) {
+  if (!e.showMarkup || !e.selectionInNode)
+    return ye;
+  const t = e.selectionInNode;
+  if (t.isEmpty) {
+    const r = Zs(n, t.start);
+    return r === void 0 ? ye : /* @__PURE__ */ new Set([r]);
+  }
+  const s = /* @__PURE__ */ new Set();
+  let i = 0;
+  for (const r of n.children) {
+    const o = n.cells.indexOf(r);
+    o >= 0 && i < t.endExclusive && i + r.length > t.start && s.add(o), i += r.length;
+  }
+  return s;
+}
+function Zs(n, e) {
+  let t = 0;
+  for (const s of n.children) {
+    const i = t + s.length, r = n.cells.indexOf(s);
+    if (r >= 0 && (t <= e && e < i || i === e))
+      return r;
+    t = i;
+  }
+}
+class ei extends te {
+  constructor(e, t) {
+    super(), this._parent = e, this.element = document.createElement("div"), this.element.className = "md-cursor", this.rendering = A(this, (s) => {
+      const i = s.readObservable(t.offset), r = s.readObservable(t.visualLineMap);
+      if (i === void 0 || r.isEmpty)
+        return this.element.style.display = "none", new yt(i ?? 0, !1, R.EMPTY);
+      const o = r.lineIndexOfOffset(i), c = r.lineRect(o).withZeroWidthAt(r.xAtOffset(i)), l = this._parent.getBoundingClientRect(), a = c.translate(-l.left, -l.top);
+      return this.element.style.left = `${a.x}px`, this.element.style.top = `${a.y}px`, this.element.style.height = `${a.height}px`, this.element.style.display = "", new yt(i, !0, a);
+    }), this._register(Z((s) => {
+      s.readObservable(this.rendering);
+    })), this._register(Z((s) => {
+      s.readObservable(t.offset), this.element.style.animation = "none", this.element.offsetWidth, this.element.style.animation = "";
+    }));
+  }
+  element;
+  rendering;
+}
+class yt {
+  constructor(e, t, s) {
+    this.offset = e, this.visible = t, this.rect = s;
+  }
+}
+class ti extends te {
+  constructor(e, t) {
+    super(), this._parent = e, this.element = document.createElementNS("http://www.w3.org/2000/svg", "svg"), this.element.setAttribute("class", "md-selection-layer"), this._path = document.createElementNS("http://www.w3.org/2000/svg", "path"), this._path.setAttribute("class", "md-selection-path"), this.element.appendChild(this._path), this.rendering = A(this, (s) => {
+      const i = s.readObservable(t.selection), r = s.readObservable(t.visualLineMap), o = s.readObservable(t.blocks);
+      return ni(this._path, this._parent, i, r, o);
+    }), this._register(Z((s) => {
+      s.readObservable(this.rendering);
+    }));
+  }
+  element;
+  rendering;
+  _path;
+}
+class Et {
+  constructor(e) {
+    this.rects = e;
+  }
+}
+function ni(n, e, t, s, i) {
+  if (!t || t.isCollapsed)
+    return n.setAttribute("d", ""), new Et([]);
+  const r = t.range, o = e.getBoundingClientRect(), c = [];
+  for (const d of s.lines) {
+    const f = Zt(d);
+    if (!f || !r.intersects(f))
+      continue;
+    const p = i.find((m) => _.ofStartAndLength(m.absoluteStart, m.block.length).containsRange(f));
+    c.push({ line: d, lineRange: f, block: p });
+  }
+  const l = [], a = [];
+  for (let d = 0; d < c.length; d++) {
+    const { line: f, lineRange: p } = c[d], m = d === 0, w = d === c.length - 1, v = m ? f.xAtOffset(Math.max(r.start, p.start)) : f.rect.left, I = w ? f.xAtOffset(Math.min(r.endExclusive, p.endExclusive)) : f.rect.right;
+    l.push({
+      x: v - o.left,
+      y: f.rect.top - o.top,
+      width: Math.max(0, I - v),
+      height: f.rect.height
+    }), a.push({ left: v, right: I, top: f.rect.top, bottom: f.rect.top + f.rect.height });
+  }
+  for (let d = 0; d < a.length - 1; d++) {
+    const f = a[d], p = a[d + 1];
+    if (p.top <= f.bottom)
+      continue;
+    const m = Math.max(f.left, p.left), w = Math.min(f.right, p.right);
+    w <= m || l.push({
+      x: m - o.left,
+      y: f.bottom - o.top,
+      width: w - m,
+      height: p.top - f.bottom
+    });
+  }
+  const h = /* @__PURE__ */ new Map(), g = /* @__PURE__ */ new Map();
+  for (let d = 0; d < c.length; d++) {
+    const f = c[d].block;
+    f && (h.has(f) || h.set(f, d), g.set(f, d));
+  }
+  const u = i.map(
+    (d) => r.intersects(_.ofStartAndLength(d.absoluteStart, d.block.length))
+  );
+  for (let d = 0; d < i.length - 1; d++) {
+    const f = i[d], p = i[d + 1], m = f.absoluteStart + f.block.length, w = p.absoluteStart;
+    if (m < w && !r.containsRange(_.fromTo(m, w)) || m >= w && !(u[d] && u[d + 1]))
+      continue;
+    const v = f.element.getBoundingClientRect(), I = p.element.getBoundingClientRect(), X = si(s, p, I.top), q = v.bottom;
+    if (X <= q)
+      continue;
+    const ce = g.get(f), Ge = h.get(p), ze = ce !== void 0 ? a[ce] : { left: v.left, right: v.right }, Xe = Ge !== void 0 ? a[Ge] : { left: I.left, right: I.right }, Ce = Math.max(ze.left, Xe.left), Qe = Math.min(ze.right, Xe.right);
+    Qe <= Ce || l.push({
+      x: Ce - o.left,
+      y: q - o.top,
+      width: Qe - Ce,
+      height: X - q
+    });
+  }
+  for (const d of i) {
+    const f = _.ofStartAndLength(d.absoluteStart, d.block.length);
+    if (!r.intersects(f))
+      continue;
+    let p = !1;
+    for (const { lineRange: w } of c)
+      if (w.intersects(f)) {
+        p = !0;
+        break;
+      }
+    if (p)
+      continue;
+    const m = d.element.getBoundingClientRect();
+    l.push({
+      x: m.left - o.left,
+      y: m.top - o.top,
+      width: m.width,
+      height: m.height
+    });
+  }
+  return n.setAttribute("d", ii(l, 4)), new Et(l);
+}
+function Zt(n) {
+  if (n.runs.length === 0)
+    return;
+  let e = 1 / 0, t = -1 / 0;
+  for (const s of n.runs)
+    s.sourceStart < e && (e = s.sourceStart), s.sourceEndExclusive > t && (t = s.sourceEndExclusive);
+  return _.fromTo(e, t);
+}
+function si(n, e, t) {
+  const s = _.ofStartAndLength(e.absoluteStart, e.block.length);
+  for (const i of n.lines) {
+    const r = Zt(i);
+    if (r && s.containsRange(r))
+      return i.rect.top;
+  }
+  return t;
+}
+function ii(n, e) {
+  if (n.length === 0)
+    return "";
+  const t = n.slice().sort((r, o) => r.y - o.y || r.x - o.x), s = [];
+  let i = [];
+  for (const r of t) {
+    const o = i[i.length - 1], c = o !== void 0 && r.y <= o.y + o.height + 0.5, l = o !== void 0 && Math.max(o.x, r.x) < Math.min(o.x + o.width, r.x + r.width);
+    c && l ? i.push(r) : (i.length > 0 && s.push(i), i = [r]);
+  }
+  return i.length > 0 && s.push(i), s.map((r) => ri(r, e)).filter(Boolean).join(" ");
+}
+function ri(n, e) {
+  const t = [];
+  t.push({ x: n[0].x + n[0].width, y: n[0].y, convex: !0 });
+  for (let i = 0; i < n.length - 1; i++) {
+    const r = n[i], o = n[i + 1], c = r.x + r.width, l = o.x + o.width;
+    if (Math.abs(c - l) > 0.5) {
+      const a = r.y + r.height, h = c > l;
+      t.push({ x: c, y: a, convex: h }), t.push({ x: l, y: a, convex: !h });
+    }
+  }
+  const s = n[n.length - 1];
+  t.push({ x: s.x + s.width, y: s.y + s.height, convex: !0 }), t.push({ x: s.x, y: s.y + s.height, convex: !0 });
+  for (let i = n.length - 1; i > 0; i--) {
+    const r = n[i], o = n[i - 1];
+    if (Math.abs(r.x - o.x) > 0.5) {
+      const c = r.y, l = r.x < o.x;
+      t.push({ x: r.x, y: c, convex: l }), t.push({ x: o.x, y: c, convex: !l });
+    }
+  }
+  return t.push({ x: n[0].x, y: n[0].y, convex: !0 }), oi(t, e);
+}
+function oi(n, e) {
+  const t = n.length;
+  if (t < 3)
+    return "";
+  const s = new Array(t);
+  for (let o = 0; o < t; o++) {
+    const c = n[(o + t - 1) % t], l = n[(o + 1) % t], a = xe(n[o], c), h = xe(n[o], l);
+    s[o] = Math.min(e, a / 2, h / 2);
+  }
+  const i = Se(n[t - 1], n[0], xe(n[t - 1], n[0]) - s[0]), r = [`M${D(i.x)},${D(i.y)}`];
+  for (let o = 0; o < t; o++) {
+    const c = n[o], l = n[(o + 1) % t], a = s[o], h = Se(c, l, a);
+    a > 0 ? r.push(`A${D(a)},${D(a)} 0 0 ${c.convex ? 1 : 0} ${D(h.x)},${D(h.y)}`) : r.push(`L${D(h.x)},${D(h.y)}`);
+    const g = s[(o + 1) % t], u = Se(c, l, xe(c, l) - g);
+    r.push(`L${D(u.x)},${D(u.y)}`);
+  }
+  return r.push("Z"), r.join(" ");
+}
+function xe(n, e) {
+  return Math.hypot(n.x - e.x, n.y - e.y);
+}
+function Se(n, e, t) {
+  const s = e.x - n.x, i = e.y - n.y, r = Math.hypot(s, i);
+  if (r === 0)
+    return { x: n.x, y: n.y };
+  const o = t / r;
+  return { x: n.x + s * o, y: n.y + i * o };
+}
+function D(n) {
+  return n.toFixed(2);
+}
+class Ii extends te {
+  constructor(e, t) {
+    super(), this._model = e, this._options = t, this.element = document.createElement("div"), this.element.className = "md-editor", this._options?.classNames && this.element.classList.add(...this._options.classNames), this.element.tabIndex = 0, this.measuredLayout = new Pn(), this._selectionView = this._register(new ti(this.element, {
+      selection: this._model.selection,
+      visualLineMap: this.measuredLayout.visualLineMap,
+      blocks: this._selectionBlocksObs
+    })), this.element.appendChild(this._selectionView.element), this._cursorView = this._register(new ei(this.element, {
+      offset: this._model.cursorOffset,
+      visualLineMap: this.measuredLayout.visualLineMap
+    })), this.element.appendChild(this._cursorView.element), this.editContext = new EditContext({
+      text: this._model.sourceText.get().value,
+      selectionStart: 0,
+      selectionEnd: 0
+    }), this.element.editContext = this.editContext, this._register(Z(this._renderAutorun)), this._register(Z((s) => {
+      const i = s.readObservable(this._model.selection)?.range;
+      this.editContext.updateSelection(i?.start ?? 0, i?.endExclusive ?? 0);
+    })), this._register({ dispose: () => {
+      this._document.get()?.dispose();
+    } });
+  }
+  element;
+  editContext;
+  measuredLayout;
+  _cursorView;
+  _selectionView;
+  /**
+   * The mounted block sequence, in source order. Rebuilt (not mutated) each
+   * frame by {@link DocumentViewNode.create}; the view just swaps one
+   * immutable node for the next. Never used for source-of-truth lookups
+   * (those go through the measured-layout model).
+   */
+  _document = G(this, void 0);
+  /** The current view-node tree (AST overlaid with rendered DOM), for debugging. */
+  get documentViewNode() {
+    return this._document;
+  }
+  /**
+   * Last frame's view-data overlay, threaded back into
+   * {@link buildDocumentViewData} so any subtree whose ast and selection flags
+   * are unchanged keeps its view-data object — which lets the renderer reuse
+   * its DOM by identity.
+   */
+  _previousViewData;
+  /** The current view-data tree (AST overlaid with selection flags), for debugging. */
+  _viewData = G(this, void 0);
+  get viewData() {
+    return this._viewData;
+  }
+  /**
+   * The block cache projected for views (selection painting) that need to
+   * react to mount/unmount. Derived from {@link _document}, so it stays in
+   * lock-step without any manual bookkeeping.
+   */
+  _selectionBlocksObs = A(this, (e) => {
+    const t = this._document.read(e);
+    return t ? t.blocks.map((s) => ({
+      block: s.node.block,
+      absoluteStart: s.absoluteStart,
+      viewNode: s.node,
+      element: s.node.element
+    })) : [];
+  });
+  focus() {
+    this.element.focus({ preventScroll: !0 });
+  }
+  /**
+   * Client coordinates → absolute source offset (any block). Used during
+   * drag to keep extending the selection even when the pointer leaves the
+   * original block.
+   */
+  resolveOffsetFromPoint(e) {
+    const t = bs(e);
+    if (t)
+      return this._document.get()?.resolveSource(t);
+  }
+  /**
+   * Whether a client point falls on the rendered document content, as
+   * opposed to the surrounding editor padding (the green area). Uses DOM
+   * containment rather than the content node's bounding box so that markers
+   * which overflow into the padding (e.g. a heading's `##`, which renders in
+   * the left margin) still count as content. Overlays (cursor, selection)
+   * have `pointer-events: none`, so the hit-test sees through them.
+   */
+  isPointInContent(e) {
+    const t = this._document.get()?.contentDomNode;
+    if (!t)
+      return !1;
+    const s = document.elementFromPoint(e.x, e.y);
+    return s !== null && t.contains(s);
+  }
+  // ----- render autorun ------------------------------------------------
+  _renderAutorun = (e) => {
+    const t = e.readObservable(this._model.document), s = e.readObservable(this._model.sourceText).value, i = e.readObservable(this._model.activeBlocks), r = e.readObservable(this._model.selection);
+    this.editContext.text !== s && this.editContext.updateText(0, this.editContext.text.length, s);
+    const o = this._document.get(), c = Qt(t, i, r?.range, this._previousViewData);
+    this._previousViewData = c, this._viewData.set(c, void 0);
+    const l = je.create(c, this._options, o);
+    if (o) {
+      if (l.contentDomNode !== o.contentDomNode)
+        throw new Error("DocumentViewNode.contentDomNode must be stable across rebuilds");
+    } else
+      this.element.insertBefore(l.contentDomNode, this.element.firstChild);
+    this._document.set(l, void 0), this._publishMeasurements(l);
+  };
+  /** Current mounted blocks, or empty before the first render. */
+  get _blocks() {
+    return this._document.get()?.blocks ?? [];
+  }
+  /**
+   * Measure each mounted block's rect and per-block visual line map, then
+   * publish the result into the {@link MeasuredLayoutModel}. The model
+   * is not read here, so there is no feedback loop into the render autorun.
+   */
+  _publishMeasurements(e) {
+    const t = [];
+    for (const s of e.blocks) {
+      const i = s.node.element.getBoundingClientRect();
+      s.node.recordMeasuredHeight(i.height);
+      const r = _e.measure([{
+        absoluteStart: s.absoluteStart,
+        viewNode: s.node
+      }]);
+      t.push({
+        block: s.node.block,
+        absoluteStart: s.absoluteStart,
+        height: i.height,
+        isMeasured: !0,
+        visualLineMap: r,
+        viewNode: s.node
+      });
+    }
+    this.measuredLayout.measurements.set(t, void 0);
+  }
+}
+class Bi extends te {
+  constructor(e, t) {
+    super(), this._model = e, this._view = t;
+    const s = this._view.element;
+    s.addEventListener("mousedown", this._handleMouseDown), s.addEventListener("keydown", this._handleKeyDown), s.addEventListener("copy", this._handleCopy), s.addEventListener("cut", this._handleCut), s.addEventListener("paste", this._handlePaste), this._register({
+      dispose: () => {
+        s.removeEventListener("mousedown", this._handleMouseDown), s.removeEventListener("keydown", this._handleKeyDown), s.removeEventListener("copy", this._handleCopy), s.removeEventListener("cut", this._handleCut), s.removeEventListener("paste", this._handlePaste);
+      }
+    });
+    const i = this._view.editContext;
+    i.addEventListener("textupdate", this._handleTextUpdate), this._register({
+      dispose: () => i.removeEventListener("textupdate", this._handleTextUpdate)
+    });
+  }
+  _desiredColumn;
+  _handleTextUpdate = (e) => {
+    const t = y.replace(
+      new _(e.updateRangeStart, e.updateRangeEnd),
+      e.text
+    );
+    this._model.applyEdit(t);
+  };
+  _handleMouseDown = (e) => {
+    e.preventDefault(), this._view.focus(), this._desiredColumn = void 0;
+    const t = new ee(e.clientX, e.clientY);
+    if (!this._view.isPointInContent(t)) {
+      this._model.selection.set(void 0, void 0);
+      return;
+    }
+    const s = this._view.resolveOffsetFromPoint(t) ?? this._model.sourceText.get().value.length;
+    if (e.detail === 2) {
+      const o = this._makeCursorContext();
+      this._model.selection.set(ls(o, s), void 0);
+      return;
+    }
+    if (e.detail === 3) {
+      const o = ci(this._model.document.get(), s);
+      o && this._model.selection.set(as(this._makeCursorContext(), o), void 0);
+      return;
+    }
+    if (e.shiftKey) {
+      const o = this._model.selection.get() ?? x.collapsed(s);
+      this._model.selection.set(o.withActive(s), void 0);
+    } else
+      this._model.selection.set(x.collapsed(s), void 0);
+    const i = (o) => {
+      const c = this._model.selection.get() ?? x.collapsed(s), l = this._view.resolveOffsetFromPoint(new ee(o.clientX, o.clientY)) ?? c.active;
+      this._model.selection.set(new x(c.anchor, l), void 0);
+    }, r = () => {
+      document.removeEventListener("mousemove", i), document.removeEventListener("mouseup", r);
+    };
+    document.addEventListener("mousemove", i), document.addEventListener("mouseup", r);
+  };
+  _makeCursorContext() {
+    return {
+      text: this._model.sourceText.get().value,
+      selection: this._model.selection.get() ?? x.collapsed(0),
+      document: this._model.document.get(),
+      activeBlock: this._model.activeBlock.get()
+    };
+  }
+  _makeVisualCursorContext() {
+    return {
+      ...this._makeCursorContext(),
+      desiredColumn: this._desiredColumn,
+      lineMap: this._view.measuredLayout.visualLineMap.get()
+    };
+  }
+  _executeCursorCommand(e, t) {
+    const s = this._makeCursorContext(), i = e(s), r = s.selection;
+    this._model.selection.set(
+      t ? r.withActive(i) : x.collapsed(i),
+      void 0
+    ), this._desiredColumn = void 0;
+  }
+  _executeEditCommand(e) {
+    const t = this._makeCursorContext(), s = e(t);
+    s && (this._model.applyEdit(s.edit), this._desiredColumn = void 0);
+  }
+  _executeVisualCursorCommand(e, t) {
+    const s = this._makeVisualCursorContext(), i = e(s);
+    this._model.selection.set(
+      t ? s.selection.withActive(i.offset) : x.collapsed(i.offset),
+      void 0
+    ), this._desiredColumn = i.desiredColumn;
+  }
+  /** Move the cursor down one visual line (Arrow Down). */
+  cursorDown(e = !1) {
+    this._executeVisualCursorCommand(nt, e);
+  }
+  /** Move the cursor up one visual line (Arrow Up). */
+  cursorUp(e = !1) {
+    this._executeVisualCursorCommand(st, e);
+  }
+  _handleCopy = (e) => {
+    const t = this._selectedText();
+    t !== void 0 && (e.preventDefault(), e.clipboardData?.setData("text/plain", t));
+  };
+  _handleCut = (e) => {
+    const t = this._selectedText();
+    t !== void 0 && (e.preventDefault(), e.clipboardData?.setData("text/plain", t), this._executeEditCommand(it));
+  };
+  _handlePaste = (e) => {
+    e.preventDefault();
+    const t = e.clipboardData?.getData("text/plain");
+    t && this._executeEditCommand(ss(t));
+  };
+  _selectedText() {
+    const e = this._model.selection.get();
+    if (!(!e || e.isCollapsed))
+      return this._model.sourceText.get().value.slice(e.range.start, e.range.endExclusive);
+  }
+  _handleKeyDown = (e) => {
+    const t = e.ctrlKey || e.metaKey;
+    if (e.key === "ArrowLeft")
+      e.preventDefault(), t ? this._executeCursorCommand((e.shiftKey, tt), e.shiftKey) : e.shiftKey ? this._executeCursorCommand(Xn, !0) : this._executeCursorCommand(Gn, !1);
+    else if (e.key === "ArrowRight")
+      e.preventDefault(), t ? this._executeCursorCommand(Qn, e.shiftKey) : e.shiftKey ? this._executeCursorCommand(zn, !0) : this._executeCursorCommand(jn, !1);
+    else if (e.key === "ArrowUp")
+      e.preventDefault(), this._executeVisualCursorCommand(st, e.shiftKey);
+    else if (e.key === "ArrowDown")
+      e.preventDefault(), this._executeVisualCursorCommand(nt, e.shiftKey);
+    else if (e.key === "Home")
+      e.preventDefault(), t ? this._executeCursorCommand(Jn, e.shiftKey) : this._executeCursorCommand(Un, e.shiftKey);
+    else if (e.key === "End")
+      e.preventDefault(), t ? this._executeCursorCommand(Zn, e.shiftKey) : this._executeCursorCommand(Yn, e.shiftKey);
+    else if (e.key === "a" && t) {
+      e.preventDefault();
+      const s = this._makeCursorContext();
+      this._model.selection.set(cs(s), void 0);
+    } else e.key === "Backspace" ? (e.preventDefault(), this._executeEditCommand(t ? ts : it)) : e.key === "Delete" ? (e.preventDefault(), this._executeEditCommand(t ? ns : es)) : e.key === "Enter" && (e.preventDefault(), this._executeEditCommand(t ? is : e.shiftKey ? os : rs));
+  };
+}
+function ci(n, e) {
+  let t = 0;
+  for (const s of n.children) {
+    if (n.blocks.includes(s)) {
+      const i = _.ofStartAndLength(t, s.length);
+      if (i.contains(e) || i.endExclusive === e)
+        return i;
+    }
+    t += s.length;
+  }
+}
+const Ct = "md-debug-show-line-rects";
+function li(n, e) {
+  try {
+    const t = localStorage.getItem(n);
+    return t === null ? e : t === "true";
+  } catch {
+    return e;
+  }
+}
+function ai(n, e) {
+  try {
+    localStorage.setItem(n, String(e));
+  } catch {
+  }
+}
+class Ri extends te {
+  constructor(e, t) {
+    super(), this._overlayParent = e, this.overlayElement = document.createElement("div"), this.overlayElement.className = "md-debug-layout-overlay", Object.assign(this.overlayElement.style, {
+      position: "absolute",
+      top: "0",
+      left: "0",
+      right: "0",
+      bottom: "0",
+      pointerEvents: "none"
+    }), this.infoElement = document.createElement("div"), this.infoElement.className = "md-debug-layout-info", Object.assign(this.infoElement.style, {
+      fontFamily: "monospace",
+      fontSize: "11px",
+      padding: "8px 12px",
+      background: "#111",
+      color: "#fff",
+      borderRadius: "4px",
+      lineHeight: "1.4"
+    });
+    const s = document.createElement("label");
+    Object.assign(s.style, {
+      display: "flex",
+      alignItems: "center",
+      gap: "6px",
+      marginBottom: "6px",
+      cursor: "pointer",
+      userSelect: "none"
+    });
+    const i = document.createElement("input");
+    i.type = "checkbox", i.checked = this._showLineRects.get(), i.addEventListener("change", () => {
+      this._showLineRects.set(i.checked, void 0), ai(Ct, i.checked);
+    }), s.appendChild(i), s.appendChild(document.createTextNode("show line rects")), this.infoElement.appendChild(s);
+    const r = document.createElement("pre");
+    r.style.margin = "0", r.style.whiteSpace = "pre", this.infoElement.appendChild(r), this.rendering = A(this, (o) => {
+      const c = o.readObservable(t.model.measurements), l = o.readObservable(this._showLineRects);
+      return ui(this.overlayElement, r, this._overlayParent, c, l, t.colorForOffset, t.hoveredOffset);
+    }), this.mappedOffsets = A(this, (o) => o.readObservable(this.rendering).mappedOffsets), this._register(Z((o) => {
+      o.readObservable(this.rendering);
+      const c = t.hoveredOffset ? o.readObservable(t.hoveredOffset) : void 0;
+      t.hoveredOffset && fi(this.overlayElement, c);
+    }));
+  }
+  overlayElement;
+  infoElement;
+  rendering;
+  /** Absolute source offsets that map to a rendered DOM character. */
+  mappedOffsets;
+  /** Whether the dashed line-bands and run boxes are drawn (persisted). */
+  _showLineRects = G(this, li(Ct, !0));
+}
+class hi {
+  constructor(e, t, s, i) {
+    this.blockCount = e, this.mountedCount = t, this.lineCount = s, this.mappedOffsets = i;
+  }
+}
+function ui(n, e, t, s, i, r, o) {
+  n.textContent = "";
+  const c = t.getBoundingClientRect();
+  let l = 0, a = 0, h = 0;
+  const g = /* @__PURE__ */ new Set();
+  for (let f = 0; f < s.length; f++) {
+    const p = s[f], m = p.visualLineMap?.lines ?? [];
+    if (p.isMeasured && l++, a += m.length, i)
+      for (let w = 0; w < m.length; w++) {
+        const v = m[w], I = v.rect, X = document.createElement("div");
+        Object.assign(X.style, {
+          position: "absolute",
+          left: "0",
+          right: "0",
+          top: `${I.y - c.top}px`,
+          height: `${I.height}px`,
+          border: "1px dashed rgba(180, 0, 200, 0.45)",
+          boxSizing: "border-box"
+        }), n.appendChild(X);
+        for (const q of v.runs) {
+          const ce = document.createElement("div");
+          Object.assign(ce.style, {
+            position: "absolute",
+            left: `${q.rect.x - c.left}px`,
+            top: `${q.rect.y - c.top}px`,
+            width: `${q.rect.width}px`,
+            height: `${q.rect.height}px`,
+            outline: "1px solid rgba(255, 100, 0, 0.45)",
+            boxSizing: "border-box"
+          }), n.appendChild(ce);
+        }
+      }
+    p.viewNode && (h += di(n, c, p.viewNode, p.absoluteStart, g, r, o));
+  }
+  const u = `blocks: ${s.length}   mounted: ${l}   lines: ${a}   chars: ${h}`, d = s.map((f, p) => {
+    const m = f.isMeasured ? "M" : "e", w = f.visualLineMap?.lines.length ?? 0;
+    return `${String(p).padStart(2)} ${m} start=${String(f.absoluteStart).padStart(4)} h=${f.height.toFixed(1).padStart(6)} lines=${w} kind=${f.block.kind}`;
+  });
+  return e.textContent = [u, ...d].join(`
+`), new hi(s.length, l, a, g);
+}
+function di(n, e, t, s, i, r, o) {
+  let c = 0;
+  const l = document.createRange(), a = s + t.sourceLength, h = [];
+  t.forEachTextLeaf(s, (u, d) => {
+    h.push({ start: d, end: d + u.sourceLength });
+  });
+  const g = (u) => h.some((d) => u >= d.start && u < d.end);
+  for (let u = s; u < a; u++) {
+    if (!g(u))
+      continue;
+    const d = t.sourceToDom(u + 1, s);
+    if (!d || d.offset < 1)
+      continue;
+    l.setStart(d.node, d.offset - 1), l.setEnd(d.node, d.offset);
+    const f = l.getBoundingClientRect();
+    if (f.height === 0)
+      continue;
+    const p = f.width === 0 ? 2 : f.width, m = document.createElement("div");
+    Object.assign(m.style, {
+      position: "absolute",
+      left: `${f.x - e.left}px`,
+      top: `${f.y - e.top}px`,
+      width: `${p}px`,
+      height: `${f.height}px`,
+      background: r?.(u) ?? "rgba(0, 120, 220, 0.30)",
+      boxSizing: "border-box",
+      pointerEvents: "auto"
+    });
+    const w = d.node.data?.[d.offset - 1] ?? "";
+    m.title = `offset ${u}: ${JSON.stringify(w)}`, m.dataset.offset = String(u), o ? (m.addEventListener("mouseenter", () => o.set(u, void 0)), m.addEventListener("mouseleave", () => o.set(void 0, void 0))) : (m.addEventListener("mouseenter", () => Ot(n, m, !0)), m.addEventListener("mouseleave", () => Ot(n, m, !1))), n.appendChild(m), i.add(u), c++;
+  }
+  return c;
+}
+function fi(n, e) {
+  for (const t of Array.from(n.children)) {
+    if (!t.style)
+      continue;
+    const s = t.dataset.offset, i = s !== void 0 && Number(s) === e;
+    t.style.visibility = e === void 0 || i ? "" : "hidden";
+  }
+}
+function Ot(n, e, t) {
+  for (const s of Array.from(n.children))
+    s.style.visibility = t && s !== e ? "hidden" : "";
+}
+class de {
+  constructor(e, t) {
+    this.length = e, this.className = t;
+  }
+}
+class gi {
+  /**
+   * @param _monaco The Monarch runtime ({@link IMonarchApi}), injected so this
+   * package depends on `monaco-editor` for types only.
+   * @param _grammars Maps a language id to its Monarch language definition.
+   */
+  constructor(e, t) {
+    this._monaco = e, this._grammars = t;
+  }
+  _tokenizers = /* @__PURE__ */ new Map();
+  create(e, t) {
+    return new pi(this._tokenizerFor(e), t);
+  }
+  dispose() {
+    for (const e of this._tokenizers.values())
+      e.dispose();
+    this._tokenizers.clear();
+  }
+  _tokenizerFor(e) {
+    const t = this._grammars.get(e);
+    if (t === void 0)
+      return;
+    let s = this._tokenizers.get(e);
+    return s || (s = new this._monaco.MonarchTokenizer(ki, xi, e, this._monaco.compile(e, t), vi), this._tokenizers.set(e, s)), s;
+  }
+}
+class pi {
+  constructor(e, t) {
+    this._tokenizer = e, this._initialState = e?.getInitialState(), this._text = t, this._lines = this._tokenizeFrom(0, [], this._initialState, t.split(`
+`)), this._lineStarts = this._computeLineStarts(), this._snapshotObs = G("syntaxSnapshot", new Mt(this, this._version));
+  }
+  _text;
+  _lines;
+  /** Source offset of each line's first char; `length === _lines.length`. */
+  _lineStarts;
+  _version = 1;
+  _disposed = !1;
+  _initialState;
+  _snapshotObs;
+  get snapshot() {
+    return this._snapshotObs;
+  }
+  update(e, t) {
+    if (this._disposed)
+      throw new Error("document is disposed");
+    if (e.isEmpty)
+      return;
+    const s = Tt(this._lines), i = e.apply(this._text), r = e.replacements[0].replaceRange.start, o = this._lineIndexAt(r), c = this._lines.slice(0, o), l = o === 0 ? this._initialState : this._lines[o - 1].endState;
+    this._text = i, this._lines = this._tokenizeFrom(o, c, l, i.split(`
+`)), this._lineStarts = this._computeLineStarts(), this._version++;
+    const a = wi(s, Tt(this._lines));
+    this._snapshotObs.set(new Mt(this, this._version), t, a);
+  }
+  dispose() {
+    this._disposed = !0;
+  }
+  /**
+   * Tokenize `allLines[fromLine..]`, keeping `reusedPrefix` (already tokenized
+   * lines `[0, fromLine)`) verbatim. `startState` is the state entering
+   * `fromLine`.
+   */
+  _tokenizeFrom(e, t, s, i) {
+    const r = t.slice();
+    let o = s;
+    for (let c = e; c < i.length; c++) {
+      const l = i[c], a = c < i.length - 1;
+      if (this._tokenizer && o) {
+        const h = this._tokenizer.tokenize(l, a, o);
+        r.push({ text: l, tokens: _i(h.tokens, l.length), endState: h.endState }), o = h.endState;
+      } else
+        r.push({ text: l, tokens: l.length === 0 ? [] : [new de(l.length, void 0)], endState: o });
+    }
+    return r;
+  }
+  _computeLineStarts() {
+    const e = [];
+    let t = 0;
+    for (const s of this._lines)
+      e.push(t), t += s.text.length + 1;
+    return e;
+  }
+  _lineIndexAt(e) {
+    for (let t = this._lineStarts.length - 1; t >= 0; t--)
+      if (e >= this._lineStarts[t])
+        return t;
+    return 0;
+  }
+  /** @internal Called by {@link MonacoHighlightedSnapshot}. */
+  _getTokens(e, t) {
+    if (e !== this._version)
+      throw new Error("stale snapshot");
+    const s = this._text.length, i = Math.max(0, Math.min(t.start, s)), r = Math.max(i, Math.min(t.endExclusive, s)), o = [];
+    let c = i, l = i, a = !1, h = 0;
+    const g = (u, d) => {
+      const f = h, p = h + u;
+      h = p, u !== 0 && f < r && p > i && (a || (c = f, a = !0), o.push(new de(u, d)), l = p);
+    };
+    for (let u = 0; u < this._lines.length && h < r; u++) {
+      for (const d of this._lines[u].tokens)
+        g(d.length, d.className);
+      u < this._lines.length - 1 && g(1, void 0);
+    }
+    return { range: new _(c, a ? l : i), tokens: o };
+  }
+}
+class Mt {
+  constructor(e, t) {
+    this._doc = e, this._version = t;
+  }
+  getTokens(e) {
+    return this._doc._getTokens(this._version, e);
+  }
+}
+function mi(n) {
+  return n === "" ? void 0 : n;
+}
+function _i(n, e) {
+  if (n.length === 0)
+    return e === 0 ? [] : [new de(e, void 0)];
+  const t = [];
+  for (let s = 0; s < n.length; s++) {
+    const i = n[s].offset, r = s + 1 < n.length ? n[s + 1].offset : e;
+    r > i && t.push(new de(r - i, mi(n[s].type)));
+  }
+  return t;
+}
+function Tt(n) {
+  const e = [];
+  for (let t = 0; t < n.length; t++) {
+    for (const s of n[t].tokens)
+      e.push(s);
+    t < n.length - 1 && e.push(new de(1, void 0));
+  }
+  return e;
+}
+function St(n, e) {
+  return n.length === e.length && n.className === e.className;
+}
+function Lt(n) {
+  let e = 0;
+  for (const t of n)
+    e += t.length;
+  return e;
+}
+function wi(n, e) {
+  const t = n.length, s = e.length;
+  let i = 0, r = 0;
+  for (; i < t && i < s && St(n[i], e[i]); )
+    r += n[i].length, i++;
+  let o = 0, c = 0;
+  for (; o < t - i && o < s - i && St(n[t - 1 - o], e[s - 1 - o]); )
+    c += n[t - 1 - o].length, o++;
+  const l = Lt(n), a = Lt(e), h = new _(r, l - c), g = a - c - r;
+  return h.isEmpty && g === 0 ? J.empty : J.replace(h, g);
+}
+const ki = {
+  languageIdCodec: { encodeLanguageId: () => 0, decodeLanguageId: () => "" },
+  isRegisteredLanguageId: () => !1,
+  getLanguageIdByLanguageName: () => null,
+  getLanguageIdByMimeType: () => null,
+  requestBasicLanguageFeatures: () => {
+  }
+}, xi = {
+  getColorTheme: () => ({ tokenTheme: {} })
+}, vi = {
+  getValue: () => 2e4,
+  onDidChangeConfiguration: () => ({ dispose() {
+  } })
+};
+function Di(n, e) {
+  const t = /* @__PURE__ */ new Map([
+    ["typescript", e.typescript],
+    ["ts", e.typescript],
+    ["javascript", e.javascript],
+    ["js", e.javascript],
+    ["css", e.css],
+    ["html", e.html],
+    ["python", e.python],
+    ["py", e.python],
+    ["rust", e.rust],
+    ["rs", e.rust],
+    ["shell", e.shell],
+    ["sh", e.shell],
+    ["bash", e.shell]
+  ]);
+  return new gi(n, t);
+}
+export {
+  E as AstNode,
+  pe as BlockQuoteAstNode,
+  M as BlockViewNode,
+  K as CodeBlockAstNode,
+  We as CodeBlockViewNode,
+  ei as CursorView,
+  yt as CursorViewRendering,
+  Fe as DocumentAstNode,
+  je as DocumentViewNode,
+  Bi as EditorController,
+  Ni as EditorModel,
+  Ii as EditorView,
+  Re as EmphasisAstNode,
+  N as GlueAstNode,
+  U as HeadingAstNode,
+  ge as ImageAstNode,
+  Ae as InlineCodeAstNode,
+  $e as InlineMathAstNode,
+  J as LengthEdit,
+  Ie as LengthReplacement,
+  fe as LinkAstNode,
+  H as ListAstNode,
+  $ as ListItemAstNode,
+  On as MarkdownParser,
+  k as MarkerAstNode,
+  se as MathBlockAstNode,
+  hi as MeasuredLayoutDebugRendering,
+  Ri as MeasuredLayoutDebugView,
+  Pn as MeasuredLayoutModel,
+  gi as MonacoSyntaxHighlighter,
+  _ as OffsetRange,
+  z as ParagraphAstNode,
+  ee as Point2D,
+  R as Rect2D,
+  x as Selection,
+  ti as SelectionView,
+  Et as SelectionViewRendering,
+  De as StrikethroughAstNode,
+  y as StringEdit,
+  V as StringReplacement,
+  Oe as StringValue,
+  Be as StrongAstNode,
+  me as TableAstNode,
+  ue as TableCellAstNode,
+  he as TableRowAstNode,
+  ve as TextAstNode,
+  ne as ThematicBreakAstNode,
+  de as Token,
+  ie as ViewNode,
+  Bn as VisualLine,
+  _e as VisualLineMap,
+  Le as VisualRun,
+  Di as createDefaultMonacoSyntaxHighlighter,
+  Zn as cursorDocumentEnd,
+  Jn as cursorDocumentStart,
+  nt as cursorDown,
+  Gn as cursorLeft,
+  Yn as cursorLineEnd,
+  Un as cursorLineStart,
+  Xn as cursorMoveLeft,
+  zn as cursorMoveRight,
+  jn as cursorRight,
+  st as cursorUp,
+  tt as cursorWordLeft,
+  Qn as cursorWordRight,
+  it as deleteLeft,
+  es as deleteRight,
+  ts as deleteWordLeft,
+  ns as deleteWordRight,
+  fn as findNodeOffsetById,
+  hn as findWordAt,
+  It as findWordBoundaryLeft,
+  Bt as findWordBoundaryRight,
+  Mn as getAnnotatedSource,
+  os as insertHardLineBreak,
+  rs as insertLineBreak,
+  is as insertParagraph,
+  ss as insertText,
+  Vt as nextCursorPosition,
+  cs as selectAll,
+  as as selectBlock,
+  ls as selectWord,
+  Si as taskCheckboxRange,
+  Li as visualizeAst
+};
+//# sourceMappingURL=index.js.map