@smwb/ui-solid 0.12.0 → 0.13.0

package/dist/components/dataDisplay/table/tableColumns.d.ts

@@ -0,0 +1,146 @@
+import { type Accessor, type JSX } from "solid-js";
+/**
+ * The column labels of a stacked table (`Table stackBelow`): its head cells
+ * publish them by column position, and the body cells of each column read them.
+ * A column may have a head cell in several head rows; the lowest row's wins,
+ * whatever order the cells wrote in, so each label is kept by its head row.
+ * Head cells write as they are created, so the body cells created after them —
+ * the body follows the head in the markup — find the labels at once: on the
+ * server too, so the server markup has them, and the client makes the same.
+ */
+export interface ColumnLabels {
+    get: (column: number) => string | undefined;
+    set: (column: number, row: number, owner: symbol, label: string | undefined) => void;
+    /** Drops the label of the column's head cell in `row`, unless another head cell has taken that place since. */
+    remove: (column: number, row: number, owner: symbol) => void;
+}
+export declare function createColumnLabels(): ColumnLabels;
+export interface TableLabelsContextValue {
+    /** Whether the table stacks rows (`stackBelow`). */
+    stacked: Accessor<boolean>;
+    labels: ColumnLabels;
+}
+export declare const TableLabelsContext: import("solid-js").Context<TableLabelsContextValue | undefined>;
+/** Whether the cells around are in the table's head. */
+export declare const TableHeadContext: import("solid-js").Context<boolean>;
+/** Where a cell sits: the column it starts at and its row within the head or body, both from 0. */
+export interface CellPlace {
+    column: number;
+    row: number;
+}
+/** The place of a cell that has none (yet): outside a stacked table, or not drawn. */
+export declare const NOWHERE: CellPlace;
+/**
+ * A cell's place, read by part: a body cell reads only its column, so a row
+ * added or removed above it, which moves it down or up, doesn't run its label
+ * again.
+ */
+export interface CellPlaceAccessor {
+    column: Accessor<number>;
+    row: Accessor<number>;
+}
+/** The place of a cell outside a row. */
+export declare const NO_PLACE: CellPlaceAccessor;
+interface CellRecord {
+    element: Accessor<Element | undefined>;
+    span: Accessor<number>;
+    rowSpan: Accessor<number>;
+    /** Moves the cell to a column; staying in the same one notifies no one. */
+    moveTo: (column: number) => void;
+}
+interface RowRecord {
+    element: Accessor<Element | undefined>;
+    /** The row's cells, in the order they were created. */
+    cells: CellRecord[];
+    /** The row's elements, once its children have resolved (browser only). */
+    items: Accessor<Element[] | undefined>;
+}
+/**
+ * Where creation-order placement stands: after the last cell placed, all the
+ * rows up to and including that cell's row, with the columns their cells take.
+ * Rows and cells are created in markup order, so each new cell continues from
+ * there in O(its row) instead of placing every row above again.
+ */
+interface CreationState {
+    row: RowRecord;
+    /** The row's index among the section's rows. */
+    index: number;
+    /** How many of the row's cells are placed. */
+    placed: number;
+    /** The row each column is taken until (exclusive). */
+    taken: number[];
+    /** The first column after the row's cells placed so far. */
+    column: number;
+    /** `changes` when it was last updated. */
+    changes: number;
+}
+interface CreationPlacer {
+    /** Counts every row and cell added or removed. */
+    changes: number;
+    state: CreationState | undefined;
+}
+export interface TableSectionContextValue {
+    /** The section's rows, in the order they were created. */
+    rows: RowRecord[];
+    placer: CreationPlacer;
+    setItems: (items: Element[]) => void;
+    /** Whether the cells' places come from the section's elements, known once its children have resolved (browser only). */
+    laidOut: Accessor<boolean>;
+    /** The index of a row element among the section's rows; -1 if it isn't one. */
+    rowOf: (tr: Element | undefined) => number;
+    /** Lays the row out again, from the section's next pass on: its cells or their spans changed. */
+    invalidate: (record: RowRecord) => void;
+}
+/** The head or body around the rows. */
+export declare const TableSectionContext: import("solid-js").Context<TableSectionContextValue | undefined>;
+export interface TableRowContextValue {
+    /**
+     * Each cell registers on setup with its element (set once it renders), its
+     * `colSpan` and its `rowSpan`, and gets back its place: the column it starts
+     * at, counted as in HTML, and its row in the head or body. The place follows
+     * the cell when cells or rows are added, removed or reordered.
+     */
+    registerCell: (element: Accessor<Element | undefined>, span: Accessor<number>, rowSpan: Accessor<number>) => CellPlaceAccessor;
+}
+export declare const TableRowContext: import("solid-js").Context<TableRowContextValue | undefined>;
+/** How many columns a cell spans, from its `colSpan`. */
+export declare const cellSpan: (colSpan: number | string | undefined) => number;
+/** How many rows a cell spans, from its `rowSpan`: `0` spans the rest of its head or body, as in HTML. */
+export declare const cellRowSpan: (rowSpan: number | string | undefined) => number;
+/**
+ * A head's or body's row registry. In the browser the cells' places come from
+ * its elements, known once its children have resolved. Before that, and on the
+ * server, they come from the order rows and cells were created in, which is the
+ * markup order, so the first client pass gives the server's places.
+ */
+export declare function createSectionRows(stacked: Accessor<boolean>): TableSectionContextValue;
+/**
+ * A row's cell registry, inside a head or body or on its own. See
+ * `createSectionRows` for how the places are found.
+ */
+export declare function createRowColumns(stacked: Accessor<boolean>, section: TableSectionContextValue | undefined, element: Accessor<Element | undefined>): TableRowContextValue & {
+    setItems: (items: Element[]) => void;
+};
+/**
+ * Children resolved once, with their elements reported in order whenever they
+ * change: a row's cells, or a head's or body's rows. It renders inside the
+ * context provider of its row or section, so the children it creates find it.
+ */
+export declare function ChildElements(props: {
+    children?: JSX.Element;
+    onItems: (items: Element[]) => void;
+}): JSX.Element;
+/**
+ * The text of a header's resolved content, with white space collapsed: strings
+ * and numbers, and the text of elements. On the server elements are markup
+ * strings, read as the browser reads the same markup: tags and comments dropped,
+ * character references decoded. A component that makes its text itself gives
+ * the text it renders; name a column by `TableHeadCell label` where that is not
+ * its name.
+ */
+export declare function textOf(content: unknown): string;
+export declare const useTableLabels: () => TableLabelsContextValue | undefined;
+export declare const useTableSection: () => TableSectionContextValue | undefined;
+export declare const useTableRow: () => TableRowContextValue | undefined;
+export declare const useInTableHead: () => boolean;
+export {};

package/dist/components/dataDisplay/table/tableColumns.js

