@rcarls/rc-textarea 0.1.0

package/dist/line-actions-controller-BsM6DJ0b.js

@@ -0,0 +1,2334 @@
+import { css as St, LitElement as tt, html as Lt } from "lit";
+import { property as b } from "lit/decorators.js";
+const Tt = St`
+  :host {
+    display: block;
+    box-sizing: border-box;
+    color-scheme: inherit;
+  }
+
+  :host([hidden]) {
+    display: none;
+  }
+
+  /* ── Root layout ──────────────────────────────────────────────────────── */
+
+  #root {
+    display: flex;
+    align-items: stretch;
+    border: var(--rc-textarea-border, 1px solid ButtonBorder);
+    border-radius: var(--rc-textarea-border-radius, 2px);
+    background: var(--rc-textarea-background, Field);
+    color: var(--rc-textarea-color, var(--rc-text, FieldText));
+    overflow: hidden;
+    min-height: var(--_rc-textarea-min-height, auto);
+  }
+
+  /* ── Gutter ───────────────────────────────────────────────────────────── */
+
+  #gutter {
+    display: none;
+    flex-shrink: 0;
+    background: var(--rc-textarea-gutter-bg, Canvas);
+    color: var(--rc-textarea-gutter-color, GrayText);
+    border-right: var(--rc-textarea-gutter-border, 1px solid ButtonBorder);
+    overflow: hidden;
+    user-select: none;
+  }
+
+  :host([line-numbers]) #gutter,
+  :host([list-numbers]) #gutter,
+  :host([gutter]) #gutter {
+    display: block;
+  }
+
+  #gutter-cells {
+    padding: var(--rc-textarea-padding, 0.5em);
+    padding-inline-end: var(--rc-textarea-gutter-padding-inline-end, 0.75em);
+    font-family: var(--rc-textarea-font-family, monospace);
+    font-size: var(--rc-textarea-font-size, 1em);
+    line-height: var(--rc-textarea-line-height, 1.5);
+    text-align: right;
+    min-width: 2.5ch;
+  }
+
+  .gutter-cell {
+    display: block;
+    white-space: pre;
+  }
+
+  .gutter-cell--active {
+    color: var(--rc-textarea-color, var(--rc-text, FieldText));
+  }
+
+  /* ── Editor area ──────────────────────────────────────────────────────── */
+
+  #editor-area {
+    position: relative;
+    flex: 1;
+    min-width: 0;
+    overflow: hidden;
+  }
+
+  #editor {
+    position: relative;
+    z-index: 1;
+    width: 100%;
+    min-height: 100%;
+    box-sizing: border-box;
+    padding: var(--rc-textarea-padding, 0.5em);
+    font-family: var(--rc-textarea-font-family, monospace);
+    font-size: var(--rc-textarea-font-size, 1em);
+    line-height: var(--rc-textarea-line-height, 1.5);
+    color: var(--rc-textarea-color, var(--rc-text, FieldText));
+    caret-color: var(
+      --rc-textarea-caret-color,
+      var(--rc-textarea-color, FieldText)
+    );
+    background: transparent;
+    outline: none;
+    overflow: auto;
+    resize: none;
+    white-space: pre;
+    word-break: normal;
+    overflow-wrap: normal;
+    tab-size: 4;
+    word-break: normal;
+    /* Prevent contenteditable from injecting <div> wrappers on Enter in some browsers */
+    -webkit-user-modify: read-write-plaintext-only;
+  }
+
+  :host([word-wrap]) #editor {
+    white-space: pre-wrap;
+    overflow-wrap: break-word;
+    word-break: normal;
+  }
+
+  :host([auto-grow]) #editor {
+    overflow: visible;
+    height: auto;
+  }
+
+  :host([auto-grow]) #root {
+    height: auto;
+  }
+
+  :host([read-only]) #root {
+    border: none;
+    background: transparent;
+    border-radius: 0;
+  }
+
+  :host([read-only]) #editor {
+    cursor: default;
+    padding: 0;
+    -webkit-user-modify: read-only;
+  }
+
+  /* Focus ring on the root when editor is focused */
+  #root:has(#editor:focus) {
+    outline: var(--rc-textarea-focus-outline, 2px solid Highlight);
+    outline-offset: -1px;
+  }
+
+  /* ── Slot (hidden lightDOM textarea) ──────────────────────────────────── */
+
+  ::slotted(textarea) {
+    /* Visually hidden but accessible to form submission.
+       Inline styles applied via JS take precedence and are more reliable,
+       but this provides a baseline in case of timing issues. */
+    position: absolute !important;
+    width: 1px !important;
+    height: 1px !important;
+    padding: 0 !important;
+    margin: -1px !important;
+    overflow: hidden !important;
+    clip: rect(0, 0, 0, 0) !important;
+    border: 0 !important;
+    opacity: 0 !important;
+    pointer-events: none !important;
+  }
+
+  /* ── Line structure ───────────────────────────────────────────────────── */
+
+  .v2-line {
+    position: relative;
+    display: block;
+  }
+
+  /* Active line highlight — opt-in via CSS custom property. */
+  .v2-line--active {
+    background: var(--rc-textarea-active-line-bg, transparent);
+  }
+
+  /* Error-lens style end-of-line message via ::after pseudo-element.
+     content: attr(data-message) is set when V2Document assigns data-message.
+     Using ::after keeps the annotation completely outside the DOM selection
+     and clipboard path — no user-select tricks needed. */
+  .v2-line[data-message]::after {
+    content: attr(data-message);
+    display: inline;
+    margin-left: 4ch;
+    white-space: nowrap;
+    pointer-events: none;
+    font-size: 0.875em;
+    opacity: 0.8;
+    font-style: italic;
+  }
+
+  /* ── Inline decoration spans ──────────────────────────────────────────── */
+
+  .v2-mark {
+    /* Base class; formatting applied via inline style by V2InlineBlot */
+    border-radius: 2px;
+  }
+
+  /* ── Widget spans ─────────────────────────────────────────────────────── */
+
+  .v2-widget {
+    display: inline-block;
+    user-select: none;
+    cursor: default;
+    vertical-align: middle;
+  }
+
+  /* ── Scrollbar sync between editor and gutter ─────────────────────────── */
+  /* Gutter doesn't scroll independently; editor scroll is handled in JS */
+`;
+var f = /* @__PURE__ */ ((n) => (n[n.TYPE = 3] = "TYPE", n[n.LEVEL = 12] = "LEVEL", n[n.ATTRIBUTE = 13] = "ATTRIBUTE", n[n.BLOT = 14] = "BLOT", n[n.INLINE = 7] = "INLINE", n[n.BLOCK = 11] = "BLOCK", n[n.BLOCK_BLOT = 10] = "BLOCK_BLOT", n[n.INLINE_BLOT = 6] = "INLINE_BLOT", n[n.BLOCK_ATTRIBUTE = 9] = "BLOCK_ATTRIBUTE", n[n.INLINE_ATTRIBUTE = 5] = "INLINE_ATTRIBUTE", n[n.ANY = 15] = "ANY", n))(f || {});
+class T {
+  constructor(t, e, s = {}) {
+    this.attrName = t, this.keyName = e;
+    const i = f.TYPE & f.ATTRIBUTE;
+    this.scope = s.scope != null ? (
+      // Ignore type bits, force attribute bit
+      s.scope & f.LEVEL | i
+    ) : f.ATTRIBUTE, s.whitelist != null && (this.whitelist = s.whitelist);
+  }
+  static keys(t) {
+    return Array.from(t.attributes).map((e) => e.name);
+  }
+  add(t, e) {
+    return this.canAdd(t, e) ? (t.setAttribute(this.keyName, e), !0) : !1;
+  }
+  canAdd(t, e) {
+    return this.whitelist == null ? !0 : typeof e == "string" ? this.whitelist.indexOf(e.replace(/["']/g, "")) > -1 : this.whitelist.indexOf(e) > -1;
+  }
+  remove(t) {
+    t.removeAttribute(this.keyName);
+  }
+  value(t) {
+    const e = t.getAttribute(this.keyName);
+    return this.canAdd(t, e) && e ? e : "";
+  }
+}
+class S extends Error {
+  constructor(t) {
+    t = "[Parchment] " + t, super(t), this.message = t, this.name = this.constructor.name;
+  }
+}
+const ht = class j {
+  constructor() {
+    this.attributes = {}, this.classes = {}, this.tags = {}, this.types = {};
+  }
+  static find(t, e = !1) {
+    if (t == null)
+      return null;
+    if (this.blots.has(t))
+      return this.blots.get(t) || null;
+    if (e) {
+      let s = null;
+      try {
+        s = t.parentNode;
+      } catch {
+        return null;
+      }
+      return this.find(s, e);
+    }
+    return null;
+  }
+  create(t, e, s) {
+    const i = this.query(e);
+    if (i == null)
+      throw new S(`Unable to create ${e} blot`);
+    const r = i, o = (
+      // @ts-expect-error Fix me later
+      e instanceof Node || e.nodeType === Node.TEXT_NODE ? e : r.create(s)
+    ), a = new r(t, o, s);
+    return j.blots.set(a.domNode, a), a;
+  }
+  find(t, e = !1) {
+    return j.find(t, e);
+  }
+  query(t, e = f.ANY) {
+    let s;
+    return typeof t == "string" ? s = this.types[t] || this.attributes[t] : t instanceof Text || t.nodeType === Node.TEXT_NODE ? s = this.types.text : typeof t == "number" ? t & f.LEVEL & f.BLOCK ? s = this.types.block : t & f.LEVEL & f.INLINE && (s = this.types.inline) : t instanceof Element && ((t.getAttribute("class") || "").split(/\s+/).some((i) => (s = this.classes[i], !!s)), s = s || this.tags[t.tagName]), s == null ? null : "scope" in s && e & f.LEVEL & s.scope && e & f.TYPE & s.scope ? s : null;
+  }
+  register(...t) {
+    return t.map((e) => {
+      const s = "blotName" in e, i = "attrName" in e;
+      if (!s && !i)
+        throw new S("Invalid definition");
+      if (s && e.blotName === "abstract")
+        throw new S("Cannot register abstract class");
+      const r = s ? e.blotName : i ? e.attrName : void 0;
+      return this.types[r] = e, i ? typeof e.keyName == "string" && (this.attributes[e.keyName] = e) : s && (e.className && (this.classes[e.className] = e), e.tagName && (Array.isArray(e.tagName) ? e.tagName = e.tagName.map((o) => o.toUpperCase()) : e.tagName = e.tagName.toUpperCase(), (Array.isArray(e.tagName) ? e.tagName : [e.tagName]).forEach((o) => {
+        (this.tags[o] == null || e.className == null) && (this.tags[o] = e);
+      }))), e;
+    });
+  }
+};
+ht.blots = /* @__PURE__ */ new WeakMap();
+let z = ht;
+function et(n, t) {
+  return (n.getAttribute("class") || "").split(/\s+/).filter((e) => e.indexOf(`${t}-`) === 0);
+}
+class kt extends T {
+  static keys(t) {
+    return (t.getAttribute("class") || "").split(/\s+/).map((e) => e.split("-").slice(0, -1).join("-"));
+  }
+  add(t, e) {
+    return this.canAdd(t, e) ? (this.remove(t), t.classList.add(`${this.keyName}-${e}`), !0) : !1;
+  }
+  remove(t) {
+    et(t, this.keyName).forEach((e) => {
+      t.classList.remove(e);
+    }), t.classList.length === 0 && t.removeAttribute("class");
+  }
+  value(t) {
+    const e = (et(t, this.keyName)[0] || "").slice(this.keyName.length + 1);
+    return this.canAdd(t, e) ? e : "";
+  }
+}
+const Bt = kt;
+function F(n) {
+  const t = n.split("-"), e = t.slice(1).map((s) => s[0].toUpperCase() + s.slice(1)).join("");
+  return t[0] + e;
+}
+class Dt extends T {
+  static keys(t) {
+    return (t.getAttribute("style") || "").split(";").map((e) => e.split(":")[0].trim());
+  }
+  add(t, e) {
+    return this.canAdd(t, e) ? (t.style[F(this.keyName)] = e, !0) : !1;
+  }
+  remove(t) {
+    t.style[F(this.keyName)] = "", t.getAttribute("style") || t.removeAttribute("style");
+  }
+  value(t) {
+    const e = t.style[F(this.keyName)];
+    return this.canAdd(t, e) ? e : "";
+  }
+}
+const It = Dt;
+class Rt {
+  constructor(t) {
+    this.attributes = {}, this.domNode = t, this.build();
+  }
+  attribute(t, e) {
+    e ? t.add(this.domNode, e) && (t.value(this.domNode) != null ? this.attributes[t.attrName] = t : delete this.attributes[t.attrName]) : (t.remove(this.domNode), delete this.attributes[t.attrName]);
+  }
+  build() {
+    this.attributes = {};
+    const t = z.find(this.domNode);
+    if (t == null)
+      return;
+    const e = T.keys(this.domNode), s = Bt.keys(this.domNode), i = It.keys(this.domNode);
+    e.concat(s).concat(i).forEach((r) => {
+      const o = t.scroll.query(r, f.ATTRIBUTE);
+      o instanceof T && (this.attributes[o.attrName] = o);
+    });
+  }
+  copy(t) {
+    Object.keys(this.attributes).forEach((e) => {
+      const s = this.attributes[e].value(this.domNode);
+      t.format(e, s);
+    });
+  }
+  move(t) {
+    this.copy(t), Object.keys(this.attributes).forEach((e) => {
+      this.attributes[e].remove(this.domNode);
+    }), this.attributes = {};
+  }
+  values() {
+    return Object.keys(this.attributes).reduce(
+      (t, e) => (t[e] = this.attributes[e].value(this.domNode), t),
+      {}
+    );
+  }
+}
+const ut = Rt, dt = class {
+  constructor(t, e) {
+    this.scroll = t, this.domNode = e, z.blots.set(e, this), this.prev = null, this.next = null;
+  }
+  static create(t) {
+    if (this.tagName == null)
+      throw new S("Blot definition missing tagName");
+    let e, s;
+    return Array.isArray(this.tagName) ? (typeof t == "string" ? (s = t.toUpperCase(), parseInt(s, 10).toString() === s && (s = parseInt(s, 10))) : typeof t == "number" && (s = t), typeof s == "number" ? e = document.createElement(this.tagName[s - 1]) : s && this.tagName.indexOf(s) > -1 ? e = document.createElement(s) : e = document.createElement(this.tagName[0])) : e = document.createElement(this.tagName), this.className && e.classList.add(this.className), e;
+  }
+  // Hack for accessing inherited static methods
+  get statics() {
+    return this.constructor;
+  }
+  attach() {
+  }
+  clone() {
+    const t = this.domNode.cloneNode(!1);
+    return this.scroll.create(t);
+  }
+  detach() {
+    this.parent != null && this.parent.removeChild(this), z.blots.delete(this.domNode);
+  }
+  deleteAt(t, e) {
+    this.isolate(t, e).remove();
+  }
+  formatAt(t, e, s, i) {
+    const r = this.isolate(t, e);
+    if (this.scroll.query(s, f.BLOT) != null && i)
+      r.wrap(s, i);
+    else if (this.scroll.query(s, f.ATTRIBUTE) != null) {
+      const o = this.scroll.create(this.statics.scope);
+      r.wrap(o), o.format(s, i);
+    }
+  }
+  insertAt(t, e, s) {
+    const i = s == null ? this.scroll.create("text", e) : this.scroll.create(e, s), r = this.split(t);
+    this.parent.insertBefore(i, r || void 0);
+  }
+  isolate(t, e) {
+    const s = this.split(t);
+    if (s == null)
+      throw new Error("Attempt to isolate at end");
+    return s.split(e), s;
+  }
+  length() {
+    return 1;
+  }
+  offset(t = this.parent) {
+    return this.parent == null || this === t ? 0 : this.parent.children.offset(this) + this.parent.offset(t);
+  }
+  optimize(t) {
+    this.statics.requiredContainer && !(this.parent instanceof this.statics.requiredContainer) && this.wrap(this.statics.requiredContainer.blotName);
+  }
+  remove() {
+    this.domNode.parentNode != null && this.domNode.parentNode.removeChild(this.domNode), this.detach();
+  }
+  replaceWith(t, e) {
+    const s = typeof t == "string" ? this.scroll.create(t, e) : t;
+    return this.parent != null && (this.parent.insertBefore(s, this.next || void 0), this.remove()), s;
+  }
+  split(t, e) {
+    return t === 0 ? this : this.next;
+  }
+  update(t, e) {
+  }
+  wrap(t, e) {
+    const s = typeof t == "string" ? this.scroll.create(t, e) : t;
+    if (this.parent != null && this.parent.insertBefore(s, this.next || void 0), typeof s.appendChild != "function")
+      throw new S(`Cannot wrap ${t}`);
+    return s.appendChild(this), s;
+  }
+};
+dt.blotName = "abstract";
+let ft = dt;
+const pt = class extends ft {
+  /**
+   * Returns the value represented by domNode if it is this Blot's type
+   * No checking that domNode can represent this Blot type is required so
+   * applications needing it should check externally before calling.
+   */
+  static value(t) {
+    return !0;
+  }
+  /**
+   * Given location represented by node and offset from DOM Selection Range,
+   * return index to that location.
+   */
+  index(t, e) {
+    return this.domNode === t || this.domNode.compareDocumentPosition(t) & Node.DOCUMENT_POSITION_CONTAINED_BY ? Math.min(e, 1) : -1;
+  }
+  /**
+   * Given index to location within blot, return node and offset representing
+   * that location, consumable by DOM Selection Range
+   */
+  position(t, e) {
+    let s = Array.from(this.parent.domNode.childNodes).indexOf(this.domNode);
+    return t > 0 && (s += 1), [this.parent.domNode, s];
+  }
+  /**
+   * Return value represented by this blot
+   * Should not change without interaction from API or
+   * user change detectable by update()
+   */
+  value() {
+    return {
+      [this.statics.blotName]: this.statics.value(this.domNode) || !0
+    };
+  }
+};
+pt.scope = f.INLINE_BLOT;
+let Pt = pt;
+const W = Pt;
+class Mt {
+  constructor() {
+    this.head = null, this.tail = null, this.length = 0;
+  }
+  append(...t) {
+    if (this.insertBefore(t[0], null), t.length > 1) {
+      const e = t.slice(1);
+      this.append(...e);
+    }
+  }
+  at(t) {
+    const e = this.iterator();
+    let s = e();
+    for (; s && t > 0; )
+      t -= 1, s = e();
+    return s;
+  }
+  contains(t) {
+    const e = this.iterator();
+    let s = e();
+    for (; s; ) {
+      if (s === t)
+        return !0;
+      s = e();
+    }
+    return !1;
+  }
+  indexOf(t) {
+    const e = this.iterator();
+    let s = e(), i = 0;
+    for (; s; ) {
+      if (s === t)
+        return i;
+      i += 1, s = e();
+    }
+    return -1;
+  }
+  insertBefore(t, e) {
+    t != null && (this.remove(t), t.next = e, e != null ? (t.prev = e.prev, e.prev != null && (e.prev.next = t), e.prev = t, e === this.head && (this.head = t)) : this.tail != null ? (this.tail.next = t, t.prev = this.tail, this.tail = t) : (t.prev = null, this.head = this.tail = t), this.length += 1);
+  }
+  offset(t) {
+    let e = 0, s = this.head;
+    for (; s != null; ) {
+      if (s === t)
+        return e;
+      e += s.length(), s = s.next;
+    }
+    return -1;
+  }
+  remove(t) {
+    this.contains(t) && (t.prev != null && (t.prev.next = t.next), t.next != null && (t.next.prev = t.prev), t === this.head && (this.head = t.next), t === this.tail && (this.tail = t.prev), this.length -= 1);
+  }
+  iterator(t = this.head) {
+    return () => {
+      const e = t;
+      return t != null && (t = t.next), e;
+    };
+  }
+  find(t, e = !1) {
+    const s = this.iterator();
+    let i = s();
+    for (; i; ) {
+      const r = i.length();
+      if (t < r || e && t === r && (i.next == null || i.next.length() !== 0))
+        return [i, t];
+      t -= r, i = s();
+    }
+    return [null, 0];
+  }
+  forEach(t) {
+    const e = this.iterator();
+    let s = e();
+    for (; s; )
+      t(s), s = e();
+  }
+  forEachAt(t, e, s) {
+    if (e <= 0)
+      return;
+    const [i, r] = this.find(t);
+    let o = t - r;
+    const a = this.iterator(i);
+    let l = a();
+    for (; l && o < t + e; ) {
+      const h = l.length();
+      t > o ? s(
+        l,
+        t - o,
+        Math.min(e, o + h - t)
+      ) : s(l, 0, Math.min(h, t + e - o)), o += h, l = a();
+    }
+  }
+  map(t) {
+    return this.reduce((e, s) => (e.push(t(s)), e), []);
+  }
+  reduce(t, e) {
+    const s = this.iterator();
+    let i = s();
+    for (; i; )
+      e = t(e, i), i = s();
+    return e;
+  }
+}
+function st(n, t) {
+  const e = t.find(n);
+  if (e)
+    return e;
+  try {
+    return t.create(n);
+  } catch {
+    const s = t.create(f.INLINE);
+    return Array.from(n.childNodes).forEach((i) => {
+      s.domNode.appendChild(i);
+    }), n.parentNode && n.parentNode.replaceChild(s.domNode, n), s.attach(), s;
+  }
+}
+const mt = class N extends ft {
+  constructor(t, e) {
+    super(t, e), this.uiNode = null, this.build();
+  }
+  appendChild(t) {
+    this.insertBefore(t);
+  }
+  attach() {
+    super.attach(), this.children.forEach((t) => {
+      t.attach();
+    });
+  }
+  attachUI(t) {
+    this.uiNode != null && this.uiNode.remove(), this.uiNode = t, N.uiClass && this.uiNode.classList.add(N.uiClass), this.uiNode.setAttribute("contenteditable", "false"), this.domNode.insertBefore(this.uiNode, this.domNode.firstChild);
+  }
+  /**
+   * Called during construction, should fill its own children LinkedList.
+   */
+  build() {
+    this.children = new Mt(), Array.from(this.domNode.childNodes).filter((t) => t !== this.uiNode).reverse().forEach((t) => {
+      try {
+        const e = st(t, this.scroll);
+        this.insertBefore(e, this.children.head || void 0);
+      } catch (e) {
+        if (e instanceof S)
+          return;
+        throw e;
+      }
+    });
+  }
+  deleteAt(t, e) {
+    if (t === 0 && e === this.length())
+      return this.remove();
+    this.children.forEachAt(t, e, (s, i, r) => {
+      s.deleteAt(i, r);
+    });
+  }
+  descendant(t, e = 0) {
+    const [s, i] = this.children.find(e);
+    return t.blotName == null && t(s) || t.blotName != null && s instanceof t ? [s, i] : s instanceof N ? s.descendant(t, i) : [null, -1];
+  }
+  descendants(t, e = 0, s = Number.MAX_VALUE) {
+    let i = [], r = s;
+    return this.children.forEachAt(
+      e,
+      s,
+      (o, a, l) => {
+        (t.blotName == null && t(o) || t.blotName != null && o instanceof t) && i.push(o), o instanceof N && (i = i.concat(
+          o.descendants(t, a, r)
+        )), r -= l;
+      }
+    ), i;
+  }
+  detach() {
+    this.children.forEach((t) => {
+      t.detach();
+    }), super.detach();
+  }
+  enforceAllowedChildren() {
+    let t = !1;
+    this.children.forEach((e) => {
+      t || this.statics.allowedChildren.some(
+        (s) => e instanceof s
+      ) || (e.statics.scope === f.BLOCK_BLOT ? (e.next != null && this.splitAfter(e), e.prev != null && this.splitAfter(e.prev), e.parent.unwrap(), t = !0) : e instanceof N ? e.unwrap() : e.remove());
+    });
+  }
+  formatAt(t, e, s, i) {
+    this.children.forEachAt(t, e, (r, o, a) => {
+      r.formatAt(o, a, s, i);
+    });
+  }
+  insertAt(t, e, s) {
+    const [i, r] = this.children.find(t);
+    if (i)
+      i.insertAt(r, e, s);
+    else {
+      const o = s == null ? this.scroll.create("text", e) : this.scroll.create(e, s);
+      this.appendChild(o);
+    }
+  }
+  insertBefore(t, e) {
+    t.parent != null && t.parent.children.remove(t);
+    let s = null;
+    this.children.insertBefore(t, e || null), t.parent = this, e != null && (s = e.domNode), (this.domNode.parentNode !== t.domNode || this.domNode.nextSibling !== s) && this.domNode.insertBefore(t.domNode, s), t.attach();
+  }
+  length() {
+    return this.children.reduce((t, e) => t + e.length(), 0);
+  }
+  moveChildren(t, e) {
+    this.children.forEach((s) => {
+      t.insertBefore(s, e);
+    });
+  }
+  optimize(t) {
+    if (super.optimize(t), this.enforceAllowedChildren(), this.uiNode != null && this.uiNode !== this.domNode.firstChild && this.domNode.insertBefore(this.uiNode, this.domNode.firstChild), this.children.length === 0)
+      if (this.statics.defaultChild != null) {
+        const e = this.scroll.create(this.statics.defaultChild.blotName);
+        this.appendChild(e);
+      } else
+        this.remove();
+  }
+  path(t, e = !1) {
+    const [s, i] = this.children.find(t, e), r = [[this, t]];
+    return s instanceof N ? r.concat(s.path(i, e)) : (s != null && r.push([s, i]), r);
+  }
+  removeChild(t) {
+    this.children.remove(t);
+  }
+  replaceWith(t, e) {
+    const s = typeof t == "string" ? this.scroll.create(t, e) : t;
+    return s instanceof N && this.moveChildren(s), super.replaceWith(s);
+  }
+  split(t, e = !1) {
+    if (!e) {
+      if (t === 0)
+        return this;
+      if (t === this.length())
+        return this.next;
+    }
+    const s = this.clone();
+    return this.parent && this.parent.insertBefore(s, this.next || void 0), this.children.forEachAt(t, this.length(), (i, r, o) => {
+      const a = i.split(r, e);
+      a != null && s.appendChild(a);
+    }), s;
+  }
+  splitAfter(t) {
+    const e = this.clone();
+    for (; t.next != null; )
+      e.appendChild(t.next);
+    return this.parent && this.parent.insertBefore(e, this.next || void 0), e;
+  }
+  unwrap() {
+    this.parent && this.moveChildren(this.parent, this.next || void 0), this.remove();
+  }
+  update(t, e) {
+    const s = [], i = [];
+    t.forEach((r) => {
+      r.target === this.domNode && r.type === "childList" && (s.push(...r.addedNodes), i.push(...r.removedNodes));
+    }), i.forEach((r) => {
+      if (r.parentNode != null && // @ts-expect-error Fix me later
+      r.tagName !== "IFRAME" && document.body.compareDocumentPosition(r) & Node.DOCUMENT_POSITION_CONTAINED_BY)
+        return;
+      const o = this.scroll.find(r);
+      o != null && (o.domNode.parentNode == null || o.domNode.parentNode === this.domNode) && o.detach();
+    }), s.filter((r) => r.parentNode === this.domNode && r !== this.uiNode).sort((r, o) => r === o ? 0 : r.compareDocumentPosition(o) & Node.DOCUMENT_POSITION_FOLLOWING ? 1 : -1).forEach((r) => {
+      let o = null;
+      r.nextSibling != null && (o = this.scroll.find(r.nextSibling));
+      const a = st(r, this.scroll);
+      (a.next !== o || a.next == null) && (a.parent != null && a.parent.removeChild(this), this.insertBefore(a, o || void 0));
+    }), this.enforceAllowedChildren();
+  }
+};
+mt.uiClass = "";
+let zt = mt;
+const L = zt;
+function Ut(n, t) {
+  if (Object.keys(n).length !== Object.keys(t).length)
+    return !1;
+  for (const e in n)
+    if (n[e] !== t[e])
+      return !1;
+  return !0;
+}
+const w = class A extends L {
+  static create(t) {
+    return super.create(t);
+  }
+  static formats(t, e) {
+    const s = e.query(A.blotName);
+    if (!(s != null && t.tagName === s.tagName)) {
+      if (typeof this.tagName == "string")
+        return !0;
+      if (Array.isArray(this.tagName))
+        return t.tagName.toLowerCase();
+    }
+  }
+  constructor(t, e) {
+    super(t, e), this.attributes = new ut(this.domNode);
+  }
+  format(t, e) {
+    if (t === this.statics.blotName && !e)
+      this.children.forEach((s) => {
+        s instanceof A || (s = s.wrap(A.blotName, !0)), this.attributes.copy(s);
+      }), this.unwrap();
+    else {
+      const s = this.scroll.query(t, f.INLINE);
+      if (s == null)
+        return;
+      s instanceof T ? this.attributes.attribute(s, e) : e && (t !== this.statics.blotName || this.formats()[t] !== e) && this.replaceWith(t, e);
+    }
+  }
+  formats() {
+    const t = this.attributes.values(), e = this.statics.formats(this.domNode, this.scroll);
+    return e != null && (t[this.statics.blotName] = e), t;
+  }
+  formatAt(t, e, s, i) {
+    this.formats()[s] != null || this.scroll.query(s, f.ATTRIBUTE) ? this.isolate(t, e).format(s, i) : super.formatAt(t, e, s, i);
+  }
+  optimize(t) {
+    super.optimize(t);
+    const e = this.formats();
+    if (Object.keys(e).length === 0)
+      return this.unwrap();
+    const s = this.next;
+    s instanceof A && s.prev === this && Ut(e, s.formats()) && (s.moveChildren(this), s.remove());
+  }
+  replaceWith(t, e) {
+    const s = super.replaceWith(t, e);
+    return this.attributes.copy(s), s;
+  }
+  update(t, e) {
+    super.update(t, e), t.some(
+      (s) => s.target === this.domNode && s.type === "attributes"
+    ) && this.attributes.build();
+  }
+  wrap(t, e) {
+    const s = super.wrap(t, e);
+    return s instanceof A && this.attributes.move(s), s;
+  }
+};
+w.allowedChildren = [w, W], w.blotName = "inline", w.scope = f.INLINE_BLOT, w.tagName = "SPAN";
+let Ht = w;
+const gt = Ht, C = class X extends L {
+  static create(t) {
+    return super.create(t);
+  }
+  static formats(t, e) {
+    const s = e.query(X.blotName);
+    if (!(s != null && t.tagName === s.tagName)) {
+      if (typeof this.tagName == "string")
+        return !0;
+      if (Array.isArray(this.tagName))
+        return t.tagName.toLowerCase();
+    }
+  }
+  constructor(t, e) {
+    super(t, e), this.attributes = new ut(this.domNode);
+  }
+  format(t, e) {
+    const s = this.scroll.query(t, f.BLOCK);
+    s != null && (s instanceof T ? this.attributes.attribute(s, e) : t === this.statics.blotName && !e ? this.replaceWith(X.blotName) : e && (t !== this.statics.blotName || this.formats()[t] !== e) && this.replaceWith(t, e));
+  }
+  formats() {
+    const t = this.attributes.values(), e = this.statics.formats(this.domNode, this.scroll);
+    return e != null && (t[this.statics.blotName] = e), t;
+  }
+  formatAt(t, e, s, i) {
+    this.scroll.query(s, f.BLOCK) != null ? this.format(s, i) : super.formatAt(t, e, s, i);
+  }
+  insertAt(t, e, s) {
+    if (s == null || this.scroll.query(e, f.INLINE) != null)
+      super.insertAt(t, e, s);
+    else {
+      const i = this.split(t);
+      if (i != null) {
+        const r = this.scroll.create(e, s);
+        i.parent.insertBefore(r, i);
+      } else
+        throw new Error("Attempt to insertAt after block boundaries");
+    }
+  }
+  replaceWith(t, e) {
+    const s = super.replaceWith(t, e);
+    return this.attributes.copy(s), s;
+  }
+  update(t, e) {
+    super.update(t, e), t.some(
+      (s) => s.target === this.domNode && s.type === "attributes"
+    ) && this.attributes.build();
+  }
+};
+C.blotName = "block", C.scope = f.BLOCK_BLOT, C.tagName = "P", C.allowedChildren = [
+  gt,
+  C,
+  W
+];
+let Kt = C;
+const Y = Kt, J = class extends L {
+  checkMerge() {
+    return this.next !== null && this.next.statics.blotName === this.statics.blotName;
+  }
+  deleteAt(t, e) {
+    super.deleteAt(t, e), this.enforceAllowedChildren();
+  }
+  formatAt(t, e, s, i) {
+    super.formatAt(t, e, s, i), this.enforceAllowedChildren();
+  }
+  insertAt(t, e, s) {
+    super.insertAt(t, e, s), this.enforceAllowedChildren();
+  }
+  optimize(t) {
+    super.optimize(t), this.children.length > 0 && this.next != null && this.checkMerge() && (this.next.moveChildren(this), this.next.remove());
+  }
+};
+J.blotName = "container", J.scope = f.BLOCK_BLOT;
+let qt = J;
+const Wt = qt;
+class $t extends W {
+  static formats(t, e) {
+  }
+  format(t, e) {
+    super.formatAt(0, this.length(), t, e);
+  }
+  formatAt(t, e, s, i) {
+    t === 0 && e === this.length() ? this.format(s, i) : super.formatAt(t, e, s, i);
+  }
+  formats() {
+    return this.statics.formats(this.domNode, this.scroll);
+  }
+}
+const Ft = $t, Gt = {
+  attributes: !0,
+  characterData: !0,
+  characterDataOldValue: !0,
+  childList: !0,
+  subtree: !0
+}, Vt = 100, O = class extends L {
+  constructor(t, e) {
+    super(null, e), this.registry = t, this.scroll = this, this.build(), this.observer = new MutationObserver((s) => {
+      this.update(s);
+    }), this.observer.observe(this.domNode, Gt), this.attach();
+  }
+  create(t, e) {
+    return this.registry.create(this, t, e);
+  }
+  find(t, e = !1) {
+    const s = this.registry.find(t, e);
+    return s ? s.scroll === this ? s : e ? this.find(s.scroll.domNode.parentNode, !0) : null : null;
+  }
+  query(t, e = f.ANY) {
+    return this.registry.query(t, e);
+  }
+  register(...t) {
+    return this.registry.register(...t);
+  }
+  build() {
+    this.scroll != null && super.build();
+  }
+  detach() {
+    super.detach(), this.observer.disconnect();
+  }
+  deleteAt(t, e) {
+    this.update(), t === 0 && e === this.length() ? this.children.forEach((s) => {
+      s.remove();
+    }) : super.deleteAt(t, e);
+  }
+  formatAt(t, e, s, i) {
+    this.update(), super.formatAt(t, e, s, i);
+  }
+  insertAt(t, e, s) {
+    this.update(), super.insertAt(t, e, s);
+  }
+  optimize(t = [], e = {}) {
+    super.optimize(e);
+    const s = e.mutationsMap || /* @__PURE__ */ new WeakMap();
+    let i = Array.from(this.observer.takeRecords());
+    for (; i.length > 0; )
+      t.push(i.pop());
+    const r = (l, h = !0) => {
+      l == null || l === this || l.domNode.parentNode != null && (s.has(l.domNode) || s.set(l.domNode, []), h && r(l.parent));
+    }, o = (l) => {
+      s.has(l.domNode) && (l instanceof L && l.children.forEach(o), s.delete(l.domNode), l.optimize(e));
+    };
+    let a = t;
+    for (let l = 0; a.length > 0; l += 1) {
+      if (l >= Vt)
+        throw new Error("[Parchment] Maximum optimize iterations reached");
+      for (a.forEach((h) => {
+        const c = this.find(h.target, !0);
+        c != null && (c.domNode === h.target && (h.type === "childList" ? (r(this.find(h.previousSibling, !1)), Array.from(h.addedNodes).forEach((d) => {
+          const g = this.find(d, !1);
+          r(g, !1), g instanceof L && g.children.forEach((u) => {
+            r(u, !1);
+          });
+        })) : h.type === "attributes" && r(c.prev)), r(c));
+      }), this.children.forEach(o), a = Array.from(this.observer.takeRecords()), i = a.slice(); i.length > 0; )
+        t.push(i.pop());
+    }
+  }
+  update(t, e = {}) {
+    t = t || this.observer.takeRecords();
+    const s = /* @__PURE__ */ new WeakMap();
+    t.map((i) => {
+      const r = this.find(i.target, !0);
+      return r == null ? null : s.has(r.domNode) ? (s.get(r.domNode).push(i), null) : (s.set(r.domNode, [i]), r);
+    }).forEach((i) => {
+      i != null && i !== this && s.has(i.domNode) && i.update(s.get(i.domNode) || [], e);
+    }), e.mutationsMap = s, s.has(this.domNode) && super.update(s.get(this.domNode), e), this.optimize(t, e);
+  }
+};
+O.blotName = "scroll", O.defaultChild = Y, O.allowedChildren = [Y, Wt], O.scope = f.BLOCK_BLOT, O.tagName = "DIV";
+let jt = O;
+const Xt = jt, it = class vt extends W {
+  static create(t) {
+    return document.createTextNode(t);
+  }
+  static value(t) {
+    return t.data;
+  }
+  constructor(t, e) {
+    super(t, e), this.text = this.statics.value(this.domNode);
+  }
+  deleteAt(t, e) {
+    this.domNode.data = this.text = this.text.slice(0, t) + this.text.slice(t + e);
+  }
+  index(t, e) {
+    return this.domNode === t ? e : -1;
+  }
+  insertAt(t, e, s) {
+    s == null ? (this.text = this.text.slice(0, t) + e + this.text.slice(t), this.domNode.data = this.text) : super.insertAt(t, e, s);
+  }
+  length() {
+    return this.text.length;
+  }
+  optimize(t) {
+    super.optimize(t), this.text = this.statics.value(this.domNode), this.text.length === 0 ? this.remove() : this.next instanceof vt && this.next.prev === this && (this.insertAt(this.length(), this.next.value()), this.next.remove());
+  }
+  position(t, e = !1) {
+    return [this.domNode, t];
+  }
+  split(t, e = !1) {
+    if (!e) {
+      if (t === 0)
+        return this;
+      if (t === this.length())
+        return this.next;
+    }
+    const s = this.scroll.create(this.domNode.splitText(t));
+    return this.parent.insertBefore(s, this.next || void 0), this.text = this.statics.value(this.domNode), s;
+  }
+  update(t, e) {
+    t.some((s) => s.type === "characterData" && s.target === this.domNode) && (this.text = this.statics.value(this.domNode));
+  }
+  value() {
+    return this.text;
+  }
+};
+it.blotName = "text", it.scope = f.INLINE_BLOT;
+const Q = class Q extends Xt {
+  constructor(t, e) {
+    super(t, e), this.observer.disconnect();
+  }
+  // Suppress Parchment's automatic DOM reconciliation
+  update(t, e) {
+  }
+  optimize(t, e) {
+  }
+};
+Q.blotName = "v2-scroll";
+let Z = Q;
+const B = class B extends Y {
+};
+B.blotName = "v2-block", B.tagName = "DIV", B.className = "v2-line";
+let U = B;
+const D = class D extends gt {
+  static create(t) {
+    const e = super.create();
+    return t && Yt(e, t), e;
+  }
+};
+D.blotName = "v2-inline", D.tagName = "SPAN", D.className = "v2-mark";
+let H = D;
+function Yt(n, t) {
+  if (t.className)
+    for (const e of t.className.split(/\s+/).filter(Boolean))
+      n.classList.add(e);
+  t.bold && (n.style.fontWeight = "bold"), t.italic && (n.style.fontStyle = "italic"), t.color && (n.style.color = t.color), t.background && (n.style.backgroundColor = t.background), t.underline && (n.style.textDecoration = `${t.underline} underline`, t.underlineColor && (n.style.textDecorationColor = t.underlineColor));
+}
+const I = class I extends Ft {
+  static create() {
+    const t = super.create();
+    return t.contentEditable = "false", t.setAttribute("aria-hidden", "true"), t;
+  }
+};
+I.blotName = "v2-widget", I.tagName = "SPAN", I.className = "v2-widget";
+let K = I;
+function Jt() {
+  const n = new z();
+  return n.register(U, H, K), n;
+}
+function Zt(n, t, e, s, i) {
+  if (t.length === 0) {
+    n.appendChild(document.createElement("br"));
+    return;
+  }
+  const r = /* @__PURE__ */ new Set([0, t.length]);
+  for (const a of s)
+    r.add(Math.max(0, a.from - e)), r.add(Math.min(t.length, a.to - e));
+  for (const a of i) {
+    const l = a.offset - e;
+    l >= 0 && l <= t.length && r.add(l);
+  }
+  const o = [...r].sort((a, l) => a - l);
+  for (let a = 0; a < o.length - 1; a++) {
+    const l = o[a], h = o[a + 1];
+    for (const u of i)
+      u.offset - e === l && (u.side ?? "before") === "before" && n.appendChild(G(u));
+    const c = t.slice(l, h);
+    if (!c) continue;
+    let d, g = 1 / 0;
+    for (const u of s) {
+      const m = u.from - e, p = u.to - e;
+      if (m <= l && p >= h) {
+        const k = p - m;
+        k < g && (g = k, d = u);
+      }
+    }
+    if (d) {
+      const u = H.create(d);
+      if (d.attributes)
+        for (const [m, p] of Object.entries(d.attributes))
+          u.setAttribute(m, p);
+      u.appendChild(document.createTextNode(c)), n.appendChild(u);
+    } else
+      n.appendChild(document.createTextNode(c));
+    for (const u of i)
+      u.offset - e === h && u.side === "after" && n.appendChild(G(u));
+  }
+  for (const a of i)
+    a.offset - e === t.length && (a.side ?? "before") === "before" && n.appendChild(G(a));
+}
+function G(n) {
+  const t = K.create();
+  return t.appendChild(n.create()), t;
+}
+class Qt {
+  constructor(t) {
+    const e = Jt();
+    this.scroll = new Z(e, t);
+  }
+  /**
+   * Rebuild the document tree from `value` + `decorations`.
+   * Reuses existing `.v2-line` elements in place to preserve DOM identity
+   * across renders (fixes DevTools node tracking and mouse gesture continuity).
+   * Only the children of each line are replaced; the line element itself survives.
+   */
+  build(t, e) {
+    const s = this.scroll.domNode, i = t.split(`
+`), r = Array.from(s.querySelectorAll(".v2-line")), o = /* @__PURE__ */ new Map(), a = [], l = [];
+    for (const c of e)
+      if (c.type === "line") {
+        const d = o.get(c.line) ?? [];
+        d.push(c), o.set(c.line, d);
+      } else c.type === "mark" ? a.push(c) : l.push(c);
+    a.sort((c, d) => c.from - d.from || c.to - d.to), l.sort((c, d) => c.offset - d.offset);
+    let h = 0;
+    for (let c = 0; c < i.length; c++) {
+      const d = i[c], g = c + 1, u = h, m = u + d.length;
+      let p;
+      if (c < r.length) {
+        for (p = r[c]; p.attributes.length > 0; )
+          p.removeAttribute(p.attributes[0].name);
+        for (p.className = "v2-line"; p.firstChild; )
+          p.removeChild(p.firstChild);
+      } else
+        p = U.create(), s.appendChild(p);
+      const k = o.get(g) ?? [];
+      for (const v of k) {
+        if (v.className)
+          for (const E of v.className.split(/\s+/).filter(Boolean))
+            p.classList.add(E);
+        if (v.attributes)
+          for (const [E, x] of Object.entries(v.attributes))
+            p.setAttribute(E, x);
+      }
+      const Ct = a.filter((v) => v.from < m && v.to > u), Ot = l.filter(
+        (v) => v.offset >= u && v.offset <= m
+      );
+      Zt(p, d, u, Ct, Ot);
+      const $ = k.filter((v) => v.message);
+      if ($.length > 0) {
+        const v = $.map((x) => x.message).join(" · ");
+        p.dataset.message = v, p.title = v;
+        const E = [
+          ...new Set(
+            $.flatMap(
+              (x) => x.messageClassName ? x.messageClassName.split(/\s+/).filter(Boolean) : []
+            )
+          )
+        ];
+        E.length > 0 && (p.dataset.messageClass = E.join(" "));
+      }
+      h += d.length + 1;
+    }
+    for (; s.children.length > i.length; )
+      s.removeChild(s.lastChild);
+  }
+  destroy() {
+    const t = this.scroll.domNode;
+    for (; t.firstChild; )
+      t.removeChild(t.firstChild);
+  }
+}
+function te(n) {
+  const t = Array.from(n.querySelectorAll(".v2-line"));
+  return t.length > 0 ? t.map((e) => ee(e)).join(`
+`) : bt(n);
+}
+function ee(n) {
+  let t = "";
+  for (const e of n.childNodes) t += _t(e);
+  return t;
+}
+function _t(n) {
+  if (n.nodeType === Node.TEXT_NODE) return n.data;
+  if (!(n instanceof Element) || n.classList.contains("v2-widget") || n.classList.contains("v2-line-message") || n.tagName === "BR") return "";
+  let t = "";
+  for (const e of n.childNodes) t += _t(e);
+  return t;
+}
+function bt(n) {
+  let t = "", e = !0;
+  for (const s of n.childNodes)
+    if (s.nodeType === Node.TEXT_NODE)
+      t += s.data;
+    else if (s instanceof HTMLElement) {
+      if (s.tagName === "BR") {
+        t += `
+`, e = !1;
+        continue;
+      }
+      if (s.classList.contains("v2-widget")) continue;
+      (s.tagName === "DIV" || s.tagName === "P") && !e && (t += `
+`), e = !1, t += bt(s);
+    }
+  return t;
+}
+function R(n) {
+  if (n.nodeType === Node.TEXT_NODE) return n.length;
+  if (!(n instanceof Element) || n.classList.contains("v2-widget") || n.tagName === "BR") return 0;
+  let t = 0;
+  for (const e of n.childNodes) t += R(e);
+  return t;
+}
+function rt(n, t, e) {
+  const s = Array.from(n.querySelectorAll(".v2-line"));
+  let i = 0;
+  for (let r = 0; r < s.length; r++) {
+    r > 0 && i++;
+    const o = s[r], a = yt(
+      o,
+      t,
+      e,
+      i
+    );
+    if (a.found) return a.offset;
+    i += R(o);
+  }
+  return i;
+}
+function yt(n, t, e, s) {
+  if (n === t) {
+    if (n.nodeType === Node.TEXT_NODE)
+      return { found: !0, offset: s + e };
+    let i = s;
+    const r = Array.from(n.childNodes);
+    for (let o = 0; o < e && o < r.length; o++)
+      i += R(r[o]);
+    return { found: !0, offset: i };
+  }
+  if (n.nodeType === Node.TEXT_NODE)
+    return { found: !1, offset: s + n.length };
+  if (n instanceof Element) {
+    if (n.classList.contains("v2-widget"))
+      return { found: !1, offset: s };
+    if (n.tagName === "BR")
+      return { found: !1, offset: s };
+    let i = s;
+    for (const r of n.childNodes) {
+      const o = yt(r, t, e, i);
+      if (o.found) return o;
+      i = o.offset;
+    }
+    return { found: !1, offset: i };
+  }
+  return { found: !1, offset: s };
+}
+function nt(n, t) {
+  const e = Array.from(n.querySelectorAll(".v2-line"));
+  let s = t;
+  for (let r = 0; r < e.length; r++) {
+    if (r > 0) {
+      if (s === 0)
+        return { node: e[r], offset: 0 };
+      s--;
+    }
+    const o = e[r], a = R(o);
+    if (s <= a) {
+      const l = Nt(o, s);
+      return l || { node: o, offset: o.childNodes.length };
+    }
+    s -= a;
+  }
+  const i = e[e.length - 1];
+  return i ? { node: i, offset: i.childNodes.length } : { node: n, offset: n.childNodes.length };
+}
+function Nt(n, t) {
+  if (n.nodeType === Node.TEXT_NODE) {
+    const e = n;
+    return t <= e.length ? { node: e, offset: t } : null;
+  }
+  if (n instanceof Element) {
+    if (n.classList.contains("v2-widget") || n.tagName === "BR") return null;
+    let e = 0;
+    for (const s of n.childNodes) {
+      const i = R(s);
+      if (t <= i) {
+        const r = Nt(s, t);
+        return r || { node: n, offset: e + 1 };
+      }
+      t -= i, e++;
+    }
+  }
+  return null;
+}
+function P(n) {
+  const e = n.getRootNode().getSelection?.() ?? window.getSelection();
+  if (!e || e.rangeCount === 0) return null;
+  const s = e.getRangeAt(0);
+  if (!n.contains(s.commonAncestorContainer)) return null;
+  const i = rt(
+    n,
+    s.startContainer,
+    s.startOffset
+  ), r = rt(
+    n,
+    s.endContainer,
+    s.endOffset
+  );
+  return { anchorOffset: i, focusOffset: r };
+}
+function se(n, t) {
+  const e = nt(n, t.anchorOffset), s = nt(n, t.focusOffset);
+  if (!(!e || !s))
+    try {
+      const i = window.getSelection();
+      if (!i) return;
+      const r = document.createRange();
+      r.setStart(e.node, e.offset), r.setEnd(s.node, s.offset), i.removeAllRanges(), i.addRange(r);
+    } catch {
+    }
+}
+function M() {
+  return crypto.randomUUID();
+}
+function Et(n, t) {
+  let e = 0;
+  for (; e < n.length && e < t.length && n[e] === t[e]; )
+    e++;
+  let s = n.length, i = t.length;
+  for (; s > e && i > e && n[s - 1] === t[i - 1]; )
+    s--, i--;
+  return { start: e, removed: s - e, inserted: i - e };
+}
+function ot(n, t, e) {
+  const s = e.start + e.removed, i = e.inserted - e.removed;
+  if (t <= e.start) return { from: n, to: t };
+  if (n >= s) return { from: n + i, to: t + i };
+  const r = Math.min(n, e.start), o = Math.max(
+    t > s ? t + i : e.start + e.inserted,
+    e.start + e.inserted
+  );
+  return r >= o ? null : { from: r, to: o };
+}
+function ie(n, t) {
+  let e = 0;
+  for (let s = 0; s < t && s < n.length; s++)
+    n[s] === `
+` && e++;
+  return e;
+}
+function re(n, t, e) {
+  const s = Et(t, e), i = s.start + s.removed, r = t.slice(s.start, i), o = e.slice(s.start, s.start + s.inserted), a = (r.match(/\n/g) ?? []).length, h = (o.match(/\n/g) ?? []).length - a, c = ie(t, s.start) + 1, d = c + a, g = [];
+  for (const u of n)
+    if (u.type === "mark") {
+      const m = ot(u.from, u.to, s);
+      m && g.push({ ...u, from: m.from, to: m.to });
+    } else if (u.type === "line")
+      u.line < c ? g.push(u) : u.line <= d || g.push({ ...u, line: u.line + h });
+    else {
+      const m = ot(u.offset, u.offset + 1, s);
+      m && g.push({ ...u, offset: m.from });
+    }
+  return g;
+}
+function ne(n, t) {
+  if (n.length === 0) return !1;
+  const e = Math.max(t.removed, t.inserted);
+  return e > 50 && e > n.length * 0.5;
+}
+function V(n, t, e) {
+  const s = Et(t, e);
+  return ne(t, s) ? [] : re(n, t, e);
+}
+function at(n, t) {
+  const e = crypto.randomUUID();
+  return n.set(e, { ...t, id: e }), e;
+}
+function oe(n, t) {
+  n.clear();
+  for (const e of t) {
+    const s = crypto.randomUUID();
+    n.set(s, { ...e, id: s });
+  }
+}
+function ae(n, t) {
+  const e = [], s = [];
+  for (const i of t) {
+    let r = i.pattern.flags.includes("g") ? i.pattern.flags : i.pattern.flags + "g";
+    i.captureGroups && !r.includes("d") && (r += "d");
+    const o = new RegExp(i.pattern.source, r);
+    let a;
+    for (; (a = o.exec(n)) !== null; ) {
+      if (a[0].length === 0) {
+        o.lastIndex++;
+        continue;
+      }
+      const l = a.index;
+      if (i.captureGroups) {
+        const h = a.indices?.groups;
+        if (h)
+          for (const [c, d] of Object.entries(i.captureGroups)) {
+            const g = h[c];
+            if (g === void 0) continue;
+            const [u, m] = g;
+            e.push({ type: "mark", from: u, to: m, ...d });
+          }
+      } else {
+        const h = l + a[0].length;
+        e.push({
+          type: "mark",
+          from: l,
+          to: h,
+          className: i.className,
+          bold: i.bold,
+          italic: i.italic,
+          color: i.color,
+          background: i.background,
+          underline: i.underline,
+          underlineColor: i.underlineColor,
+          attributes: i.attributes
+        });
+      }
+      if (i.createLineDecoration) {
+        const h = i.createLineDecoration(a);
+        if (h) {
+          const c = n.slice(0, l).split(`
+`).length;
+          s.push({ type: "line", line: c, ...h });
+        }
+      }
+    }
+  }
+  return { markDecorations: e, lineDecorations: s };
+}
+var le = Object.defineProperty, ce = Object.getOwnPropertyDescriptor, y = (n, t, e, s) => {
+  for (var i = s > 1 ? void 0 : s ? ce(t, e) : t, r = n.length - 1, o; r >= 0; r--)
+    (o = n[r]) && (i = (s ? o(t, e, i) : o(i)) || i);
+  return s && i && le(t, e, i), i;
+};
+const he = 100;
+function lt(n) {
+  const t = document.createElement("div");
+  t.innerHTML = n;
+  const e = [];
+  let s = 0;
+  function i(r) {
+    if (r.nodeType === Node.TEXT_NODE) {
+      s += r.length;
+      return;
+    }
+    if (!(r instanceof HTMLElement)) return;
+    const o = r.tagName === "SPAN" && r.className, a = s;
+    for (const l of r.childNodes)
+      i(l);
+    o && s > a && e.push({
+      type: "mark",
+      from: a,
+      to: s,
+      className: r.className
+    });
+  }
+  for (const r of t.childNodes) i(r);
+  return e;
+}
+const q = class q extends tt {
+  constructor() {
+    super(...arguments), this.lineNumbers = !1, this.listNumbers = !1, this.gutter = !1, this.wordWrap = !1, this.autoGrow = !1, this.readOnly = !1, this.label = null, this._value = "", this._initialValueResolved = !1, this._valueSetByHost = !1, this._document = null, this._textareaRef = null, this._pluginDecorations = /* @__PURE__ */ new Map(), this._patternDecorations = [], this._externalDecorations = [], this._patterns = /* @__PURE__ */ new Map(), this._plugin = null, this._pluginProperty = null, this._pluginApi = null, this._pluginSeq = 0, this._pluginSheets = /* @__PURE__ */ new Set(), this._savedSelection = null, this._rafHandle = null, this._composing = !1, this._isRendering = !1, this._activeLine = null, this._cursorCallbacks = /* @__PURE__ */ new Set(), this._docSelectionChangeHandler = () => {
+      document.activeElement === this && this._onSelectionChange();
+    }, this._undoStack = [], this._undoIndex = -1, this._resizeObserver = null, this._gutterLabels = [], this._onInputEvent = () => {
+      this._composing || this._onInput();
+    }, this._onSelectionChange = () => {
+      const t = this._getEditorEl();
+      if (!t) return;
+      const e = P(t);
+      if (e) {
+        this._savedSelection = e, this.dispatchEvent(
+          new CustomEvent("rc-textarea-select", {
+            bubbles: !0,
+            composed: !0,
+            detail: {
+              selectionStart: e.anchorOffset,
+              selectionEnd: e.focusOffset
+            }
+          })
+        ), this._updateActiveLine();
+        const s = Math.min(e.anchorOffset, e.focusOffset), i = Math.max(e.anchorOffset, e.focusOffset);
+        for (const r of this._cursorCallbacks) r(s, i);
+      }
+    }, this._onKeyDown = (t) => {
+      if (t.key === "Tab" && !t.ctrlKey && !t.metaKey && !t.altKey) {
+        t.preventDefault(), this._insertText("	");
+        return;
+      }
+      const e = (t.ctrlKey || t.metaKey) && t.key === "z" && !t.shiftKey, s = (t.ctrlKey || t.metaKey) && t.key === "y" || (t.ctrlKey || t.metaKey) && t.shiftKey && t.key === "z";
+      if (e) {
+        t.preventDefault(), this._undo();
+        return;
+      }
+      s && (t.preventDefault(), this._redo());
+    }, this._onPaste = (t) => {
+      t.preventDefault();
+      const e = t.clipboardData?.getData("text/plain") ?? "";
+      if (!e) return;
+      const s = e.replace(/\r\n/g, `
+`).replace(/\r/g, `
+`);
+      this._insertText(s);
+    };
+  }
+  get plugin() {
+    return this._pluginProperty;
+  }
+  /** Declarative plugin hook for framework integrations. */
+  set plugin(t) {
+    const e = this._pluginProperty;
+    t !== e && (this._pluginProperty = t, t ? this.usePlugin(t) : this.removePlugin(), this.requestUpdate("plugin", e));
+  }
+  get decorations() {
+    return this._externalDecorations;
+  }
+  set decorations(t) {
+    this._externalDecorations = t ?? [], this.requestUpdate();
+  }
+  get value() {
+    return this._value;
+  }
+  set value(t) {
+    const e = this._value;
+    t !== this._value && (this._valueSetByHost = !0, this._initialValueResolved = !0, this._value = t, this._syncTextareaValue(), this._scheduleRender(), this.requestUpdate("value", e));
+  }
+  get defaultValue() {
+    return this._defaultValue;
+  }
+  /** Initial uncontrolled editor value. */
+  set defaultValue(t) {
+    const e = this._defaultValue;
+    this._defaultValue = t, !this._valueSetByHost && !this._initialValueResolved && t !== void 0 && (this._value = t, this._initialValueResolved = !0, this._syncTextareaValue(), this._scheduleRender()), this.requestUpdate("defaultValue", e);
+  }
+  // ── Lifecycle ─────────────────────────────────────────────────────────
+  connectedCallback() {
+    super.connectedCallback(), document.addEventListener(
+      "selectionchange",
+      this._docSelectionChangeHandler
+    );
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback(), document.removeEventListener(
+      "selectionchange",
+      this._docSelectionChangeHandler
+    ), this._plugin?.destroy?.(), this._plugin = null, this._pluginApi = null, this._clearPluginSheets(), this._cursorCallbacks.clear(), this._resizeObserver?.disconnect(), this._rafHandle !== null && (cancelAnimationFrame(this._rafHandle), this._rafHandle = null);
+  }
+  firstUpdated() {
+    const t = this._getEditorEl();
+    t && (this._document = new Qt(t), this._bindEditorEvents(t)), this._resizeObserver = new ResizeObserver(() => {
+      this._syncGutter(), this._syncGutterHeights();
+    }), this._resizeObserver.observe(this), this._scheduleRender();
+  }
+  updated(t) {
+    if (t.has("readOnly")) {
+      const e = this._getEditorEl();
+      e && (e.contentEditable = this.readOnly ? "false" : "true"), this._syncGutterHeights();
+    }
+    if (t.has("label")) {
+      const e = this._getEditorEl();
+      e && this.label && e.setAttribute("aria-label", this.label);
+    }
+  }
+  // ── Template ──────────────────────────────────────────────────────────
+  render() {
+    return Lt`
+      <div id="root" part="root">
+        <div id="gutter" part="gutter" aria-hidden="true">
+          <div id="gutter-cells" part="gutter-cells"></div>
+        </div>
+        <div id="editor-area" part="editor-area">
+          <div
+            id="editor"
+            part="editor"
+            contenteditable=${this.readOnly ? "false" : "true"}
+            role="textbox"
+            aria-multiline="true"
+            spellcheck="false"
+            autocorrect="off"
+            autocapitalize="off"
+            aria-label=${this.label ?? ""}
+          ></div>
+          <slot @slotchange=${this._onSlotChange}></slot>
+        </div>
+      </div>
+    `;
+  }
+  // ── Slot change — lightDOM textarea wiring ────────────────────────────
+  _onSlotChange() {
+    const t = this.shadowRoot?.querySelector(
+      "slot"
+    );
+    if (!t) return;
+    const e = t.assignedElements({ flatten: !0 }).find(
+      (i) => i instanceof HTMLTextAreaElement
+    );
+    if (!e) return;
+    this._textareaRef = new WeakRef(e), Object.assign(e.style, {
+      position: "absolute",
+      width: "1px",
+      height: "1px",
+      padding: "0",
+      margin: "-1px",
+      overflow: "hidden",
+      clip: "rect(0,0,0,0)",
+      border: "0",
+      opacity: "0",
+      pointerEvents: "none",
+      tabIndex: "-1"
+    }), e.setAttribute("aria-hidden", "true"), e.tabIndex = -1;
+    const s = this._getEditorEl();
+    if (s) {
+      !this.label && e.getAttribute("aria-label") && s.setAttribute(
+        "aria-label",
+        e.getAttribute("aria-label")
+      );
+      const i = e.getAttribute("placeholder");
+      i && s.setAttribute("aria-placeholder", i);
+    }
+    this._initialValueResolved ? e.value = this._value : (this._value = e.value, this._initialValueResolved = !0), e.addEventListener("invalid", () => {
+      const i = this._getEditorEl();
+      i && i.setAttribute("aria-invalid", "true");
+    }), this._syncTypography(e), this._scheduleRender();
+  }
+  // ── Editor event binding ──────────────────────────────────────────────
+  _bindEditorEvents(t) {
+    t.addEventListener("compositionstart", () => {
+      this._composing = !0;
+    }), t.addEventListener("compositionend", () => {
+      this._composing = !1, this._onInput();
+    }), t.addEventListener("input", this._onInputEvent), t.addEventListener("keydown", this._onKeyDown), t.addEventListener("paste", this._onPaste), t.addEventListener("focus", () => {
+      this.dispatchEvent(
+        new CustomEvent("rc-textarea-focus", {
+          bubbles: !0,
+          composed: !0
+        })
+      );
+    }), t.addEventListener("blur", () => {
+      this.dispatchEvent(
+        new CustomEvent("rc-textarea-blur", {
+          bubbles: !0,
+          composed: !0
+        })
+      ), this._activeLine?.classList.remove("v2-line--active"), this._activeLine = null;
+    });
+  }
+  _onInput() {
+    const t = this._getEditorEl();
+    if (!t) return;
+    const e = te(t);
+    if (e === this._value) return;
+    const s = this._value, i = this._savedSelection, r = V(
+      [...this._pluginDecorations.values()],
+      s,
+      e
+    );
+    this._pluginDecorations.clear();
+    for (const o of r) this._pluginDecorations.set(o.id, o);
+    this._value = e, this._syncTextareaValue(!0), this._savedSelection = P(t), this._undoStack.length === 0 && (this._undoStack.push({
+      value: s,
+      anchorOffset: i?.anchorOffset ?? 0,
+      focusOffset: i?.focusOffset ?? 0
+    }), this._undoIndex = 0), this._pushUndo(this._savedSelection), this._dispatchChange(e), this._scheduleRender();
+  }
+  _updateActiveLine() {
+    const t = this._getEditorEl();
+    if (!t) return;
+    const e = this.shadowRoot.getSelection?.() ?? window.getSelection();
+    let s = null;
+    if (e?.focusNode && t.contains(e.focusNode)) {
+      let i = e.focusNode;
+      for (; i && i !== t; ) {
+        if (i instanceof HTMLElement && i.classList.contains("v2-line")) {
+          s = i;
+          break;
+        }
+        i = i.parentNode;
+      }
+    }
+    s !== this._activeLine && (this._activeLine?.classList.remove("v2-line--active"), this._activeLine = s, this._activeLine?.classList.add("v2-line--active"), this._updateActiveGutterCell());
+  }
+  _updateActiveGutterCell() {
+    const t = this.shadowRoot?.getElementById("gutter-cells");
+    if (!t) return;
+    const e = t.querySelector(".gutter-cell--active");
+    if (e && e.classList.remove("gutter-cell--active"), this._activeLine) {
+      const s = this._getEditorEl();
+      if (!s) return;
+      const i = s.querySelectorAll(".v2-line");
+      for (let r = 0; r < i.length; r++)
+        if (i[r] === this._activeLine) {
+          const o = t.children[r];
+          o && o.classList.add("gutter-cell--active");
+          break;
+        }
+    }
+  }
+  _insertText(t) {
+    const e = this._getEditorEl();
+    if (e) {
+      if (t.includes(`
+`)) {
+        const s = P(e) ?? this._savedSelection, i = Math.min(s?.anchorOffset ?? 0, s?.focusOffset ?? 0), r = Math.max(s?.anchorOffset ?? 0, s?.focusOffset ?? 0), o = this._value, a = o.slice(0, i) + t + o.slice(r), l = i + t.length, h = V(
+          [...this._pluginDecorations.values()],
+          o,
+          a
+        );
+        this._pluginDecorations.clear();
+        for (const c of h) this._pluginDecorations.set(c.id, c);
+        this._value = a, this._syncTextareaValue(!0), this._savedSelection = {
+          anchorOffset: l,
+          focusOffset: l
+        }, this._undoStack.length === 0 && (this._undoStack.push({
+          value: o,
+          anchorOffset: s?.anchorOffset ?? 0,
+          focusOffset: s?.focusOffset ?? 0
+        }), this._undoIndex = 0), this._pushUndo(this._savedSelection), this._dispatchChange(a), this._scheduleRender();
+        return;
+      }
+      document.execCommand("insertText", !1, t), this._onInput();
+    }
+  }
+  /**
+   * Wrap the current selection with `prefix` and `suffix`.
+   * No-op when the selection is collapsed (no text selected).
+   *
+   * Uses the model path directly (not `execCommand`) because callers such as
+   * toolbar buttons move focus away from the editor before this fires, which
+   * clears the DOM selection. `_savedSelection` retains the last model-level
+   * anchor/focus offsets.
+   */
+  wrapSelection(t, e) {
+    const s = this._getEditorEl();
+    if (!s) return;
+    const i = P(s) ?? this._savedSelection;
+    if (!i || i.anchorOffset === i.focusOffset) return;
+    const r = Math.min(i.anchorOffset, i.focusOffset), o = Math.max(i.anchorOffset, i.focusOffset), a = this._value.slice(r, o), l = this._value, h = l.slice(0, r) + t + a + e + l.slice(o), c = V([...this._pluginDecorations.values()], l, h);
+    this._pluginDecorations.clear();
+    for (const d of c) this._pluginDecorations.set(d.id, d);
+    this._value = h, this._syncTextareaValue(!0), this._savedSelection = {
+      anchorOffset: r + t.length,
+      focusOffset: r + t.length + a.length
+    }, this._pushUndo(this._savedSelection), this._dispatchChange(h), this._scheduleRender();
+  }
+  /**
+   * Replace the current selection with `text`.
+   * When the selection is collapsed this is equivalent to `insertText`.
+   */
+  replaceSelection(t) {
+    this._insertText(t);
+  }
+  // ── Undo/Redo ─────────────────────────────────────────────────────────
+  /** Reset the undo/redo history. Call when the editor receives entirely new content. */
+  clearHistory() {
+    this._undoStack = [], this._undoIndex = -1;
+  }
+  _pushUndo(t) {
+    const e = {
+      value: this._value,
+      anchorOffset: t?.anchorOffset ?? 0,
+      focusOffset: t?.focusOffset ?? 0
+    };
+    this._undoStack = this._undoStack.slice(0, this._undoIndex + 1), this._undoStack.push(e), this._undoStack.length > he && this._undoStack.shift(), this._undoIndex = this._undoStack.length - 1;
+  }
+  _undo() {
+    this._undoIndex <= 0 || (this._undoIndex--, this._applyUndoEntry(this._undoStack[this._undoIndex]));
+  }
+  _redo() {
+    this._undoIndex >= this._undoStack.length - 1 || (this._undoIndex++, this._applyUndoEntry(this._undoStack[this._undoIndex]));
+  }
+  _applyUndoEntry(t) {
+    this._value = t.value, this._savedSelection = {
+      anchorOffset: t.anchorOffset,
+      focusOffset: t.focusOffset
+    }, this._syncTextareaValue(!0), this._dispatchChange(this._value), this._scheduleRender();
+  }
+  // ── Plugin API ────────────────────────────────────────────────────────
+  usePlugin(t) {
+    this._plugin?.destroy?.(), this._clearPluginSheets(), this._pluginDecorations.clear(), this._cursorCallbacks.clear(), this._pluginSeq++, this._plugin = t, this._pluginApi = this._buildPluginApi(), t.mount?.(this._pluginApi), this._scheduleRender();
+  }
+  removePlugin() {
+    this._plugin?.destroy?.(), this._clearPluginSheets(), this._plugin = null, this._pluginApi = null, this._pluginDecorations.clear(), this._cursorCallbacks.clear(), this._pluginSeq++, this._scheduleRender();
+  }
+  /**
+   * Build the `RCTextareaPluginAPI` object passed to the active plugin's
+   * `mount()` call. Each getter delegates to the component's live state so the
+   * API stays accurate across render frames without needing to be rebuilt.
+   */
+  _buildPluginApi() {
+    const t = this;
+    return {
+      get host() {
+        return t;
+      },
+      get value() {
+        return t._value;
+      },
+      get selectionStart() {
+        const e = t._savedSelection;
+        return e ? Math.min(e.anchorOffset, e.focusOffset) : 0;
+      },
+      get selectionEnd() {
+        const e = t._savedSelection;
+        return e ? Math.max(e.anchorOffset, e.focusOffset) : 0;
+      },
+      getCursorRect() {
+        const e = window.getSelection();
+        if (!e?.focusNode) return null;
+        const s = t._getEditorEl();
+        if (!s || !s.contains(e.focusNode)) return null;
+        try {
+          const i = document.createRange();
+          i.setStart(e.focusNode, e.focusOffset), i.collapse(!0);
+          const r = i.getBoundingClientRect();
+          return r.height > 0 ? r : null;
+        } catch {
+          return null;
+        }
+      },
+      getWordAtCursor() {
+        const e = t._savedSelection?.focusOffset ?? 0, s = t._value;
+        if (!s) return null;
+        let i = e;
+        for (; i > 0 && /\w/.test(s[i - 1]); ) i--;
+        let r = e;
+        for (; r < s.length && /\w/.test(s[r]); ) r++;
+        return i === r ? null : { word: s.slice(i, r), from: i, to: r };
+      },
+      onCursorMove(e) {
+        return t._cursorCallbacks.add(e), () => {
+          t._cursorCallbacks.delete(e);
+        };
+      },
+      addDecoration(e) {
+        return at(t._pluginDecorations, e);
+      },
+      removeDecoration(e) {
+        t._pluginDecorations.delete(e);
+      },
+      clearDecorations() {
+        t._pluginDecorations.clear();
+      },
+      setDecorations(e) {
+        oe(t._pluginDecorations, e);
+      },
+      getDecorations() {
+        return [...t._pluginDecorations.values()];
+      },
+      scheduleUpdate() {
+        t._isRendering || t._scheduleRender();
+      },
+      adoptStyleSheet(e) {
+        let s;
+        typeof e == "string" ? (s = new CSSStyleSheet(), s.replaceSync(e)) : s = e;
+        const i = t.shadowRoot;
+        return i && !i.adoptedStyleSheets.includes(s) && (i.adoptedStyleSheets = [...i.adoptedStyleSheets, s]), t._pluginSheets.add(s), s;
+      },
+      removeStyleSheet(e) {
+        const s = t.shadowRoot;
+        s && (s.adoptedStyleSheets = s.adoptedStyleSheets.filter(
+          (i) => i !== e
+        )), t._pluginSheets.delete(e);
+      },
+      decorationsFromHtml(e) {
+        return lt(e);
+      },
+      decorationsFromTokens(e, s) {
+        const i = [];
+        for (const r of e) {
+          const o = s[r.type];
+          o && i.push({ type: "mark", from: r.from, to: r.to, ...o });
+        }
+        return i;
+      },
+      insertText(e) {
+        t._insertText(e);
+      },
+      wrapSelection(e, s) {
+        t.wrapSelection(e, s);
+      },
+      replaceSelection(e) {
+        t.replaceSelection(e);
+      }
+    };
+  }
+  _clearPluginSheets() {
+    if (this._pluginSheets.size === 0) return;
+    const t = this.shadowRoot;
+    t && (t.adoptedStyleSheets = t.adoptedStyleSheets.filter(
+      (e) => !this._pluginSheets.has(e)
+    )), this._pluginSheets.clear();
+  }
+  // ── Pattern API ───────────────────────────────────────────────────────
+  addPattern(t) {
+    const e = M();
+    return this._patterns.set(e, { ...t, id: e }), this._scheduleRender(), e;
+  }
+  removePattern(t) {
+    this._patterns.delete(t), this._scheduleRender();
+  }
+  clearPatterns() {
+    this._patterns.clear(), this._scheduleRender();
+  }
+  // ── Render pipeline ───────────────────────────────────────────────────
+  _scheduleRender() {
+    this._rafHandle === null && (this._rafHandle = requestAnimationFrame(() => {
+      this._rafHandle = null, this._performRender();
+    }));
+  }
+  async _performRender() {
+    if (!this._document) return;
+    this._isRendering = !0;
+    const t = ++this._pluginSeq;
+    try {
+      let e = this._value;
+      if (this._plugin && this._pluginApi && this._plugin.transform && this.readOnly) {
+        const a = this._plugin.transform(this._value, this._pluginApi);
+        typeof a == "string" && (e = a);
+      }
+      const { markDecorations: s, lineDecorations: i } = ae(e, [...this._patterns.values()]);
+      if (this._patternDecorations = [
+        ...s.map((a) => ({ ...a, id: M() })),
+        ...i.map((a) => ({ ...a, id: M() }))
+      ], this._plugin && this._pluginApi) {
+        const a = this._pluginApi;
+        if (this._plugin.update && (await this._plugin.update(e, a), t !== this._pluginSeq))
+          return;
+        if (this._plugin.highlight) {
+          const l = await this._plugin.highlight(e, a);
+          if (t !== this._pluginSeq) return;
+          if (typeof l == "string") {
+            const h = lt(l);
+            for (const c of h)
+              at(this._pluginDecorations, c);
+          }
+        }
+      }
+      const r = [
+        ...this._pluginDecorations.values(),
+        ...this._patternDecorations,
+        ...this._externalDecorations.map((a) => ({ ...a, id: M() }))
+      ], o = this._getEditorEl();
+      if (!o) return;
+      this._document.build(e, r), this._savedSelection && se(o, this._savedSelection), this._activeLine = null, this._updateActiveLine(), this._syncGutter(this._computeGutterLabels(r, e)), this._syncGutterHeights();
+    } finally {
+      this._isRendering = !1;
+    }
+  }
+  // ── Gutter ────────────────────────────────────────────────────────────
+  /**
+   * Compute the label string for each gutter cell based on the current gutter
+   * mode (`lineNumbers`, `listNumbers`, `gutter`) and any
+   * `LineDecoration.gutterContent` overrides in `allDecorations`.
+   *
+   * Returns one entry per line (same length as `value.split('\n')`):
+   * - `string` — the label to display
+   * - `null`   — render an empty cell
+   */
+  _computeGutterLabels(t, e = this._value) {
+    const s = e.split(`
+`), i = /* @__PURE__ */ new Map();
+    for (const o of t)
+      o.type === "line" && o.gutterContent !== void 0 && i.set(o.line, o.gutterContent);
+    let r = 0;
+    return s.map((o, a) => {
+      const l = a + 1;
+      return i.has(l) ? i.get(l) : this.lineNumbers ? String(l) : this.listNumbers ? o.trim() === "" ? null : (r++, `${r}.`) : null;
+    });
+  }
+  /**
+   * Synchronize the pixel height of each gutter cell to match the
+   * corresponding `.v2-line` element in the editor.
+   *
+   * In non-word-wrap mode the gutter uses a uniform `line-height` mirrored
+   * from the editor's first line. In word-wrap mode each cell gets an explicit
+   * `height` so wrapped lines stay vertically aligned with their gutter label.
+   * Also copies the editor's computed `paddingTop`/`paddingBottom` to the
+   * gutter to compensate for browser UA overrides on contenteditable.
+   */
+  _syncGutterHeights() {
+    const t = this.shadowRoot?.getElementById("gutter-cells"), e = this._getEditorEl();
+    if (!t || !e) return;
+    const s = getComputedStyle(e), i = s.paddingTop, r = s.paddingBottom;
+    t.style.paddingTop !== i && (t.style.paddingTop = i), t.style.paddingBottom !== r && (t.style.paddingBottom = r);
+    const o = e.querySelectorAll(".v2-line"), a = t.children;
+    if (!this.wordWrap) {
+      if (o.length > 0) {
+        const l = `${o[0].getBoundingClientRect().height}px`;
+        t.style.lineHeight !== l && (t.style.lineHeight = l);
+      }
+      for (let l = 0; l < a.length; l++)
+        a[l].style.height = "";
+      return;
+    }
+    t.style.lineHeight && (t.style.lineHeight = "");
+    for (let l = 0; l < o.length && l < a.length; l++) {
+      const c = `${o[l].getBoundingClientRect().height}px`, d = a[l];
+      d.style.height !== c && (d.style.height = c);
+    }
+  }
+  /**
+   * Add, remove, or update `.gutter-cell` spans so their count and text
+   * content match `labels`. When `labels` is provided the cached
+   * `_gutterLabels` is updated first; otherwise the cached labels are reused
+   * (called by the `ResizeObserver` without a new render pass).
+   */
+  _syncGutter(t) {
+    if (!this.lineNumbers && !this.listNumbers && !this.gutter) return;
+    const e = this.shadowRoot?.getElementById("gutter-cells");
+    if (!e) return;
+    t !== void 0 && (this._gutterLabels = t);
+    const s = this._gutterLabels;
+    for (; e.children.length < s.length; ) {
+      const i = document.createElement("span");
+      i.className = "gutter-cell", e.appendChild(i);
+    }
+    for (; e.children.length > s.length; )
+      e.removeChild(e.lastChild);
+    for (let i = 0; i < s.length; i++) {
+      const r = s[i] ?? "", o = e.children[i];
+      o.textContent !== r && (o.textContent = r);
+    }
+  }
+  // ── Typography sync ───────────────────────────────────────────────────
+  _syncTypography(t) {
+    const e = this._getEditorEl();
+    if (!e) return;
+    const s = window.getComputedStyle(t), i = [
+      "fontFamily",
+      "fontSize",
+      "fontWeight",
+      "fontStyle",
+      "fontVariant",
+      "lineHeight",
+      "letterSpacing",
+      "wordSpacing",
+      "textIndent",
+      "tabSize"
+    ];
+    if (!window.getComputedStyle(this).getPropertyValue("--rc-textarea-font-family"))
+      for (const o of i) {
+        const a = s[o];
+        a && typeof a == "string" && (e.style[o] = a);
+      }
+  }
+  // ── Form integration ──────────────────────────────────────────────────
+  _syncTextareaValue(t = !1) {
+    const e = this._textareaRef?.deref();
+    e && (e.value = this._value, t && e.dispatchEvent(new InputEvent("input", { bubbles: !0 })));
+  }
+  _dispatchChange(t) {
+    this.dispatchEvent(
+      new CustomEvent("rc-textarea-change", {
+        bubbles: !0,
+        composed: !0,
+        detail: { value: t }
+      })
+    );
+  }
+  // ── Helpers ───────────────────────────────────────────────────────────
+  _getEditorEl() {
+    return this.shadowRoot?.getElementById("editor");
+  }
+};
+q.styles = Tt, q.shadowRootOptions = {
+  ...tt.shadowRootOptions,
+  delegatesFocus: !0
+};
+let _ = q;
+y([
+  b({ type: Boolean, attribute: "line-numbers", reflect: !0 })
+], _.prototype, "lineNumbers", 2);
+y([
+  b({ type: Boolean, attribute: "list-numbers", reflect: !0 })
+], _.prototype, "listNumbers", 2);
+y([
+  b({ type: Boolean, attribute: "gutter", reflect: !0 })
+], _.prototype, "gutter", 2);
+y([
+  b({ type: Boolean, attribute: "word-wrap", reflect: !0 })
+], _.prototype, "wordWrap", 2);
+y([
+  b({ type: Boolean, attribute: "auto-grow", reflect: !0 })
+], _.prototype, "autoGrow", 2);
+y([
+  b({ type: Boolean, attribute: "read-only", reflect: !0 })
+], _.prototype, "readOnly", 2);
+y([
+  b({ type: String })
+], _.prototype, "label", 2);
+y([
+  b({ attribute: !1 })
+], _.prototype, "plugin", 1);
+y([
+  b({ attribute: !1 })
+], _.prototype, "decorations", 1);
+y([
+  b({ type: String })
+], _.prototype, "value", 1);
+y([
+  b({ type: String })
+], _.prototype, "defaultValue", 1);
+function ye(n, t = {}) {
+  const e = [];
+  return {
+    mount(s) {
+      n.styles && s.adoptStyleSheet(n.styles);
+      for (const i of t.watch ?? []) {
+        const r = i(() => s.scheduleUpdate());
+        r && e.push(r);
+      }
+    },
+    destroy() {
+      for (const s of e) s();
+      e.length = 0;
+    },
+    update(s, i) {
+      const r = s.split(`
+`), o = [];
+      let a = 0;
+      for (let l = 0; l < r.length; l++) {
+        const h = r[l];
+        for (const c of n.decorateLine(h, l))
+          c.type === "mark" ? o.push({
+            ...c,
+            from: a + c.from,
+            to: a + c.to
+          }) : o.push(c);
+        a += h.length + 1;
+      }
+      t.extraDecorations && o.push(...t.extraDecorations(s)), i.setDecorations(o);
+    }
+  };
+}
+const xt = new CSSStyleSheet();
+xt.replaceSync(`
+  .rc-line-actions {
+    display: inline-flex;
+    align-items: center;
+    gap: var(--rc-line-actions-gap, 2px);
+    margin-left: var(--rc-line-actions-margin-start, 6px);
+    vertical-align: middle;
+  }
+  .rc-line-action-btn {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    padding: var(--rc-line-action-padding, 1px);
+    border: var(--rc-line-action-border, none);
+    border-radius: var(--rc-line-action-border-radius, 3px);
+    background: var(--rc-line-action-bg, transparent);
+    color: var(--rc-line-action-color, inherit);
+    font-size: var(--rc-line-action-font-size, 1em);
+    cursor: pointer;
+    user-select: none;
+    line-height: 1;
+    opacity: var(--rc-line-action-opacity, 0.4);
+    transition: opacity 0.1s;
+  }
+  .rc-line-action-btn:hover {
+    opacity: var(--rc-line-action-hover-opacity, 1);
+    background: var(--rc-line-action-hover-bg, transparent);
+    color: var(--rc-line-action-hover-color, inherit);
+  }
+`);
+const ct = "rc-line-actions-popover-style", ue = `
+  .rc-line-actions-popover {
+    position: fixed;
+    z-index: 9999;
+    display: flex;
+    align-items: center;
+    gap: var(--rc-line-actions-gap, 4px);
+    padding: 4px 8px;
+    background: var(--rc-line-action-bg, Canvas);
+    border: var(--rc-line-action-border, 1px solid ButtonBorder);
+    border-radius: var(--rc-line-action-border-radius, 4px);
+    box-shadow: var(
+      --rc-line-action-shadow,
+      0 2px 8px color-mix(in srgb, CanvasText 15%, transparent)
+    );
+  }
+  .rc-line-actions-popover .rc-line-action-btn {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    gap: 4px;
+    padding: var(--rc-line-action-padding, 4px 6px);
+    border: var(--rc-line-action-border, none);
+    border-radius: var(--rc-line-action-border-radius, 3px);
+    background: var(--rc-line-action-bg, transparent);
+    color: var(--rc-line-action-color, ButtonText);
+    font-size: var(--rc-line-action-font-size, 0.85em);
+    cursor: pointer;
+    user-select: none;
+    line-height: 1.4;
+    white-space: nowrap;
+  }
+  .rc-line-actions-popover .rc-line-action-btn:hover {
+    background: var(--rc-line-action-hover-bg, ButtonFace);
+  }
+`;
+class wt {
+  constructor(t, e) {
+    this._popover = null, this._lastActionsKey = "", this._api = t, this._options = e ?? {}, t.adoptStyleSheet(xt), this._blurHandler = () => this._hidePopover(), t.host.addEventListener("rc-textarea-blur", this._blurHandler);
+  }
+  /**
+   * Call from plugin's `update()`. Pass the line index, its actions, the full
+   * value, and the current render mode.
+   *
+   * - `'inline'`: returns a `WidgetDecoration[]` to merge into `setDecorations()`.
+   * - `'popover'`: returns `[]` and manages a floating panel as a side effect.
+   *
+   * Passing an empty actions array hides the popover and returns `[]`.
+   */
+  getDecorations(t, e, s, i) {
+    if (i === "popover")
+      return e.length === 0 ? this._hidePopover() : this._showPopover(e), [];
+    if (this._hidePopover(), e.length === 0) return [];
+    const r = wt._lineEndOffset(s, t), o = [...e], a = { renderButton: this._options.renderButton, createIcon: this._options.createIcon };
+    return [
+      {
+        type: "widget",
+        offset: r,
+        side: "after",
+        create() {
+          return de(o, a);
+        }
+      }
+    ];
+  }
+  /**
+   * Variant for `showOn: 'always'` — one entry per line with actions.
+   *
+   * In popover mode only the `activeLineIndex` line is shown; in inline mode
+   * every line with non-empty actions gets a widget.
+   */
+  getDecorationsForLines(t, e, s, i) {
+    if (s === "popover") {
+      if (i === void 0)
+        return this._hidePopover(), [];
+      const o = t.get(i) ?? [];
+      return this.getDecorations(i, o, e, "popover");
+    }
+    this._hidePopover();
+    const r = [];
+    for (const [o, a] of t)
+      a.length > 0 && r.push(...this.getDecorations(o, a, e, "inline"));
+    return r;
+  }
+  /** Remove the floating panel and detach all listeners. Call from plugin `destroy()`. */
+  destroy() {
+    this._hidePopover(), this._api.host.removeEventListener("rc-textarea-blur", this._blurHandler);
+  }
+  /** Derive the 0-based line index from a plain-text character offset. */
+  static getActiveLineIndex(t, e) {
+    return t.slice(0, e).split(`
+`).length - 1;
+  }
+  // ── Private helpers ───────────────────────────────────────────────────────
+  /**
+   * Character offset of the end of the given 0-based line (points at the
+   * newline character, or end-of-string for the last line).
+   */
+  static _lineEndOffset(t, e) {
+    const s = t.split(`
+`);
+    let i = 0;
+    for (let r = 0; r < e && r < s.length; r++)
+      i += s[r].length + 1;
+    return e < s.length && (i += s[e].length), i;
+  }
+  _showPopover(t) {
+    const e = t.map((s) => s.id).join(",");
+    if (!document.getElementById(ct)) {
+      const s = document.createElement("style");
+      s.id = ct, s.textContent = ue, document.head.appendChild(s);
+    }
+    this._popover || (this._popover = document.createElement("div"), this._popover.className = "rc-line-actions-popover", this._popover.addEventListener("mousedown", (s) => s.preventDefault()), document.body.appendChild(this._popover)), e !== this._lastActionsKey && (this._lastActionsKey = e, this._popover.innerHTML = "", fe(this._popover, t, this._options)), this._positionPopover();
+  }
+  _positionPopover() {
+    if (!this._popover) return;
+    const t = this._api.getCursorRect(), e = this._api.host.getBoundingClientRect();
+    let s;
+    const i = this._popover.offsetHeight || 32;
+    t ? (s = t.bottom + 4, s + i > window.innerHeight && (s = t.top - i - 4)) : s = e.bottom + 4;
+    const r = this._popover.offsetWidth || 120;
+    let o = e.left;
+    o = Math.min(o, window.innerWidth - r - 8), o = Math.max(o, 8), this._popover.style.top = `${s}px`, this._popover.style.left = `${o}px`;
+  }
+  _hidePopover() {
+    this._popover && (this._popover.remove(), this._popover = null, this._lastActionsKey = "");
+  }
+}
+function At(n, t) {
+  const e = document.createElement("button");
+  if (e.className = "rc-line-action-btn", e.type = "button", e.setAttribute("title", n.label), t.renderButton)
+    t.renderButton(n, e);
+  else if (n.icon) {
+    const s = t.createIcon?.(n.icon) ?? null;
+    s ? (e.setAttribute("aria-label", n.label), e.appendChild(s)) : (e.dataset.icon = n.icon, e.setAttribute("aria-label", n.label));
+  } else
+    e.textContent = n.label;
+  return e.addEventListener("mousedown", (s) => s.preventDefault()), e.addEventListener("click", () => n.onClick()), e;
+}
+function de(n, t) {
+  const e = document.createElement("span");
+  e.className = "rc-line-actions";
+  for (const s of n)
+    e.appendChild(At(s, t));
+  return e;
+}
+function fe(n, t, e) {
+  for (const s of t)
+    n.appendChild(At(s, e));
+}
+export {
+  wt as L,
+  _ as R,
+  ye as c,
+  ae as m
+};
+//# sourceMappingURL=line-actions-controller-BsM6DJ0b.js.map