laif-ds 0.2.85 → 0.2.87

package/dist/node_modules/@lexical/table/dist/LexicalTable.prod.js

@@ -0,0 +1,929 @@
+"use client";
+import { $getNodeByKey as st, $createPoint as mt, $createParagraphNode as R, $createTextNode as Kt, $isParagraphNode as Ot, $isElementNode as Ft, $normalizeSelection__EXPERIMENTAL as Bt, isCurrentlyReadOnlyMode as Ht, TEXT_TYPE_TO_FORMAT as Ut, $applyNodeReplacement as dt, $findMatchingParent as H, $isTextNode as G, ElementNode as _t, $getDocument as k, setDOMStyleFromCSS as St, setDOMUnmanaged as Pt, addClassNamesToElement as W, $getEditor as Jt, removeClassNamesFromElement as Y, isHTMLElement as I, $getNearestNodeFromDOMNode as Mt, $isInlineElementOrDecoratorNode as vt, $isLineBreakNode as Q, isHTMLTableRowElement as qt, IS_ITALIC as Vt, IS_UNDERLINE as Xt, IS_STRIKETHROUGH as Yt, IS_BOLD as Gt } from "../../../lexical/dist/Lexical.prod.js";
+import { defineImportRule as at, sel as it, ImportTextFormat as Ct, ImportTextStyle as wt, $propagateTextAlignToBlockChildren as Qt, contextValue as yt } from "../../html/dist/LexicalHtml.prod.js";
+import { $descendantsMatching as Z } from "../../utils/dist/LexicalUtils.prod.js";
+const K = /^(\d+(?:\.\d+)?)px$/, y = { BOTH: 3, COLUMN: 2, NO_STATUS: 0, ROW: 1 };
+class P extends _t {
+  __colSpan;
+  __rowSpan;
+  __headerState;
+  __width;
+  __backgroundColor;
+  __verticalAlign;
+  static getType() {
+    return "tablecell";
+  }
+  static clone(t) {
+    return new P(t.__headerState, t.__colSpan, t.__width, t.__key);
+  }
+  afterCloneFrom(t) {
+    super.afterCloneFrom(t), this.__rowSpan = t.__rowSpan, this.__backgroundColor = t.__backgroundColor, this.__verticalAlign = t.__verticalAlign, this.__colSpan = t.__colSpan, this.__headerState = t.__headerState, this.__width = t.__width;
+  }
+  static importDOM() {
+    return { td: (t) => ({ conversion: bt, priority: 0 }), th: (t) => ({ conversion: bt, priority: 0 }) };
+  }
+  static importJSON(t) {
+    return M().updateFromJSON(t);
+  }
+  updateFromJSON(t) {
+    return super.updateFromJSON(t).setHeaderStyles(t.headerState).setColSpan(t.colSpan || 1).setRowSpan(t.rowSpan || 1).setWidth(t.width || void 0).setBackgroundColor(t.backgroundColor || null).setVerticalAlign(t.verticalAlign || void 0);
+  }
+  constructor(t = y.NO_STATUS, e = 1, n, o) {
+    super(o), this.__colSpan = e, this.__rowSpan = 1, this.__headerState = t, this.__width = n, this.__backgroundColor = null, this.__verticalAlign = void 0;
+  }
+  createDOM(t) {
+    const e = k().createElement(this.getTag());
+    return this.__width && (e.style.width = `${this.__width}px`), this.__colSpan > 1 && (e.colSpan = this.__colSpan), this.__rowSpan > 1 && (e.rowSpan = this.__rowSpan), this.__backgroundColor !== null && (e.style.backgroundColor = this.__backgroundColor), ut(this.__verticalAlign) && (e.style.verticalAlign = this.__verticalAlign), W(e, t.theme.tableCell, this.hasHeader() && t.theme.tableCellHeader), e;
+  }
+  exportDOM(t) {
+    const e = super.exportDOM(t);
+    if (I(e.element)) {
+      const n = e.element;
+      n.setAttribute("data-temporary-table-cell-lexical-key", this.getKey()), n.style.border = "1px solid black", this.__colSpan > 1 && (n.colSpan = this.__colSpan), this.__rowSpan > 1 && (n.rowSpan = this.__rowSpan), n.style.width = `${this.getWidth() || 75}px`, n.style.verticalAlign = this.getVerticalAlign() || "top", n.style.textAlign = "start", this.__backgroundColor === null && this.hasHeader() && (n.style.backgroundColor = "#f2f3f5");
+    }
+    return e;
+  }
+  exportJSON() {
+    return { ...super.exportJSON(), ...ut(this.__verticalAlign) && { verticalAlign: this.__verticalAlign }, backgroundColor: this.getBackgroundColor(), colSpan: this.__colSpan, headerState: this.__headerState, rowSpan: this.__rowSpan, width: this.getWidth() };
+  }
+  getColSpan() {
+    return this.getLatest().__colSpan;
+  }
+  setColSpan(t) {
+    const e = this.getWritable();
+    return e.__colSpan = t, e;
+  }
+  getRowSpan() {
+    return this.getLatest().__rowSpan;
+  }
+  setRowSpan(t) {
+    const e = this.getWritable();
+    return e.__rowSpan = t, e;
+  }
+  getTag() {
+    return this.hasHeader() ? "th" : "td";
+  }
+  setHeaderStyles(t, e = y.BOTH) {
+    const n = this.getWritable();
+    return n.__headerState = t & e | n.__headerState & ~e, n;
+  }
+  getHeaderStyles() {
+    return this.getLatest().__headerState;
+  }
+  setWidth(t) {
+    const e = this.getWritable();
+    return e.__width = t, e;
+  }
+  getWidth() {
+    return this.getLatest().__width;
+  }
+  getBackgroundColor() {
+    return this.getLatest().__backgroundColor;
+  }
+  setBackgroundColor(t) {
+    const e = this.getWritable();
+    return e.__backgroundColor = t, e;
+  }
+  getVerticalAlign() {
+    return this.getLatest().__verticalAlign;
+  }
+  setVerticalAlign(t) {
+    const e = this.getWritable();
+    return e.__verticalAlign = t || void 0, e;
+  }
+  toggleHeaderStyle(t) {
+    const e = this.getWritable();
+    return (e.__headerState & t) === t ? e.__headerState -= t : e.__headerState += t, e;
+  }
+  hasHeaderState(t) {
+    return (this.getHeaderStyles() & t) === t;
+  }
+  hasHeader() {
+    return this.getLatest().__headerState !== y.NO_STATUS;
+  }
+  updateDOM(t) {
+    return t.__headerState !== this.__headerState || t.__width !== this.__width || t.__colSpan !== this.__colSpan || t.__rowSpan !== this.__rowSpan || t.__backgroundColor !== this.__backgroundColor || t.__verticalAlign !== this.__verticalAlign;
+  }
+  isShadowRoot() {
+    return !0;
+  }
+  collapseAtStart() {
+    return !0;
+  }
+  canBeEmpty() {
+    return !1;
+  }
+  canIndent() {
+    return !1;
+  }
+}
+function ut(l) {
+  return l === "middle" || l === "bottom";
+}
+function bt(l) {
+  const t = l, e = l.nodeName.toLowerCase();
+  let n;
+  K.test(t.style.width) && (n = parseFloat(t.style.width));
+  let o = y.NO_STATUS;
+  if (e === "th") {
+    const m = t.getAttribute("scope");
+    if (m === "col") o = y.COLUMN;
+    else if (m === "row") o = y.ROW;
+    else {
+      const a = t.parentElement, d = I(a) && a.nodeName.toLowerCase() === "tr" && I(a.parentElement) && (a.parentElement.nodeName.toLowerCase() === "thead" || a.rowIndex === 0), C = t.cellIndex === 0;
+      d && (o |= y.ROW), C && (o |= y.COLUMN), o === y.NO_STATUS && (o = y.ROW);
+    }
+  }
+  const r = M(o, t.colSpan, n);
+  r.__rowSpan = t.rowSpan;
+  const s = t.style.backgroundColor;
+  s !== "" && (r.__backgroundColor = s);
+  const c = t.style.verticalAlign;
+  ut(c) && (r.__verticalAlign = c);
+  const i = t.style, p = (i && i.textDecoration || "").split(" "), h = i.fontWeight === "700" || i.fontWeight === "bold", u = p.includes("line-through"), g = i.fontStyle === "italic", S = p.includes("underline"), _ = i.color;
+  return { after: (m) => {
+    const a = [];
+    let d = null;
+    const C = () => {
+      if (d) {
+        const f = d.getFirstChild();
+        Q(f) && d.getChildrenSize() === 1 && f.remove();
+      }
+    };
+    for (const f of m) if (vt(f) || G(f) || Q(f)) {
+      if (G(f) && (h && f.toggleFormat("bold"), u && f.toggleFormat("strikethrough"), g && f.toggleFormat("italic"), S && f.toggleFormat("underline"), _)) {
+        const N = f.getStyle();
+        N.includes("color:") || f.setStyle(N + `color: ${_};`);
+      }
+      d ? d.append(f) : (d = R().append(f), a.push(d));
+    } else a.push(f), C(), d = null;
+    return C(), a.length === 0 && a.push(R()), a;
+  }, node: r };
+}
+function M(l = y.NO_STATUS, t = 1, e) {
+  return dt(new P(l, t, e));
+}
+function x(l) {
+  return l instanceof P;
+}
+function b(l, ...t) {
+  const e = new URL("https://lexical.dev/docs/error"), n = new URLSearchParams();
+  n.append("code", l);
+  for (const o of t) n.append("v", o);
+  throw e.search = n.toString(), Error(`Minified Lexical error #${l}; visit ${e.toString()} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`);
+}
+class j extends _t {
+  __height;
+  static getType() {
+    return "tablerow";
+  }
+  static clone(t) {
+    return new j(t.__height, t.__key);
+  }
+  afterCloneFrom(t) {
+    super.afterCloneFrom(t), this.__height = t.__height;
+  }
+  static importDOM() {
+    return { tr: (t) => ({ conversion: Zt, priority: 0 }) };
+  }
+  static importJSON(t) {
+    return B().updateFromJSON(t);
+  }
+  updateFromJSON(t) {
+    return super.updateFromJSON(t).setHeight(t.height);
+  }
+  constructor(t, e) {
+    super(e), this.__height = t;
+  }
+  exportJSON() {
+    const t = this.getHeight();
+    return { ...super.exportJSON(), ...t === void 0 ? void 0 : { height: t } };
+  }
+  createDOM(t) {
+    const e = k().createElement("tr");
+    return this.__height && (e.style.height = `${this.__height}px`), W(e, t.theme.tableRow), e;
+  }
+  extractWithChild(t, e, n) {
+    return n === "html";
+  }
+  isShadowRoot() {
+    return !0;
+  }
+  setHeight(t) {
+    const e = this.getWritable();
+    return e.__height = t, e;
+  }
+  getHeight() {
+    return this.getLatest().__height;
+  }
+  updateDOM(t) {
+    return t.__height !== this.__height;
+  }
+  canBeEmpty() {
+    return !1;
+  }
+  canIndent() {
+    return !1;
+  }
+}
+function Zt(l) {
+  const t = l;
+  let e;
+  return K.test(t.style.height) && (e = parseFloat(t.style.height)), { after: (n) => Z(n, x), node: B(e) };
+}
+function B(l) {
+  return dt(new j(l));
+}
+function T(l) {
+  return l instanceof j;
+}
+function jt(l) {
+  const t = H(l, (e) => U(e));
+  if (U(t)) return t;
+  throw new Error("Expected table cell to be inside of table.");
+}
+const ht = (l, t) => l === y.BOTH || l === t ? t : y.NO_STATUS;
+function te(l, t = !0) {
+  const [, , e] = q(l), [n, o] = J(e, l, l), r = n[0].length, { startRow: s } = o;
+  let c = null;
+  if (t) {
+    const i = s + l.__rowSpan - 1, p = n[i], h = B();
+    for (let g = 0; g < r; g++) {
+      const { cell: S, startRow: _ } = p[g];
+      if (_ + S.__rowSpan - 1 <= i) {
+        const m = p[g].cell.__headerState, a = ht(m, y.COLUMN);
+        h.append(M(a).append(R()));
+      } else S.setRowSpan(S.__rowSpan + 1);
+    }
+    const u = e.getChildAtIndex(i);
+    T(u) || b(256), u.insertAfter(h), c = h;
+  } else {
+    const i = s, p = n[i], h = B();
+    for (let g = 0; g < r; g++) {
+      const { cell: S, startRow: _ } = p[g];
+      if (_ === i) {
+        const m = p[g].cell.__headerState, a = ht(m, y.COLUMN);
+        h.append(M(a).append(R()));
+      } else S.setRowSpan(S.__rowSpan + 1);
+    }
+    const u = e.getChildAtIndex(i);
+    T(u) || b(257), u.insertBefore(h), c = h;
+  }
+  return c;
+}
+function ee(l, t = !0, e = !0) {
+  const [, , n] = q(l), [o, r] = J(n, l, l), s = o.length, { startColumn: c } = r, i = t ? c + l.__colSpan - 1 : c - 1, p = n.getFirstChild();
+  T(p) || b(120);
+  let h = null;
+  function u(_ = y.NO_STATUS) {
+    const m = M(_).append(R());
+    return h === null && (h = m), m;
+  }
+  let g = p;
+  t: for (let _ = 0; _ < s; _++) {
+    if (_ !== 0) {
+      const A = g.getNextSibling();
+      T(A) || b(121), g = A;
+    }
+    const m = o[_], a = m[i < 0 ? 0 : i].cell.__headerState, d = ht(a, y.ROW);
+    if (i < 0) {
+      Wt(g, u(d));
+      continue;
+    }
+    const { cell: C, startColumn: f, startRow: N } = m[i];
+    if (f + C.__colSpan - 1 <= i) {
+      let A = C, V = N, L = i;
+      for (; V !== _ && A.__rowSpan > 1; ) {
+        if (L -= C.__colSpan, !(L >= 0)) {
+          g.append(u(d));
+          continue t;
+        }
+        {
+          const { cell: z, startRow: nt } = m[L];
+          A = z, V = nt;
+        }
+      }
+      A.insertAfter(u(d));
+    } else C.setColSpan(C.__colSpan + 1);
+  }
+  h !== null && e && ne(h);
+  const S = n.getColWidths();
+  if (S) {
+    const _ = [...S], m = i < 0 ? 0 : i, a = _[m];
+    _.splice(m, 0, a), n.setColWidths(_);
+  }
+  return h;
+}
+function ne(l) {
+  const t = l.getFirstDescendant();
+  t == null ? l.selectStart() : t.getParentOrThrow().selectStart();
+}
+function Wt(l, t) {
+  const e = l.getFirstChild();
+  e !== null ? e.insertBefore(t) : l.append(t);
+}
+function oe(l) {
+  if (l.length === 0) return null;
+  const t = jt(l[0]), [e] = E(t, null, null);
+  let n = 1 / 0, o = -1 / 0, r = 1 / 0, s = -1 / 0;
+  const c = /* @__PURE__ */ new Set();
+  for (const S of e) for (const _ of S) {
+    if (!_ || !_.cell) continue;
+    const m = _.cell.getKey();
+    if (!c.has(m) && l.some((a) => a.is(_.cell))) {
+      c.add(m);
+      const a = _.startRow, d = _.startColumn, C = _.cell.__rowSpan || 1, f = _.cell.__colSpan || 1;
+      n = Math.min(n, a), o = Math.max(o, a + C - 1), r = Math.min(r, d), s = Math.max(s, d + f - 1);
+    }
+  }
+  if (n === 1 / 0 || r === 1 / 0) return null;
+  const i = o - n + 1, p = s - r + 1, h = e[n][r];
+  if (!h.cell) return null;
+  const u = h.cell;
+  u.setColSpan(p), u.setRowSpan(i);
+  const g = /* @__PURE__ */ new Set([u.getKey()]);
+  for (let S = n; S <= o; S++) for (let _ = r; _ <= s; _++) {
+    const m = e[S][_];
+    if (!m.cell) continue;
+    const a = m.cell, d = a.getKey();
+    g.has(d) || (g.add(d), re(a) || u.append(...a.getChildren()), a.remove());
+  }
+  return u.getChildrenSize() === 0 && u.append(R()), u;
+}
+function re(l) {
+  if (l.getChildrenSize() !== 1) return !1;
+  const t = l.getFirstChildOrThrow();
+  return !(!Ot(t) || !t.isEmpty());
+}
+function le(l) {
+  const [t, e, n] = q(l), o = t.__colSpan, r = t.__rowSpan;
+  if (o === 1 && r === 1) return;
+  const [s, c] = J(n, t, t), { startColumn: i, startRow: p } = c, h = t.__headerState & y.COLUMN, u = Array.from({ length: o }, (_, m) => {
+    let a = h;
+    for (let d = 0; a !== 0 && d < s.length; d++) a &= s[d][m + i].cell.__headerState;
+    return a;
+  }), g = t.__headerState & y.ROW, S = Array.from({ length: r }, (_, m) => {
+    let a = g;
+    for (let d = 0; a !== 0 && d < s[0].length; d++) a &= s[m + p][d].cell.__headerState;
+    return a;
+  });
+  if (o > 1) {
+    for (let _ = 1; _ < o; _++) t.insertAfter(M(u[_] | S[0]).append(R()));
+    t.setColSpan(1);
+  }
+  if (r > 1) {
+    let _;
+    for (let m = 1; m < r; m++) {
+      const a = p + m, d = s[a];
+      _ = (_ || e).getNextSibling(), T(_) || b(125);
+      let C = null;
+      for (let f = 0; f < i; f++) {
+        const N = d[f], A = N.cell;
+        N.startRow === a && (C = A), A.__colSpan > 1 && (f += A.__colSpan - 1);
+      }
+      if (C === null) for (let f = o - 1; f >= 0; f--) Wt(_, M(u[f] | S[m]).append(R()));
+      else for (let f = o - 1; f >= 0; f--) C.insertAfter(M(u[f] | S[m]).append(R()));
+    }
+    t.setRowSpan(1);
+  }
+}
+function J(l, t, e) {
+  const [n, o, r] = E(l, t, e);
+  return o === null && b(207), r === null && b(208), [n, o, r];
+}
+function E(l, t, e) {
+  const n = [];
+  let o = null, r = null;
+  function s(i) {
+    let p = n[i];
+    return p === void 0 && (n[i] = p = []), p;
+  }
+  const c = l.getChildren();
+  for (let i = 0; i < c.length; i++) {
+    const p = c[i];
+    T(p) || b(209);
+    const h = s(i);
+    for (let u = p.getFirstChild(), g = 0; u != null; u = u.getNextSibling()) {
+      for (x(u) || b(147); h[g] !== void 0; ) g++;
+      const S = { cell: u, startColumn: g, startRow: i }, { __rowSpan: _, __colSpan: m } = u;
+      for (let a = 0; a < _ && !(i + a >= c.length); a++) {
+        const d = s(i + a);
+        for (let C = 0; C < m; C++) d[g + C] = S;
+      }
+      t !== null && o === null && t.is(u) && (o = S), e !== null && r === null && e.is(u) && (r = S);
+    }
+  }
+  return [n, o, r];
+}
+function q(l) {
+  let t;
+  if (l instanceof P) t = l;
+  else if ("__type" in l) {
+    const o = H(l, x);
+    x(o) || b(148), t = o;
+  } else {
+    const o = H(l.getNode(), x);
+    x(o) || b(148), t = o;
+  }
+  const e = t.getParent();
+  T(e) || b(149);
+  const n = e.getParent();
+  return U(n) || b(210), [t, e, n];
+}
+function zt(l, t, e) {
+  let n, o = Math.min(t.startColumn, e.startColumn), r = Math.min(t.startRow, e.startRow), s = Math.max(t.startColumn + t.cell.__colSpan - 1, e.startColumn + e.cell.__colSpan - 1), c = Math.max(t.startRow + t.cell.__rowSpan - 1, e.startRow + e.cell.__rowSpan - 1);
+  do {
+    n = !1;
+    for (let i = 0; i < l.length; i++) for (let p = 0; p < l[0].length; p++) {
+      const h = l[i][p];
+      if (!h) continue;
+      const u = h.startColumn + h.cell.__colSpan - 1, g = h.startRow + h.cell.__rowSpan - 1, S = h.startColumn <= s && u >= o, _ = h.startRow <= c && g >= r;
+      if (S && _) {
+        const m = Math.min(o, h.startColumn), a = Math.max(s, u), d = Math.min(r, h.startRow), C = Math.max(c, g);
+        m === o && a === s && d === r && C === c || (o = m, s = a, r = d, c = C, n = !0);
+      }
+    }
+  } while (n);
+  return { maxColumn: s, maxRow: c, minColumn: o, minRow: r };
+}
+function Nt(l) {
+  const [t, , e] = q(l), n = e.getChildren().filter(T), o = n.length, r = n[0].getChildren().length, s = new Array(o);
+  for (let c = 0; c < o; c++) s[c] = new Array(r);
+  for (let c = 0; c < o; c++) {
+    const i = n[c].getChildren().filter(x);
+    let p = 0;
+    for (let h = 0; h < i.length; h++) {
+      for (; s[c][p]; ) p++;
+      const u = i[h], g = u.__rowSpan || 1, S = u.__colSpan || 1;
+      for (let _ = 0; _ < g; _++) for (let m = 0; m < S; m++) s[c + _][p + m] = u;
+      if (t === u) return { colSpan: S, columnIndex: p, rowIndex: c, rowSpan: g };
+      p += S;
+    }
+  }
+  return null;
+}
+function se(l, t) {
+  const e = t.getStartEndPoints(), n = $t(t);
+  if (e === null) return !1;
+  const [o, r] = e, [s, c, i] = q(o), p = H(r.getNode(), (w) => x(w));
+  if (!(x(s) && x(p) && T(c) && U(i))) return !1;
+  const [h, u, g] = J(i, s, p), [S] = E(l, null, null), _ = h.length, m = _ > 0 ? h[0].length : 0;
+  let a = u.startRow, d = u.startColumn, C = S.length, f = C > 0 ? S[0].length : 0;
+  if (n) {
+    const w = zt(h, u, g), O = w.maxRow - w.minRow + 1, F = w.maxColumn - w.minColumn + 1;
+    a = w.minRow, d = w.minColumn, C = Math.min(C, O), f = Math.min(f, F);
+  }
+  let N = !1;
+  const A = Math.min(_, a + C) - 1, V = Math.min(m, d + f) - 1, L = /* @__PURE__ */ new Set();
+  for (let w = a; w <= A; w++) for (let O = d; O <= V; O++) {
+    const F = h[w][O];
+    L.has(F.cell.getKey()) || F.cell.__rowSpan === 1 && F.cell.__colSpan === 1 || (le(F.cell), L.add(F.cell.getKey()), N = !0);
+  }
+  let [z] = E(i.getWritable(), null, null);
+  const nt = C - _ + a;
+  for (let w = 0; w < nt; w++)
+    te(z[_ - 1][0].cell);
+  const kt = f - m + d;
+  for (let w = 0; w < kt; w++)
+    ee(z[0][m - 1].cell, !0, !1);
+  [z] = E(i.getWritable(), null, null);
+  for (let w = a; w < a + C; w++) for (let O = d; O < d + f; O++) {
+    const F = w - a, ft = O - d, ot = S[F][ft];
+    if (ot.startRow !== F || ot.startColumn !== ft) continue;
+    const D = ot.cell;
+    if (D.__rowSpan !== 1 || D.__colSpan !== 1) {
+      const v = [], It = Math.min(w + D.__rowSpan, a + C) - 1, Lt = Math.min(O + D.__colSpan, d + f) - 1;
+      for (let rt = w; rt <= It; rt++) for (let lt = O; lt <= Lt; lt++) {
+        const Dt = z[rt][lt];
+        v.push(Dt.cell);
+      }
+      oe(v), N = !0;
+    }
+    const { cell: X } = z[w][O], gt = D.getBackgroundColor();
+    gt != null && X.setBackgroundColor(gt);
+    const Et = X.getChildren();
+    D.getChildren().forEach((v) => {
+      G(v) && R().append(v), X.append(v);
+    }), Et.forEach((v) => v.remove());
+  }
+  if (n && N) {
+    const [w] = E(i.getWritable(), null, null);
+    w[u.startRow][u.startColumn].cell.selectEnd();
+  }
+  return !0;
+}
+function ct(l) {
+  const [[t, e, n, o], [r, s, c, i]] = ["anchor", "focus"].map((p) => {
+    const h = l[p].getNode(), u = H(h, x);
+    x(u) || b(238, p, h.getKey(), h.getType());
+    const g = u.getParent();
+    T(g) || b(239, p);
+    const S = g.getParent();
+    return U(S) || b(240, p), [h, u, g, S];
+  });
+  return o.is(i) || b(241), { anchorCell: e, anchorNode: t, anchorRow: n, anchorTable: o, focusCell: s, focusNode: r, focusRow: c, focusTable: i };
+}
+class pt {
+  tableKey;
+  anchor;
+  focus;
+  _cachedNodes;
+  dirty;
+  constructor(t, e, n) {
+    this.anchor = e, this.focus = n, e._selection = this, n._selection = this, this._cachedNodes = null, this.dirty = !1, this.tableKey = t;
+  }
+  getStartEndPoints() {
+    return [this.anchor, this.focus];
+  }
+  isValid() {
+    if (this.tableKey === "root" || this.anchor.key === "root" || this.anchor.type !== "element" || this.focus.key === "root" || this.focus.type !== "element") return !1;
+    const t = st(this.tableKey), e = st(this.anchor.key), n = st(this.focus.key);
+    return t !== null && e !== null && n !== null;
+  }
+  isBackward() {
+    return this.focus.isBefore(this.anchor);
+  }
+  getCachedNodes() {
+    return this._cachedNodes;
+  }
+  setCachedNodes(t) {
+    this._cachedNodes = t;
+  }
+  is(t) {
+    return $t(t) && this.tableKey === t.tableKey && this.anchor.is(t.anchor) && this.focus.is(t.focus);
+  }
+  set(t, e, n) {
+    this.dirty = this.dirty || t !== this.tableKey || e !== this.anchor.key || n !== this.focus.key, this.tableKey = t, this.anchor.key = e, this.focus.key = n, this._cachedNodes = null;
+  }
+  clone() {
+    return new pt(this.tableKey, mt(this.anchor.key, this.anchor.offset, this.anchor.type), mt(this.focus.key, this.focus.offset, this.focus.type));
+  }
+  isCollapsed() {
+    return !1;
+  }
+  extract() {
+    return this.getNodes();
+  }
+  insertRawText(t) {
+    if (t === "") return;
+    const e = (t.endsWith(`
+`) ? t.slice(0, -1) : t).split(`
+`).map((r) => r.split("	")), n = et();
+    for (const r of e) {
+      const s = B();
+      for (const c of r) {
+        const i = M(y.NO_STATUS), p = R();
+        c && p.append(Kt(c)), i.append(p), s.append(i);
+      }
+      n.append(s);
+    }
+    const { anchorCell: o } = ct(this);
+    se(n, o.select(0, o.getChildrenSize()));
+  }
+  insertText() {
+  }
+  hasFormat(t) {
+    let e = 0;
+    this.getNodes().filter(x).forEach((o) => {
+      const r = o.getFirstChild();
+      Ot(r) && (e |= r.getTextFormat());
+    });
+    const n = Ut[t];
+    return (e & n) !== 0;
+  }
+  insertNodes(t) {
+    const e = this.focus.getNode();
+    Ft(e) || b(151), Bt(e.select(0, e.getChildrenSize())).insertNodes(t);
+  }
+  getShape() {
+    const { anchorCell: t, focusCell: e } = ct(this), n = Nt(t);
+    n === null && b(153);
+    const o = Nt(e);
+    o === null && b(155);
+    const r = Math.min(n.columnIndex, o.columnIndex), s = Math.max(n.columnIndex + n.colSpan - 1, o.columnIndex + o.colSpan - 1), c = Math.min(n.rowIndex, o.rowIndex), i = Math.max(n.rowIndex + n.rowSpan - 1, o.rowIndex + o.rowSpan - 1);
+    return { fromX: Math.min(r, s), fromY: Math.min(c, i), toX: Math.max(r, s), toY: Math.max(c, i) };
+  }
+  getNodes() {
+    if (!this.isValid()) return [];
+    const t = this._cachedNodes;
+    if (t !== null) return t;
+    const { anchorTable: e, anchorCell: n, focusCell: o } = ct(this), r = o.getParents()[1];
+    if (r !== e) {
+      if (e.isParentOf(o)) {
+        const a = r.getParent();
+        a == null && b(159), this.set(this.tableKey, o.getKey(), a.getKey());
+      } else {
+        const a = e.getParent();
+        a == null && b(158), this.set(this.tableKey, a.getKey(), o.getKey());
+      }
+      return this.getNodes();
+    }
+    const [s, c, i] = J(e, n, o), { minColumn: p, maxColumn: h, minRow: u, maxRow: g } = zt(s, c, i), S = /* @__PURE__ */ new Map([[e.getKey(), e]]);
+    let _ = null;
+    for (let a = u; a <= g; a++) for (let d = p; d <= h; d++) {
+      const { cell: C } = s[a][d], f = C.getParent();
+      T(f) || b(160), f !== _ && (S.set(f.getKey(), f), _ = f), S.has(C.getKey()) || ae(C, (N) => {
+        S.set(N.getKey(), N);
+      });
+    }
+    const m = Array.from(S.values());
+    return Ht() || (this._cachedNodes = m), m;
+  }
+  getTextContent() {
+    const t = this.getNodes().filter((n) => x(n));
+    let e = "";
+    for (let n = 0; n < t.length; n++) {
+      const o = t[n], r = o.__parent, s = (t[n + 1] || {}).__parent;
+      e += o.getTextContent() + (s !== r ? `
+` : "	");
+    }
+    return e;
+  }
+}
+function $t(l) {
+  return l instanceof pt;
+}
+function ae(l, t) {
+  const e = [[l]];
+  for (let n = e.at(-1); n !== void 0 && e.length > 0; n = e.at(-1)) {
+    const o = n.pop();
+    o === void 0 ? e.pop() : t(o) !== !1 && Ft(o) && e.push(o.getChildren());
+  }
+}
+function $(l) {
+  return I(l) && l.nodeName === "TABLE";
+}
+function xt(l, t) {
+  if (!t) return t;
+  const e = $(t) ? t : t.querySelector("table");
+  return $(e) || b(341, l.constructor.name, l.getType(), l.getKey(), t.nodeName), e;
+}
+function ie(l, t) {
+  for (let e = t, n = null; e !== null; e = e.getParent()) {
+    if (l.is(e)) return n;
+    x(e) && (n = e);
+  }
+  return null;
+}
+function ce(l, t, e) {
+  return ie(l, Mt(t, e));
+}
+function Tt(l, t, e) {
+  const n = l.querySelector("colgroup");
+  if (!n) return;
+  const o = [];
+  for (let r = 0; r < t; r++) {
+    const s = k().createElement("col"), c = e && e[r];
+    c && (s.style.width = `${c}px`), o.push(s);
+  }
+  n.replaceChildren(...o);
+}
+function Rt(l, t, e) {
+  if (!t.theme.tableAlignment) return;
+  const n = [], o = [];
+  for (const r of ["center", "right"]) {
+    const s = t.theme.tableAlignment[r];
+    s && (r === e ? o : n).push(s);
+  }
+  Y(l, ...n), W(l, ...o);
+}
+const ue = /* @__PURE__ */ new WeakSet();
+function At(l = Jt()) {
+  return ue.has(l);
+}
+class tt extends _t {
+  __rowStriping;
+  __frozenColumnCount;
+  __frozenRowCount;
+  __colWidths;
+  static getType() {
+    return "table";
+  }
+  getColWidths() {
+    return this.getLatest().__colWidths;
+  }
+  setColWidths(t) {
+    const e = this.getWritable();
+    return e.__colWidths = t, e;
+  }
+  static clone(t) {
+    return new tt(t.__key);
+  }
+  afterCloneFrom(t) {
+    super.afterCloneFrom(t), this.__colWidths = t.__colWidths, this.__rowStriping = t.__rowStriping, this.__frozenColumnCount = t.__frozenColumnCount, this.__frozenRowCount = t.__frozenRowCount;
+  }
+  static importDOM() {
+    return { table: (t) => ({ conversion: he, priority: 1 }) };
+  }
+  static importJSON(t) {
+    return et().updateFromJSON(t);
+  }
+  updateFromJSON(t) {
+    return super.updateFromJSON(t).setRowStriping(t.rowStriping || !1).setFrozenColumns(t.frozenColumnCount || 0).setFrozenRows(t.frozenRowCount || 0).setColWidths(t.colWidths);
+  }
+  constructor(t) {
+    super(t), this.__rowStriping = !1, this.__frozenColumnCount = 0, this.__frozenRowCount = 0, this.__colWidths = void 0;
+  }
+  exportJSON() {
+    return { ...super.exportJSON(), colWidths: this.getColWidths(), frozenColumnCount: this.__frozenColumnCount ? this.__frozenColumnCount : void 0, frozenRowCount: this.__frozenRowCount ? this.__frozenRowCount : void 0, rowStriping: this.__rowStriping ? this.__rowStriping : void 0 };
+  }
+  extractWithChild(t, e, n) {
+    return n === "html";
+  }
+  getDOMSlot(t) {
+    const e = $(t) ? t : t.querySelector("table");
+    return $(e) || b(229), super.getDOMSlot(t).withElement(e).withAfter(e.querySelector("colgroup"));
+  }
+  createDOM(t, e) {
+    const n = k().createElement("table");
+    this.__style && St(n.style, this.__style);
+    const o = k().createElement("colgroup");
+    if (n.appendChild(o), Pt(o), W(n, t.theme.table), this.updateTableElement(null, n, t), At(e)) {
+      const r = k().createElement("div"), s = t.theme.tableScrollableWrapper;
+      return s ? W(r, s) : r.style.overflowX = "auto", r.appendChild(n), this.updateTableWrapper(null, r, n, t), r;
+    }
+    return n;
+  }
+  updateTableWrapper(t, e, n, o) {
+    this.__frozenColumnCount !== (t ? t.__frozenColumnCount : 0) && (function(r, s, c, i) {
+      i > 0 ? (W(r, c.theme.tableFrozenColumn), s.setAttribute("data-lexical-frozen-column", "true")) : (Y(r, c.theme.tableFrozenColumn), s.removeAttribute("data-lexical-frozen-column"));
+    })(e, n, o, this.__frozenColumnCount), this.__frozenRowCount !== (t ? t.__frozenRowCount : 0) && (function(r, s, c, i) {
+      i > 0 ? (W(r, c.theme.tableFrozenRow), s.setAttribute("data-lexical-frozen-row", "true")) : (Y(r, c.theme.tableFrozenRow), s.removeAttribute("data-lexical-frozen-row"));
+    })(e, n, o, this.__frozenRowCount);
+  }
+  updateTableElement(t, e, n) {
+    this.__style !== (t ? t.__style : "") && St(e.style, this.__style, t ? t.__style : ""), this.__rowStriping !== (!!t && t.__rowStriping) && (function(s, c, i) {
+      i ? (W(s, c.theme.tableRowStriping), s.setAttribute("data-lexical-row-striping", "true")) : (Y(s, c.theme.tableRowStriping), s.removeAttribute("data-lexical-row-striping"));
+    })(e, n, this.__rowStriping);
+    const o = t ? t.getColumnCount() : 0, r = t ? t.__colWidths : void 0;
+    this.getColumnCount() === o && this.getColWidths() === r || Tt(e, this.getColumnCount(), this.getColWidths()), Rt(e, n, this.getFormatType());
+  }
+  updateDOM(t, e, n) {
+    const o = xt(this, e);
+    return e === o === At() || (I(r = e) && r.nodeName === "DIV" && this.updateTableWrapper(t, e, o, n), this.updateTableElement(t, o, n), !1);
+    var r;
+  }
+  scaleDOMColWidths(t, e) {
+    const n = this.getColWidths();
+    n && Tt(xt(this, t), this.getColumnCount(), n.map((o) => o * e));
+  }
+  exportDOM(t) {
+    const e = super.exportDOM(t), { element: n } = e;
+    return { after: (o) => {
+      if (e.after && (o = e.after(o)), !$(o) && I(o) && (o = o.querySelector("table")), !$(o)) return null;
+      Rt(o, t._config, this.getFormatType());
+      const [r] = E(this, null, null), s = /* @__PURE__ */ new Map();
+      for (const h of r) for (const u of h) {
+        const g = u.cell.getKey();
+        s.has(g) || s.set(g, { colSpan: u.cell.getColSpan(), startColumn: u.startColumn });
+      }
+      const c = /* @__PURE__ */ new Set();
+      for (const h of o.querySelectorAll(":scope > tr > [data-temporary-table-cell-lexical-key]")) {
+        const u = h.getAttribute("data-temporary-table-cell-lexical-key");
+        if (u) {
+          const g = s.get(u);
+          if (h.removeAttribute("data-temporary-table-cell-lexical-key"), g) {
+            s.delete(u);
+            for (let S = 0; S < g.colSpan; S++) c.add(S + g.startColumn);
+          }
+        }
+      }
+      const i = o.querySelector(":scope > colgroup");
+      if (i) {
+        const h = Array.from(o.querySelectorAll(":scope > colgroup > col")).filter((u, g) => c.has(g));
+        i.replaceChildren(...h);
+      }
+      const p = o.querySelectorAll(":scope > tr");
+      if (p.length > 0) {
+        const h = k().createElement("tbody");
+        for (const u of p) h.appendChild(u);
+        o.append(h);
+      }
+      return o;
+    }, element: !$(n) && I(n) ? n.querySelector("table") : n };
+  }
+  canBeEmpty() {
+    return !1;
+  }
+  isShadowRoot() {
+    return !0;
+  }
+  getCordsFromCellNode(t, e) {
+    const { rows: n, domRows: o } = e;
+    for (let r = 0; r < n; r++) {
+      const s = o[r];
+      if (s != null) for (let c = 0; c < s.length; c++) {
+        const i = s[c];
+        if (i == null) continue;
+        const { elem: p } = i, h = ce(this, p);
+        if (h !== null && t.is(h)) return { x: c, y: r };
+      }
+    }
+    throw new Error("Cell not found in table.");
+  }
+  getDOMCellFromCords(t, e, n) {
+    const { domRows: o } = n, r = o[e];
+    if (r == null) return null;
+    const s = r[t < r.length ? t : r.length - 1];
+    return s ?? null;
+  }
+  getDOMCellFromCordsOrThrow(t, e, n) {
+    const o = this.getDOMCellFromCords(t, e, n);
+    if (!o) throw new Error("Cell not found at cords.");
+    return o;
+  }
+  getCellNodeFromCords(t, e, n) {
+    const o = this.getDOMCellFromCords(t, e, n);
+    if (o == null) return null;
+    const r = Mt(o.elem);
+    return x(r) ? r : null;
+  }
+  getCellNodeFromCordsOrThrow(t, e, n) {
+    const o = this.getCellNodeFromCords(t, e, n);
+    if (!o) throw new Error("Node at cords not TableCellNode.");
+    return o;
+  }
+  getRowStriping() {
+    return !!this.getLatest().__rowStriping;
+  }
+  setRowStriping(t) {
+    const e = this.getWritable();
+    return e.__rowStriping = t, e;
+  }
+  setFrozenColumns(t) {
+    const e = this.getWritable();
+    return e.__frozenColumnCount = t, e;
+  }
+  getFrozenColumns() {
+    return this.getLatest().__frozenColumnCount;
+  }
+  setFrozenRows(t) {
+    const e = this.getWritable();
+    return e.__frozenRowCount = t, e;
+  }
+  getFrozenRows() {
+    return this.getLatest().__frozenRowCount;
+  }
+  canSelectBefore() {
+    return !0;
+  }
+  canIndent() {
+    return !1;
+  }
+  getColumnCount() {
+    const t = this.getFirstChild();
+    if (!T(t)) return 0;
+    let e = 0;
+    return t.getChildren().forEach((n) => {
+      x(n) && (e += n.getColSpan());
+    }), e;
+  }
+}
+function he(l) {
+  const t = et();
+  l.hasAttribute("data-lexical-row-striping") && t.setRowStriping(!0), l.hasAttribute("data-lexical-frozen-column") && t.setFrozenColumns(1), l.hasAttribute("data-lexical-frozen-row") && t.setFrozenRows(1);
+  const e = l.querySelector(":scope > colgroup");
+  if (e) {
+    let n = [];
+    for (const o of e.querySelectorAll(":scope > col")) {
+      let r = o.style.width || "";
+      if (!K.test(r) && (r = o.getAttribute("width") || "", !/^\d+$/.test(r))) {
+        n = void 0;
+        break;
+      }
+      n.push(parseFloat(r));
+    }
+    n && t.setColWidths(n);
+  }
+  return { after: (n) => Z(n, T), node: t };
+}
+function et() {
+  return dt(new tt());
+}
+function U(l) {
+  return l instanceof tt;
+}
+it.tag("table"), it.tag("tr"), it.tag("td", "th");
+export {
+  J as $computeTableMap,
+  E as $computeTableMapSkipCellCheck,
+  M as $createTableCellNode,
+  et as $createTableNode,
+  B as $createTableRowNode,
+  q as $getNodeTriplet,
+  Nt as $getTableCellNodeRect,
+  jt as $getTableNodeFromLexicalNodeOrThrow,
+  ee as $insertTableColumnAtNode,
+  te as $insertTableRowAtNode,
+  At as $isScrollableTablesActive,
+  x as $isTableCellNode,
+  U as $isTableNode,
+  T as $isTableRowNode,
+  $t as $isTableSelection,
+  oe as $mergeCells,
+  y as TableCellHeaderStates,
+  P as TableCellNode,
+  tt as TableNode,
+  j as TableRowNode,
+  xt as getTableElement
+};