@@ -0,0 +1,254 @@
+import { isServer as g, memo as N } from "solid-js/web";
+import { createContext as p, useContext as d, createSignal as h, createMemo as O, createComputed as R, untrack as w, children as I, onCleanup as E } from "solid-js";
+import { htmlText as L } from "./tableHtmlText.js";
+function J() {
+  const o = /* @__PURE__ */ new Map(), n = (t) => {
+    let r = o.get(t);
+    return r || (r = h([]), o.set(t, r)), r;
+  };
+  return {
+    get: (t) => {
+      let r;
+      for (const l of n(t)[0]()) (!r || l.row > r.row) && (r = l);
+      return r?.label;
+    },
+    set: (t, r, l, e) => {
+      const [a, f] = n(t), c = w(a), s = c.find((i) => i.row === r);
+      s?.owner === l && s.label === e || f([...c.filter((i) => i.row !== r), {
+        row: r,
+        owner: l,
+        label: e
+      }]);
+    },
+    remove: (t, r, l) => {
+      const [e, a] = n(t), f = w(e);
+      f.find((c) => c.row === r)?.owner === l && a(f.filter((c) => c.row !== r));
+    }
+  };
+}
+const k = p(), H = p(!1), T = {
+  column: -1,
+  row: -1
+}, K = {
+  column: () => -1,
+  row: () => -1
+}, W = p(), j = p(), _ = (o) => Math.max(1, Math.floor(Number(o)) || 1), P = (o) => {
+  if (o === void 0 || o === "") return 1;
+  const n = Math.floor(Number(o));
+  return n === 0 ? 1 / 0 : Math.max(1, n) || 1;
+}, Y = (o) => o.tagName === "TR", M = [];
+function q(o, n) {
+  const t = Math.max(o.length, n.length);
+  for (let r = 0; r < t; r++) if ((o[r] ?? 0) !== (n[r] ?? 0)) return !1;
+  return !0;
+}
+function A(o, n, t) {
+  const r = /* @__PURE__ */ new Map();
+  for (const c of n?.cells ?? []) {
+    const s = c.element();
+    s && !r.has(s) && r.set(s, c);
+  }
+  const l = t.slice(), e = n ? /* @__PURE__ */ new Map() : void 0;
+  let a = 0;
+  for (const c of n?.items() ?? Array.from(o.children)) {
+    for (; (l[a] ?? 0) > 0; ) a++;
+    const s = r.get(c), i = c, u = s ? s.span() : _(i.colSpan), x = s ? s.rowSpan() : P(i.rowSpan);
+    for (let m = 0; m < u; m++) l[a + m] = x;
+    e?.set(c, a), a += u;
+  }
+  if (n && e)
+    for (const c of n.cells) {
+      let s;
+      for (let i = c.element(); i && s === void 0; i = i.parentElement ?? void 0)
+        s = e.get(i);
+      c.moveTo(s ?? -1);
+    }
+  const f = l.map((c) => Math.max(0, c - 1));
+  for (; f.length && !f[f.length - 1]; ) f.pop();
+  return {
+    carry: t,
+    next: f
+  };
+}
+function z() {
+  let o = [], n = !1;
+  const t = /* @__PURE__ */ new WeakMap(), r = /* @__PURE__ */ new WeakMap();
+  return {
+    /** The row's cells or their spans changed: it is laid out again in the next pass. */
+    invalidate: (l) => {
+      const e = l.element();
+      e && (r.set(e, l), t.delete(e) && (n = !0));
+    },
+    reset: () => {
+      o = [];
+    },
+    run: (l) => {
+      let e = 0;
+      for (; e < l.length && l[e] === o[e] && (!n || t.has(l[e])); ) e++;
+      if (n = !1, e === l.length && e === o.length) return;
+      let a = e ? t.get(l[e - 1])?.next ?? M : M;
+      for (let f = e; f < l.length; f++) {
+        const c = l[f];
+        let s = t.get(c);
+        (!s || !q(s.carry, a)) && (s = A(c, r.get(c), a), t.set(c, s)), a = s.next;
+      }
+      if (e < o.length) {
+        const f = new Set(l);
+        for (let c = e; c < o.length; c++) {
+          const s = o[c];
+          f.has(s) || (t.delete(s), r.get(s)?.cells.forEach((i) => i.moveTo(-1)));
+        }
+      }
+      o = l;
+    }
+  };
+}
+function y(o, n, t) {
+  const {
+    index: r,
+    taken: l
+  } = o;
+  let e = o.column;
+  for (; (l[e] ?? 0) > r; ) e++;
+  const a = n.span(), f = r + n.rowSpan();
+  for (let c = 0; c < a; c++) l[e + c] = f;
+  return o.column = e + a, o.placed++, o.changes = t, {
+    column: e,
+    row: r
+  };
+}
+function B(o, n, t, r) {
+  const {
+    state: l,
+    changes: e
+  } = n;
+  if (l && t.cells[t.cells.length - 1] === r) {
+    if (l.row === t && e === l.changes + 1 && t.cells.length === l.placed + 1)
+      return y(l, r, e);
+    const s = o.length - 1;
+    if (o[s] === t && t.cells.length === 1 && o[l.index] === l.row && e === l.changes + (s - l.index) + 1)
+      return l.row = t, l.index = s, l.placed = 0, l.column = 0, y(l, r, e);
+  }
+  const a = o.indexOf(t);
+  if (a < 0) return T;
+  const f = {
+    row: t,
+    index: a,
+    placed: 0,
+    taken: [],
+    column: 0,
+    changes: e
+  };
+  let c = T;
+  for (let s = 0; s <= a; s++) {
+    f.index = s, f.placed = 0, f.column = 0;
+    for (const i of o[s].cells) {
+      const u = y(f, i, e);
+      i === r && s === a && (c = u);
+    }
+  }
+  return f.row = t, n.state = f, c;
+}
+function Q(o) {
+  const [n, t] = h(), [r, l] = h(0), e = [], a = O(() => o() ? n()?.filter(Y) : void 0), f = O(() => !!a()), c = z();
+  return g || R(() => {
+    r();
+    const s = a();
+    s ? w(() => c.run(s)) : c.reset();
+  }), {
+    rows: e,
+    placer: {
+      changes: 0,
+      state: void 0
+    },
+    setItems: t,
+    laidOut: f,
+    rowOf: (s) => s ? a()?.indexOf(s) ?? -1 : -1,
+    invalidate: (s) => {
+      c.invalidate(s), l((i) => i + 1);
+    }
+  };
+}
+function U(o, n, t) {
+  const [r, l] = h(), e = {
+    element: t,
+    cells: [],
+    items: r
+  }, a = n ? n.placer : {
+    changes: 0,
+    state: void 0
+  }, f = [e];
+  n && (n.rows.push(e), a.changes++, E(() => {
+    n.rows.splice(n.rows.indexOf(e) >>> 0, 1), a.changes++;
+  }));
+  const c = n ? n.laidOut : O(() => o() && r() !== void 0 && !!t()), s = n ? n.rowOf : (i) => i && i === t() ? 0 : -1;
+  return g || R(() => {
+    r();
+    for (const i of e.cells)
+      i.element(), i.span(), i.rowSpan();
+    if (n) n.invalidate(e);
+    else {
+      const i = c() && t();
+      i && w(() => A(i, e, M));
+    }
+  }), {
+    setItems: l,
+    registerCell: (i, u, x) => {
+      const [m, S] = h(-1), C = {
+        element: i,
+        span: u,
+        rowSpan: x,
+        moveTo: S
+      };
+      e.cells.push(C), a.changes++, E(() => {
+        e.cells.splice(e.cells.indexOf(C) >>> 0, 1), a.changes++;
+      });
+      let b = T;
+      w(() => {
+        o() && !c() && (b = B(n ? n.rows : f, a, e, C), S(b.column));
+      });
+      const v = () => o() ? m() : -1;
+      return {
+        column: v,
+        row: () => v() < 0 ? -1 : c() ? s(t()) : b.row
+      };
+    }
+  };
+}
+function V(o) {
+  const n = I(() => o.children);
+  return g || R(() => o.onItems(n.toArray().filter((t) => t instanceof Element))), N(n);
+}
+function X(o) {
+  const n = (t) => {
+    if (typeof t == "string" || typeof t == "number") return String(t);
+    if (Array.isArray(t)) return t.map(n).join("");
+    if (t && typeof t == "object") {
+      if ("textContent" in t) return t.textContent ?? "";
+      if (g && "t" in t && typeof t.t == "string") return L(t.t);
+    }
+    return "";
+  };
+  return n(o).replace(/\s+/g, " ").trim();
+}
+const Z = () => d(k), $ = () => d(W), tt = () => d(j), et = () => d(H);
+export {
+  V as ChildElements,
+  T as NOWHERE,
+  K as NO_PLACE,
+  H as TableHeadContext,
+  k as TableLabelsContext,
+  j as TableRowContext,
+  W as TableSectionContext,
+  P as cellRowSpan,
+  _ as cellSpan,
+  J as createColumnLabels,
+  U as createRowColumns,
+  Q as createSectionRows,
+  X as textOf,
+  et as useInTableHead,
+  Z as useTableLabels,
+  tt as useTableRow,
+  $ as useTableSection
+};
+//# sourceMappingURL=tableColumns.js.map

