@aintela/chat 0.2.15

package/dist/sortable-table-DgQHxWIh.js

@@ -0,0 +1,819 @@
+var A = Object.defineProperty;
+var h = (a, t) => A(a, "name", { value: t, configurable: !0 });
+const $ = /* @__PURE__ */ h((a) => {
+  if (a[0] == "#")
+    return null;
+  const t = a.split("/");
+  let e = t[t.length - 1];
+  if (e == "" && t.length > 1 && (e = t[t.length - 2]), e == "")
+    return null;
+  const s = e.split("?")[0];
+  return s.startsWith("#") ? s : s.split("#")[0];
+}, "parseAndValidateArtifactUrl"), W = /* @__PURE__ */ h((a, t, e) => {
+  let s = "URL", o = null, i = null, r = null;
+  if (a[0] == "#") {
+    const n = a.indexOf("-"), l = a.slice(1, n);
+    switch (r = a.slice(n + 1), l.toLowerCase()) {
+      case "opendashboard":
+        s = "OpenDashboard";
+        break;
+      case "ask":
+        s = "Question", o = e;
+        break;
+    }
+  } else
+    a.indexOf("http") > -1 ? (s = "URL", i = a) : (a = a.replaceAll("exported/", `exported/${t}/`), s = "Export");
+  return { action: s, url: i, question: o, parameter: r };
+}, "extractLinkAction"), E = /* @__PURE__ */ h((a, t) => Array.from(
+  { length: Math.ceil(a.length / t) },
+  (e, s) => a.slice(s * t, s * t + t)
+), "chunkArray"), q = /* @__PURE__ */ h((a) => {
+  a = a.replaceAll("\\n", `
+`);
+  const t = 90, e = a.split(" "), s = [];
+  let o = !1;
+  for (const i of e)
+    if (i.length > t) {
+      o = !0;
+      const r = [...i], l = E(r, t).map((c) => c.join("")).join(`
+`);
+      s.push(l);
+    } else
+      s.push(i);
+  return o ? s.join(" ") : a;
+}, "splitBigLinesWithSpaces");
+function L(a) {
+  let t = parseFloat(a);
+  if (!isNaN(t))
+    return a = a.replaceAll(/[,\.]/g, ""), parseInt(a);
+  var e = "";
+  for (const o of a)
+    o.match(/[0-9]/) && (e += o);
+  const s = e.length / a.length;
+  return t = parseInt(e), !isNaN(t) && s > 0.5 ? t : NaN;
+}
+h(L, "parseRawNumber");
+function D(a) {
+  if (!a) return { prefix: void 0, suffix: void 0, number: void 0 };
+  const t = /[$%(\w?\$)]/gi, e = /[a-z]?\$/gi;
+  let s = "", o = "";
+  if (a.match(t)) {
+    a.indexOf("%") > -1 && (o = " %");
+    const n = a.match(e);
+    n && (s = n[0] + " ");
+  }
+  let i = parseFloat(a);
+  if (!isNaN(i))
+    return a = a.replaceAll(".", "").replaceAll(",", "."), { prefix: s, suffix: o, number: parseFloat(a) };
+  var r = "";
+  for (const n of a)
+    if (n.match(/[0-9.,]/)) {
+      let l = n;
+      l == "." ? l = "" : l == "," && (l = "."), r += l;
+    }
+  return i = parseFloat(r), isNaN(i) ? { prefix: void 0, suffix: void 0, number: void 0 } : { prefix: s, suffix: o, number: i };
+}
+h(D, "parseKnownNumbers");
+const S = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i, x = /^[0-9a-f]{32}/i;
+function M(a) {
+  if (!a || typeof a != "string")
+    return !1;
+  const t = T(a);
+  return t === null ? !1 : a.startsWith(t);
+}
+h(M, "startsWithInteractionId");
+function T(a) {
+  if (!a || typeof a != "string")
+    return null;
+  const t = a.match(S);
+  if (t)
+    return t[0];
+  const e = a.match(x);
+  return e ? e[0] : null;
+}
+h(T, "extractInteractionId");
+function O(a) {
+  const s = a.replaceAll("_", " ").replaceAll("-", " ").replaceAll("user:", "").replace(/\.[^/.]+$/, ""), o = k(s).trim();
+  return o.length > 1 ? o[0].toUpperCase() + o.slice(1) : o;
+}
+h(O, "prettiffyFileName");
+function F(a) {
+  if (a.length == 0)
+    return a;
+  const t = a.replaceAll("_", " ").replaceAll("-", " ");
+  return t[0].toUpperCase() + t.slice(1);
+}
+h(F, "prettiffyPythonFunctionName");
+function k(a) {
+  const t = a.match(S);
+  if (t)
+    return a.replace(t[0], "");
+  const e = a.match(x);
+  return e ? a.replace(e[0], "") : a;
+}
+h(k, "extractNameFromStringWithInteractionId");
+function z(a) {
+  return !a || typeof a != "string" ? !1 : !!(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(a) || /^[0-9a-f]{32}$/i.test(a));
+}
+h(z, "isValidInteractionId");
+const C = /* @__PURE__ */ new Set(), w = class w {
+  constructor(t = {}) {
+    this.options = {
+      // CSS class for sortable headers
+      sortableClass: "sortable-header",
+      // CSS class for active sort
+      activeSortClass: "active-sort",
+      // CSS class for ascending sort
+      ascendingClass: "sort-asc",
+      // CSS class for descending sort
+      descendingClass: "sort-desc",
+      // Icon for unsorted state
+      unsortedIcon: "unfold_more",
+      // Icon for ascending sort
+      ascendingIcon: "keyboard_arrow_up",
+      // Icon for descending sort
+      descendingIcon: "keyboard_arrow_down",
+      // Whether to sort on first click (true) or cycle through states (false)
+      sortOnFirstClick: !0,
+      // Custom sort functions for specific columns
+      customSorters: {},
+      // Columns to exclude from sorting (0-based index)
+      excludeColumns: [],
+      // Whether to preserve existing icons in headers
+      preserveExistingIcons: !1,
+      // Enable column resizing
+      enableResizing: !0,
+      // Enable column reordering
+      enableReordering: !0,
+      // CSS class for resizable columns
+      resizableClass: "resizable-column",
+      // CSS class for draggable columns
+      draggableClass: "draggable-column",
+      // CSS class for drag placeholder
+      dragPlaceholderClass: "drag-placeholder",
+      // CSS class for drag over state
+      dragOverClass: "drag-over",
+      theme: {
+        palette: {
+          primary: {
+            main: "#999"
+          },
+          background: {
+            default: "#fff",
+            paper: "#555"
+          },
+          text: {
+            primary: "#000",
+            secondary: "#999",
+            disabled: "#BBB"
+          },
+          surface: {
+            panel: "#999",
+            raised: "#999",
+            hover: "#444"
+          },
+          divider: "#999",
+          border: {
+            default: "#999",
+            soft: "#BBB"
+          }
+        },
+        shape: {
+          borderRadius: 7,
+          radiusSm: 1,
+          radiusLg: 10
+        }
+      },
+      ...t
+    }, this.tables = [], this.sortStates = /* @__PURE__ */ new Map(), this.originalColumnOrder = /* @__PURE__ */ new Map(), this.isDragging = !1, this.dragSource = null, this.dragTarget = null, this.charWidth = 0;
+  }
+  /**
+   * Initialize the library - scan document for tables and make them sortable
+   * @param {HTMLElement} container - Optional container element to limit search scope
+   */
+  init(t = null) {
+    this.charWidth == 0 && (this.charWidth = this.getCharWidth(this.options.theme.typography.fontFamily, this.options.theme.typography.fontMono)), this.scanTables(t), this.makeTablesSortable(), this.addStyles();
+  }
+  /**
+   * Scan for tables in the document or within a specific container
+   * @param {HTMLElement} container - Optional container element to limit search scope
+   */
+  scanTables(t = null) {
+    const s = (t || document).querySelectorAll("table");
+    this.tables = Array.from(s);
+  }
+  /**
+   * Make all found tables sortable
+   */
+  makeTablesSortable() {
+    this.tables.forEach((t, e) => {
+      this.makeTableSortable(t, e);
+    });
+  }
+  /**
+   * Make a specific table sortable
+   */
+  makeTableSortable(t, e) {
+    let s = t.querySelector("thead"), o = null, i = [];
+    if (s && (o = s.querySelector("tr"), o && (i = o.querySelectorAll("th"))), i.length === 0) {
+      console.warn("Table has no sortable columns, skipping");
+      return;
+    }
+    const r = !t.hasAttribute("data-sortable-arrived");
+    t.classList.add("sortable-table"), r && (t.setAttribute("data-sortable-arrived", "true"), t.classList.add("sortable-table-arriving"), setTimeout(() => {
+      t.classList.remove("sortable-table-arriving");
+    }, 400)), this.sortStates.set(e, {
+      currentColumn: -1,
+      direction: "none"
+    }), t.hasAttribute("data-original-width") || t.setAttribute("data-original-width", t.getBoundingClientRect().width), this.applyTableStyles(t), this.originalColumnOrder.set(e, Array.from(i).map((n, l) => l)), i.forEach((n, l) => {
+      this.options.excludeColumns.includes(l) || this.makeHeaderSortable(n, t, e, l);
+    }), this.replaceExponentialValues(t), C.add(t);
+  }
+  /**
+   * Replace exponential values in table cells with full numbers
+   * @param {HTMLElement} table - The table to process
+   */
+  replaceExponentialValues(t) {
+    const e = t.querySelector("tbody");
+    if (!e) return;
+    e.querySelectorAll("tr").forEach((o) => {
+      o.querySelectorAll("td, th").forEach((r) => {
+        const l = r.textContent.trim().match(/^([\d,]+\.?\d*)[eE][+-]?(\d+)$/);
+        if (l) {
+          const c = parseFloat(l[1].replace(/,/g, "")), u = parseInt(l[2]), p = c * Math.pow(10, u), d = this.formatNumber(p);
+          r.textContent = d;
+        }
+      });
+    });
+  }
+  /**
+   * Format a number with commas for readability
+   * @param {number} num - The number to format
+   * @returns {string} The formatted number
+   */
+  formatNumber(t) {
+    return t === 0 ? "0" : Math.abs(t) >= 1e12 ? (t / 1e12).toFixed(2) + "T" : Math.abs(t) >= 1e9 ? (t / 1e9).toFixed(2) + "B" : Math.abs(t) >= 1e6 ? (t / 1e6).toFixed(2) + "M" : Math.abs(t) >= 1e3 ? (t / 1e3).toFixed(2) + "K" : Math.abs(t) < 0.01 && t !== 0 ? t.toExponential(2) : t.toLocaleString();
+  }
+  /**
+   * Convert the first row to a header row
+   * @param {HTMLElement} firstRow - The first row to convert
+   * @param {HTMLElement} thead - The thead element to append to
+   * @param {HTMLElement} tbody - The tbody element to remove from
+   * @returns {HTMLElement} The converted header row
+   */
+  convertRowToHeader(t, e, s) {
+    try {
+      const o = t.cloneNode(!0);
+      return o.querySelectorAll("td").forEach((r) => {
+        const n = document.createElement("th");
+        Array.from(r.attributes).forEach((l) => {
+          n.setAttribute(l.name, l.value);
+        }), n.innerHTML = r.innerHTML, n.style.cssText = r.style.cssText, r.parentNode.replaceChild(n, r);
+      }), s && s.contains(t) ? s.removeChild(t) : t.parentNode && t.parentNode.removeChild(t), e.appendChild(o), o;
+    } catch (o) {
+      return console.error("Error converting row to header:", o), null;
+    }
+  }
+  /**
+  * Make a specific header sortable
+  */
+  makeHeaderSortable(t, e, s, o) {
+    t.classList.add(this.options.sortableClass), t.style.cursor = "pointer", (!this.options.preserveExistingIcons || !t.querySelector(".material-icons")) && this.addSortIcon(t), this.options.enableResizing && this.addResizing(t, e, s, o), this.options.enableReordering && this.addDragAndDrop(t, e, s, o);
+    const i = /* @__PURE__ */ h((l) => {
+      l.preventDefault(), this.sortTable(e, s, o);
+    }, "clickListener"), r = /* @__PURE__ */ h((l) => {
+      t.classList.contains(this.options.activeSortClass) || (t.style.background = this.options.theme.palette.surface.hover);
+    }, "mouseEnterListener"), n = /* @__PURE__ */ h((l) => {
+      t.classList.contains(this.options.activeSortClass) || (t.style.background = "");
+    }, "mouseLeaveListener");
+    t.removeEventListener("click", i), t.addEventListener("click", i), t.removeEventListener("mouseenter", r), t.addEventListener("mouseenter", r), t.removeEventListener("mouseleave", n), t.addEventListener("mouseleave", n);
+  }
+  /**
+  * Add sort icon to header
+  */
+  addSortIcon(t) {
+    if (t.querySelector(".sortable-table-icon"))
+      return;
+    const e = document.createElement("i");
+    e.id = "sortable-table-icon", e.className = "material-icons", e.textContent = this.options.unsortedIcon, e.style.marginRight = "2px", e.style.fontSize = "12px", e.style.verticalAlign = "middle", e.style.opacity = "0", t.querySelector(".material-icons") || (t.insertBefore(e, t.firstChild), requestAnimationFrame(() => {
+      requestAnimationFrame(() => {
+        e.style.opacity = "0.6";
+      });
+    }));
+  }
+  /**
+   * Sort table by column
+   */
+  sortTable(t, e, s) {
+    const o = t.querySelector("tbody");
+    if (!o) {
+      console.warn("Table has no tbody element");
+      return;
+    }
+    const i = Array.from(o.querySelectorAll("tr"));
+    if (i.length === 0) {
+      console.warn("Table has no data rows");
+      return;
+    }
+    const r = this.sortStates.get(e);
+    t.querySelector(`thead tr th:nth-child(${s + 1})`);
+    let n;
+    if (this.options.sortOnFirstClick ? n = r.currentColumn === s && r.direction === "asc" ? "desc" : "asc" : r.currentColumn !== s ? n = "asc" : n = r.direction === "none" ? "asc" : r.direction === "asc" ? "desc" : "none", r.currentColumn = s, r.direction = n, this.sortStates.set(e, r), this.updateSortIndicators(t, e, s, n), n === "none") {
+      this.restoreOriginalOrder(t, i);
+      return;
+    }
+    this.sortRows(i, s, n).forEach((c) => o.appendChild(c));
+  }
+  /**
+   * Sort rows based on column data
+   */
+  sortRows(t, e, s) {
+    return t.sort((o, i) => {
+      const r = o.cells[e], n = i.cells[e];
+      if (!r || !n) return 0;
+      const l = this.extractValue(r), c = this.extractValue(n);
+      if (this.options.customSorters[e])
+        return this.options.customSorters[e](l, c, s);
+      const u = this.compareValues(l, c);
+      return s === "asc" ? u : -u;
+    });
+  }
+  /**
+  * Extract sortable value from cell
+  */
+  extractValue(t) {
+    let e = t.textContent.trim(), s = L(e);
+    if (!isNaN(s))
+      return console.log(s), s;
+    if (e = e.replace(/arrow_upward|arrow_downward|remove|keyboard_arrow_up|keyboard_arrow_down|unfold_more|expand_more|expand_less|trending_up|trending_down|↗|↘|↑|↓|→|←/g, "").trim(), /^(N\/A|N\/D|ND|N\/A|n\/a|n\/d|nd|N\/A|N\/D|ND|\s*)$/i.test(e))
+      return -1;
+    const i = e.match(/^([\d,]+\.?\d*)\s*%$/);
+    if (i)
+      return parseFloat(i[1].replace(/,/g, ""));
+    const r = e.match(/^([\d,]+\.?\d*)[eE][+-]?(\d+)$/);
+    if (r) {
+      const u = parseFloat(r[1].replace(/,/g, "")), p = parseInt(r[2]);
+      return u * Math.pow(10, p);
+    }
+    if (e.match(/^[\d,]+\.?\d*[KMB]?$/))
+      return this.parseNumber(e);
+    const l = e.match(/^R\$\s*([\d,]+\.?\d*)$/);
+    if (l)
+      return this.parseNumber(l[1]);
+    const c = new Date(e);
+    return isNaN(c.getTime()) ? e.toLowerCase() : c.getTime();
+  }
+  /**
+   * Compare two values for sorting
+   */
+  compareValues(t, e) {
+    return t == null && e == null ? 0 : t == null ? -1 : e == null ? 1 : typeof t != typeof e ? String(t).localeCompare(String(e)) : typeof t == "number" ? t - e : t instanceof Date ? t.getTime() - e.getTime() : t.localeCompare(e);
+  }
+  /**
+   * Update visual indicators for sort state
+   */
+  updateSortIndicators(t, e, s, o) {
+    const i = t.querySelectorAll("thead tr th");
+    if (i.forEach((r, n) => {
+      r.classList.remove(this.options.activeSortClass, this.options.ascendingClass, this.options.descendingClass);
+      const l = r.querySelector(".material-icons");
+      l && (l.textContent = this.options.unsortedIcon, l.style.opacity = "0.6");
+    }), o !== "none") {
+      const r = i[s];
+      r.classList.add(this.options.activeSortClass);
+      const n = r.querySelector(".material-icons");
+      n && (o === "asc" ? (r.classList.add(this.options.ascendingClass), n.textContent = this.options.ascendingIcon) : (r.classList.add(this.options.descendingClass), n.textContent = this.options.descendingIcon), n.style.opacity = "1");
+    }
+  }
+  /**
+   * Restore original order (when sort direction is 'none')
+   */
+  restoreOriginalOrder(t, e) {
+    const s = t.querySelector("tbody");
+    e.forEach((o) => s.appendChild(o));
+  }
+  /**
+  * Add resizing functionality to a header
+  */
+  addResizing(t, e, s, o) {
+    if (t.classList.add(this.options.resizableClass), t.style.position = "relative", t.querySelector(".resize-handle"))
+      return;
+    const i = document.createElement("div");
+    i.className = "resize-handle", i.style.cssText = `
+            position: absolute;
+            top: 0;
+            right: 0;
+            width: 4px;
+            height: 100%;
+            background: transparent;
+            cursor: col-resize;
+            z-index: 10;
+        `, t.appendChild(i);
+    let r = !1, n = 0, l = 0;
+    i.addEventListener("mousedown", (p) => {
+      p.preventDefault(), p.stopPropagation(), p.stopImmediatePropagation(), r = !0, n = p.clientX, l = t.offsetWidth, t.style.borderRight = "2px solid var(--primary-main, #2196F3)", t.style.background = "var(--background-active, rgba(255, 255, 255, 0.1))", document.addEventListener("mousemove", c), document.addEventListener("mouseup", u), document.body.style.cursor = "col-resize", document.body.style.userSelect = "none";
+    });
+    const c = /* @__PURE__ */ h((p) => {
+      if (!r) return;
+      const d = l + (p.clientX - n);
+      if (d > 30) {
+        t.style.width = d + "px";
+        const m = Array.from(t.parentNode.children).indexOf(t), f = e.querySelector("tbody");
+        f && f.querySelectorAll("tr").forEach((y) => {
+          const b = y.children[m];
+          b && (b.style.width = d + "px");
+        }), this.updateTableWidth(e);
+      }
+    }, "handleResize"), u = /* @__PURE__ */ h(() => {
+      r = !1, t.style.borderRight = "", t.style.background = "", document.removeEventListener("mousemove", c), document.removeEventListener("mouseup", u), document.body.style.cursor = "", document.body.style.userSelect = "";
+    }, "stopResize");
+  }
+  /**
+   * Add drag and drop functionality to a header
+   */
+  addDragAndDrop(t, e, s, o) {
+    if (t.querySelector(".drag-handle"))
+      return;
+    t.classList.add(this.options.draggableClass), t.draggable = !0;
+    const i = e.querySelector("thead tr");
+    t.addEventListener("dragstart", (r) => {
+      this.isDragging = !0;
+      const n = Array.from(i.children).indexOf(t);
+      this.dragSource = { table: e, tableIndex: s, columnIndex: n }, r.dataTransfer.effectAllowed = "move", r.dataTransfer.setData("text/html", t.outerHTML);
+      const l = t.outerHTML;
+      t.style.opacity = "0.5", this.createCustomDragImage(r, t, l);
+    }), t.addEventListener("dragend", (r) => {
+      this.isDragging = !1, this.dragSource = null, t.style.opacity = "", this.clearAllColumnHighlights(e);
+    }), t.addEventListener("dragover", (r) => {
+      r.preventDefault(), r.dataTransfer.dropEffect = "move";
+    }), t.addEventListener("dragenter", (r) => {
+      if (r.preventDefault(), this.dragSource && this.dragSource.tableIndex === s) {
+        const n = Array.from(i.children).indexOf(t);
+        this.dragSource.columnIndex !== n && this.highlightColumn(e, n, !0);
+      }
+    }), t.addEventListener("dragleave", (r) => {
+      if (!t.contains(r.relatedTarget)) {
+        const n = Array.from(i.children).indexOf(t);
+        this.highlightColumn(e, n, !1);
+      }
+    }), t.addEventListener("drop", (r) => {
+      if (r.preventDefault(), this.dragSource && this.dragSource.tableIndex === s) {
+        const n = Array.from(i.children).indexOf(t);
+        this.dragSource.columnIndex !== n && this.reorderColumns(e, s, this.dragSource.columnIndex, n);
+      }
+      this.clearAllColumnHighlights(e);
+    });
+  }
+  /**
+   * Create a custom drag image for better UX
+   */
+  createCustomDragImage(t, e, s) {
+    const o = document.createElement("div");
+    o.style.cssText = `
+            position: absolute;
+            top: -1000px;
+            left: -1000px;
+            background: var(--background-elevated, #333);
+            border: 2px solid var(--primary-main, #2196F3);
+            border-radius: 4px;
+            padding: 8px 12px;
+            font-size: 12px;
+            font-weight: bold;
+            color: var(--text-primary, #fff);
+            white-space: nowrap;
+            max-width: 150px;
+            min-width: 60px;
+            overflow: hidden;
+            text-overflow: ellipsis;
+            box-shadow: 0 4px 12px rgba(0, 0, 0, 0.3);
+            z-index: 10000;
+            pointer-events: none;
+            min-height: 50px;
+            display: flex;
+            align-items: center;
+        `;
+    const i = s;
+    o.innerHTML = `
+            <div style="display: flex; align-items: center; gap: 5px; align-content: center;color:white;">
+                <span style="overflow: hidden; text-overflow: ellipsis">${i}</span>
+                <svg style="fill: grey; font-size: 10px" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="20" height="20" viewBox="0 0 20 20" ><defs><path id="a" d="M0 0h24v24H0V0z"/></defs><clipPath id="b"><use xlink:href="#a" overflow="visible"/></clipPath><path clip-path="url(#b)" d="M9.01 14H2v2h7.01v3L13 15l-3.99-4v3zm5.98-1v-3H22V8h-7.01V5L11 9l3.99 4z"/></svg>
+            </div>        
+        `, document.body.appendChild(o), t.dataTransfer.setDragImage(o, 50, 12), setTimeout(() => {
+      document.body.contains(o) && document.body.removeChild(o);
+    }, 100);
+  }
+  /**
+   * Highlight an entire column during drag operations
+   */
+  highlightColumn(t, e, s) {
+    const o = t.querySelector("thead tr"), i = t.querySelector("tbody");
+    if (!o || !i) return;
+    const r = o.children[e];
+    if (r)
+      if (s) {
+        r.classList.add(this.options.dragOverClass);
+        const n = i.children;
+        for (let l = 0; l < n.length; l++) {
+          const c = n[l].children[e];
+          c && c.classList.add(this.options.dragOverClass);
+        }
+      } else {
+        r.classList.remove(this.options.dragOverClass);
+        const n = i.children;
+        for (let l = 0; l < n.length; l++) {
+          const c = n[l].children[e];
+          c && c.classList.remove(this.options.dragOverClass);
+        }
+      }
+  }
+  /**
+   * Clear all column highlights
+   */
+  clearAllColumnHighlights(t) {
+    const e = t.querySelector("thead tr"), s = t.querySelector("tbody");
+    if (!e || !s) return;
+    const o = e.children;
+    for (let r = 0; r < o.length; r++)
+      o[r].classList.remove(this.options.dragOverClass);
+    const i = s.children;
+    for (let r = 0; r < i.length; r++) {
+      const n = i[r].children;
+      for (let l = 0; l < n.length; l++)
+        n[l].classList.remove(this.options.dragOverClass);
+    }
+  }
+  /**
+   * Reorder columns in a table
+   */
+  reorderColumns(t, e, s, o) {
+    const i = t.querySelector("thead tr"), r = t.querySelector("tbody");
+    if (!i || !r) return;
+    const n = Array.from(i.children), l = Array.from(r.children);
+    if (s < 0 || s >= n.length || o < 0 || o >= n.length) {
+      console.warn("Invalid column indices for reordering");
+      return;
+    }
+    if (s === o)
+      return;
+    const c = n[s], u = n[o];
+    s < o ? i.insertBefore(c, u.nextSibling) : i.insertBefore(c, u), l.forEach((d, m) => {
+      const f = Array.from(d.children), g = f[s], y = f[o];
+      s < o ? d.insertBefore(g, y.nextSibling) : d.insertBefore(g, y);
+    });
+    const p = this.originalColumnOrder.get(e);
+    if (p) {
+      const d = [...p], m = d[s];
+      d.splice(s, 1), d.splice(o, 0, m), this.originalColumnOrder.set(e, d);
+    }
+    this.applyTableStyles(t), this.refreshDragAndDropListeners(t, e);
+  }
+  /**
+   * Refresh drag and drop listeners after column reordering
+   */
+  refreshDragAndDropListeners(t, e) {
+    const s = t.querySelector("thead tr");
+    if (!s) return;
+    Array.from(s.children).forEach((i, r) => {
+      if (i.classList.contains(this.options.draggableClass)) {
+        i.style.opacity = "", i.style.background = "", i.style.borderRight = "";
+        const n = i.cloneNode(!0);
+        i.parentNode.replaceChild(n, i), this.makeHeaderSortable(n, t, e, r);
+      }
+    });
+  }
+  /**
+   * Update table width based on current column widths
+   */
+  updateTableWidth(t) {
+    const e = t.querySelectorAll("th");
+    let s = 0;
+    e.forEach((o) => {
+      const i = o.style.width;
+      if (i) {
+        const r = parseInt(i.replace("px", ""));
+        s += r;
+      } else {
+        const r = o.textContent.replace(/[📊🔍]/g, "").trim();
+        s += r.length;
+      }
+    }), t.style.width = `${s}px`;
+  }
+  /**
+   * Calculate intelligent table width based on header text length
+   */
+  calculateTableWidth(t) {
+    var p;
+    const e = t.getAttribute("data-original-width"), s = e ? parseFloat(e) : 0, o = t.querySelectorAll("th");
+    let i = 0;
+    t.parentElement.clientWidth;
+    const r = [];
+    o.forEach((d) => {
+      let f = d.textContent.replace(/[📊🔍]/g, "").trim().length * this.charWidth + 15;
+      r.push(f), i += f;
+    });
+    const n = t.querySelectorAll("tr"), l = ((p = t.parentElement) == null ? void 0 : p.getBoundingClientRect().width) ?? i;
+    var c = 0;
+    for (const d of n)
+      d.querySelectorAll("td").forEach((f, g) => {
+        const b = f.textContent.length * this.charWidth + 15;
+        b > r[g] && g < r.length && (r[g] = b);
+      });
+    c = r.reduce((d, m) => d += m, 0), o.forEach((d, m) => {
+      if (c > l) {
+        const f = r[m] / c;
+        d.style.width = `${l * f}px`;
+      } else
+        d.style.width = `${r[m]}px`;
+    });
+    let u = 0;
+    return c > l ? u = "100%" : u = `${Math.max(c, s)}px`, u;
+  }
+  /**
+   * Apply inline styles to ensure text clipping and horizontal scroll work
+   */
+  applyTableStyles(t) {
+    const e = this.calculateTableWidth(t);
+    t.style.width = e, t.style.maxWidth = "100%";
+  }
+  getCharWidth(t, e, s) {
+    const i = document.createElement("canvas").getContext("2d");
+    return i.fontFamily = e, i.fontMono = s, i.measureText("A ").width;
+  }
+  /**
+   * Add CSS styles for sortable tables
+   */
+  addStyles() {
+    if (document.getElementById("sortable-table-styles"))
+      return;
+    const t = document.createElement("style");
+    t.id = "sortable-table-styles", t.textContent = `            
+            .${this.options.sortableClass} {
+                position: relative;
+                user-select: none;
+                transition: background-color 0.2s ease;
+            }
+            
+            .${this.options.sortableClass}:hover {
+                background-color: ${this.options.theme.palette.surface.hover} !important;
+            }
+            
+            .${this.options.activeSortClass} {
+                background-color: ${this.options.theme.palette.surface.raised} !important;
+                font-weight: bold;
+            }
+            
+            .${this.options.ascendingClass} {
+                border-bottom: 2px solid var(${this.options.theme.palette.primary.main}, #3a3a3a);
+            }
+            
+            .${this.options.descendingClass} {
+                border-bottom: 2px solid var(${this.options.theme.palette.primary.main}, #3a3a3a);
+            }
+            
+            .${this.options.sortableClass} .material-icons {
+                transition: opacity 0.2s ease, transform 0.2s ease;
+            }
+            
+            .${this.options.activeSortClass} .material-icons {
+                color: var(${this.options.theme.palette.primary.main}, #3a3a3a);
+            }
+            
+            .${this.options.resizableClass} .resize-handle:hover {
+                background-color: var(${this.options.theme.palette.primary.light}, #64B5F6);
+            }
+            
+            .${this.options.draggableClass} {
+                cursor: move;
+                position: relative;
+            }
+            
+            .${this.options.draggableClass}::before {
+                content: '';
+                position: absolute;
+                top: 0;
+                left: -5px;
+                right: -5px;
+                bottom: 0;
+                z-index: 1;
+                pointer-events: none;
+            }
+            
+            .${this.options.dragOverClass} {
+                background-color: rgba(128, 128, 128, 0.2) !important;
+                border: 2px dashed rgba(128, 128, 128, 0.8);
+            }
+            
+            .${this.options.draggableClass}:hover {
+                background-color: var(${this.options.theme.palette.surface.raised}, rgba(100, 181, 246, 0.1)) !important;
+            }
+
+            .sortable-table tbody td {
+                width: auto
+            }            
+
+            .sortable-table {
+                background-color: 'inherit';
+                /* Cross-fade bg/row stripes when the .sortable-table
+                 * class flip lands on a freshly-streamed markdown
+                 * table. Width is NOT animated: column widths set
+                 * by calculateTableWidth can be narrower than the
+                 * content currently fills, so animating them down
+                 * causes mid-transition cell wrap. Snap widths,
+                 * animate only colours. */
+                transition: background-color 280ms ease-out;
+            }
+
+            .sortable-table th {
+                transition: background-color 280ms ease-out;
+            }
+
+            /* Zebra striping for table rows */
+            .sortable-table tbody tr:nth-child(odd) {
+                background-color: ${this.options.theme.palette.background.defalt};
+                color: ${this.options.theme.palette.text.primary};
+            }
+
+            .sortable-table tbody tr:nth-child(even) {
+                background-color: ${this.options.theme.palette.background.defalt};
+                color: ${this.options.theme.palette.text.primary};
+            }
+
+            /* One-shot arrival animation. Applied via a transient
+             * class (added by makeTableSortable on first mount only)
+             * so it does NOT re-fire on every destroy/init cycle.
+             * scaleX with origin top-left gives the "right edge
+             * grows outward" feel the user asked for; the 0.96
+             * start is subtle enough that text compression isn't
+             * obvious. */
+            @keyframes sortable-table-arrive {
+                from {
+                    opacity: 0.35;
+                    transform: scaleX(0.96);
+                    transform-origin: top left;
+                }
+                to {
+                    opacity: 1;
+                    transform: scaleX(1);
+                }
+            }
+
+            .sortable-table-arriving {
+                animation: sortable-table-arrive 320ms cubic-bezier(0.16, 1, 0.3, 1) both;
+            }
+            
+            /* Ensure hover effects work with zebra striping */
+            .sortable-table tbody tr:hover {
+                background-color: ${this.options.theme.palette.surface.hover} !important;
+            }
+            
+            /* Fix table-container overflow issue */
+            .table-container {
+                overflow: auto !important;
+                overflow-x: auto !important;
+                overflow-y: auto !important;
+            }
+        `, document.getElementById("sortable-table-styles") || document.head.appendChild(t);
+  }
+  /**
+   * Destroy the sortable functionality
+   */
+  destroy() {
+    this.tables.forEach((e) => {
+      e.querySelectorAll(`.${this.options.sortableClass}`).forEach((o) => {
+        o.classList.remove(
+          this.options.sortableClass,
+          this.options.activeSortClass,
+          this.options.ascendingClass,
+          this.options.descendingClass
+        ), o.style.cursor = "", o.style.background = "";
+        const i = o.cloneNode(!0);
+        o.parentNode.replaceChild(i, o);
+      });
+    });
+    const t = document.getElementById("sortable-table-styles");
+    t && t.remove(), this.tables = [], this.sortStates.clear(), C.clear();
+  }
+  /**
+   * Refresh the library (useful after DOM changes)
+   */
+  refresh() {
+    this.destroy(), this.init();
+  }
+};
+h(w, "SortableTable");
+let v = w;
+typeof window < "u" && (window.SortableTable = v);
+export {
+  v as S,
+  W as a,
+  D as b,
+  E as c,
+  O as d,
+  T as e,
+  F as f,
+  M as g,
+  z as i,
+  $ as p,
+  q as s
+};
+//# sourceMappingURL=sortable-table-DgQHxWIh.js.map