spaday-regular-table 0.1.0__py3-none-any.whl

spaday_regular_table/extension/cdn/index.js

@@ -0,0 +1,1202 @@
+// node_modules/.pnpm/regular-table@0.9.0/node_modules/regular-table/dist/esm/regular-table.js
+var G = 0;
+var k = 0;
+var te = performance.now();
+function ie() {
+  let w = performance.now(), e = w - te, t = G, i = k * 1e3 / e, s = 1e3 / t, n = k;
+  return G = 0, k = 0, te = w, { avg: t, real_fps: i, virtual_fps: s, num_frames: n, elapsed: e };
+}
+function se(w) {
+  G = (G * k + w) / (k + 1), k += 1;
+}
+var z = /* @__PURE__ */ new Map();
+async function ne(w) {
+  return await new Promise(requestAnimationFrame), await z.get(w)?.promise;
+}
+async function $(w, e) {
+  if (z.has(w) && (await z.get(w)?.promise, z.has(w))) {
+    await z.get(w)?.promise;
+    return;
+  }
+  z.set(w, Promise.withResolvers());
+  try {
+    return await e();
+  } finally {
+    let t = z.get(w);
+    z.delete(w), t?.resolve(void 0);
+  }
+}
+var me = navigator.userAgent.toLowerCase().indexOf("firefox") > -1;
+var re = me ? 5e6 : 1e7;
+var oe = ":host{position:absolute;top:0px;left:0px;right:0px;bottom:0px;overflow:scroll;overflow-anchor:none;overscroll-behavior:none;-webkit-overflow-scrolling:touch;}div.rt-virtual-panel{position:absolute;top:0;left:0;right:0;pointer-events:none;}div.rt-scroll-table-clip{position:sticky;contain:strict;overflow-anchor:none;width:100%;height:100%;}slot{position:absolute;overflow:hidden;overflow-anchor:none;}";
+var le = ":host ::slotted(table){--regular-table--transform-x:0px;--regular-table--transform-y:0px;--regular-table--clip-x:0px;--regular-table--clip-y:0px;}";
+var be = "--regular-table--clip-x";
+var pe = "--regular-table--clip-y";
+var we = "--regular-table--transform-x";
+var ge = "--regular-table--transform-y";
+var Me = '<div class="rt-virtual-panel"></div><div class="rt-scroll-table-clip"><slot></slot></div>';
+var ve = 1;
+var q = class extends HTMLElement {
+  f;
+  a;
+  i;
+  r;
+  G;
+  q;
+  _;
+  b;
+  p;
+  U;
+  s;
+  e;
+  t;
+  it;
+  st;
+  table_model;
+  n;
+  T;
+  Y;
+  h;
+  o;
+  async draw(e = {}) {
+    return typeof e.throttle < "u" && !e.throttle ? await he.call(this, e) : await $(this, () => he.call(this, e));
+  }
+  async flush() {
+    do
+      await ne(this);
+    while (this.T);
+  }
+  async predraw(e, t, i = {}) {
+    let { invalid_viewport: s = true, preserve_width: n = false, cache: r = false, scroll_left: o = this.scrollLeft, scroll_top: l = this.scrollTop, container_height: u = t, throttle: d } = i, h = () => Object.assign(() => true, { inline: true }), a = async () => (await this.draw({ invalid_viewport: s, preserve_width: n, cache: r, throttle: d }), h());
+    if (!this.t) return console.warn("data listener not configured"), h();
+    let { num_columns: _, num_rows: p } = await this.j(r);
+    if (!this.e.row_height) return await a();
+    let c = p || 0, M = _ || 0, f = this.K(() => e, () => t, () => u);
+    this.r = f;
+    let m = Math.round(this.P(c)), T = Number.isFinite(f.containerHeight) ? Math.min(l, Math.max(0, m - f.containerHeight)) : l, b, v, L = false, y = false;
+    for (let V = 0; V < 2; V++) {
+      let D = this.t.row_headers_length, S = this.Z(c, M, T, o), A = this.Ce(S, M);
+      if (A === void 0) return await a();
+      if (S.end_col = Math.min(M, A + ve), V === 0) {
+        let { invalid_row: C, invalid_column: H } = this.J(S);
+        y = !!(this.p || H), L = y || C || s;
+      } else if (Math.floor(S.start_col) === Math.floor(b.start_col) && Math.ceil(S.end_col) <= Math.ceil(b.end_col)) {
+        S.end_col = b.end_col, b = S;
+        break;
+      }
+      if (b = S, !L) break;
+      v = await this.t.view(Math.floor(b.start_col), Math.floor(b.start_row), Math.ceil(b.end_col), Math.ceil(b.end_row));
+      let g = v.num_row_headers ?? v.row_headers?.[0]?.length ?? 0;
+      if (g === D) break;
+      this.t.row_headers_length = g;
+    }
+    let E = this.t;
+    return Object.assign(() => {
+      if (this.r = f, this.Q(b), this.ee(s, c, M, n), !L || v === void 0) return this.w(b), true;
+      let V = true, D = () => {
+        V && (this.w(b), V = false);
+        for (let A of this.n) A({ detail: this });
+      }, S = this.table_model.draw_sync(f, E, this.U, n, b, M, v, D);
+      return this.te(b, c, M, n, y), E === this.t && (this.p = false), S || this.draw({ invalid_viewport: true }), S;
+    }, { inline: false });
+  }
+  async j(e) {
+    e || this.table_model.Te();
+    let t = await this.table_model.Se(this.t);
+    return this.Y = t.num_columns || 0, this.e.row_height = t.row_height || this.e.row_height, t.num_row_headers !== void 0 && (this.t.row_headers_length = t.num_row_headers), t.num_column_headers !== void 0 && (this.t.column_headers_length = t.num_column_headers), t;
+  }
+  K(e, t, i) {
+    let s = this.i === "none" || this.i === "horizontal";
+    return { width: this.i === "none" || this.i === "vertical" ? 1 / 0 : e(), height: s ? 1 / 0 : t(), containerHeight: s ? 1 / 0 : i() };
+  }
+  ee(e, t, i, s) {
+    this.ie(t), s || this.se(e, i);
+  }
+  te(e, t, i, s, n) {
+    this.w(e);
+    let r = this.e.row_height;
+    this.table_model.header.reset_header_cache(), r !== this.e.row_height && this.ie(t), s || this.se(n, i);
+  }
+  Ce(e, t) {
+    if (this.i === "none" || this.i === "vertical") return e.end_col;
+    let { indices: i, override: s } = this.e, n = (h) => s[h] ?? i[h], r = this.t.row_headers_length, o = 0;
+    for (let h = 0; h < r; h++) {
+      let a = n(h);
+      if (a === void 0) return;
+      o += a;
+    }
+    let l = Math.floor(e.start_col), u = i[r + l] ?? 0, d = l;
+    for (; d < t && o - u <= this.r.width; ) {
+      let h = n(r + d);
+      if (h === void 0) return;
+      o += h, d++;
+    }
+    return d;
+  }
+  Ee() {
+    if (this._ === void 0 || this.b === void 0 || !this.t || this.i === "none" || this.i === "vertical" || this.b >= (this.Y ?? 0)) return;
+    let { indices: e, override: t } = this.e, i = this.t.row_headers_length, s = 0;
+    for (let r = 0; r < i; r++) s += e[r] || 0;
+    for (let r = this._; r < this.b; r++) {
+      let o = i + r, l = t[o] ?? e[o];
+      if (l === void 0) return;
+      s += l;
+    }
+    let n = e[i + this._];
+    s - (n ?? 0) <= this.r.width && this.draw({ invalid_viewport: true });
+  }
+  xe() {
+    if (!this.o) {
+      this.o = [document.createElement("table"), document.createElement("td")], this.o[0].style.visibility = "hidden", this.o[0].style.position = "absolute";
+      let e = document.createElement("tbody"), t = document.createElement("tr");
+      this.o[1].textContent = "X", t.appendChild(this.o[1]), e.appendChild(t), this.o[0].appendChild(e);
+    }
+    this.appendChild(this.o[0]), this.e.row_height = this.o[1].offsetHeight, this.o[0].remove();
+  }
+  Le() {
+    if (this.attachShadow({ mode: "open" }), !this.shadowRoot) return;
+    let e = new CSSStyleSheet();
+    e.replaceSync(oe);
+    let t = new CSSStyleSheet();
+    t.replaceSync(le), this.f = t.cssRules[0], this.shadowRoot.adoptedStyleSheets = [e, t], this.shadowRoot.innerHTML = Me;
+    let [i, s] = this.shadowRoot.children;
+    this.s = s, this.a = i, this.ne();
+  }
+  ne() {
+    this.s && (this.i === "both" || this.i === "vertical" ? this.s.style.top = "0px" : this.s.style.removeProperty("top"), this.i === "both" || this.i === "horizontal" ? this.s.style.left = "0px" : this.s.style.removeProperty("left"), this.i !== "both" ? this.s.style.contain = "none" : this.s.style.removeProperty("contain"));
+  }
+  Z(e, t, i, s) {
+    let { start_row: n, end_row: r } = this.He(e, i), { start_col: o, end_col: l } = this.V(t, s);
+    return { start_col: o, end_col: l, start_row: n, end_row: r };
+  }
+  J({ start_col: e, end_col: t, start_row: i, end_row: s }) {
+    i = Math.floor(i), s = Math.ceil(s), e = Math.floor(e), t = Math.ceil(t);
+    let n = this._ !== e, r = this.G !== i || this.q !== s || this.b !== t;
+    return { invalid_column: n, invalid_row: r };
+  }
+  Q({ start_col: e, end_col: t, start_row: i, end_row: s }) {
+    this._ = Math.floor(e), this.b = Math.ceil(t), this.G = Math.floor(i), this.q = Math.ceil(s);
+  }
+  se(e, t) {
+    if (e) if (this.i === "vertical" || this.i === "none") {
+      let i = 0;
+      for (let s of this.e.indices) i += s || 0;
+      this.a.style.width = i.toPrecision(10) + "px";
+    } else {
+      let i = this.Re(t);
+      if (i !== 0) {
+        let s = this.r.width + i + 2;
+        this.a.style.width = s.toPrecision(10) + "px";
+      } else this.a.style.width = "1px";
+    }
+  }
+  ie(e) {
+    let t = this.P(e);
+    this.a.style.height = `${t.toPrecision(10)}px`;
+  }
+  P(e) {
+    let { row_height: t = 0 } = this.e, i = this.t.column_headers_length * t;
+    return Math.min(re, e * t + i);
+  }
+  w(e) {
+    let t = (this.e.row_height || 0) * (e.start_row % 1) || 0, i = (this.table_model.c || 0) + Math.floor(e.start_col), s = (this.e.indices[i] ?? this.table_model.Ae()) * (e.start_col % 1) || 0;
+    this.f.style.setProperty(be, `${s}px`), this.f.style.setProperty(pe, `${t}px`), this.f.style.setProperty(we, `${-s}px`), this.f.style.setProperty(ge, `${-t}px`);
+  }
+  V(e, t) {
+    if (this.i === "none" || this.i === "vertical") return { start_col: 0, end_col: 1 / 0 };
+    {
+      let i = this.Pe(t), s = this.table_model.num_columns() || Math.min(e, Math.ceil(this.r.width / 60)), n = i + s + 1;
+      return { start_col: i, end_col: n };
+    }
+  }
+  He(e, t) {
+    let { height: i, containerHeight: s } = this.r, n = this.e.row_height || 0, r = this.t.column_headers_length, o = Math.round(this.P(e)), l = Math.max(1, o - s), u = Math.max(Math.ceil(t), 0) / l, d = i / n - r, _ = Math.max(0, (e || 0) - d) * u, p = Math.max(0, Math.min(_ + d, e));
+    return { start_row: _, end_row: p };
+  }
+  Pe(e) {
+    let t = this.t.row_headers_length, i = 0, s = 0, n = 0;
+    for (; s < e; ) {
+      let r = this.e.indices[i + t];
+      n = e - s, i += 1, s += r !== void 0 ? r : 60;
+    }
+    return i += n / (this.e.indices[i + t - 1] || 60), Math.max(0, i - 1);
+  }
+  Ve(e) {
+    let t = 0;
+    if (this.t.row_headers_length > 0) for (let n of this.e.indices.slice(0, this.t.row_headers_length)) t += n || 0;
+    let i = this.t.row_headers_length, s = e;
+    for (; t < this.r.width && s >= 0; ) s--, t += this.e.indices[s + i] || 60;
+    return Math.min(e - 1, s + 1);
+  }
+  Re(e) {
+    let t = this.t.row_headers_length, i = this.Ve(e), s = t, n = 0;
+    for (; s < i + t; ) n += this.e.indices[s] || 60, s++;
+    if (s < this.e.indices.length) {
+      let r = 0, o = this.t.row_headers_length;
+      for (let l = 0; l < o && l < this.e.indices.length; l++) r += this.e.indices[l] || 0;
+      n += Math.max(0, (this.e.indices[s] || 0) - (this.r.width - (r || 0)) || 0);
+    }
+    return n;
+  }
+};
+async function he(w) {
+  let e = performance.now(), { invalid_viewport: t = true, preserve_width: i = false } = w, { num_columns: s, num_rows: n } = await this.j(w.cache);
+  this.e.row_height || this.xe();
+  let r = n || 0, o = s || 0;
+  this.r = this.K(() => this.s.clientWidth, () => this.s.clientHeight, () => this.clientHeight), this.ee(t, r, o, i);
+  let l = this.Z(r, o, this.scrollTop, this.scrollLeft), { invalid_row: u, invalid_column: d } = this.J(l);
+  this.Q(l);
+  let h = this.p || d;
+  if (h || u || t) {
+    let a = true;
+    await this.table_model.draw(this.r, this.t, this.U, i, l, o, async () => {
+      a && (this.w(l), a = false);
+      for (let _ of this.n) await _({ detail: this });
+    }), this.te(l, r, o, i, h), this.p = false;
+  } else this.w(l);
+  se(performance.now() - e);
+}
+var P = /* @__PURE__ */ new WeakMap();
+var B = /* @__PURE__ */ new WeakMap();
+var F = class {
+  e;
+  De;
+  table;
+  cells;
+  rows;
+  constructor(e, t, i) {
+    this.e = e, this.De = t, this.table = i, this.cells = [], this.rows = [];
+  }
+  num_columns() {
+    return this.S(Math.max(0, this.rows.length - 1)).row_container.length;
+  }
+  num_rows() {
+    return this.cells.length;
+  }
+  nt(e, t) {
+    P.set(e, t);
+  }
+  D(e, t) {
+    let i = B.get(e);
+    i !== t && (i !== void 0 && e.classList.remove(`rt-col-${i}`), e.classList.add(`rt-col-${t}`), B.set(e, t));
+  }
+  g(e) {
+    let t = B.get(e);
+    t !== void 0 && (e.classList.remove(`rt-col-${t}`), B.delete(e));
+  }
+  M(e) {
+    if (!e) return { value: void 0 };
+    let t = P.get(e);
+    return t || (t = { value: void 0 }, P.set(e, t)), t;
+  }
+  re(e, t) {
+    let { tr: i, row_container: s } = this.S(e), n = s[t];
+    return n && (i.removeChild(n), s.splice(t, 1, void 0)), n;
+  }
+  v(e, t) {
+    if (!(e < 0 || t < 0)) return this.cells[e]?.[t];
+  }
+  S(e) {
+    let t = this.rows[e];
+    t || (t = this.rows[e] = document.createElement("tr"), this.table.appendChild(t));
+    let i = this.cells[e];
+    return i || (i = this.cells[e] = []), { tr: t, row_container: i };
+  }
+  z(e = "TD", t, i) {
+    let { tr: s, row_container: n } = this.S(t), r = n[i];
+    if (!r) if (i < n.length) {
+      r = n[i] = document.createElement(e);
+      let o = n.slice(i + 1).find((l) => l);
+      s.insertBefore(r, o || null);
+    } else r = n[i] = document.createElement(e), s.appendChild(r);
+    if (r.tagName !== e) {
+      let o = document.createElement(e);
+      s.replaceChild(o, r), this.cells[t].splice(i, 1, o), r = o;
+    }
+    return r;
+  }
+  oe(e) {
+    for (let t = 0; t < this.rows.length; t++) {
+      let i = this.rows[t], s = this.cells[t];
+      s.length = (Array.isArray(e) ? e[t] : e) || 0;
+      let n = this.cells[t].filter((o) => o !== void 0).length, r = [];
+      for (let o = n; o < i.children.length; o++) r.push(i.children[o]);
+      for (let o of r) o.remove();
+    }
+  }
+  E(e) {
+    e = Math.min(e, this.rows.length);
+    let t = [];
+    for (let i = e; i < this.table.children.length; i++) t.push(this.table.children[i]);
+    for (let i of t) i.remove();
+    this.rows.length = e, this.cells.length = e;
+  }
+};
+var ye = false;
+var U = class extends q {
+  le;
+  ae;
+  he;
+  de;
+  L;
+  O;
+  ce;
+  ue;
+  register_listeners() {
+    this.addEventListener("mousedown", this.ze.bind(this)), this.addEventListener("scroll", this.W.bind(this), { passive: true }), this.Oe();
+  }
+  async W(e) {
+    if (e.stopPropagation(), this.ce = this.scrollLeft, this.ue = this.scrollTop, this.T) {
+      this.O = true;
+      return;
+    }
+    this.T = true;
+    let t = this.s.clientWidth, i = this.s.clientHeight, s = this.clientHeight;
+    try {
+      await $(this, async () => {
+        do {
+          this.O = false;
+          let n = await this.predraw(t, i, { invalid_viewport: false, cache: true, throttle: false, container_height: s, scroll_left: this.ce, scroll_top: this.ue });
+          n.inline || (await new Promise(requestAnimationFrame), n());
+        } while (this.O);
+      });
+    } finally {
+      this.T = false;
+    }
+    this.dispatchEvent(new CustomEvent("regular-table-scroll"));
+  }
+  Oe() {
+    this.addEventListener("mousewheel", this.We.bind(this), { passive: true }), ye && (this.addEventListener("touchmove", this.ke.bind(this)), this.addEventListener("touchstart", this.Be.bind(this), { passive: true }));
+  }
+  We(e) {
+    if (!window.hasOwnProperty("safari")) return;
+    let t = e, { clientWidth: i, clientHeight: s, scrollTop: n, scrollLeft: r } = this;
+    t.preventDefault(), t.returnValue = false;
+    let o = Math.max(1, this.a.offsetHeight - s), l = Math.max(1, this.a.offsetWidth - i);
+    this.scrollTop = Math.max(0, Math.min(o, n + t.deltaY)), this.scrollLeft = Math.max(0, Math.min(l, r + t.deltaX)), this.W(t);
+  }
+  ke(e) {
+    e.stopPropagation(), e.preventDefault(), e.returnValue = false;
+    let { clientWidth: t, clientHeight: i } = this, s = Math.max(1, this.a.offsetHeight - i), n = Math.max(1, this.a.offsetWidth - t);
+    this.scrollTop = Math.min(s, (this.le || 0) + ((this.he || 0) - e.touches[0].pageY)), this.scrollLeft = Math.min(n, (this.ae || 0) + ((this.de || 0) - e.touches[0].pageX)), this.W(e);
+  }
+  Be(e) {
+    this.he = e.touches[0].pageY, this.de = e.touches[0].pageX, this.le = this.scrollTop, this.ae = this.scrollLeft;
+  }
+  async Fe(e) {
+    let t = e.target, i = t.classList.contains("rt-column-resize");
+    for (; t.tagName !== "TD" && t.tagName !== "TH"; ) if (t = t.parentElement, !this.contains(t)) return;
+    let s = P.get(t);
+    if (i && s) {
+      e.stopImmediatePropagation(), e.shiftKey ? (this.e.override = {}, this.e.auto = [], this.e.indices = []) : (delete this.e.override[s.size_key], this.e.auto[s.size_key] = void 0, this.e.indices[s.size_key] = void 0), this.table_model.updateColumnWidthStyles({ start_row: 0, end_row: 0, ...this.V(0, this.scrollLeft) }, this.t.row_headers_length);
+      for (let n of e.shiftKey ? [this.table_model.header.cells[this.table_model.header.cells.length - 1], ...this.table_model.body.cells] : this.table_model.body.cells) for (let r of e.shiftKey ? n : [n[s.virtual_x]]) r && (r.classList.remove("rt-cell-clip"), this.h || this.table_model.body.g(r));
+      await this.draw({ cache: true });
+    }
+  }
+  async $e(e) {
+    if (e.button !== 0) return;
+    let t = e.target, i = t.classList.contains("rt-column-resize");
+    for (; t.tagName !== "TD" && t.tagName !== "TH"; ) if (t = t.parentElement, !this.contains(t)) return;
+    let s = P.get(t);
+    i && s && (this.Ne(e, t, s), e.stopImmediatePropagation());
+  }
+  async ze(e) {
+    let t = performance.now();
+    this.L && t - this.L < 500 ? (this.L = t, await this.Fe(e)) : (this.L = t, await this.$e(e));
+  }
+  Ne(e, t, i) {
+    let { virtual_x: s, size_key: n } = i, r = e.pageX, o = (s || 0) + t.colSpan - 1, l = this.table_model.header.get_column_header(o), u = this.e.indices[n || 0] || 0, d = (a) => $(this, async () => await this.Ie(a, l, r, u, n || 0, o)), h = () => {
+      document.removeEventListener("mousemove", d), document.removeEventListener("mouseup", h);
+      let a = this.e.override[n || 0], _ = this.e.indices[n || 0] !== a;
+      this.e.indices[n || 0] = a, _ && this.draw({ cache: true });
+    };
+    document.addEventListener("mousemove", d), document.addEventListener("mouseup", h);
+  }
+  async Ie(e, t, i, s, n, r) {
+    await new Promise(requestAnimationFrame);
+    let o = e.pageX - i, l = Math.max(1, s + o);
+    if (this.e.override[n] = l, o < 0) await this.draw({ preserve_width: true, throttle: false, cache: true });
+    else {
+      this.table_model.updateColumnWidthStyles({ start_row: 0, end_row: 0, ...this.V(0, this.scrollLeft) }, this.t.row_headers_length);
+      let d = (this.e.auto[n] || 0) > l;
+      t.classList.toggle("rt-cell-clip", d);
+      for (let h of this.table_model.body.cells) {
+        let a = h[r];
+        a && (a.classList.toggle("rt-cell-clip", d), this.h || (d ? this.table_model.body.D(a, n) : this.table_model.body.g(a)));
+      }
+    }
+  }
+};
+var de = /* @__PURE__ */ new WeakMap();
+var Y = class extends F {
+  l;
+  d;
+  H;
+  constructor(e, t, i, s) {
+    super(e, t, i), this.l = [], this.d = [], this.H = s;
+  }
+  me(e, t, i) {
+    let s = this.z("TH", t, e[t] || 0);
+    e[t] += 1;
+    let n = de.get(s);
+    if (n !== void 0 && n.value === i && s.lastChild === n.resize && s.firstChild === (i instanceof HTMLElement ? i : n.span)) return s;
+    if (s.removeAttribute("colspan"), s.textContent = "", n === void 0) {
+      let r = document.createElement("span");
+      r.className = "rt-column-resize", n = { value: void 0, span: document.createElement("span"), resize: r }, de.set(s, n);
+    }
+    return i instanceof HTMLElement ? s.appendChild(i) : (n.span.textContent = String(i ?? ""), s.appendChild(n.span)), s.appendChild(n.resize), n.value = i, s;
+  }
+  Xe(e, t, i) {
+    let s = this.M(i);
+    return this.g(i), s.column_header = e, s.value = t, s;
+  }
+  Ge(e, t, i, s) {
+    let n = this.M(i);
+    if (n.column_header = e, n.value = t, n.size_key = Array.isArray(s) ? s[0] : s, !Array.isArray(s) || s.length <= 1) {
+      this.D(i, n.size_key || 0), this.H?.(i);
+      let r = this.e.override[n.size_key || 0], o = this.e.auto[n.size_key || 0] || 0;
+      i.classList.toggle("rt-cell-clip", !!r && o > r);
+    } else this.g(i);
+    return n;
+  }
+  get_column_header(e) {
+    return this.z("TH", this.num_rows() - 1, e);
+  }
+  draw(e, t, i, s, n, r, o, l, u) {
+    let d = t?.length;
+    if (d === 0) return;
+    let h, a, _, p;
+    l = typeof l > "u" ? d - 1 : l;
+    for (let c = 0; c < d; c++) {
+      if (_ = t[c] ? t[c] : "", this.d[c] = this.d[c] || 0, c < l) u && this.l?.[c]?.[0]?.value === _ ? (h = this.l[c][1], this.l[c][2] += 1, i === 1 && (this.l[c][0].row_header_x = Array.isArray(n) ? n[0] : n)) : (this.fe(c), h = this.me(this.d, c, _), a = this.Xe(t, _, h), this.l[c] = [a, h, 1]);
+      else {
+        h = this.me(this.d, c, _), a = this.Ge(e.length > 0 ? e : t, _, h, n), typeof p > "u" && (p = { th: h, metadata: a });
+        for (let [M] of this.l) M.size_key = a.size_key;
+        h.removeAttribute("colspan");
+      }
+      this.S(c).tr.classList.toggle("rt-autosize", c === l), h.classList.toggle("rt-group-corner", s === void 0), a && (a.x = typeof s > "u" ? s : Math.floor(s), a.column_header_y = c, a.x0 = Math.floor(r), a.virtual_x = o, i === 1 ? (a.type = "corner", a.row_header_x = Array.isArray(n) ? n[0] : n) : (a.type = "column_header", delete a.row_header_x));
+    }
+    return this.E(this.d.length), p = p || { th: h, metadata: a }, p;
+  }
+  fe(e) {
+    let t = this.l[e];
+    if (!t) return;
+    let [, i, s] = t;
+    if (s > 1) {
+      let n = String(s);
+      i.getAttribute("colspan") !== n && i.setAttribute("colspan", n);
+    } else i.hasAttribute("colspan") && i.removeAttribute("colspan");
+  }
+  flush_colspans() {
+    for (let e = 0; e < this.l.length; e++) this.fe(e);
+  }
+  clean() {
+    this.flush_colspans(), this.oe(this.d);
+  }
+  reset_header_cache() {
+    this.d = [], this.l = [];
+  }
+};
+var j = class extends F {
+  h;
+  _e(e, t, i, s, { column_name: n }, { ridx_offset: r }, o) {
+    let l = this.z(e, t, s), u = this.M(l);
+    u.y = t + Math.floor(r);
+    let d = u.size_key = o || 0;
+    e === "TD" && (u.column_header = n);
+    let h = this.e.override[d], a = !!h && (this.e.auto[d] || 0) > h;
+    return l.classList.toggle("rt-cell-clip", a), this.h || a ? this.D(l, d) : this.g(l), u.value !== i && (i instanceof HTMLElement ? (l.textContent = "", l.appendChild(i)) : l.textContent = String(i ?? "")), u.value = i, { td: l, metadata: u };
+  }
+  draw(e, t, i, s = false, n, r, o, l) {
+    let { cidx: u, column_data: d, row_headers: h, column_data_listener_metadata: a } = t, { row_height: _ } = i, p, c = [], M = [], f = 0, m = [], T = s ? i.row_headers_length ?? 1 : 1, b = (i.ridx_offset ?? 0) % 1 !== 0 ? 1 : 0, v = false, L = Math.floor(i.ridx_offset), y = Math.ceil(i.y1), E = Math.ceil(i.x1), V = n === void 0 ? n : Math.floor(n), D = r === void 0 ? void 0 : Math.floor(r), S = Math.floor((n ?? 0) - (r ?? 0));
+    for (let g = 0; g < T; g++) {
+      f = 0, v = false;
+      let C = u + g;
+      for (let H of d) {
+        let R;
+        if (s) {
+          let x = H, N = x[g], Q = c[g] || 1, I = this.v(f - Q, C), ce = this.M(I), ee = m[f] || 1, X = this.v(f, C - ee), ue = this.M(X);
+          if (l && X && (ue.value === N || N === void 0) && !X.hasAttribute("rowspan")) {
+            let O = m[f] = ee + 1;
+            X.setAttribute("colspan", String(O)), this.re(f, C);
+          } else if (l && I && ce.value === N && !I.hasAttribute("colspan")) {
+            let O = c[g] = Q + 1;
+            I.setAttribute("rowspan", String(O)), this.re(f, C);
+          } else {
+            R = this._e("TH", f, N, C, t, i, g);
+            let O = R.td, W = R.metadata;
+            O.style.display = "", O.removeAttribute("rowspan"), O.removeAttribute("colspan"), W.type = "row_header", W.row_header = x, W.row_header_x = g, W.y0 = L, W.y1 = y, W.virtual_x = g, D !== void 0 && (W.x0 = D), c[g] = 1, m[f] = 1, M[g] = R;
+          }
+        } else {
+          R = this._e("TD", f, H, u, t, i, o ?? 0);
+          let x = R.metadata;
+          a && (x.user = a[f]), x.type = "body", x.x = V || 0, x.x1 = E, x.row_header = h?.[f] || [], x.y0 = L, x.y1 = y, x.dx = S, x.dy = (x.y ?? 0) - L, x.virtual_x = u, D !== void 0 && (x.x0 = D), M[0] = R;
+        }
+        if (f++, p = R ? R.metadata : p, _ = _ || R?.td.offsetHeight, (f - b) * (_ ?? 0) > e) {
+          v = true;
+          break;
+        }
+      }
+    }
+    let A = v ? f : f + b;
+    if (A > f) {
+      let g = this.rows[f], C = this.rows[f - 1];
+      (!!l && (i.row_headers_length ?? 0) > 0 || !g || !C || g.children.length !== C.children.length || g.querySelector("[colspan],[rowspan]") !== null || C.querySelector("[colspan],[rowspan]") !== null) && (A = f);
+    }
+    return this.E(A), { tds: M, ridx: A, drawn_ridx: f, row_height: _ };
+  }
+  clean({ ridx: e, cidx: t, drawn_ridx: i = e }) {
+    if (this.E(e), this.oe(t), i < this.rows.length) {
+      let s = this.rows[i], n = this.rows[i - 1], r = (h) => h?.children[h.children.length - 1], o = r(s), l = r(n), u = o && P.get(o), d = l && P.get(l);
+      (!u || !d || u.x !== d.x || s.children.length !== n.children.length) && this.E(i);
+    }
+  }
+};
+var Z = class {
+  e;
+  c = 0;
+  header;
+  body;
+  qe(e, t) {
+    let { start_row: i = 0, start_col: s = 0, end_col: n = 0, end_row: r = 0 } = e, o = this.e.indices[(this.c || 0) + Math.floor(e.start_col)] ?? 0;
+    return { viewport_width: 0, selected_id: t, ridx_offset: i, sub_cell_offset: o, x0: s, x1: n, y1: r, row_height: this.e.row_height, row_headers_length: this.c };
+  }
+  Ae() {
+    let e = 0, t = 0;
+    for (let i of this.e.indices) i && (e += i, t++);
+    return t ? e / t : 60;
+  }
+  Ue(e, t, i, s, n, r, o, l, u, d) {
+    let h = [`${t}`], a = [], _ = { column_name: h, cidx: 0, column_data: e, row_headers: e, first_col: true }, p = Math.floor(o), c = this.body.draw(s, _, { ...n, x0: 0 }, true, void 0, void 0, p, d), M = [];
+    for (let m = 0; m < t; m++) {
+      let T = this.header.draw(h, Array(i).fill(""), 1, void 0, m, o, m, l, u);
+      T && M.push(T);
+    }
+    for (let m = 0; m < M.length; m++) {
+      let { th: T } = M[m];
+      n.viewport_width += this.e.indices[m] || T.offsetWidth;
+    }
+    n.row_height = n.row_height || c.row_height;
+    let f = e[0].length;
+    if (!r) for (let m = 0; m < t; m++) {
+      let { td: T, metadata: b } = c.tds[m] || {}, { th: v, metadata: L } = M[m] || {};
+      (T || v) && a.push([v || T, L || b]);
+    }
+    return { cont_body: c, first_col: false, Ye: f, last_cells: a };
+  }
+  je(e, t, i, s, n, r) {
+    let o = 0, l = 0;
+    for (; this.e.indices.length > n + r + o + 1 && l + t.viewport_width < i; ) o++, l += this.e.indices[n + r + o] || 0;
+    if (l + t.viewport_width < i) {
+      let u = Math.min(s, e.start_col + 5);
+      e.end_col = Math.max(1, Math.min(s, u));
+    } else e.end_col = Math.max(1, Math.min(s, e.start_col + o));
+  }
+  Ke(e, t, i, s, n, r, o, l, u, d) {
+    let h = t.column_headers?.[e] || [], a = t.data[e], _ = t.metadata?.[e], p = { column_name: h, cidx: i, column_data: a, column_data_listener_metadata: _, row_headers: t.row_headers, first_col: o }, c = e + s, M = i + Math.floor(s), f = this.header.draw(h, h, void 0, c, M, s, i, l, u), m = this.body.draw(n, p, r, false, c, s, M, d);
+    return { cont_head: f, cont_body: m };
+  }
+  async Ze(e, t, i, s, n, r, o, l, u) {
+    let d = Math.max(s + Math.floor(u), 0), h = structuredClone(e);
+    h.start_col = d, this.je(h, n, r, o, l, u);
+    let a = await t(Math.floor(h.start_col), Math.floor(h.start_row), Math.ceil(h.end_col), Math.ceil(h.end_row)), _, p;
+    if (typeof a.column_header_merge_depth < "u" && (_ = a.column_header_merge_depth), typeof a.merge_headers < "u" && (p = a.merge_headers), a.data.length === 0) return { column_header_merge_depth: _, merge_headers: p };
+    e.end_col = h.start_col + a.data.length;
+    for (let c = 0; c < a.data.length; c++) i.data[s + c] = a.data[c], a.metadata && i.metadata && (i.metadata[s + c] = a.metadata[c]), i.column_headers && a.column_headers?.[c] && (i.column_headers[s + c] = a.column_headers[c]);
+    return { column_header_merge_depth: _, merge_headers: p };
+  }
+  R(e, t) {
+    this.body.clean({ ridx: e?.ridx || 0, cidx: t, drawn_ridx: e?.drawn_ridx ?? e?.ridx ?? 0 }), this.header.clean();
+  }
+};
+var Ce = 0;
+var K = class extends Z {
+  table;
+  u;
+  k = /* @__PURE__ */ new Map();
+  A = /* @__PURE__ */ new Map();
+  B;
+  C;
+  Je;
+  m;
+  be = /* @__PURE__ */ new WeakSet();
+  pe = {};
+  F = false;
+  we;
+  constructor(e, t, i) {
+    super(), this.e = t, this.clear(i);
+    let [s] = i.children, [n, r] = s.children;
+    this.table = s, this.B = `rt-scope-${Ce++}`, this.table.classList.add(this.B), this.m = new ResizeObserver(this.Qe.bind(this)), this.header = new Y(t, e, n, (o) => this.H(o)), this.body = new j(t, e, r);
+  }
+  dispose() {
+    this.m?.disconnect();
+  }
+  H(e) {
+    !this.m || this.be.has(e) || (this.be.add(e), this.m.observe(e));
+  }
+  Qe(e) {
+    if (this.F) {
+      for (let s of e) this.m.unobserve(s.target), this.m.observe(s.target);
+      return;
+    }
+    let t = this.table.currentCSSZoom ?? 1, i = [];
+    for (let s of e) {
+      let n = B.get(s.target);
+      if (n === void 0 || this.e.override[n] !== void 0) continue;
+      let r = s.target.getBoundingClientRect().width / t;
+      r && this.e.indices[n] !== r && i.push([n, r]);
+    }
+    if (i.length > 0) {
+      this.ge();
+      for (let [s, n] of i) this.e.indices[s] = n, this.e.auto[s] = n, this.$(s);
+      this.we?.();
+    }
+  }
+  num_columns() {
+    return this.header.num_columns();
+  }
+  clear(e) {
+    e.innerHTML = '<table cellspacing="0"><thead></thead><tbody></tbody></table>';
+  }
+  N(e) {
+    for (let [, t] of e) {
+      let i = t?.size_key;
+      if (i === void 0) return true;
+      let s = this.e.override[i];
+      if (s !== void 0) {
+        if (this.pe[i] !== s) return true;
+      } else if (!this.e.indices[i]) return true;
+    }
+    return false;
+  }
+  autosize_cells(e, t) {
+    let i = this.table.currentCSSZoom ?? 1, s = [];
+    for (let [n, r] of e) {
+      let o = n.getBoundingClientRect();
+      s.push({ cell: n, metadata: r, box: o });
+    }
+    for (let { metadata: n, box: r } of s) if (this.e.row_height = t ?? Math.max(10, Math.min(this.e.row_height ?? r.height / i, r.height / i)), n?.size_key !== void 0) {
+      this.e.indices[n.size_key] = r.width / i;
+      let o = this.e.override[n.size_key];
+      r.width / i && o === void 0 && (this.e.auto[n.size_key] = r.width / i), o !== void 0 && (this.pe[n.size_key] = o);
+    }
+  }
+  updateColumnWidthStyles(e, t) {
+    if (!this.ge()) return;
+    let i;
+    for (i = 0; i < t; i++) this.$(i);
+    let s = Math.floor(e.start_col);
+    for (let n = i; n < i + (Math.floor(e.end_col) - s); n++) this.$(n + s);
+  }
+  $(e) {
+    let t = this.e.override[e], i = this.e.auto[e];
+    t !== void 0 ? this.Me(e, t, t) : i !== void 0 ? this.Me(e, i, void 0) : this.et(e);
+  }
+  ge() {
+    let e = this.table.getRootNode();
+    if (!(!e || !e.adoptedStyleSheets)) return this.u || (this.u = new CSSStyleSheet()), e.adoptedStyleSheets.includes(this.u) || (e.adoptedStyleSheets = [...e.adoptedStyleSheets, this.u]), this.u;
+  }
+  tt(e) {
+    let t = this.k.get(e);
+    if (t) return t;
+    let i = this.u;
+    if (!i) return;
+    let s = i.cssRules.length;
+    return i.insertRule(`.${this.B} .rt-col-${e}{}`, s), t = i.cssRules[s], this.k.set(e, t), t;
+  }
+  Me(e, t, i) {
+    let s = i === void 0 ? `${t}` : `${t}|${i}`;
+    if (this.A.get(e) === s) return;
+    let n = this.tt(e);
+    n && (n.style.minWidth = `${t}px`, i === void 0 ? n.style.removeProperty("max-width") : n.style.maxWidth = `${i}px`, this.A.set(e, s));
+  }
+  et(e) {
+    if (this.A.get(e) === "") return;
+    let t = this.k.get(e);
+    t && (t.style.removeProperty("min-width"), t.style.removeProperty("max-width")), this.A.set(e, "");
+  }
+  async Se(e) {
+    return this.C ? this.C : await e.view(0, 0, 0, 0);
+  }
+  Te() {
+    this.C = void 0, this.Je = void 0;
+  }
+  async draw(e, t, i, s, n, r, o) {
+    let l = this.C = await t.view(Math.floor(n.start_col), Math.floor(n.start_row), Math.ceil(n.end_col), Math.ceil(n.end_row)), u = this.ve(e, t, i, s, n, r, l);
+    this.F = true;
+    try {
+      let d = u.next();
+      for (; !d.done; ) await o(), d = u.next(d.value === "style" ? void 0 : await d.value.fetch());
+    } finally {
+      this.F = false, u.return(false);
+    }
+  }
+  draw_sync(e, t, i, s, n, r, o, l) {
+    this.C = o;
+    let u = this.ve(e, t, i, s, n, r, o), d = u.next();
+    for (; !d.done; ) d.value === "style" && l(), d = u.next();
+    return d.value;
+  }
+  *ve(e, t, i, s, n, r, o) {
+    let { width: l, height: u } = e, { column_header_merge_depth: d, merge_headers: h = "both" } = o, a = h === "both" || h === "row", _ = h === "both" || h === "column", p = n.start_col ?? 0;
+    if (o.row_headers) {
+      let y = 0;
+      for (let E of o.row_headers) E.length > y && (y = E.length);
+      this.c = y;
+      for (let E = 0; E < o.row_headers.length; E++) o.row_headers[E].length = this.c || 0;
+    }
+    t.row_headers_length = o.num_row_headers ?? o.row_headers?.[0]?.length ?? 0, t.column_headers_length = o.num_column_headers ?? o.column_headers?.[0]?.length ?? 0;
+    let { view: c, row_headers_length: M, column_headers_length: f } = t, m = this.qe(n, i), T, b = 0, v = [], L = true;
+    if (o.row_headers?.length) {
+      let y = this.Ue(o.row_headers, M, f, u, m, s, p, d, _, a);
+      T = y.cont_body, L = y.first_col, b = y.Ye, v = y.last_cells;
+    }
+    try {
+      let y = 0, E = 0, V = r - n.start_col, D = this.e.indices.some(Boolean);
+      for (; y < V; ) {
+        if (!o.data[y]) {
+          this.header.flush_colspans(), this.updateColumnWidthStyles(n, t.row_headers_length);
+          let C = yield { fetch: () => this.Ze(n, c, o, y, m, l, r, b, p) };
+          if (C?.column_header_merge_depth !== void 0 && (d = C.column_header_merge_depth), C?.merge_headers !== void 0 && (h = C.merge_headers), !o.data[y]) return this.R(T, b), this.updateColumnWidthStyles(n, t.row_headers_length), yield "style", this.N(v) && this.autosize_cells(v, this.e.row_height), this.I(m, l);
+        }
+        let { cont_head: S, cont_body: A } = this.Ke(y, o, b, p, u, m, L, d, _, a);
+        if (T = A, L = false, !s) for (let { td: C, metadata: H } of T.tds) v.push([S?.th || C, S?.metadata || H]);
+        let g = this.e.indices[b + Math.floor(p)] || (D ? E : 0);
+        if (!g) {
+          if (g = S?.th?.offsetWidth || 0, !g) for (let { td: C } of T.tds) g += C?.offsetWidth || 0;
+          E = g;
+        }
+        if (m.viewport_width += g, m.row_height = m.row_height || T.row_height, b++, y++, this.I(m, l)) {
+          if (this.R(T, b), this.updateColumnWidthStyles(n, t.row_headers_length), yield "style", s) return true;
+          m.viewport_width = 0, this.N(v) && this.autosize_cells(v, this.e.row_height), E = 0;
+          let C = m.row_headers_length || 0;
+          for (let H = 0; H < v.length; H++) {
+            let R = H < C ? H : Math.floor(p) + H;
+            m.viewport_width += this.e.indices[R] || 0;
+          }
+          if (this.I(m, l)) return true;
+        }
+      }
+      return this.R(T, b), this.updateColumnWidthStyles(n, t.row_headers_length), yield "style", this.N(v) && this.autosize_cells(v, this.e.row_height), true;
+    } finally {
+      this.R(T, b);
+    }
+  }
+  I(e, t) {
+    return e.viewport_width - e.sub_cell_offset > t;
+  }
+};
+var Te = ["both", "horizontal", "vertical", "none"];
+var J = class extends U {
+  X;
+  constructor() {
+    super(), this.e = { auto: [], override: {}, indices: [] }, this.n = [], this.X = false;
+  }
+  connectedCallback() {
+    this.X || (this.Le(), this.register_listeners(), this.setAttribute("tabindex", "0"), this.X = true, this.ye());
+  }
+  ye() {
+    this.table_model?.dispose(), this.table_model = new K(this.s, this.e, this), this.table_model.we = () => this.Ee(), this.table_model.body.h = this.h;
+  }
+  resetAutoSize(e) {
+    (!e || e.auto) && (this.e.auto = []), (!e || e.override) && (this.e.override = {}), (!e || e.indices) && (this.e.indices = []), (!e || e.row_height) && (this.e.row_height = void 0);
+  }
+  saveColumnSizes() {
+    return structuredClone(this.e.override);
+  }
+  restoreColumnSizes(e) {
+    this.e.override = structuredClone(e);
+  }
+  clear() {
+    this.ye();
+  }
+  addStyleListener(e) {
+    this.n.push(e);
+    let t = true;
+    return () => {
+      if (!t) return;
+      t = false, this.n = this.n.slice();
+      let s = this.n.indexOf(e);
+      this.n.splice(s, 1);
+    };
+  }
+  removeStyleListener(e) {
+    let t = this.n.length;
+    this.n = this.n.filter((i) => i !== e), console.assert(this.n.length === t - 1, "No listener found");
+  }
+  getMeta(e) {
+    if (e !== void 0) {
+      if (e instanceof HTMLElement) return P.get(e);
+      if ("row_header_x" in e && e.row_header_x && e.row_header_x >= 0) {
+        if (e.row_header_x < this.t.row_headers_length) {
+          let t = this.table_model.body.v(e.y, e.row_header_x);
+          return this.getMeta(t);
+        }
+      } else if ("column_header_y" in e && e.column_header_y >= 0) {
+        if (e.column_header_y < this.t.column_headers_length) {
+          let t = this.table_model.header.v(e.column_header_y, e.x);
+          return this.getMeta(t);
+        }
+      } else if ("dx" in e) return this.getMeta(this.table_model.body.v(e.dy, e.dx + (this.table_model.c || 0)));
+    }
+  }
+  getDrawFPS() {
+    return ie();
+  }
+  async scrollToCell(e, t) {
+    if (!this.t) {
+      console.warn("data listener not configured");
+      return;
+    }
+    let i = this.e.row_height || 0;
+    this.scrollTop = Math.ceil(i * t);
+    let s = 0;
+    for (; e > 0; ) e--, s += this.e.indices[e + this.t.row_headers_length] || 60;
+    this.scrollLeft = Math.ceil(s), await new Promise(requestAnimationFrame), await this.flush();
+  }
+  setDataListener(e, { virtual_mode: t = "both", preserve_state: i = false, column_classes: s = false } = {}) {
+    console.assert(Te.indexOf(t) > -1, `Unknown virtual_mode ${t};  valid options are "both" (default), "horizontal", "vertical" or "none"`);
+    let n = this.i !== t;
+    i ? (console.assert(!n, "preserve_state called with modified virtual_mode"), this.t.view = e) : (this.i = t, this.h = s, this.table_model && (this.table_model.body.h = s), this.p = true, this.t = { view: e, row_headers_length: 0, column_headers_length: 0 }, n && this.ne());
+  }
+};
+document.createElement("regular-table").constructor === HTMLElement && window.customElements.define("regular-table", J);
+
+// src/ts/index.ts
+function cellValue(value) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  return value === void 0 ? "" : JSON.stringify(value);
+}
+function formattedCell(value, renderer) {
+  if (!renderer?.format) return String(cellValue(value) ?? "");
+  const number = Number(value);
+  if (!Number.isFinite(number)) return String(cellValue(value) ?? "");
+  const digits = Math.max(
+    0,
+    renderer.digits ?? (renderer.format === "percent" ? 2 : 0)
+  );
+  const displayedNumber = renderer.signed ? Math.abs(number) : number;
+  const text = renderer.format === "number" ? displayedNumber.toLocaleString(void 0, {
+    minimumFractionDigits: digits,
+    maximumFractionDigits: digits
+  }) : `${Math.abs(number).toFixed(digits)}%`;
+  if (!renderer.signed || number === 0)
+    return number < 0 && renderer.format === "percent" ? `-${text}` : text;
+  return `${number > 0 ? "+" : "-"}${text}`;
+}
+var SpadayRegularTable = class extends HTMLElement {
+  #table = null;
+  #rows = [];
+  #columns = [];
+  #explicitColumns = false;
+  #virtualMode = "both";
+  #rowHeader = null;
+  #rowHeight;
+  #rowPatch = null;
+  #patchRevision;
+  #streamUrl = null;
+  #stream = null;
+  #drawQueued = false;
+  connectedCallback() {
+    this.style.display ||= "block";
+    this.style.position ||= "relative";
+    this.#ensureTable();
+    this.#connectStream();
+    this.#scheduleDraw(false);
+  }
+  disconnectedCallback() {
+    this.#stream?.close();
+    this.#stream = null;
+  }
+  get rows() {
+    return this.#rows;
+  }
+  set rows(value) {
+    this.#rows = Array.isArray(value) ? value : [];
+    if (!this.#explicitColumns) this.#inferColumns();
+    this.#scheduleDraw(true);
+  }
+  /** Apply a small, serializable batch of row operations from a bound Python model. */
+  get rowPatch() {
+    return this.#rowPatch;
+  }
+  set rowPatch(value) {
+    this.#rowPatch = value;
+    if (!value || !Array.isArray(value.operations)) return;
+    if (value.revision !== void 0 && value.revision === this.#patchRevision)
+      return;
+    if (typeof value.revision === "number" && typeof this.#patchRevision === "number" && value.revision < this.#patchRevision)
+      return;
+    this.#patchRevision = value.revision;
+    for (const operation of value.operations) {
+      if (operation.type === "update")
+        this.updateRow(operation.index, operation.changes);
+      if (operation.type === "insert")
+        this.insertRow(operation.index, operation.row);
+      if (operation.type === "remove") this.removeRow(operation.index);
+    }
+    if (value.operations.length) {
+      this.dispatchEvent(
+        new CustomEvent("row-patch", {
+          bubbles: true,
+          composed: true,
+          detail: value
+        })
+      );
+    }
+  }
+  /** SSE endpoint whose messages are serializable row patches. */
+  get streamUrl() {
+    return this.#streamUrl;
+  }
+  set streamUrl(value) {
+    this.#streamUrl = value || null;
+    this.#connectStream();
+  }
+  /** Merge fields into one row without replacing the full dataset. */
+  updateRow(index, changes) {
+    if (!Number.isInteger(index) || index < 0 || index >= this.#rows.length) {
+      return false;
+    }
+    this.#rows[index] = { ...this.#rows[index], ...changes };
+    this.#rowsMutated(index === 0);
+    return true;
+  }
+  /** Insert one row at an exact virtual index. */
+  insertRow(index, row) {
+    if (!Number.isInteger(index) || index < 0 || index > this.#rows.length) {
+      return false;
+    }
+    this.#rows.splice(index, 0, row);
+    this.#rowsMutated(index === 0);
+    return true;
+  }
+  /** Remove and return one row at an exact virtual index. */
+  removeRow(index) {
+    if (!Number.isInteger(index) || index < 0 || index >= this.#rows.length) {
+      return void 0;
+    }
+    const [removed] = this.#rows.splice(index, 1);
+    this.#rowsMutated(index === 0);
+    return removed;
+  }
+  /** Resolve a rendered cell back to its virtual coordinates and source row. */
+  getMeta(element) {
+    if (!this.#table) return void 0;
+    const cell = element.closest("td,th");
+    if (!(cell instanceof HTMLElement)) return void 0;
+    const meta = this.#table.getMeta(cell);
+    if (!meta) return void 0;
+    return {
+      ...meta,
+      column: meta.x === void 0 ? void 0 : this.#columns[meta.x]?.key,
+      row: meta.y === void 0 ? void 0 : this.#rows[meta.y]
+    };
+  }
+  get columns() {
+    return this.#columns;
+  }
+  set columns(value) {
+    this.#explicitColumns = Array.isArray(value) && value.length > 0;
+    this.#columns = this.#explicitColumns ? value.map(
+      (column) => typeof column === "string" ? { key: column, label: column } : {
+        key: column.key,
+        label: column.label ?? column.key,
+        cell: column.cell
+      }
+    ) : [];
+    if (!this.#explicitColumns) this.#inferColumns();
+    this.#table?.resetAutoSize();
+    this.#scheduleDraw(false);
+  }
+  get virtualMode() {
+    return this.#virtualMode;
+  }
+  set virtualMode(value) {
+    this.#virtualMode = ["both", "horizontal", "vertical", "none"].includes(
+      value
+    ) ? value : "both";
+    this.#configureListener();
+    this.#scheduleDraw(false);
+  }
+  get rowHeader() {
+    return this.#rowHeader;
+  }
+  set rowHeader(value) {
+    this.#rowHeader = value || null;
+    this.#table?.resetAutoSize();
+    this.#scheduleDraw(false);
+  }
+  get rowHeight() {
+    return this.#rowHeight;
+  }
+  set rowHeight(value) {
+    this.#rowHeight = value && value > 0 ? value : void 0;
+    this.#table?.resetAutoSize({
+      row_height: true,
+      auto: false,
+      override: false,
+      indices: false
+    });
+    this.#scheduleDraw(true);
+  }
+  #ensureTable() {
+    if (this.#table) return;
+    this.#table = document.createElement("regular-table");
+    this.#table.addEventListener("click", (event) => this.#emitCell(event));
+    this.#table.addStyleListener(() => {
+      this.#renderCells();
+      this.dispatchEvent(
+        new CustomEvent("table-draw", {
+          bubbles: true,
+          composed: true
+        })
+      );
+    });
+    this.appendChild(this.#table);
+    this.#configureListener();
+  }
+  #connectStream() {
+    this.#stream?.close();
+    this.#stream = null;
+    if (!this.isConnected || !this.#streamUrl) return;
+    this.#stream = new EventSource(this.#streamUrl);
+    this.#stream.addEventListener("message", (event) => {
+      try {
+        const patch = JSON.parse(event.data);
+        if (!patch || !Array.isArray(patch.operations)) throw new Error();
+        this.rowPatch = patch;
+      } catch {
+        this.dispatchEvent(
+          new CustomEvent("row-stream-error", {
+            bubbles: true,
+            composed: true,
+            detail: { data: event.data }
+          })
+        );
+      }
+    });
+  }
+  #inferColumns() {
+    const first = this.#rows[0];
+    this.#columns = first ? Object.keys(first).filter((key) => key !== this.#rowHeader).map((key) => ({ key, label: key })) : [];
+  }
+  #rowsMutated(firstRowChanged) {
+    if (!this.#explicitColumns && firstRowChanged) {
+      this.#inferColumns();
+      this.#table?.resetAutoSize();
+      this.#scheduleDraw(false);
+      return;
+    }
+    this.#scheduleDraw(true);
+  }
+  #configureListener() {
+    if (!this.#table) return;
+    this.#table.setDataListener(
+      async (x0, y0, x1, y1) => this.#slice(x0, y0, x1, y1),
+      { virtual_mode: this.#virtualMode, column_classes: true }
+    );
+  }
+  #slice(x0, y0, x1, y1) {
+    const startRow = Math.max(0, y0);
+    const endRow = Math.min(this.#rows.length, y1);
+    const visibleColumns = this.#columns.slice(x0, x1);
+    const data = visibleColumns.map(({ key }) => {
+      const values = [];
+      for (let y = startRow; y < endRow; y += 1) {
+        values.push(cellValue(this.#rows[y]?.[key]));
+      }
+      return values;
+    });
+    const response = {
+      num_rows: this.#rows.length,
+      num_columns: this.#columns.length,
+      data,
+      column_headers: visibleColumns.map(({ label }) => [label])
+    };
+    if (this.#rowHeader) {
+      response.row_headers = this.#rows.slice(startRow, endRow).map((row) => [cellValue(row[this.#rowHeader])]);
+    }
+    if (this.#rowHeight) response.row_height = this.#rowHeight;
+    return response;
+  }
+  #scheduleDraw(preserveWidth) {
+    if (!this.isConnected || !this.#table || this.#drawQueued) return;
+    this.#drawQueued = true;
+    requestAnimationFrame(() => {
+      this.#drawQueued = false;
+      void this.#table?.draw({ preserve_width: preserveWidth });
+    });
+  }
+  #renderCells() {
+    if (!this.#table) return;
+    for (const cell of this.#table.querySelectorAll("tbody td")) {
+      const element = cell;
+      const priorClasses = element.dataset.spadayClasses?.split(" ").filter(Boolean) ?? [];
+      element.classList.remove(...priorClasses);
+      delete element.dataset.spadayClasses;
+      const meta = this.#table.getMeta(element);
+      if (meta?.x === void 0) continue;
+      const renderer = this.#columns[meta.x]?.cell;
+      if (!renderer) continue;
+      const classes = [renderer.cell_class];
+      const number = Number(meta.value);
+      if (Number.isFinite(number)) {
+        classes.push(
+          number >= 0 ? renderer.positive_class : renderer.negative_class
+        );
+      }
+      const appliedClasses = classes.filter(
+        (name) => Boolean(name)
+      );
+      element.classList.add(...appliedClasses);
+      if (appliedClasses.length)
+        element.dataset.spadayClasses = appliedClasses.join(" ");
+      const text = formattedCell(meta.value, renderer);
+      if (!renderer.tag) {
+        element.textContent = text;
+        continue;
+      }
+      const content = document.createElement(renderer.tag);
+      if (renderer.class) content.className = renderer.class;
+      if (renderer.title) content.title = renderer.title;
+      for (const [name, value] of Object.entries(renderer.attributes ?? {})) {
+        content.setAttribute(name, value);
+      }
+      content.textContent = text;
+      element.replaceChildren(content);
+    }
+  }
+  #emitCell(event) {
+    const target = event.target;
+    if (!(target instanceof HTMLElement)) return;
+    const detail = this.getMeta(target);
+    if (!detail) return;
+    this.dispatchEvent(
+      new CustomEvent("cell-click", {
+        bubbles: true,
+        composed: true,
+        detail
+      })
+    );
+    const renderer = detail.x === void 0 ? void 0 : this.#columns[detail.x]?.cell;
+    if (renderer?.event && renderer.event !== "cell-click") {
+      this.dispatchEvent(
+        new CustomEvent(renderer.event, {
+          bubbles: true,
+          composed: true,
+          detail
+        })
+      );
+    }
+  }
+};
+if (!customElements.get("spaday-regular-table")) {
+  customElements.define("spaday-regular-table", SpadayRegularTable);
+}
+export {
+  SpadayRegularTable
+};
+//# sourceMappingURL=index.js.map