package/dist/components/dataDisplay/table/tableColumns.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tableColumns.js","sources":["../../../../src/components/dataDisplay/table/tableColumns.tsx"],"sourcesContent":["import {\n  type Accessor,\n  type JSX,\n  type Signal,\n  children,\n  createComputed,\n  createContext,\n  createMemo,\n  createSignal,\n  onCleanup,\n  untrack,\n  useContext,\n} from \"solid-js\";\nimport { isServer } from \"solid-js/web\";\nimport { htmlText } from \"./tableHtmlText\";\n\ninterface ColumnLabel {\n  /** The head row of the cell that gives the label. */\n  row: number;\n  owner: symbol;\n  label: string | undefined;\n}\n\n/**\n * The column labels of a stacked table (`Table stackBelow`): its head cells\n * publish them by column position, and the body cells of each column read them.\n * A column may have a head cell in several head rows; the lowest row's wins,\n * whatever order the cells wrote in, so each label is kept by its head row.\n * Head cells write as they are created, so the body cells created after them —\n * the body follows the head in the markup — find the labels at once: on the\n * server too, so the server markup has them, and the client makes the same.\n */\nexport interface ColumnLabels {\n  get: (column: number) => string | undefined;\n  set: (column: number, row: number, owner: symbol, label: string | undefined) => void;\n  /** Drops the label of the column's head cell in `row`, unless another head cell has taken that place since. */\n  remove: (column: number, row: number, owner: symbol) => void;\n}\n\nexport function createColumnLabels(): ColumnLabels {\n  const columns = new Map<number, Signal<ColumnLabel[]>>();\n  const slot = (column: number): Signal<ColumnLabel[]> => {\n    let signal = columns.get(column);\n    if (!signal) {\n      signal = createSignal<ColumnLabel[]>([]);\n      columns.set(column, signal);\n    }\n    return signal;\n  };\n  return {\n    get: (column) => {\n      let lowest: ColumnLabel | undefined;\n      for (const entry of slot(column)[0]()) if (!lowest || entry.row > lowest.row) lowest = entry;\n      return lowest?.label;\n    },\n    set: (column, row, owner, label) => {\n      const [read, write] = slot(column);\n      const list = untrack(read);\n      const prev = list.find((entry) => entry.row === row);\n      if (prev?.owner === owner && prev.label === label) return;\n      write([...list.filter((entry) => entry.row !== row), { row, owner, label }]);\n    },\n    remove: (column, row, owner) => {\n      const [read, write] = slot(column);\n      const list = untrack(read);\n      if (list.find((entry) => entry.row === row)?.owner !== owner) return;\n      write(list.filter((entry) => entry.row !== row));\n    },\n  };\n}\n\nexport interface TableLabelsContextValue {\n  /** Whether the table stacks rows (`stackBelow`). */\n  stacked: Accessor<boolean>;\n  labels: ColumnLabels;\n}\n\nexport const TableLabelsContext = createContext<TableLabelsContextValue>();\n\n/** Whether the cells around are in the table's head. */\nexport const TableHeadContext = createContext(false);\n\n/** Where a cell sits: the column it starts at and its row within the head or body, both from 0. */\nexport interface CellPlace {\n  column: number;\n  row: number;\n}\n\n/** The place of a cell that has none (yet): outside a stacked table, or not drawn. */\nexport const NOWHERE: CellPlace = { column: -1, row: -1 };\n\n/**\n * A cell's place, read by part: a body cell reads only its column, so a row\n * added or removed above it, which moves it down or up, doesn't run its label\n * again.\n */\nexport interface CellPlaceAccessor {\n  column: Accessor<number>;\n  row: Accessor<number>;\n}\n\n/** The place of a cell outside a row. */\nexport const NO_PLACE: CellPlaceAccessor = { column: () => -1, row: () => -1 };\n\ninterface CellRecord {\n  element: Accessor<Element | undefined>;\n  span: Accessor<number>;\n  rowSpan: Accessor<number>;\n  /** Moves the cell to a column; staying in the same one notifies no one. */\n  moveTo: (column: number) => void;\n}\n\ninterface RowRecord {\n  element: Accessor<Element | undefined>;\n  /** The row's cells, in the order they were created. */\n  cells: CellRecord[];\n  /** The row's elements, once its children have resolved (browser only). */\n  items: Accessor<Element[] | undefined>;\n}\n\n/**\n * Where creation-order placement stands: after the last cell placed, all the\n * rows up to and including that cell's row, with the columns their cells take.\n * Rows and cells are created in markup order, so each new cell continues from\n * there in O(its row) instead of placing every row above again.\n */\ninterface CreationState {\n  row: RowRecord;\n  /** The row's index among the section's rows. */\n  index: number;\n  /** How many of the row's cells are placed. */\n  placed: number;\n  /** The row each column is taken until (exclusive). */\n  taken: number[];\n  /** The first column after the row's cells placed so far. */\n  column: number;\n  /** `changes` when it was last updated. */\n  changes: number;\n}\n\ninterface CreationPlacer {\n  /** Counts every row and cell added or removed. */\n  changes: number;\n  state: CreationState | undefined;\n}\n\nexport interface TableSectionContextValue {\n  /** The section's rows, in the order they were created. */\n  rows: RowRecord[];\n  placer: CreationPlacer;\n  setItems: (items: Element[]) => void;\n  /** Whether the cells' places come from the section's elements, known once its children have resolved (browser only). */\n  laidOut: Accessor<boolean>;\n  /** The index of a row element among the section's rows; -1 if it isn't one. */\n  rowOf: (tr: Element | undefined) => number;\n  /** Lays the row out again, from the section's next pass on: its cells or their spans changed. */\n  invalidate: (record: RowRecord) => void;\n}\n\n/** The head or body around the rows. */\nexport const TableSectionContext = createContext<TableSectionContextValue>();\n\nexport interface TableRowContextValue {\n  /**\n   * Each cell registers on setup with its element (set once it renders), its\n   * `colSpan` and its `rowSpan`, and gets back its place: the column it starts\n   * at, counted as in HTML, and its row in the head or body. The place follows\n   * the cell when cells or rows are added, removed or reordered.\n   */\n  registerCell: (\n    element: Accessor<Element | undefined>,\n    span: Accessor<number>,\n    rowSpan: Accessor<number>\n  ) => CellPlaceAccessor;\n}\n\nexport const TableRowContext = createContext<TableRowContextValue>();\n\n/** How many columns a cell spans, from its `colSpan`. */\nexport const cellSpan = (colSpan: number | string | undefined): number => Math.max(1, Math.floor(Number(colSpan)) || 1);\n\n/** How many rows a cell spans, from its `rowSpan`: `0` spans the rest of its head or body, as in HTML. */\nexport const cellRowSpan = (rowSpan: number | string | undefined): number => {\n  if (rowSpan === undefined || rowSpan === \"\") return 1;\n  const rows = Math.floor(Number(rowSpan));\n  return rows === 0 ? Infinity : Math.max(1, rows) || 1;\n};\n\nconst isRow = (element: Element): boolean => element.tagName === \"TR\";\n\n/**\n * The columns that cells of the rows above still take at a row: for each\n * column, in how many rows from this one on it is free again (0 or missing:\n * free here). It doesn't depend on the row's index, so a row keeps its\n * columns when rows are added or removed above it and what reaches it from\n * above stays the same.\n */\ntype Carry = readonly number[];\n\nconst NO_CARRY: Carry = [];\n\nfunction sameCarry(a: Carry, b: Carry): boolean {\n  const length = Math.max(a.length, b.length);\n  for (let i = 0; i < length; i++) if ((a[i] ?? 0) !== (b[i] ?? 0)) return false;\n  return true;\n}\n\n/** A row as last laid out: what reached it from above, and what it passes down. */\ninterface RowLayout {\n  carry: Carry;\n  next: Carry;\n}\n\n/**\n * Places a row's cells as HTML does: each starts at the first column from the\n * left not taken by an earlier cell of the row or by a cell of a row above\n * that spans down into it. A registered row gives its resolved cells, with a\n * registered cell's own spans, and moves its cells there; any other row gives\n * its elements and their attributes. A registered cell not drawn in the row\n * goes nowhere.\n */\nfunction layOutRow(tr: Element, record: RowRecord | undefined, carry: Carry): RowLayout {\n  const cells = new Map<Element, CellRecord>();\n  for (const cell of record?.cells ?? []) {\n    const at = cell.element();\n    if (at && !cells.has(at)) cells.set(at, cell);\n  }\n  // The rows each column stays taken from this one on: 1 for this row only.\n  const taken = carry.slice();\n  const columns = record ? new Map<Element, number>() : undefined;\n  let column = 0;\n  for (const item of record?.items() ?? Array.from(tr.children)) {\n    while ((taken[column] ?? 0) > 0) column++;\n    const cell = cells.get(item);\n    const td = item as HTMLTableCellElement;\n    const span = cell ? cell.span() : cellSpan(td.colSpan);\n    const rows = cell ? cell.rowSpan() : cellRowSpan(td.rowSpan);\n    for (let i = 0; i < span; i++) taken[column + i] = rows;\n    columns?.set(item, column);\n    column += span;\n  }\n  if (record && columns) {\n    for (const cell of record.cells) {\n      // The cell's element, or the drawn element around it.\n      let at: number | undefined;\n      for (let element = cell.element(); element && at === undefined; element = element.parentElement ?? undefined) {\n        at = columns.get(element);\n      }\n      cell.moveTo(at ?? -1);\n    }\n  }\n  const next = taken.map((rows) => Math.max(0, rows - 1));\n  while (next.length && !next[next.length - 1]) next.pop();\n  return { carry, next };\n}\n\n/**\n * Lays out a head's or body's rows (its `<tr>` elements, in order) after a\n * change, from the first row that differs from the last pass, or that changed\n * itself. A row whose carry from above is the one it had keeps its columns, so\n * a row added, removed or moved costs its own cells plus a check of the rows\n * after it, not a pass over every cell. A registered row no longer drawn has\n * its cells moved nowhere.\n */\nfunction createLayout() {\n  let last: Element[] = [];\n  // Whether a row drawn in the last pass changed since.\n  let changed = false;\n  const done = new WeakMap<Element, RowLayout>();\n  const owners = new WeakMap<Element, RowRecord>();\n  return {\n    /** The row's cells or their spans changed: it is laid out again in the next pass. */\n    invalidate: (record: RowRecord) => {\n      const tr = record.element();\n      if (!tr) return;\n      owners.set(tr, record);\n      if (done.delete(tr)) changed = true;\n    },\n    reset: () => {\n      last = [];\n    },\n    run: (trs: Element[]) => {\n      let start = 0;\n      while (start < trs.length && trs[start] === last[start] && (!changed || done.has(trs[start]!))) start++;\n      changed = false;\n      if (start === trs.length && start === last.length) return;\n      let carry = start ? (done.get(trs[start - 1]!)?.next ?? NO_CARRY) : NO_CARRY;\n      for (let row = start; row < trs.length; row++) {\n        const tr = trs[row]!;\n        let laid = done.get(tr);\n        if (!laid || !sameCarry(laid.carry, carry)) {\n          laid = layOutRow(tr, owners.get(tr), carry);\n          done.set(tr, laid);\n        }\n        carry = laid.next;\n      }\n      if (start < last.length) {\n        const drawn = new Set(trs);\n        for (let row = start; row < last.length; row++) {\n          const tr = last[row]!;\n          if (drawn.has(tr)) continue;\n          done.delete(tr);\n          owners.get(tr)?.cells.forEach((cell) => cell.moveTo(-1));\n        }\n      }\n      last = trs;\n    },\n  };\n}\n\n/** Takes the next column free in the state's row for the cell, and returns its place. */\nfunction advance(state: CreationState, cell: CellRecord, changes: number): CellPlace {\n  const { index, taken } = state;\n  let column = state.column;\n  while ((taken[column] ?? 0) > index) column++;\n  const span = cell.span();\n  const until = index + cell.rowSpan();\n  for (let i = 0; i < span; i++) taken[column + i] = until;\n  state.column = column + span;\n  state.placed++;\n  state.changes = changes;\n  return { column, row: index };\n}\n\n/**\n * A cell's place from the order rows and cells were created in. The cell just\n * created continues from where the last one was placed: in its row, or in a\n * row created after it. Anything else (a cell added to an earlier row, a row or\n * cell removed) places the rows up to the cell's again.\n */\nfunction placeCreated(rows: RowRecord[], placer: CreationPlacer, record: RowRecord, cell: CellRecord): CellPlace {\n  const { state, changes } = placer;\n  if (state && record.cells[record.cells.length - 1] === cell) {\n    // Only this cell was added since, to the row last placed in.\n    if (state.row === record && changes === state.changes + 1 && record.cells.length === state.placed + 1) {\n      return advance(state, cell, changes);\n    }\n    // Only rows were added since, the last of them this cell's, and then this cell.\n    const index = rows.length - 1;\n    if (\n      rows[index] === record &&\n      record.cells.length === 1 &&\n      rows[state.index] === state.row &&\n      changes === state.changes + (index - state.index) + 1\n    ) {\n      state.row = record;\n      state.index = index;\n      state.placed = 0;\n      state.column = 0;\n      return advance(state, cell, changes);\n    }\n  }\n  const index = rows.indexOf(record);\n  if (index < 0) return NOWHERE;\n  const next: CreationState = { row: record, index, placed: 0, taken: [], column: 0, changes };\n  let place = NOWHERE;\n  for (let row = 0; row <= index; row++) {\n    next.index = row;\n    next.placed = 0;\n    next.column = 0;\n    for (const each of rows[row]!.cells) {\n      const at = advance(next, each, changes);\n      if (each === cell && row === index) place = at;\n    }\n  }\n  next.row = record;\n  placer.state = next;\n  return place;\n}\n\n/**\n * A head's or body's row registry. In the browser the cells' places come from\n * its elements, known once its children have resolved. Before that, and on the\n * server, they come from the order rows and cells were created in, which is the\n * markup order, so the first client pass gives the server's places.\n */\nexport function createSectionRows(stacked: Accessor<boolean>): TableSectionContextValue {\n  const [items, setItems] = createSignal<Element[]>();\n  const [changed, setChanged] = createSignal(0);\n  const rows: RowRecord[] = [];\n  const trs = createMemo(() => (stacked() ? items()?.filter(isRow) : undefined));\n  const laidOut = createMemo(() => !!trs());\n  const layout = createLayout();\n  if (!isServer) {\n    createComputed(() => {\n      changed();\n      const list = trs();\n      if (list) untrack(() => layout.run(list));\n      else layout.reset();\n    });\n  }\n  return {\n    rows,\n    placer: { changes: 0, state: undefined },\n    setItems,\n    laidOut,\n    rowOf: (tr) => (tr ? (trs()?.indexOf(tr) ?? -1) : -1),\n    invalidate: (record) => {\n      layout.invalidate(record);\n      setChanged((count) => count + 1);\n    },\n  };\n}\n\n/**\n * A row's cell registry, inside a head or body or on its own. See\n * `createSectionRows` for how the places are found.\n */\nexport function createRowColumns(\n  stacked: Accessor<boolean>,\n  section: TableSectionContextValue | undefined,\n  element: Accessor<Element | undefined>\n): TableRowContextValue & { setItems: (items: Element[]) => void } {\n  const [items, setItems] = createSignal<Element[]>();\n  const record: RowRecord = { element, cells: [], items };\n  const placer: CreationPlacer = section ? section.placer : { changes: 0, state: undefined };\n  const ownRows = [record];\n  if (section) {\n    section.rows.push(record);\n    placer.changes++;\n    onCleanup(() => {\n      section.rows.splice(section.rows.indexOf(record) >>> 0, 1);\n      placer.changes++;\n    });\n  }\n  // A row on its own, outside a head or body, is laid out alone.\n  const laidOut = section ? section.laidOut : createMemo(() => stacked() && items() !== undefined && !!element());\n  const rowOf = section ? section.rowOf : (tr: Element | undefined) => (tr && tr === element() ? 0 : -1);\n  if (!isServer) {\n    // The row's cells, their elements and spans: when they change, the row is\n    // laid out again.\n    createComputed(() => {\n      items();\n      for (const cell of record.cells) {\n        cell.element();\n        cell.span();\n        cell.rowSpan();\n      }\n      if (section) section.invalidate(record);\n      else {\n        const tr = laidOut() && element();\n        if (tr) untrack(() => layOutRow(tr, record, NO_CARRY));\n      }\n    });\n  }\n\n  return {\n    setItems,\n    registerCell: (cellElement, span, rowSpan) => {\n      const [column, setColumn] = createSignal(-1);\n      const cell: CellRecord = { element: cellElement, span, rowSpan, moveTo: setColumn };\n      record.cells.push(cell);\n      placer.changes++;\n      onCleanup(() => {\n        record.cells.splice(record.cells.indexOf(cell) >>> 0, 1);\n        placer.changes++;\n      });\n      // Before the elements are known (the first client pass, and the server):\n      // the order of creation, which later cells do not change. After that the\n      // section's layout moves the cell, and its row is its row's index.\n      let created = NOWHERE;\n      untrack(() => {\n        if (stacked() && !laidOut()) {\n          created = placeCreated(section ? section.rows : ownRows, placer, record, cell);\n          setColumn(created.column);\n        }\n      });\n      const placed = (): number => (stacked() ? column() : -1);\n      return {\n        column: placed,\n        row: () => {\n          if (placed() < 0) return -1;\n          return laidOut() ? rowOf(element()) : created.row;\n        },\n      };\n    },\n  };\n}\n\n/**\n * Children resolved once, with their elements reported in order whenever they\n * change: a row's cells, or a head's or body's rows. It renders inside the\n * context provider of its row or section, so the children it creates find it.\n */\nexport function ChildElements(props: { children?: JSX.Element; onItems: (items: Element[]) => void }): JSX.Element {\n  const resolved = children(() => props.children);\n  if (!isServer) {\n    createComputed(() => props.onItems(resolved.toArray().filter((node) => node instanceof Element)));\n  }\n  return <>{resolved()}</>;\n}\n\n/**\n * The text of a header's resolved content, with white space collapsed: strings\n * and numbers, and the text of elements. On the server elements are markup\n * strings, read as the browser reads the same markup: tags and comments dropped,\n * character references decoded. A component that makes its text itself gives\n * the text it renders; name a column by `TableHeadCell label` where that is not\n * its name.\n */\nexport function textOf(content: unknown): string {\n  const collect = (value: unknown): string => {\n    if (typeof value === \"string\" || typeof value === \"number\") return String(value);\n    if (Array.isArray(value)) return value.map(collect).join(\"\");\n    if (value && typeof value === \"object\") {\n      if (\"textContent\" in value) return (value as Node).textContent ?? \"\";\n      // An SSR node: `{ t: \"<b>Name</b>\" }`.\n      if (isServer && \"t\" in value && typeof value.t === \"string\") return htmlText(value.t);\n    }\n    return \"\";\n  };\n  return collect(content).replace(/\\s+/g, \" \").trim();\n}\n\nexport const useTableLabels = (): TableLabelsContextValue | undefined => useContext(TableLabelsContext);\nexport const useTableSection = (): TableSectionContextValue | undefined => useContext(TableSectionContext);\nexport const useTableRow = (): TableRowContextValue | undefined => useContext(TableRowContext);\nexport const useInTableHead = (): boolean => useContext(TableHeadContext);\n"],"names":["createColumnLabels","columns","Map","slot","column","signal","get","createSignal","set","lowest","entry","row","label","owner","read","write","list","untrack","prev","find","filter","remove","TableLabelsContext","createContext","TableHeadContext","NOWHERE","NO_PLACE","TableSectionContext","TableRowContext","cellSpan","colSpan","Math","max","floor","Number","cellRowSpan","rowSpan","undefined","rows","Infinity","isRow","element","tagName","NO_CARRY","sameCarry","a","b","length","i","layOutRow","tr","record","carry","cells","cell","at","has","taken","slice","item","items","Array","from","children","td","span","parentElement","moveTo","next","map","pop","createLayout","last","changed","done","WeakMap","owners","invalidate","delete","reset","run","trs","start","laid","drawn","Set","forEach","advance","state","changes","index","until","placed","placeCreated","placer","indexOf","place","each","createSectionRows","stacked","setItems","setChanged","createMemo","laidOut","layout","isServer","createComputed","rowOf","count","createRowColumns","section","ownRows","push","onCleanup","splice","registerCell","cellElement","setColumn","created","ChildElements","props","resolved","onItems","toArray","node","Element","_$memo","textOf","content","collect","value","String","isArray","join","textContent","t","htmlText","replace","trim","useTableLabels","useContext","useTableSection","useTableRow","useInTableHead"],"mappings":";;;AAuCO,SAASA,IAAmC;AACjD,QAAMC,wBAAcC,IAAAA,GACdC,IAAOA,CAACC,MAA0C;AACtD,QAAIC,IAASJ,EAAQK,IAAIF,CAAM;AAC/B,WAAKC,MACHA,IAASE,EAA4B,EAAE,GACvCN,EAAQO,IAAIJ,GAAQC,CAAM,IAErBA;AAAAA,EACT;AACA,SAAO;AAAA,IACLC,KAAMF,CAAAA,MAAW;AACf,UAAIK;AACJ,iBAAWC,KAASP,EAAKC,CAAM,EAAE,CAAC,EAAA,EAAK,EAAI,CAACK,KAAUC,EAAMC,MAAMF,EAAOE,SAAKF,IAASC;AACvF,aAAOD,GAAQG;AAAAA,IACjB;AAAA,IACAJ,KAAKA,CAACJ,GAAQO,GAAKE,GAAOD,MAAU;AAClC,YAAM,CAACE,GAAMC,CAAK,IAAIZ,EAAKC,CAAM,GAC3BY,IAAOC,EAAQH,CAAI,GACnBI,IAAOF,EAAKG,KAAMT,CAAAA,MAAUA,EAAMC,QAAQA,CAAG;AACnD,MAAIO,GAAML,UAAUA,KAASK,EAAKN,UAAUA,KAC5CG,EAAM,CAAC,GAAGC,EAAKI,OAAQV,OAAUA,EAAMC,QAAQA,CAAG,GAAG;AAAA,QAAEA,KAAAA;AAAAA,QAAKE,OAAAA;AAAAA,QAAOD,OAAAA;AAAAA,MAAAA,CAAO,CAAC;AAAA,IAC7E;AAAA,IACAS,QAAQA,CAACjB,GAAQO,GAAKE,MAAU;AAC9B,YAAM,CAACC,GAAMC,CAAK,IAAIZ,EAAKC,CAAM,GAC3BY,IAAOC,EAAQH,CAAI;AACzB,MAAIE,EAAKG,KAAMT,CAAAA,MAAUA,EAAMC,QAAQA,CAAG,GAAGE,UAAUA,KACvDE,EAAMC,EAAKI,OAAQV,CAAAA,MAAUA,EAAMC,QAAQA,CAAG,CAAC;AAAA,IACjD;AAAA,EAAA;AAEJ;AAQO,MAAMW,IAAqBC,EAAAA,GAGrBC,IAAmBD,EAAc,EAAK,GAStCE,IAAqB;AAAA,EAAErB,QAAQ;AAAA,EAAIO,KAAK;AAAG,GAa3Ce,IAA8B;AAAA,EAAEtB,QAAQA,MAAM;AAAA,EAAIO,KAAKA,MAAM;AAAG,GA0DhEgB,IAAsBJ,EAAAA,GAgBtBK,IAAkBL,EAAAA,GAGlBM,IAAWA,CAACC,MAAiDC,KAAKC,IAAI,GAAGD,KAAKE,MAAMC,OAAOJ,CAAO,CAAC,KAAK,CAAC,GAGzGK,IAAcA,CAACC,MAAiD;AAC3E,MAAIA,MAAYC,UAAaD,MAAY,GAAI,QAAO;AACpD,QAAME,IAAOP,KAAKE,MAAMC,OAAOE,CAAO,CAAC;AACvC,SAAOE,MAAS,IAAIC,QAAWR,KAAKC,IAAI,GAAGM,CAAI,KAAK;AACtD,GAEME,IAAQA,CAACC,MAA8BA,EAAQC,YAAY,MAW3DC,IAAkB,CAAA;AAExB,SAASC,EAAUC,GAAUC,GAAmB;AAC9C,QAAMC,IAAShB,KAAKC,IAAIa,EAAEE,QAAQD,EAAEC,MAAM;AAC1C,WAASC,IAAI,GAAGA,IAAID,GAAQC,IAAK,MAAKH,EAAEG,CAAC,KAAK,QAAQF,EAAEE,CAAC,KAAK,GAAI,QAAO;AACzE,SAAO;AACT;AAgBA,SAASC,EAAUC,GAAaC,GAA+BC,GAAyB;AACtF,QAAMC,wBAAYnD,IAAAA;AAClB,aAAWoD,KAAQH,GAAQE,SAAS,CAAA,GAAI;AACtC,UAAME,IAAKD,EAAKb,QAAAA;AAChB,IAAIc,KAAM,CAACF,EAAMG,IAAID,CAAE,KAAGF,EAAM7C,IAAI+C,GAAID,CAAI;AAAA,EAC9C;AAEA,QAAMG,IAAQL,EAAMM,MAAAA,GACdzD,IAAUkD,IAAS,oBAAIjD,IAAAA,IAAyBmC;AACtD,MAAIjC,IAAS;AACb,aAAWuD,KAAQR,GAAQS,MAAAA,KAAWC,MAAMC,KAAKZ,EAAGa,QAAQ,GAAG;AAC7D,YAAQN,EAAMrD,CAAM,KAAK,KAAK,IAAGA,CAAAA;AACjC,UAAMkD,IAAOD,EAAM/C,IAAIqD,CAAI,GACrBK,IAAKL,GACLM,IAAOX,IAAOA,EAAKW,SAASpC,EAASmC,EAAGlC,OAAO,GAC/CQ,IAAOgB,IAAOA,EAAKlB,YAAYD,EAAY6B,EAAG5B,OAAO;AAC3D,aAASY,IAAI,GAAGA,IAAIiB,GAAMjB,IAAKS,CAAAA,EAAMrD,IAAS4C,CAAC,IAAIV;AACnDrC,IAAAA,GAASO,IAAImD,GAAMvD,CAAM,GACzBA,KAAU6D;AAAAA,EACZ;AACA,MAAId,KAAUlD;AACZ,eAAWqD,KAAQH,EAAOE,OAAO;AAE/B,UAAIE;AACJ,eAASd,IAAUa,EAAKb,QAAAA,GAAWA,KAAWc,MAAOlB,QAAWI,IAAUA,EAAQyB,iBAAiB7B;AACjGkB,QAAAA,IAAKtD,EAAQK,IAAImC,CAAO;AAE1Ba,MAAAA,EAAKa,OAAOZ,KAAM,EAAE;AAAA,IACtB;AAEF,QAAMa,IAAOX,EAAMY,IAAK/B,CAAAA,MAASP,KAAKC,IAAI,GAAGM,IAAO,CAAC,CAAC;AACtD,SAAO8B,EAAKrB,UAAU,CAACqB,EAAKA,EAAKrB,SAAS,CAAC,IAAGqB,CAAAA,EAAKE,IAAAA;AACnD,SAAO;AAAA,IAAElB,OAAAA;AAAAA,IAAOgB,MAAAA;AAAAA,EAAAA;AAClB;AAUA,SAASG,IAAe;AACtB,MAAIC,IAAkB,CAAA,GAElBC,IAAU;AACd,QAAMC,wBAAWC,QAAAA,GACXC,wBAAaD,QAAAA;AACnB,SAAO;AAAA;AAAA,IAELE,YAAYA,CAAC1B,MAAsB;AACjC,YAAMD,IAAKC,EAAOV,QAAAA;AAClB,MAAKS,MACL0B,EAAOpE,IAAI0C,GAAIC,CAAM,GACjBuB,EAAKI,OAAO5B,CAAE,MAAGuB,IAAU;AAAA,IACjC;AAAA,IACAM,OAAOA,MAAM;AACXP,MAAAA,IAAO,CAAA;AAAA,IACT;AAAA,IACAQ,KAAKA,CAACC,MAAmB;AACvB,UAAIC,IAAQ;AACZ,aAAOA,IAAQD,EAAIlC,UAAUkC,EAAIC,CAAK,MAAMV,EAAKU,CAAK,MAAM,CAACT,KAAWC,EAAKlB,IAAIyB,EAAIC,CAAK,CAAE,KAAIA,CAAAA;AAEhG,UADAT,IAAU,IACNS,MAAUD,EAAIlC,UAAUmC,MAAUV,EAAKzB,OAAQ;AACnD,UAAIK,IAAQ8B,IAASR,EAAKpE,IAAI2E,EAAIC,IAAQ,CAAC,CAAE,GAAGd,QAAQzB,IAAYA;AACpE,eAAShC,IAAMuE,GAAOvE,IAAMsE,EAAIlC,QAAQpC,KAAO;AAC7C,cAAMuC,IAAK+B,EAAItE,CAAG;AAClB,YAAIwE,IAAOT,EAAKpE,IAAI4C,CAAE;AACtB,SAAI,CAACiC,KAAQ,CAACvC,EAAUuC,EAAK/B,OAAOA,CAAK,OACvC+B,IAAOlC,EAAUC,GAAI0B,EAAOtE,IAAI4C,CAAE,GAAGE,CAAK,GAC1CsB,EAAKlE,IAAI0C,GAAIiC,CAAI,IAEnB/B,IAAQ+B,EAAKf;AAAAA,MACf;AACA,UAAIc,IAAQV,EAAKzB,QAAQ;AACvB,cAAMqC,IAAQ,IAAIC,IAAIJ,CAAG;AACzB,iBAAStE,IAAMuE,GAAOvE,IAAM6D,EAAKzB,QAAQpC,KAAO;AAC9C,gBAAMuC,IAAKsB,EAAK7D,CAAG;AACnB,UAAIyE,EAAM5B,IAAIN,CAAE,MAChBwB,EAAKI,OAAO5B,CAAE,GACd0B,EAAOtE,IAAI4C,CAAE,GAAGG,MAAMiC,QAAShC,CAAAA,MAASA,EAAKa,OAAO,EAAE,CAAC;AAAA,QACzD;AAAA,MACF;AACAK,MAAAA,IAAOS;AAAAA,IACT;AAAA,EAAA;AAEJ;AAGA,SAASM,EAAQC,GAAsBlC,GAAkBmC,GAA4B;AACnF,QAAM;AAAA,IAAEC,OAAAA;AAAAA,IAAOjC,OAAAA;AAAAA,EAAAA,IAAU+B;AACzB,MAAIpF,IAASoF,EAAMpF;AACnB,UAAQqD,EAAMrD,CAAM,KAAK,KAAKsF,IAAOtF,CAAAA;AACrC,QAAM6D,IAAOX,EAAKW,KAAAA,GACZ0B,IAAQD,IAAQpC,EAAKlB,QAAAA;AAC3B,WAASY,IAAI,GAAGA,IAAIiB,GAAMjB,IAAKS,CAAAA,EAAMrD,IAAS4C,CAAC,IAAI2C;AACnDH,SAAAA,EAAMpF,SAASA,IAAS6D,GACxBuB,EAAMI,UACNJ,EAAMC,UAAUA,GACT;AAAA,IAAErF,QAAAA;AAAAA,IAAQO,KAAK+E;AAAAA,EAAAA;AACxB;AAQA,SAASG,EAAavD,GAAmBwD,GAAwB3C,GAAmBG,GAA6B;AAC/G,QAAM;AAAA,IAAEkC,OAAAA;AAAAA,IAAOC,SAAAA;AAAAA,EAAAA,IAAYK;AAC3B,MAAIN,KAASrC,EAAOE,MAAMF,EAAOE,MAAMN,SAAS,CAAC,MAAMO,GAAM;AAE3D,QAAIkC,EAAM7E,QAAQwC,KAAUsC,MAAYD,EAAMC,UAAU,KAAKtC,EAAOE,MAAMN,WAAWyC,EAAMI,SAAS;AAClG,aAAOL,EAAQC,GAAOlC,GAAMmC,CAAO;AAGrC,UAAMC,IAAQpD,EAAKS,SAAS;AAC5B,QACET,EAAKoD,CAAK,MAAMvC,KAChBA,EAAOE,MAAMN,WAAW,KACxBT,EAAKkD,EAAME,KAAK,MAAMF,EAAM7E,OAC5B8E,MAAYD,EAAMC,WAAWC,IAAQF,EAAME,SAAS;AAEpDF,aAAAA,EAAM7E,MAAMwC,GACZqC,EAAME,QAAQA,GACdF,EAAMI,SAAS,GACfJ,EAAMpF,SAAS,GACRmF,EAAQC,GAAOlC,GAAMmC,CAAO;AAAA,EAEvC;AACA,QAAMC,IAAQpD,EAAKyD,QAAQ5C,CAAM;AACjC,MAAIuC,IAAQ,EAAG,QAAOjE;AACtB,QAAM2C,IAAsB;AAAA,IAAEzD,KAAKwC;AAAAA,IAAQuC,OAAAA;AAAAA,IAAOE,QAAQ;AAAA,IAAGnC,OAAO,CAAA;AAAA,IAAIrD,QAAQ;AAAA,IAAGqF,SAAAA;AAAAA,EAAAA;AACnF,MAAIO,IAAQvE;AACZ,WAASd,IAAM,GAAGA,KAAO+E,GAAO/E,KAAO;AACrCyD,IAAAA,EAAKsB,QAAQ/E,GACbyD,EAAKwB,SAAS,GACdxB,EAAKhE,SAAS;AACd,eAAW6F,KAAQ3D,EAAK3B,CAAG,EAAG0C,OAAO;AACnC,YAAME,IAAKgC,EAAQnB,GAAM6B,GAAMR,CAAO;AACtC,MAAIQ,MAAS3C,KAAQ3C,MAAQ+E,MAAOM,IAAQzC;AAAAA,IAC9C;AAAA,EACF;AACAa,SAAAA,EAAKzD,MAAMwC,GACX2C,EAAON,QAAQpB,GACR4B;AACT;AAQO,SAASE,EAAkBC,GAAsD;AACtF,QAAM,CAACvC,GAAOwC,CAAQ,IAAI7F,EAAAA,GACpB,CAACkE,GAAS4B,CAAU,IAAI9F,EAAa,CAAC,GACtC+B,IAAoB,CAAA,GACpB2C,IAAMqB,EAAW,MAAOH,EAAAA,IAAYvC,KAASxC,OAAOoB,CAAK,IAAIH,MAAU,GACvEkE,IAAUD,EAAW,MAAM,CAAC,CAACrB,GAAK,GAClCuB,IAASjC,EAAAA;AACf,SAAKkC,KACHC,EAAe,MAAM;AACnBjC,IAAAA,EAAAA;AACA,UAAMzD,IAAOiE,EAAAA;AACb,IAAIjE,IAAMC,EAAQ,MAAMuF,EAAOxB,IAAIhE,CAAI,CAAC,MAC5B+D,MAAAA;AAAAA,EACd,CAAC,GAEI;AAAA,IACLzC,MAAAA;AAAAA,IACAwD,QAAQ;AAAA,MAAEL,SAAS;AAAA,MAAGD,OAAOnD;AAAAA,IAAAA;AAAAA,IAC7B+D,UAAAA;AAAAA,IACAG,SAAAA;AAAAA,IACAI,OAAQzD,OAAQA,IAAM+B,EAAAA,GAAOc,QAAQ7C,CAAE,KAAK,KAAM;AAAA,IAClD2B,YAAa1B,CAAAA,MAAW;AACtBqD,MAAAA,EAAO3B,WAAW1B,CAAM,GACxBkD,EAAYO,CAAAA,MAAUA,IAAQ,CAAC;AAAA,IACjC;AAAA,EAAA;AAEJ;AAMO,SAASC,EACdV,GACAW,GACArE,GACiE;AACjE,QAAM,CAACmB,GAAOwC,CAAQ,IAAI7F,EAAAA,GACpB4C,IAAoB;AAAA,IAAEV,SAAAA;AAAAA,IAASY,OAAO,CAAA;AAAA,IAAIO,OAAAA;AAAAA,EAAAA,GAC1CkC,IAAyBgB,IAAUA,EAAQhB,SAAS;AAAA,IAAEL,SAAS;AAAA,IAAGD,OAAOnD;AAAAA,EAAAA,GACzE0E,IAAU,CAAC5D,CAAM;AACvB,EAAI2D,MACFA,EAAQxE,KAAK0E,KAAK7D,CAAM,GACxB2C,EAAOL,WACPwB,EAAU,MAAM;AACdH,IAAAA,EAAQxE,KAAK4E,OAAOJ,EAAQxE,KAAKyD,QAAQ5C,CAAM,MAAM,GAAG,CAAC,GACzD2C,EAAOL;AAAAA,EACT,CAAC;AAGH,QAAMc,IAAUO,IAAUA,EAAQP,UAAUD,EAAW,MAAMH,EAAAA,KAAavC,EAAAA,MAAYvB,UAAa,CAAC,CAACI,GAAS,GACxGkE,IAAQG,IAAUA,EAAQH,QAAQ,CAACzD,MAA6BA,KAAMA,MAAOT,EAAAA,IAAY,IAAI;AACnG,SAAKgE,KAGHC,EAAe,MAAM;AACnB9C,IAAAA,EAAAA;AACA,eAAWN,KAAQH,EAAOE;AACxBC,MAAAA,EAAKb,QAAAA,GACLa,EAAKW,KAAAA,GACLX,EAAKlB,QAAAA;AAEP,QAAI0E,EAASA,CAAAA,EAAQjC,WAAW1B,CAAM;AAAA,SACjC;AACH,YAAMD,IAAKqD,EAAAA,KAAa9D,EAAAA;AACxB,MAAIS,KAAIjC,EAAQ,MAAMgC,EAAUC,GAAIC,GAAQR,CAAQ,CAAC;AAAA,IACvD;AAAA,EACF,CAAC,GAGI;AAAA,IACLyD,UAAAA;AAAAA,IACAe,cAAcA,CAACC,GAAanD,GAAM7B,MAAY;AAC5C,YAAM,CAAChC,GAAQiH,CAAS,IAAI9G,EAAa,EAAE,GACrC+C,IAAmB;AAAA,QAAEb,SAAS2E;AAAAA,QAAanD,MAAAA;AAAAA,QAAM7B,SAAAA;AAAAA,QAAS+B,QAAQkD;AAAAA,MAAAA;AACxElE,MAAAA,EAAOE,MAAM2D,KAAK1D,CAAI,GACtBwC,EAAOL,WACPwB,EAAU,MAAM;AACd9D,QAAAA,EAAOE,MAAM6D,OAAO/D,EAAOE,MAAM0C,QAAQzC,CAAI,MAAM,GAAG,CAAC,GACvDwC,EAAOL;AAAAA,MACT,CAAC;AAID,UAAI6B,IAAU7F;AACdR,MAAAA,EAAQ,MAAM;AACZ,QAAIkF,EAAAA,KAAa,CAACI,QAChBe,IAAUzB,EAAaiB,IAAUA,EAAQxE,OAAOyE,GAASjB,GAAQ3C,GAAQG,CAAI,GAC7E+D,EAAUC,EAAQlH,MAAM;AAAA,MAE5B,CAAC;AACD,YAAMwF,IAASA,MAAeO,MAAY/F,MAAW;AACrD,aAAO;AAAA,QACLA,QAAQwF;AAAAA,QACRjF,KAAKA,MACCiF,EAAAA,IAAW,IAAU,KAClBW,MAAYI,EAAMlE,EAAAA,CAAS,IAAI6E,EAAQ3G;AAAAA,MAChD;AAAA,IAEJ;AAAA,EAAA;AAEJ;AAOO,SAAS4G,EAAcC,GAAqF;AACjH,QAAMC,IAAW1D,EAAS,MAAMyD,EAAMzD,QAAQ;AAC9C,SAAK0C,KACHC,EAAe,MAAMc,EAAME,QAAQD,EAASE,QAAAA,EAAUvG,OAAQwG,CAAAA,MAASA,aAAgBC,OAAO,CAAC,CAAC,GAElGC,EAAUL,CAAQ;AACpB;AAUO,SAASM,EAAOC,GAA0B;AAC/C,QAAMC,IAAUA,CAACC,MAA2B;AAC1C,QAAI,OAAOA,KAAU,YAAY,OAAOA,KAAU,SAAU,QAAOC,OAAOD,CAAK;AAC/E,QAAIrE,MAAMuE,QAAQF,CAAK,EAAG,QAAOA,EAAM7D,IAAI4D,CAAO,EAAEI,KAAK,EAAE;AAC3D,QAAIH,KAAS,OAAOA,KAAU,UAAU;AACtC,UAAI,iBAAiBA,EAAO,QAAQA,EAAeI,eAAe;AAElE,UAAI7B,KAAY,OAAOyB,KAAS,OAAOA,EAAMK,KAAM,SAAU,QAAOC,EAASN,EAAMK,CAAC;AAAA,IACtF;AACA,WAAO;AAAA,EACT;AACA,SAAON,EAAQD,CAAO,EAAES,QAAQ,QAAQ,GAAG,EAAEC,KAAAA;AAC/C;AAEO,MAAMC,IAAiBA,MAA2CC,EAAWtH,CAAkB,GACzFuH,IAAkBA,MAA4CD,EAAWjH,CAAmB,GAC5FmH,KAAcA,MAAwCF,EAAWhH,CAAe,GAChFmH,KAAiBA,MAAeH,EAAWpH,CAAgB;"}

package/dist/components/dataDisplay/table/tableEntities.d.ts

@@ -0,0 +1,4 @@
+/** The named character references of HTML: `name:codepoint.codepoint`, comma-separated. */
+export declare const NAMED_REFERENCES: string;
+/** The names that also count without a ";", as browsers read them in text. */
+export declare const LEGACY_REFERENCES: string;

package/dist/components/dataDisplay/table/tableEntities.js

@@ -0,0 +1,6 @@
+const E = "", R = "";
+export {
+  R as LEGACY_REFERENCES,
+  E as NAMED_REFERENCES
+};
+//# sourceMappingURL=tableEntities.js.map

package/dist/components/dataDisplay/table/tableEntities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tableEntities.js","sources":["../../../../src/components/dataDisplay/table/tableEntities.ts"],"sourcesContent":["export const NAMED_REFERENCES = \"\";\nexport const LEGACY_REFERENCES = \"\";\n"],"names":["NAMED_REFERENCES","LEGACY_REFERENCES"],"mappings":"AAAO,MAAMA,IAAmB,IACnBC,IAAoB;"}

package/dist/components/dataDisplay/table/tableHead.js

@@ -1,20 +1,38 @@
-import { use as a, spread as l, mergeProps as m, insert as f, template as n } from "solid-js/web";
+import { use as c, spread as i, mergeProps as m, insert as u, createComponent as t, template as d } from "solid-js/web";
 import { splitProps as p } from "solid-js";
-import c from "clsx";
-import { mergeRefs as i } from "../../../primitives/mergeRefs.js";
-var u = /* @__PURE__ */ n("<thead>");
-function g(s) {
-  const [e, o] = p(s, ["children", "class", "ref"]);
+import f from "clsx";
+import { mergeRefs as b } from "../../../primitives/mergeRefs.js";
+import { useTableLabels as h, createSectionRows as g, TableHeadContext as v, TableSectionContext as _, ChildElements as C } from "./tableColumns.js";
+var P = /* @__PURE__ */ d("<thead>");
+function I(s) {
+  const [r, a] = p(s, ["children", "class", "ref"]), l = h(), o = g(() => !!l?.stacked());
   return (() => {
-    var r = u(), t = i(e.ref);
-    return typeof t == "function" && a(t, r), l(r, m(o, {
+    var e = P(), n = b(r.ref);
+    return typeof n == "function" && c(n, e), i(e, m(a, {
       get class() {
-        return c("smwb-table__head", e.class);
+        return f("smwb-table__head", r.class);
       }
-    }), !1, !0), f(r, () => e.children), r;
+    }), !1, !0), u(e, t(v.Provider, {
+      value: !0,
+      get children() {
+        return t(_.Provider, {
+          value: o,
+          get children() {
+            return t(C, {
+              get onItems() {
+                return o.setItems;
+              },
+              get children() {
+                return r.children;
+              }
+            });
+          }
+        });
+      }
+    })), e;
   })();
 }
 export {
-  g as TableHead
+  I as TableHead
 };
 //# sourceMappingURL=tableHead.js.map

package/dist/components/dataDisplay/table/tableHead.js.map

@@ -1 +1 @@
-{"version":3,"file":"tableHead.js","sources":["../../../../src/components/dataDisplay/table/tableHead.tsx"],"sourcesContent":["import { type JSX, type ParentProps, splitProps } from \"solid-js\";\nimport cn from \"clsx\";\nimport { mergeRefs, type Ref } from \"../../../primitives/mergeRefs\";\n\nexport interface TableHeadProps extends JSX.HTMLAttributes<HTMLTableSectionElement> {\n  ref?: Ref<HTMLTableSectionElement>;\n}\n\nexport function TableHead(props: ParentProps<TableHeadProps>): JSX.Element {\n  const [local, rest] = splitProps(props, [\"children\", \"class\", \"ref\"]);\n  return (\n    <thead {...rest} ref={mergeRefs(local.ref)} class={cn(\"smwb-table__head\", local.class)}>\n      {local.children}\n    </thead>\n  );\n}\n\nexport default TableHead;\n"],"names":["TableHead","props","local","rest","splitProps","_el$","_tmpl$","_ref$","mergeRefs","ref","_$use","_$spread","_$mergeProps","cn","class","_$insert","children"],"mappings":";;;;;AAQO,SAASA,EAAUC,GAAiD;AACzE,QAAM,CAACC,GAAOC,CAAI,IAAIC,EAAWH,GAAO,CAAC,YAAY,SAAS,KAAK,CAAC;AACpE,UAAA,MAAA;AAAA,QAAAI,IAAAC,EAAAA,GAAAC,IACwBC,EAAUN,EAAMO,GAAG;AAAC,kBAAAF,KAAA,cAAAG,EAAAH,GAAAF,CAAA,GAAAM,EAAAN,GAAAO,EAA/BT,GAAI;AAAA,MAAA,IAAA,QAAA;AAAA,eAAoCU,EAAG,oBAAoBX,EAAMY,KAAK;AAAA,MAAC;AAAA,IAAA,CAAA,GAAA,IAAA,EAAA,GAAAC,EAAAV,GAAA,MACnFH,EAAMc,QAAQ,GAAAX;AAAAA,EAAA,GAAA;AAGrB;"}
+{"version":3,"file":"tableHead.js","sources":["../../../../src/components/dataDisplay/table/tableHead.tsx"],"sourcesContent":["import { type JSX, type ParentProps, splitProps } from \"solid-js\";\nimport cn from \"clsx\";\nimport { mergeRefs, type Ref } from \"../../../primitives/mergeRefs\";\nimport {\n  ChildElements,\n  TableHeadContext,\n  TableSectionContext,\n  createSectionRows,\n  useTableLabels,\n} from \"./tableColumns\";\n\nexport interface TableHeadProps extends JSX.HTMLAttributes<HTMLTableSectionElement> {\n  ref?: Ref<HTMLTableSectionElement>;\n}\n\nexport function TableHead(props: ParentProps<TableHeadProps>): JSX.Element {\n  const [local, rest] = splitProps(props, [\"children\", \"class\", \"ref\"]);\n  // The head's rows, so that each head cell labels the column it stands over,\n  // after the columns that `rowSpan` cells above it take.\n  const table = useTableLabels();\n  const rows = createSectionRows(() => !!table?.stacked());\n  return (\n    <thead {...rest} ref={mergeRefs(local.ref)} class={cn(\"smwb-table__head\", local.class)}>\n      <TableHeadContext.Provider value={true}>\n        <TableSectionContext.Provider value={rows}>\n          <ChildElements onItems={rows.setItems}>{local.children}</ChildElements>\n        </TableSectionContext.Provider>\n      </TableHeadContext.Provider>\n    </thead>\n  );\n}\n\nexport default TableHead;\n"],"names":["TableHead","props","local","rest","splitProps","table","useTableLabels","rows","createSectionRows","stacked","_el$","_tmpl$","_ref$","mergeRefs","ref","_$use","_$spread","_$mergeProps","cn","class","_$insert","_$createComponent","TableHeadContext","Provider","value","children","TableSectionContext","ChildElements","onItems","setItems"],"mappings":";;;;;;AAeO,SAASA,EAAUC,GAAiD;AACzE,QAAM,CAACC,GAAOC,CAAI,IAAIC,EAAWH,GAAO,CAAC,YAAY,SAAS,KAAK,CAAC,GAG9DI,IAAQC,EAAAA,GACRC,IAAOC,EAAkB,MAAM,CAAC,CAACH,GAAOI,SAAS;AACvD,UAAA,MAAA;AAAA,QAAAC,IAAAC,EAAAA,GAAAC,IACwBC,EAAUX,EAAMY,GAAG;AAAC,kBAAAF,KAAA,cAAAG,EAAAH,GAAAF,CAAA,GAAAM,EAAAN,GAAAO,EAA/Bd,GAAI;AAAA,MAAA,IAAA,QAAA;AAAA,eAAoCe,EAAG,oBAAoBhB,EAAMiB,KAAK;AAAA,MAAC;AAAA,IAAA,CAAA,GAAA,IAAA,EAAA,GAAAC,EAAAV,GAAAW,EACnFC,EAAiBC,UAAQ;AAAA,MAACC,OAAO;AAAA,MAAI,IAAAC,WAAA;AAAA,eAAAJ,EACnCK,EAAoBH,UAAQ;AAAA,UAACC,OAAOjB;AAAAA,UAAI,IAAAkB,WAAA;AAAA,mBAAAJ,EACtCM,GAAa;AAAA,cAAA,IAACC,UAAO;AAAA,uBAAErB,EAAKsB;AAAAA,cAAQ;AAAA,cAAA,IAAAJ,WAAA;AAAA,uBAAGvB,EAAMuB;AAAAA,cAAQ;AAAA,YAAA,CAAA;AAAA,UAAA;AAAA,QAAA,CAAA;AAAA,MAAA;AAAA,IAAA,CAAA,CAAA,GAAAf;AAAAA,EAAA,GAAA;AAKhE;"}

package/dist/components/dataDisplay/table/tableHeadCell.d.ts

@@ -16,13 +16,35 @@ export interface TableHeadCellProps extends JSX.ThHTMLAttributes<HTMLTableCellEl
      * button, link, label, anything focusable) or in a portal. Content that is not
      * a control, such as click-to-edit text, keeps its click from sorting by
      * calling `preventDefault()` on it. A nested control's name, or its value,
-     * becomes part of the sort control's accessible name.
+     * becomes part of the sort control's accessible name: put controls in
+     * `actions` instead.
      */
     sortable?: boolean;
     /** Current sort direction for this column. */
     sortDirection?: SortDirection;
     /** Invoked when the user activates the sort control. */
     onSort?: () => void;
+    /**
+     * The column's controls — a filter field, a menu button, a column resizer —
+     * drawn after the sort control, outside it. Their names and values stay out
+     * of the sort control's accessible name, and their keys and clicks never
+     * reach it. Rendered whether or not the cell is sortable.
+     *
+     * The column header is then named after the children alone: the cell's
+     * `aria-labelledby` points at the sort control, unless the cell is given
+     * `aria-label` or `aria-labelledby`. Named from its content, the header would
+     * take in the controls' names and values too.
+     */
+    actions?: JSX.Element;
+    /**
+     * The column's name for its body cells while the table stacks rows as cards
+     * (`Table stackBelow`). Without it, the text of the children is the name; give
+     * `label` where they hold no text of their own (an icon) or more than the
+     * name, or where their text changes inside markup: the text of markup is read
+     * when it is created. An empty `label` leaves the column's cells unlabelled, so
+     * they fill the card's width.
+     */
+    label?: string;
     ref?: Ref<HTMLTableCellElement>;
 }
 export declare function TableHeadCell(props: ParentProps<TableHeadCellProps>): JSX.Element;