@heycys/gallery 0.0.0-stage → 0.1.0

package/kit/tables.js

@@ -0,0 +1,1449 @@
+"use strict";
+(() => {
+  // src/render/kit/tables/auto-column-widths.ts
+  var defaults = {
+    percentile: 0.9,
+    hardMinWidth: 48,
+    narrativeMinWidth: 160,
+    maxReadableFloor: Infinity,
+    tokenHeavyMinWidth: 140,
+    compactMaxProtectedWidth: 160,
+    cellPadding: 24,
+    columnOverhead: 0,
+    font: "14px system-ui"
+  };
+  var kinds = ["token-heavy", "narrative", "compact"];
+  var total = (columns) => columns.reduce((sum, column) => sum + column.width, 0);
+  var clamp = (value, min, max) => Math.min(max, Math.max(min, value));
+  function quantile(values, q) {
+    if (!values.length) return 0;
+    const sorted = [...values].sort((a, b) => a - b);
+    const position = (sorted.length - 1) * q;
+    const low = Math.floor(position), high = Math.ceil(position);
+    return sorted[low] * (1 - position + low) + sorted[high] * (position - low);
+  }
+  function createTextMeasurer(font) {
+    const context = typeof document === "undefined" ? null : document.createElement("canvas").getContext("2d");
+    if (context) context.font = font;
+    const size = Number(font.match(/([\d.]+)px/)?.[1]) || 14;
+    const cache = /* @__PURE__ */ new Map();
+    return (text) => {
+      if (cache.has(text)) return cache.get(text);
+      const width = Math.max(0, ...text.split(/\r\n|\r|\n/).map((line) => context ? context.measureText(line).width : Array.from(line).reduce((sum, char) => sum + size * (/[^\x00-\xff]/.test(char) ? 1 : 0.55), 0)));
+      cache.set(text, width);
+      return width;
+    };
+  }
+  var WORD_BREAKS = /\s+|(?<=[、，。；：！？）」』》】〉〕”’,;!?)\]/])(?=[^\s、，。；：！？）」』》】〉〕”’,;!?)\]])|(?<=-)(?=[^\d\s-])|(?<=[^\s（「『《【〈〔“‘(\[])(?=[（「『《【〈〔“‘(\[])/u;
+  var PIECE_BREAKS = new RegExp(String.raw`${WORD_BREAKS.source}|(?<=[^\s（「『《【〈〔“‘(\[])(?=[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}])|(?<=[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}])(?=[^\s、，。；：！？）」』》】〉〕”’,;!?)\]])`, "u");
+  var longest = (text, breaks, measure) => Math.max(0, ...text.trim().split(breaks).map(measure));
+  function tokenHeavy(token) {
+    if (/^https?:\/\//i.test(token) || /[/\\]/.test(token)) return true;
+    if (/^[a-f0-9]{20,}$/i.test(token)) return true;
+    if (token.length >= 24 && /^[A-Za-z0-9_.:@/+~-]+$/.test(token)) return true;
+    return token.length >= 28 && !/[\u3040-\u30ff\u3400-\u9fff\uac00-\ud7af]/.test(token);
+  }
+  function columnKind(header, cells, measure) {
+    return analyze(header, cells, measure).kind;
+  }
+  function analyze(header, cells, measure) {
+    const values = cells.length ? cells : [header];
+    let words = 0, width = 0, heavy = 0;
+    for (const value of values) {
+      const tokens = value.trim().split(/\s+/).filter(Boolean);
+      words += tokens.length;
+      width += measure(value);
+      for (const token of tokens) {
+        if (tokenHeavy(token)) heavy++;
+      }
+    }
+    const kind = heavy > 0 && heavy / words >= 0.5 ? "token-heavy" : words / values.length >= 4 || width / values.length >= measure("abcdefghijklmnopqrstuvwxyz") ? "narrative" : "compact";
+    return { kind };
+  }
+  function shrink(columns, available, padding) {
+    let overflow = total(columns) - available;
+    const epsilon = 1e-6;
+    for (const compact of [false, true]) {
+      const group = columns.filter((column) => column.kind === "compact" === compact);
+      while (overflow > epsilon) {
+        const states = group.map((column) => ({
+          column,
+          slack: column.width - column.softMinWidth,
+          content: Math.max(1, column.preferredWidth - padding)
+        })).filter((item) => item.slack > epsilon);
+        if (!states.length) break;
+        const contentSum = states.reduce((sum, state) => sum + state.content, 0);
+        const fraction = Math.min(overflow / contentSum, ...states.map((state) => state.slack / state.content));
+        let reduced = 0;
+        for (const { column, content } of states) {
+          const before = column.width;
+          column.width = Math.max(column.softMinWidth, before - fraction * content);
+          reduced += before - column.width;
+        }
+        if (reduced <= epsilon) break;
+        overflow -= reduced;
+      }
+    }
+  }
+  function lowerWidest(widths, floors, excess) {
+    const lowered = (level) => widths.map((width, index) => Math.min(width, Math.max(level, floors[index])));
+    const saved = (level) => widths.reduce((sum, width, index) => sum + width - Math.min(width, Math.max(level, floors[index])), 0);
+    let low = Math.min(...floors), high = Math.max(...widths);
+    if (saved(low) <= excess) return lowered(low);
+    for (let step = 0; step < 40; step++) {
+      const level = (low + high) / 2;
+      if (saved(level) > excess) low = level;
+      else high = level;
+    }
+    return lowered(high);
+  }
+  function allocateColumnWidths(columns, options) {
+    const config = { ...defaults, ...options };
+    if (!Number.isFinite(config.totalWidth) || config.totalWidth <= 0) throw new Error("totalWidth must be positive and finite.");
+    for (const key of ["percentile", "hardMinWidth", "narrativeMinWidth", "tokenHeavyMinWidth", "compactMaxProtectedWidth", "cellPadding", "columnOverhead"]) {
+      if (!Number.isFinite(config[key]) || config[key] < 0) throw new Error(`${key} must be finite and nonnegative.`);
+    }
+    if (!(config.maxReadableFloor > 0)) throw new Error("maxReadableFloor must be positive.");
+    if (config.hardMinWidth === 0 || config.percentile > 1) throw new Error("hardMinWidth must be positive; percentile must be between 0 and 1.");
+    if (typeof config.font !== "string" || !config.font.trim()) throw new Error("font must be a nonempty string.");
+    if (!Array.isArray(columns)) throw new Error("columns must be an array.");
+    const keys = /* @__PURE__ */ new Set();
+    const measure = createTextMeasurer(config.font);
+    const compactTargets = [];
+    const wordFloors = /* @__PURE__ */ new Map();
+    const layouts2 = columns.map((column) => {
+      if (!column || typeof column.key !== "string" || !column.key || keys.has(column.key)) throw new Error("Column keys must be unique nonempty strings.");
+      keys.add(column.key);
+      if (typeof column.header !== "string" || !Array.isArray(column.cells)) throw new Error("Each column requires a header and cells.");
+      if (column.kind !== void 0 && !kinds.includes(column.kind)) throw new Error("Invalid column kind.");
+      if (column.numeric !== void 0 && typeof column.numeric !== "boolean") throw new Error("numeric must be a boolean.");
+      for (const value of column.cells) if (value != null && typeof value !== "string" && (typeof value !== "number" || !Number.isFinite(value))) throw new Error("Cells must be strings, finite numbers, null or undefined.");
+      const hardMinWidth = Math.max(config.hardMinWidth, column.minWidth ?? 0);
+      for (const bound of [column.minWidth, column.maxWidth]) if (bound !== void 0 && (!Number.isFinite(bound) || bound <= 0)) throw new Error("Column bounds must be positive and finite.");
+      if (column.maxWidth !== void 0 && column.maxWidth < hardMinWidth) throw new Error("maxWidth cannot be below the hard minimum.");
+      if (column.cellWidths !== void 0 && (!Array.isArray(column.cellWidths) || column.cellWidths.length !== column.cells.length || column.cellWidths.some((width) => !Number.isFinite(width) || width < 0))) throw new Error("cellWidths must match cells and contain finite nonnegative widths.");
+      if (column.cellWordWidths !== void 0 && (!Array.isArray(column.cellWordWidths) || column.cellWordWidths.length !== column.cells.length || column.cellWordWidths.some((width) => !Number.isFinite(width) || width < 0))) throw new Error("cellWordWidths must match cells and contain finite nonnegative widths.");
+      if (column.headerWordWidth !== void 0 && (!Number.isFinite(column.headerWordWidth) || column.headerWordWidth < 0)) throw new Error("headerWordWidth must be finite and nonnegative.");
+      if (column.cellPieceWidths !== void 0 && (!Array.isArray(column.cellPieceWidths) || column.cellPieceWidths.length !== column.cells.length || column.cellPieceWidths.some((width) => !Number.isFinite(width) || width < 0))) throw new Error("cellPieceWidths must match cells and contain finite nonnegative widths.");
+      const nonempty = column.cells.map((value, index) => ({ value, index })).filter(({ value }) => value != null && String(value).trim() !== "");
+      const values = nonempty.map(({ value }) => String(value));
+      if (column.headerWidth !== void 0 && (!Number.isFinite(column.headerWidth) || column.headerWidth < 0)) throw new Error("headerWidth must be finite and nonnegative.");
+      const headerWidth = column.headerWidth ?? measure(column.header) + config.cellPadding;
+      const analysis = analyze(column.header, values, measure);
+      const kind = column.kind ?? analysis.kind;
+      const measuredWidths = nonempty.map(({ value, index }) => column.cellWidths?.[index] ?? measure(String(value)) + config.cellPadding);
+      const protectedWidth = kind === "compact" ? measuredWidths.reduce((max, width) => width <= config.compactMaxProtectedWidth ? Math.max(max, width) : max, 0) : 0;
+      const preferredWidth = clamp(Math.max(headerWidth, protectedWidth, quantile(measuredWidths, config.percentile)), hardMinWidth, column.maxWidth ?? Infinity);
+      const contentFloor = Math.min(320, config.cellPadding + Math.max(0, quantile(measuredWidths, config.percentile) - config.cellPadding) / 3);
+      const floor = kind === "token-heavy" ? Math.max(config.tokenHeavyMinWidth, contentFloor) : kind === "narrative" ? Math.max(config.narrativeMinWidth, contentFloor) : Math.min(config.compactMaxProtectedWidth, preferredWidth);
+      const soft = column.numeric ? floor : Math.min(config.maxReadableFloor, floor);
+      const layout = { key: column.key, kind, preferredWidth, softMinWidth: clamp(soft, hardMinWidth, preferredWidth), hardMinWidth, width: preferredWidth, ratio: 0 };
+      if (kind === "compact") {
+        for (const width of new Set(measuredWidths)) {
+          if (width > preferredWidth && width <= (column.maxWidth ?? Infinity)) compactTargets.push({ column: layout, width });
+        }
+        if (!column.numeric) {
+          const words = nonempty.map(({ value, index }) => column.cellWordWidths?.[index] ?? longest(String(value), WORD_BREAKS, measure) + config.cellPadding);
+          const pieces = nonempty.map(({ value, index }) => column.cellPieceWidths?.[index] ?? longest(String(value), PIECE_BREAKS, measure) + config.cellPadding);
+          const least = Math.max(column.headerWordWidth ?? longest(column.header, WORD_BREAKS, measure) + config.cellPadding, ...pieces);
+          wordFloors.set(layout, { whole: Math.max(least, quantile(words, config.percentile)), least: Math.max(least, quantile(words, 0.5)) });
+        }
+      }
+      return layout;
+    });
+    const besideProse = layouts2.some((column) => column.kind === "narrative") ? wordFloors : /* @__PURE__ */ new Map();
+    for (const [column, { whole }] of besideProse) column.softMinWidth = clamp(Math.min(column.softMinWidth, whole), column.hardMinWidth, column.preferredWidth);
+    const target = config.totalWidth - columns.length * config.columnOverhead;
+    const readableWidth = layouts2.reduce((sum2, column) => sum2 + column.softMinWidth, 0);
+    const available = Math.max(target, readableWidth);
+    let spare = available - total(layouts2);
+    compactTargets.sort((a, b) => a.width - a.column.width - (b.width - b.column.width) || a.column.key.localeCompare(b.column.key));
+    for (const { column, width } of compactTargets) {
+      const extra = width - column.width;
+      if (extra > 0 && extra <= spare) {
+        column.width = width;
+        column.preferredWidth = width;
+        spare -= extra;
+      }
+    }
+    shrink(layouts2, available, config.cellPadding);
+    const excess = total(layouts2) - target;
+    if (excess > 0.5 && besideProse.size) {
+      const lowered = [...besideProse].map(([column, { least }]) => ({ column, floor: clamp(Math.min(column.softMinWidth, least), column.hardMinWidth, column.preferredWidth) }));
+      if (lowered.reduce((sum2, { column, floor }) => sum2 + column.width - floor, 0) >= excess) {
+        const widths = lowerWidest(lowered.map(({ column }) => column.width), lowered.map(({ floor }) => floor), excess);
+        lowered.forEach(({ column }, index) => {
+          column.width = widths[index];
+          column.softMinWidth = Math.min(column.softMinWidth, widths[index]);
+        });
+      }
+    }
+    const sum = total(layouts2);
+    layouts2.forEach((column) => {
+      column.ratio = column.width / sum;
+    });
+    return layouts2;
+  }
+
+  // src/shared/number-reading.mjs
+  function rawCellValue(cell) {
+    return (cell?.dataset.sortValue ?? cell?.textContent ?? "").trim();
+  }
+  var missingValues = /* @__PURE__ */ new Set(["", "-", "\u2014", "\u2013", "\u2212", "n/a", "na", "null"]);
+  function isMissingValue(raw) {
+    return missingValues.has(raw.toLowerCase());
+  }
+  var QUALIFIER = String.raw`(?:约|大约|近|超过|不足|≈|~|<=?|>=?|≤|≥|±)?`;
+  var AMOUNT = String.raw`[$¥€£₩₹]?\s*((?:\d{1,3}(?:[,\s\u00a0\u2009]\d{3})+|\d{1,4}(?:,\d{4})+|\d+)(?:\.\d*)?(?:e[+-]?\d+)?|\.\d+)`;
+  var UNIT = String.raw`((?:[%‰x×]|[A-Za-zµμ\u4e00-\u9fff°℃]+(?:\/[A-Za-zµμ\u4e00-\u9fff°℃·]+)?)?)`;
+  var UNIT_SCALES = { \u5343: 1e3, \u4E07: 1e4, \u4EBF: 1e8 };
+  var SCALE = UNIT_SCALES;
+  var SINGLE = new RegExp(`^${QUALIFIER}\\s*([+-]?)\\s*${AMOUNT}\\s*${UNIT}$`, "i");
+  var RANGE = new RegExp(`^([+-]?)\\s*${AMOUNT}\\s*${UNIT}\\s*(?:-|~|\u81F3|\u5230)\\s*[+-]?\\s*${AMOUNT}\\s*${UNIT}$`, "i");
+  function numberReading(raw) {
+    let text = raw.normalize("NFKC").trim().replace(/[−–—]/g, "-");
+    const accounting = /^\((.+)\)$/.exec(text);
+    if (accounting) text = accounting[1].trim();
+    const single = SINGLE.exec(text);
+    const match = single ?? RANGE.exec(text);
+    if (!match) return null;
+    const value = Number(`${match[1]}${match[2].replace(/[,\s\u00a0\u2009]/g, "")}`);
+    const written = accounting ? -value : value;
+    const unit = match[3] ?? "";
+    const scaled = written * (SCALE[unit[0]] ?? 1);
+    if (!Number.isFinite(scaled)) return null;
+    return single ? { value: scaled, written, unit } : { value: scaled, written, unit, range: true };
+  }
+  function numberValue(raw) {
+    return numberReading(raw)?.value ?? null;
+  }
+  function numericParts(cell) {
+    const raw = rawCellValue(cell);
+    if (isMissingValue(raw)) return null;
+    const scalar = numberValue(raw);
+    if (scalar !== null) return [scalar];
+    const tokens = raw.split(/\s*\/\s*/);
+    if (tokens.length < 2) return null;
+    const values = tokens.map(numberValue);
+    return values.every((value) => value !== null) ? values : null;
+  }
+  function parsedValue(cell, type) {
+    const raw = rawCellValue(cell);
+    if (isMissingValue(raw)) return null;
+    if (type === "number") {
+      const values = numericParts(cell);
+      return values?.length === 1 ? values[0] : null;
+    }
+    if (type === "date") {
+      const value = Date.parse(raw);
+      return Number.isFinite(value) ? value : null;
+    }
+    return raw;
+  }
+
+  // src/render/kit/tables/cells.js
+  function elementFor(target) {
+    const element = typeof target === "string" ? document.querySelector(target) : target;
+    if (!(element instanceof HTMLTableElement)) {
+      throw new Error("DocTables target must be a table element.");
+    }
+    return element;
+  }
+  var wrapperOf = (table) => table.parentElement?.classList.contains("doc-table-wrap") ? table.parentElement : null;
+  var numbersOff = (table) => table.getAttribute("data-number-columns") === "off" || wrapperOf(table)?.getAttribute("data-number-columns") === "off";
+  var mergedCells = (table) => [...table.tHead?.rows || [], ...Array.from(table.tBodies).flatMap((body) => [...body.rows])].some((row) => Array.from(row.cells).some((cell) => cell.rowSpan !== 1 || cell.colSpan !== 1));
+  function tableRows(table) {
+    return Array.from(table.tBodies).flatMap((body) => Array.from(body.rows));
+  }
+  var footRows = (table) => Array.from(table.tFoot?.rows || []);
+  function footColumns(table) {
+    const columns = /* @__PURE__ */ new Map();
+    const rows = footRows(table);
+    if (rows.some((row) => Array.from(row.cells).some((cell) => cell.rowSpan !== 1))) return columns;
+    for (const row of rows) {
+      let column = 0;
+      for (const cell of row.cells) {
+        if (cell.colSpan === 1) columns.set(column, [...columns.get(column) || [], cell]);
+        column += cell.colSpan;
+      }
+    }
+    return columns;
+  }
+  function cellText(cell) {
+    return cell.textContent.trim();
+  }
+  var RUN = /\/*[^\s/]+\/*|\/+|\s+/g;
+  var CODE_RUN = "doc-code-run";
+  var NAME_BREAK = /(?<=[^.\s]\.)(?=[^.])|(?<=[^_./\s])(?=_+[A-Za-z0-9])|(?<=[a-z0-9])(?=[A-Z])/;
+  var codeRuns = (text) => text.match(RUN) ?? [];
+  var runParts = (run) => run.split(NAME_BREAK);
+  function splitCodeRuns(table) {
+    for (const code of table.querySelectorAll("td code, th code")) {
+      if (code.closest("[contenteditable]") || code.querySelector(`.${CODE_RUN}`) || !code.textContent.trim() || [...code.childNodes].some((node) => node.nodeType !== Node.TEXT_NODE)) continue;
+      const doc = code.ownerDocument;
+      const pieces = codeRuns(code.textContent);
+      code.replaceChildren(...pieces.flatMap((piece, index) => {
+        if (!piece.trim()) return [doc.createTextNode(piece)];
+        const run = doc.createElement("span");
+        run.className = CODE_RUN;
+        run.replaceChildren(...runParts(piece).flatMap((part, at) => at ? [doc.createElement("wbr"), doc.createTextNode(part)] : [doc.createTextNode(part)]));
+        return piece.endsWith("/") && index < pieces.length - 1 ? [run, doc.createElement("wbr")] : [run];
+      }));
+    }
+  }
+  function joinCodeRuns(root) {
+    for (const code of new Set([...root.querySelectorAll(`.${CODE_RUN}`)].map((run) => run.parentElement))) code.textContent = code.textContent;
+  }
+  var TEXT_SORTS = /* @__PURE__ */ new Set(["text", "date"]);
+  function inferColumnSemantics(table) {
+    const headers = Array.from(table.tHead?.rows[0]?.cells || []);
+    const rows = tableRows(table);
+    if (mergedCells(table) || numbersOff(table)) {
+      table.querySelectorAll(".number").forEach((cell) => cell.classList.remove("number"));
+      headers.forEach((header) => {
+        if (header.dataset.sortType === "number") delete header.dataset.sortType;
+      });
+      return [];
+    }
+    if (headers.length === 0 || rows.length === 0) return [];
+    const numericColumns = [];
+    const foot = footColumns(table);
+    headers.forEach((header, index) => {
+      const cells = rows.map((row) => row.cells[index]).filter(Boolean);
+      if (cells.length === 0) return;
+      const observedCells = cells.filter((cell) => !isMissingValue(rawCellValue(cell)));
+      const inferredNumericDisplay = !TEXT_SORTS.has(header.dataset.sortType) && observedCells.length > 0 && observedCells.every((cell) => numericParts(cell) !== null);
+      const inferredSortableNumber = inferredNumericDisplay && observedCells.every((cell) => parsedValue(cell, "number") !== null);
+      header.classList.toggle("number", inferredNumericDisplay);
+      cells.forEach((cell) => cell.classList.toggle("number", inferredNumericDisplay));
+      (foot.get(index) || []).forEach((cell) => cell.classList.toggle(
+        "number",
+        inferredNumericDisplay && (isMissingValue(rawCellValue(cell)) || numericParts(cell) !== null)
+      ));
+      if (!inferredSortableNumber) {
+        if (header.dataset.sortType === "number") delete header.dataset.sortType;
+        if (inferredNumericDisplay) numericColumns.push(index);
+        return;
+      }
+      numericColumns.push(index);
+      if (!header.dataset.sortType && !header.hasAttribute("data-sort-ignore")) {
+        header.dataset.sortType = "number";
+      }
+    });
+    return numericColumns;
+  }
+
+  // src/shared/table-slots.mjs
+  function tileSlots(rows) {
+    const matrix = rows.map(() => []);
+    const places = /* @__PURE__ */ new Map();
+    for (let r = 0; r < rows.length; r++) {
+      let c = 0;
+      for (const { ref, rowspan, colspan } of rows[r].cells) {
+        while (matrix[r][c]) c++;
+        if (!(rowspan >= 1) || !(colspan >= 1)) return null;
+        for (let i = 0; i < rowspan; i++) {
+          if (rows[r + i]?.section !== rows[r].section) return null;
+          for (let j = 0; j < colspan; j++) {
+            if (matrix[r + i][c + j]) return null;
+            matrix[r + i][c + j] = ref;
+          }
+        }
+        places.set(ref, { r, c, rows: rowspan, cols: colspan });
+        c += colspan;
+      }
+    }
+    const columns = matrix[0]?.length ?? 0;
+    if (columns === 0 || matrix.some((row) => row.length !== columns || row.includes(void 0))) return null;
+    return { matrix, places, columns };
+  }
+  var slotsOf = (rows) => tileSlots(rows.map((row) => ({ section: row.parentElement, cells: [...row.cells].map((cell) => ({ ref: cell, rowspan: cell.rowSpan, colspan: cell.colSpan })) })));
+  var columnCells = (slots, c) => [...slots.places].filter(([, place]) => place.c === c && place.cols === 1).map(([ref]) => ref);
+  var columnWidths = (slots, widthOf) => Array.from({ length: slots.columns }, (_, c) => {
+    for (const cell of columnCells(slots, c)) {
+      const width = widthOf(cell);
+      if (width) return width;
+    }
+    return null;
+  });
+
+  // src/render/kit/tables/edges.js
+  var EDGE = "data-doc-edge";
+  function markEdges(table) {
+    const rows = [...table.rows];
+    const edges = /* @__PURE__ */ new Map();
+    const spans = table.parentElement?.classList.contains("doc-table-wrap") && rows.some((row) => [...row.cells].some((cell) => cell.rowSpan !== 1));
+    const slots = spans ? slotsOf(rows) : null;
+    if (slots) {
+      for (const [cell, { r, c, rows: down, cols }] of slots.places) {
+        const sides = [c + cols === slots.columns && "right", r + down === rows.length && "bottom"].filter(Boolean).join(" ");
+        if (sides) edges.set(cell, sides);
+      }
+    }
+    for (const cell of table.querySelectorAll(`:scope > * > tr > [${EDGE}]`)) if (!edges.has(cell)) cell.removeAttribute(EDGE);
+    for (const [cell, sides] of edges) if (cell.getAttribute(EDGE) !== sides) cell.setAttribute(EDGE, sides);
+  }
+
+  // src/shared/table-hides.mjs
+  function cellColumns(table) {
+    const taken = [];
+    const columnOf = /* @__PURE__ */ new Map();
+    let columns = 0;
+    [...table.rows].forEach((row, r) => {
+      let c = 0;
+      for (const cell of row.cells) {
+        while (taken[r]?.[c]) c++;
+        const across = Math.max(1, cell.colSpan);
+        for (let i = 0; i < Math.max(1, cell.rowSpan); i++) for (let j = 0; j < across; j++) (taken[r + i] ??= [])[c + j] = true;
+        columnOf.set(cell, c + across - 1);
+        c += across;
+        columns = Math.max(columns, c);
+      }
+    });
+    return { columnOf, columns };
+  }
+  function wordsBox(cell) {
+    const boxes = [];
+    const range = document.createRange();
+    const walker = document.createTreeWalker(cell, NodeFilter.SHOW_TEXT);
+    for (let node = walker.nextNode(); node; node = walker.nextNode()) {
+      if (!node.nodeValue.trim() || node.parentElement?.closest(".katex-mathml")) continue;
+      range.selectNodeContents(node);
+      boxes.push(...range.getClientRects());
+    }
+    for (const element of cell.querySelectorAll("img, svg, canvas, input, video")) boxes.push(element.getBoundingClientRect());
+    const drawn = boxes.filter((box) => box.width > 0 || box.height > 0);
+    if (drawn.length === 0) return null;
+    return {
+      left: Math.min(...drawn.map((box) => box.left)),
+      right: Math.max(...drawn.map((box) => box.right)),
+      top: Math.min(...drawn.map((box) => box.top)),
+      bottom: Math.max(...drawn.map((box) => box.bottom))
+    };
+  }
+  function tableHides(wrapper, table) {
+    const width = wrapper.clientWidth;
+    const height = wrapper.clientHeight;
+    const box = table.getBoundingClientRect();
+    const holds = (cell) => Boolean((cell.textContent ?? "").trim() || cell.querySelector("img, svg, canvas, input, video"));
+    const { columnOf, columns } = cellColumns(table);
+    const fixed = table.classList.contains("doc-table--sticky-first") || Boolean(table.querySelector(':scope > tbody > tr > th[scope="row"]:first-child'));
+    const before = /* @__PURE__ */ new Set();
+    const past = /* @__PURE__ */ new Set();
+    const names = [];
+    let reach = 0;
+    for (const row of table.rows) {
+      if (row.getClientRects().length === 0) continue;
+      for (const cell of row.cells) {
+        const column = columnOf.get(cell);
+        if (names[column] === void 0 && cell.colSpan <= 1 && holds(cell)) names[column] = (cell.textContent ?? "").replace(/\s+/g, " ").trim();
+        if (fixed && column === 0) continue;
+        if (cell.getBoundingClientRect().right - box.left <= width + 1) {
+          if (holds(cell)) before.add(column);
+          continue;
+        }
+        const found = wordsBox(cell);
+        if (!found) continue;
+        if (found.left - box.left < width - 1) before.add(column);
+        if (found.right - box.left > width + 1) {
+          past.add(column);
+          reach = Math.max(reach, found.right - box.left);
+        }
+      }
+    }
+    const named = (column) => ({ column, name: names[column] ?? "" });
+    const away = [...past].filter((column) => !before.has(column)).sort((a, b) => a - b).map(named);
+    const cut = [...past].filter((column) => before.has(column)).sort((a, b) => a - b).map(named);
+    const quoted = (list) => `${list.slice(0, 4).map(({ column, name }) => name ? `"${name.length > 16 ? `${name.slice(0, 15)}\u2026` : name}"` : `column ${column + 1}`).join(", ")}${list.length > 4 ? ", \u2026" : ""}`;
+    const parts = [cut.length && `${cut.length} cut at the frame's edge (${quoted(cut)})`, away.length && `${away.length} out of sight (${quoted(away)})`].filter(Boolean);
+    const rows = [...table.tBodies].flatMap((body) => [...body.rows]).filter((row) => row.getClientRects().length > 0);
+    const shown = rows.filter((row) => {
+      const { top, bottom } = row.getBoundingClientRect();
+      if (bottom - box.top <= height + 1) return true;
+      if (top - box.top >= height - 1) return false;
+      return Math.max(-Infinity, ...[...row.cells].map(wordsBox).filter(Boolean).map((found) => found.bottom)) - box.top <= height + 1;
+    }).length;
+    return { columns, away, cut, said: parts.length ? `of ${columns} columns, ${parts.join(", ")}` : "", reach, rows: rows.length, shown };
+  }
+
+  // src/render/kit/tables/sticky.js
+  function fixedFirstCell(table) {
+    return table.classList.contains("doc-table--sticky-first") ? table.rows[0]?.cells[0] ?? null : table.querySelector(':scope > tbody > tr > th[scope="row"]:first-child');
+  }
+
+  // src/render/kit/tables/scrollbars.js
+  var global = globalThis;
+  var RAIL = 12;
+  var MIN_THUMB = 24;
+  var scrollbars = /* @__PURE__ */ new WeakMap();
+  var probe = globalThis.document?.createElement("div");
+  function setStyle(element, property, value) {
+    probe.style.setProperty(property, value);
+    if (element.style.getPropertyValue(property) !== probe.style.getPropertyValue(property)) element.style.setProperty(property, value);
+  }
+  function drawScrollbars(wrapper, table) {
+    if (scrollbars.has(wrapper)) return;
+    let node = wrapper.querySelector(":scope > .doc-scrollbars");
+    if (!node) {
+      node = document.createElement("div");
+      node.className = "doc-scrollbars";
+      node.setAttribute("aria-hidden", "true");
+      node.innerHTML = '<div class="doc-scrollbar doc-scrollbar--y"><div class="doc-scrollbar-thumb"></div></div><div class="doc-scrollbar doc-scrollbar--x"><div class="doc-scrollbar-thumb"></div></div>';
+      wrapper.prepend(node);
+    }
+    let frame = node.querySelector(":scope > .doc-scrollbars-frame");
+    if (!frame) {
+      frame = document.createElement("div");
+      frame.className = "doc-scrollbars-frame";
+      node.prepend(frame);
+    }
+    const bars = { node, table, frame, y: node.querySelector(".doc-scrollbar--y"), x: node.querySelector(".doc-scrollbar--x"), timer: 0, axes: {}, noted: "", reach: 0 };
+    scrollbars.set(wrapper, bars);
+    wrapper.addEventListener("scroll", () => {
+      placeScrollbars(wrapper);
+      bars.node.setAttribute("data-active", "");
+      clearTimeout(bars.timer);
+      bars.timer = setTimeout(() => bars.node.removeAttribute("data-active"), 900);
+    }, { passive: true });
+    wrapper.addEventListener("wheel", (event) => passOn(wrapper, event), { passive: true });
+    const observer = new ResizeObserver(() => placeScrollbars(wrapper));
+    observer.observe(wrapper);
+    observer.observe(table);
+  }
+  function placeScrollbars(wrapper, { renote = false } = {}) {
+    const bars = scrollbars.get(wrapper);
+    if (!bars) return;
+    const { table } = bars;
+    const { clientWidth: width, clientHeight: height, offsetWidth, offsetHeight } = wrapper;
+    const content = { width: Math.max(width, table.offsetWidth), height: Math.max(height, table.offsetHeight) };
+    setStyle(bars.frame, "width", `${offsetWidth}px`);
+    setStyle(bars.frame, "height", `${offsetHeight}px`);
+    const x = content.width - width > 1, y = content.height - height > 1;
+    const sizes = `${width}x${height}:${content.width}x${content.height}`;
+    if (width > 0 && (renote || sizes !== bars.noted)) {
+      bars.noted = sizes;
+      bars.reach = noteHidden(wrapper, table);
+    }
+    bars.node.toggleAttribute("data-more", x && wrapper.scrollLeft + width < bars.reach - 1);
+    const style = getComputedStyle(wrapper);
+    const corner = (radius, border) => Math.max(0, (parseFloat(style[radius]) || 0) - (parseFloat(style[border]) || 0));
+    const header = table.tHead?.getBoundingClientRect().height || 0;
+    const first = fixedFirstCell(table)?.getBoundingClientRect().width || 0;
+    const place = (rail, start, end, fixed, view, total2, at) => {
+      const track = Math.max(0, end - start);
+      const size = Math.min(track, Math.max(MIN_THUMB, track * Math.max(0, view - fixed) / (total2 - fixed)));
+      const range = total2 - view;
+      setStyle(rail, "--doc-scrollbar-track", `${track}px`);
+      setStyle(rail, "--doc-scrollbar-thumb-size", `${size}px`);
+      setStyle(rail, "--doc-scrollbar-thumb-at", `${(track - size) * Math.min(1, Math.max(0, at / range))}px`);
+      return { track, size, range };
+    };
+    bars.node.toggleAttribute("data-x", x);
+    bars.node.toggleAttribute("data-y", y);
+    if (y) {
+      const start = Math.max(header, corner("borderTopRightRadius", "borderTopWidth"));
+      const end = height - Math.max(corner("borderBottomRightRadius", "borderBottomWidth"), x ? RAIL : 0);
+      setStyle(bars.y, "left", `${width - RAIL}px`);
+      setStyle(bars.y, "top", `${start}px`);
+      bars.axes.y = place(bars.y, start, end, header, height, content.height, wrapper.scrollTop);
+    }
+    if (x) {
+      const start = Math.max(first, corner("borderBottomLeftRadius", "borderLeftWidth"));
+      const end = width - Math.max(corner("borderBottomRightRadius", "borderRightWidth"), y ? RAIL : 0);
+      setStyle(bars.x, "left", `${start}px`);
+      setStyle(bars.x, "top", `${height - RAIL}px`);
+      bars.axes.x = place(bars.x, start, end, first, width, content.width, wrapper.scrollLeft);
+    }
+  }
+  function noteHidden(wrapper, table) {
+    const notes = [];
+    const hides = tableHides(wrapper, table);
+    if (hides.said) notes.push(`columns-hidden: ${hides.said} (scroll sideways)`);
+    if (hides.shown < hides.rows) notes.push(`rows-hidden: the frame shows ${hides.shown} of ${hides.rows} rows (scroll down)`);
+    const said = notes.join("\n");
+    if (said && wrapper.getAttribute("data-doc-layout") !== said) wrapper.setAttribute("data-doc-layout", said);
+    else if (!said && wrapper.hasAttribute("data-doc-layout")) wrapper.removeAttribute("data-doc-layout");
+    return hides.reach;
+  }
+  function passOn(wrapper, event) {
+    if (event.ctrlKey || !event.deltaY || getComputedStyle(wrapper).overscrollBehaviorBlock !== "none") return;
+    const atTop = wrapper.scrollTop <= 0;
+    const atEnd = wrapper.scrollTop + wrapper.clientHeight >= wrapper.scrollHeight - 1;
+    if (!(event.deltaY < 0 ? atTop : atEnd)) return;
+    const delta = event.deltaY * (event.deltaMode === 1 ? 16 : event.deltaMode === 2 ? innerHeight : 1);
+    for (let node = wrapper.parentElement; node && node !== document.body; node = node.parentElement) {
+      const { overflowY } = getComputedStyle(node);
+      if ((overflowY === "auto" || overflowY === "scroll") && node.scrollHeight > node.clientHeight + 1) return node.scrollBy({ top: delta, behavior: "instant" });
+    }
+    global.scrollBy({ top: delta, behavior: "instant" });
+  }
+  global.addEventListener("pointerdown", (event) => {
+    const rail = event.button === 0 ? event.target.closest?.(".doc-scrollbar") : null;
+    const wrapper = rail?.parentElement.parentElement;
+    if (!scrollbars.has(wrapper) || document.documentElement.hasAttribute("data-ge-resize")) return;
+    event.preventDefault();
+    event.stopPropagation();
+    const vertical = rail.classList.contains("doc-scrollbar--y");
+    const property = vertical ? "scrollTop" : "scrollLeft";
+    const along = (pointer) => vertical ? pointer.clientY - rail.getBoundingClientRect().top : pointer.clientX - rail.getBoundingClientRect().left;
+    const { track = 0, size = 0, range = 0 } = scrollbars.get(wrapper).axes[vertical ? "y" : "x"] ?? {};
+    const perPixel = track > size ? range / (track - size) : 0;
+    if (event.target === rail) wrapper[property] = (along(event) - size / 2) * perPixel;
+    const start = { pointer: along(event), scroll: wrapper[property] };
+    rail.setAttribute("data-drag", "");
+    rail.setPointerCapture?.(event.pointerId);
+    const move = (moved) => {
+      wrapper[property] = start.scroll + (along(moved) - start.pointer) * perPixel;
+    };
+    const end = () => {
+      rail.removeAttribute("data-drag");
+      rail.removeEventListener("pointermove", move);
+      rail.removeEventListener("pointerup", end);
+      rail.removeEventListener("pointercancel", end);
+    };
+    rail.addEventListener("pointermove", move);
+    rail.addEventListener("pointerup", end);
+    rail.addEventListener("pointercancel", end);
+  }, true);
+
+  // src/render/kit/tables/whole.js
+  var WHOLE_ROWS = 20;
+  function shownWhole(rows, columns) {
+    if (rows <= WHOLE_ROWS) return true;
+    const all = columns.reduce((sum, column) => sum + column.width, 0);
+    const words = columns.reduce((sum, column) => sum + (column.words ? column.width : 0), 0);
+    return all > 0 && words * 2 >= all;
+  }
+
+  // src/render/kit/tables/layout.js
+  var COLUMN_FLOOR = 120;
+  var COLUMN_NATURAL_MAX = 240;
+  var NARROW = "(max-width: 420px)";
+  var CODE_RUN_MAX = 320;
+  var WIDE = "\u2014\u3000-\u30FF\u3400-\u9FFF\uAC00-\uD7AF\uF900-\uFAFF\uFF00-\uFFEF";
+  var NATIVE_BREAKS = new RegExp(`(?<=-)|(?<=[${WIDE}])|(?=[${WIDE}])`, "u");
+  var layouts = /* @__PURE__ */ new WeakMap();
+  var layoutObservers = /* @__PURE__ */ new WeakMap();
+  var pendingLayouts = /* @__PURE__ */ new Set();
+  var layoutFrame = 0;
+  var fontOf = (style) => `${style.fontStyle || "normal"} ${style.fontWeight || "400"} ${style.fontSize || "15px"} ${style.fontFamily || "system-ui"}`;
+  function fontFor(element) {
+    return fontOf(getComputedStyle(element));
+  }
+  var familyName = (name) => name.trim().replace(/^(["'])(.*)\1$/, "$2").toLowerCase();
+  var familiesOf = (list) => list.split(",").map(familyName).filter(Boolean);
+  var measurers = /* @__PURE__ */ new Map();
+  function measurerFor(font, family) {
+    let measurer = measurers.get(font);
+    if (!measurer) measurers.set(font, measurer = { measure: createTextMeasurer(font), families: familiesOf(family) });
+    return measurer.measure;
+  }
+  function forgetMeasurers(faces) {
+    if (!faces) return measurers.clear();
+    const loaded = new Set(faces.map((face) => familyName(String(face.family ?? ""))));
+    for (const [font, { families }] of [...measurers]) if (families.some((name) => loaded.has(name))) measurers.delete(font);
+  }
+  globalThis.document?.fonts?.addEventListener?.("loadingdone", (event) => forgetMeasurers([...event.fontfaces ?? []]));
+  globalThis.document?.fonts?.ready.then(() => forgetMeasurers());
+  var cellMeasures = /* @__PURE__ */ new WeakMap();
+  var measuredRatio = globalThis.devicePixelRatio;
+  function sameZoom() {
+    if (globalThis.devicePixelRatio === measuredRatio) return;
+    measuredRatio = globalThis.devicePixelRatio;
+    measurers.clear();
+    cellMeasures = /* @__PURE__ */ new WeakMap();
+  }
+  var measuredFamilies = /* @__PURE__ */ new WeakMap();
+  var forgetMeasures = (table) => cellMeasures.delete(table);
+  function fontsChange(table, faces) {
+    const families = measuredFamilies.get(table);
+    if (!faces || !families) return "words";
+    const names = faces.map((face) => familyName(String(face.family ?? "")));
+    if (names.some((name) => families.has(name))) return "words";
+    return names.some((name) => name.startsWith("katex")) && table.querySelector(".katex") ? "formulas" : "";
+  }
+  function cellPaddingFor(style) {
+    return (parseFloat(style.paddingLeft || "12px") || 0) + (parseFloat(style.paddingRight || "12px") || 0) + (parseFloat(style.borderLeftWidth) || 0) + (parseFloat(style.borderRightWidth) || 0);
+  }
+  var tabularDigits = /* @__PURE__ */ new Map();
+  function tabularDigitWidth(font) {
+    if (!tabularDigits.has(font)) {
+      const probe2 = document.createElement("span");
+      probe2.style.cssText = `position:absolute;visibility:hidden;white-space:pre;font:${font};font-variant-numeric:tabular-nums`;
+      probe2.textContent = "0123456789";
+      document.body.append(probe2);
+      tabularDigits.set(font, probe2.getBoundingClientRect().width / 10);
+      probe2.remove();
+    }
+    return tabularDigits.get(font);
+  }
+  function codeEdges(style) {
+    return (parseFloat(style.paddingLeft) || 0) + (parseFloat(style.paddingRight) || 0) + (parseFloat(style.borderLeftWidth) || 0) + (parseFloat(style.borderRightWidth) || 0);
+  }
+  function contextOf(table) {
+    const root = document.documentElement;
+    const classes = [...table.classList].filter((name) => name !== "doc-table--auto").join(" ");
+    return `${classes}${wrapperOf(table)?.className ?? ""}${root.getAttribute("data-doc-theme") ?? ""}|${root.getAttribute("data-doc-width") ?? ""}`;
+  }
+  function createCellMeasurer(table) {
+    sameZoom();
+    const styles = /* @__PURE__ */ new Map();
+    const kept = cellMeasures.get(table);
+    const measured = /* @__PURE__ */ new Map();
+    const families = /* @__PURE__ */ new Set();
+    const context = contextOf(table);
+    let using = null;
+    const styleOf = (element) => {
+      let style = styles.get(element);
+      if (!style) {
+        const computed = getComputedStyle(element);
+        style = { computed, font: fontOf(computed), family: computed.fontFamily || "system-ui", spacing: parseFloat(computed.letterSpacing) || 0, tabular: /tabular-nums/.test(computed.fontVariantNumeric || "") };
+        styles.set(element, style);
+      }
+      return style;
+    };
+    const widthOf = (text, parent) => {
+      const { font, family, spacing, tabular } = styleOf(parent);
+      using?.add(family);
+      const measureText = measurerFor(font, family);
+      const digits = tabular ? text.replace(/\D/g, "").length : 0;
+      return (digits ? measureText(text.replace(/\d/g, "")) + digits * tabularDigitWidth(font) : measureText(text)) + Math.max(0, text.length - 1) * spacing;
+    };
+    const cellKey = (cell) => {
+      if (cell.querySelector(".katex")) return null;
+      const { computed, font } = styleOf(cell);
+      return `${context}
${cell.className}
${cell.getAttribute("style") ?? ""}
${font}|${computed.letterSpacing}|${computed.fontVariantNumeric}|${computed.paddingLeft}|${computed.paddingRight}|${computed.borderLeftWidth}|${computed.borderRightWidth}
${cell.innerHTML}`;
+    };
+    const measureCell = (cell) => {
+      let entry = measured.get(cell);
+      if (!entry) {
+        const key = cellKey(cell);
+        const before = key === null ? null : kept?.get(cell);
+        if (before && before.key === key) entry = before;
+        else {
+          using = /* @__PURE__ */ new Set();
+          entry = { key, result: measureWords(cell), families: using };
+          using = null;
+        }
+        measured.set(cell, entry);
+        entry.families.forEach((family) => families.add(family));
+      }
+      return entry.result;
+    };
+    const measure = (cell) => measureCell(cell).width;
+    measure.least = (cell) => measureCell(cell).least;
+    measure.run = (cell) => measureCell(cell).run;
+    measure.word = (cell) => measureCell(cell).word;
+    measure.piece = (cell) => measureCell(cell).piece;
+    measure.done = () => {
+      if (measured.size === 0) return measuredFamilies.delete(table);
+      cellMeasures.set(table, new Map([...measured].filter(([, entry]) => entry.key !== null)));
+      measuredFamilies.set(table, new Set([...families].flatMap(familiesOf)));
+    };
+    return measure;
+    function measureWords(cell) {
+      let line = 0, widest = 0, lastSpace = true, run = 0;
+      const word = { now: 0, widest: 0 }, piece = { now: 0, widest: 0 };
+      const along = (part, width, restart) => {
+        part.now = (restart ? 0 : part.now) + width;
+        part.widest = Math.max(part.widest, part.now);
+      };
+      const content = cell;
+      const walk = (node) => {
+        if (node.nodeType === Node.TEXT_NODE) {
+          let text = node.textContent.replace(/\s+/g, " ");
+          if (lastSpace) text = text.replace(/^ /, "");
+          if (!text) return;
+          const parent = node.parentElement;
+          const width = widthOf(text, parent);
+          line += width;
+          lastSpace = text.endsWith(" ");
+          if (parent.closest(".doc-range")) {
+            run = Math.max(run, width);
+            along(word, width, false);
+            along(piece, width, false);
+            return;
+          }
+          text.split(WORD_BREAKS).forEach((part, index) => along(word, widthOf(part, parent), index > 0));
+          text.split(PIECE_BREAKS).forEach((part, index) => along(piece, widthOf(part, parent), index > 0));
+          return;
+        }
+        if (node.nodeType !== Node.ELEMENT_NODE) return;
+        if (node.tagName === "BR") {
+          widest = Math.max(widest, line);
+          line = 0;
+          lastSpace = true;
+          word.now = piece.now = 0;
+          return;
+        }
+        if (node.classList.contains("katex")) {
+          const drawn = [...node.getClientRects()].reduce((sum, rect) => sum + rect.width, 0);
+          line += drawn;
+          along(word, drawn, false);
+          along(piece, drawn, false);
+          lastSpace = false;
+          return;
+        }
+        if (node.classList.contains("doc-link-mention-icon")) {
+          const { computed } = styleOf(node);
+          const drawn = (parseFloat(computed.width) || 0) + (parseFloat(computed.marginInlineEnd) || 0);
+          line += drawn;
+          along(word, drawn, false);
+          along(piece, drawn, false);
+          lastSpace = false;
+          return;
+        }
+        if (node.tagName === "UL" || node.tagName === "OL") {
+          widest = Math.max(widest, line);
+          const indent = parseFloat(styleOf(node).computed.paddingInlineStart) || 0;
+          for (const item of node.children) {
+            line = word.now = piece.now = indent;
+            lastSpace = true;
+            item.childNodes.forEach(walk);
+            widest = Math.max(widest, line);
+          }
+          line = word.now = piece.now = 0;
+          lastSpace = true;
+          return;
+        }
+        if (node.tagName === "CODE") {
+          const edges = codeEdges(styleOf(node).computed);
+          const runs = node.querySelector(`.${CODE_RUN}`) ? codeRuns(node.textContent) : node.textContent.split(/\s+/).flatMap((part) => part.split(NATIVE_BREAKS));
+          for (const part of runs) if (part.trim()) run = Math.max(run, widthOf(part, node) + edges);
+        }
+        if (node !== content) {
+          const style = styleOf(node).computed;
+          line += (parseFloat(style.paddingLeft) || 0) + (parseFloat(style.paddingRight) || 0);
+        }
+        node.childNodes.forEach(walk);
+      };
+      walk(content);
+      const padding = cellPaddingFor(styleOf(cell).computed);
+      return {
+        width: Math.ceil(Math.max(widest, line) + padding),
+        least: run > 0 ? Math.ceil(Math.min(run, CODE_RUN_MAX) + padding) : 0,
+        run: run > 0 ? Math.ceil(run + padding) : 0,
+        word: Math.ceil(word.widest + padding),
+        piece: Math.ceil(piece.widest + padding)
+      };
+    }
+  }
+  function frameOf(table) {
+    const wrapper = wrapperOf(table);
+    const sized = Boolean(wrapper) && getComputedStyle(wrapper).getPropertyValue("--doc-span-width").trim() !== "";
+    const wider = sized ? Math.max(1, parseFloat(getComputedStyle(wrapper).getPropertyValue("--doc-span")) || 1) : 1;
+    return { wrapper, sized, wider, previousWidth: wrapper?.style.width };
+  }
+  function sizedInside({ wrapper, sized, wider }) {
+    if (!sized) return null;
+    wrapper.style.width = "";
+    const style = getComputedStyle(wrapper);
+    const inner = wrapper.clientWidth - (parseFloat(style.paddingLeft) || 0) - (parseFloat(style.paddingRight) || 0);
+    return inner > 0 ? { wider, inner } : null;
+  }
+  function frameEdges(wrapper) {
+    const style = getComputedStyle(wrapper);
+    return (parseFloat(style.borderLeftWidth) || 0) + (parseFloat(style.borderRightWidth) || 0) + (parseFloat(style.paddingLeft) || 0) + (parseFloat(style.paddingRight) || 0);
+  }
+  var scratch = globalThis.document?.createElement("col");
+  function writeColgroup(table, columns) {
+    let colgroup = table.querySelector(":scope > colgroup[data-doc-columns]");
+    if (!colgroup) {
+      table.querySelectorAll(":scope > colgroup").forEach((node) => node.remove());
+      colgroup = document.createElement("colgroup");
+      colgroup.dataset.docColumns = "";
+      table.insertBefore(colgroup, table.firstElementChild?.tagName === "CAPTION" ? table.firstElementChild.nextSibling : table.firstElementChild);
+    }
+    const cols = colgroup.children;
+    const same = ({ width, key }, index) => {
+      const col = cols[index];
+      scratch.style.width = width;
+      return col.attributes.length === 2 && col.dataset.columnKey === key && col.style.width === scratch.style.width;
+    };
+    if (cols.length === columns.length && columns.every(same)) return;
+    colgroup.replaceChildren(...columns.map(({ width, key }) => {
+      const col = document.createElement("col");
+      col.style.width = width;
+      col.dataset.columnKey = key;
+      return col;
+    }));
+  }
+  function clearColumnMarks(table) {
+    table.querySelectorAll("[data-column-kind], [data-column-wrap], [data-run-wrap]").forEach((cell) => {
+      delete cell.dataset.columnKind;
+      cell.removeAttribute("data-column-wrap");
+      cell.removeAttribute("data-run-wrap");
+    });
+  }
+  var setAttribute = (element, name, value) => {
+    if (element.getAttribute(name) !== value) element.setAttribute(name, value);
+  };
+  var markRunWrap = (cell, width, measureCell) => cell.toggleAttribute("data-run-wrap", measureCell.run(cell) > width + 0.5);
+  function clearAuto(table, wrapper) {
+    table.classList.remove("doc-table--auto");
+    table.style.removeProperty("width");
+    table.querySelector("colgroup[data-doc-columns]")?.remove();
+    clearColumnMarks(table);
+    if (wrapper) {
+      wrapper.style.removeProperty("width");
+      delete wrapper.dataset.docMinWidth;
+    }
+    layouts.delete(table);
+  }
+  var tableSlots = (table) => slotsOf([...table.rows]);
+  var columnWidthOf = (cell) => {
+    const width = parseFloat(cell.style.getPropertyValue("--doc-column-width"));
+    return width > 0 ? width : null;
+  };
+  function manualWidths(table) {
+    const slots = tableSlots(table);
+    if (!slots) return null;
+    const widths = columnWidths(slots, columnWidthOf);
+    return widths.some((width) => width !== null) ? widths : null;
+  }
+  function manualLayout(table, frame, widths, measureCell) {
+    const { wrapper } = frame;
+    const slots = tableSlots(table);
+    const natural = widths.map((width, index) => width ?? Math.min(COLUMN_NATURAL_MAX, Math.max(COLUMN_FLOOR, ...columnCells(slots, index).map(measureCell))));
+    const frameSize = sizedInside(frame);
+    const scale = frameSize ? frameSize.inner * frameSize.wider / natural.reduce((sum, width) => sum + width, 0) : 1;
+    const sizes = natural.map((width) => width * scale);
+    const total2 = sizes.reduce((sum, width) => sum + width, 0);
+    table.classList.add("doc-table--auto");
+    table.style.width = `${total2}px`;
+    clearColumnMarks(table);
+    if (wrapper) {
+      const edges = frameEdges(wrapper);
+      setAttribute(wrapper, "data-doc-min-width", String(Math.min(total2, COLUMN_FLOOR) + edges));
+      if (!frameSize) {
+        wrapper.style.width = "100%";
+        const style = getComputedStyle(wrapper);
+        const available = wrapper.clientWidth - (parseFloat(style.paddingLeft) || 0) - (parseFloat(style.paddingRight) || 0);
+        wrapper.style.width = total2 < available ? `${total2 + edges}px` : "100%";
+      }
+    }
+    writeColgroup(table, sizes.map((width, index) => ({ width: `${width}px`, key: String(index) })));
+    layouts.set(table, sizes.map((width, index) => ({ key: String(index), kind: "compact", preferredWidth: width, softMinWidth: width, hardMinWidth: width, width, ratio: width / total2 })));
+    for (const [cell, { c, cols }] of slots?.places ?? []) markRunWrap(cell, sizes.slice(c, c + cols).reduce((sum, width) => sum + width, 0), measureCell);
+  }
+  function raiseNarrow(widths, room, floor) {
+    const low = widths.filter((width) => width < floor).sort((a, b) => a - b);
+    let level = floor;
+    if (low.reduce((sum, width) => sum + floor - width, 0) > room) {
+      let sum = 0;
+      for (let index = 0; index < low.length; index++) {
+        sum += low[index];
+        level = (room + sum) / (index + 1);
+        if (index === low.length - 1 || level <= low[index + 1]) break;
+      }
+    }
+    return widths.map((width) => Math.max(width, Math.min(level, floor)));
+  }
+  function refreshLayout(table) {
+    idleLayouts.delete(table);
+    const measure = createCellMeasurer(table);
+    layOut(table, measure);
+    measure.done();
+    markWhole(table);
+    const wrapper = wrapperOf(table);
+    if (wrapper) placeScrollbars(wrapper, { renote: true });
+  }
+  function layOut(table, measure) {
+    const headers = [...table.tHead?.rows[0]?.cells || []];
+    const rows = [...tableRows(table), ...footRows(table)];
+    const spanned = [...table.rows].some((row) => [...row.cells].some((cell) => cell.colSpan !== 1 || cell.rowSpan !== 1));
+    const frame = frameOf(table);
+    const manual = manualWidths(table);
+    if (manual) return manualLayout(table, frame, manual, measure);
+    const count = headers.length || rows[0]?.cells.length || 0;
+    if (!count || table.tHead && table.tHead.rows.length !== 1 || spanned) return nativeLayout(table, frame);
+    allocatedLayout(table, frame, headers, rows, count, measure);
+  }
+  var wholeTexts = /* @__PURE__ */ new WeakMap();
+  function markWhole(table) {
+    const wrapper = wrapperOf(table);
+    if (!wrapper) return;
+    const rows = bodyRows(table);
+    const whole = rows.length <= WHOLE_ROWS || mostlyWords(table, rows);
+    const was = wrapper.hasAttribute("data-doc-whole");
+    wrapper.toggleAttribute("data-doc-whole", whole);
+    if (was && !whole) keepCaret(wrapper);
+  }
+  function bodyRows(table) {
+    const rows = tableRows(table);
+    const headerCells = (row) => row.cells.length > 0 && [...row.cells].every((cell) => cell.tagName === "TH");
+    return !table.tHead && rows.length > 1 && headerCells(rows[0]) && !headerCells(rows[1]) ? rows.slice(1) : rows;
+  }
+  var textMeasurers = /* @__PURE__ */ new Map();
+  function mostlyWords(table, rows) {
+    const slots = slotsOf(rows);
+    const columns = [];
+    rows.forEach((row) => [...row.cells].forEach((cell, index) => {
+      const text2 = cellText(cell);
+      if (text2) (columns[slots ? slots.places.get(cell).c : index] ??= []).push(text2);
+    }));
+    const font = fontFor(rows[0]?.cells[0] || table);
+    const text = `${font}
+${columns.map((texts) => texts?.join("\n") ?? "").join("\f")}`;
+    const kept = wholeTexts.get(table);
+    if (kept?.text === text) return kept.whole;
+    if (!textMeasurers.has(font)) textMeasurers.set(font, createTextMeasurer(font));
+    const measure = textMeasurers.get(font);
+    const whole = shownWhole(rows.length, columns.filter(Boolean).map((texts) => ({
+      words: columnKind("", texts, measure) === "narrative",
+      width: texts.reduce((sum, each) => sum + measure(each), 0)
+    })));
+    wholeTexts.set(table, { text, whole });
+    return whole;
+  }
+  function keepCaret(wrapper) {
+    const node = globalThis.getSelection?.()?.focusNode;
+    const cell = (node?.nodeType === Node.ELEMENT_NODE ? node : node?.parentElement)?.closest("td, th");
+    if (!cell || !wrapper.contains(cell)) return;
+    const frame = wrapper.getBoundingClientRect();
+    const below = cell.getBoundingClientRect().bottom - (frame.top + wrapper.clientTop + wrapper.clientHeight);
+    if (below > 0) wrapper.scrollTop += below;
+  }
+  function nativeLayout(table, frame) {
+    if (table.classList.contains("doc-table--auto")) clearAuto(table, frame.wrapper);
+    const frameSize = sizedInside(frame);
+    if (frameSize) {
+      table.dataset.docFilled = "";
+      table.style.width = frameSize.wider > 1 ? `${frameSize.inner * frameSize.wider}px` : "100%";
+    } else if (table.hasAttribute("data-doc-filled")) {
+      table.removeAttribute("data-doc-filled");
+      table.style.removeProperty("width");
+    }
+  }
+  function allocatedLayout(table, frame, headers, rows, count, measureCell) {
+    table.removeAttribute("data-doc-filled");
+    const { wrapper, sized, wider, previousWidth } = frame;
+    const parent = wrapper || table.parentElement;
+    if (!parent) return;
+    if (wrapper) wrapper.style.width = sized ? "" : "100%";
+    const style = getComputedStyle(parent);
+    const padding = (parseFloat(style.paddingLeft) || 0) + (parseFloat(style.paddingRight) || 0);
+    const border = (parseFloat(style.borderLeftWidth) || 0) + (parseFloat(style.borderRightWidth) || 0);
+    const available = (parent.clientWidth || parent.getBoundingClientRect().width - border) - padding;
+    if (!(available > 0)) {
+      if (wrapper) wrapper.style.width = previousWidth;
+      return;
+    }
+    const font = fontFor(rows[0]?.cells[0] || table);
+    const cellPadding = cellPaddingFor(getComputedStyle(rows[0]?.cells[0] || headers[0]));
+    const measuredCells = /* @__PURE__ */ new Map();
+    for (const cell of [...headers, ...rows.flatMap((row) => [...row.cells])]) measuredCells.set(cell, measureCell(cell));
+    const narrow = Boolean(globalThis.matchMedia?.(NARROW).matches);
+    const share = narrow ? available / 3 : Infinity;
+    const runRoom = narrow ? Math.max(share, available - (count - 1) * share) : Infinity;
+    const columns = Array.from({ length: count }, (_, index) => {
+      const cells = [headers[index], ...rows.map((row) => row.cells[index])].filter(Boolean);
+      const least = Math.min(runRoom, Math.max(0, ...cells.map(measureCell.least)));
+      return {
+        key: headers[index]?.dataset.columnKey || String(index),
+        header: headers[index] ? cellText(headers[index]) : "",
+        headerWidth: headers[index] ? measuredCells.get(headers[index]) : 0,
+        // Include filtered-out rows so toggling a filter does not shift the columns.
+        cells: rows.map((row) => row.cells[index] ? cellText(row.cells[index]) : ""),
+        cellWidths: rows.map((row) => measuredCells.get(row.cells[index]) ?? 0),
+        // Its longest words (WORD_BREAKS), for a short text column that wraps beside columns of prose.
+        headerWordWidth: headers[index] ? measureCell.word(headers[index]) : 0,
+        cellWordWidths: rows.map((row) => row.cells[index] ? measureCell.word(row.cells[index]) : 0),
+        // Its widest pieces no line breaks in (PIECE_BREAKS), the least such a column is lowered to.
+        cellPieceWidths: rows.map((row) => row.cells[index] ? measureCell.piece(row.cells[index]) : 0),
+        // A numeric column (cells.js) keeps its floor on a narrow screen: a number never wraps.
+        numeric: cells.some((cell) => cell.classList.contains("number")),
+        ...least > 0 ? { minWidth: least } : {}
+      };
+    });
+    const target = available * wider;
+    const result = allocateColumnWidths(columns, { totalWidth: target, font, cellPadding, ...share < Infinity ? { maxReadableFloor: share } : {} });
+    let sum = result.reduce((value, column) => value + column.width, 0);
+    if (!sized && sum < available) {
+      const raised = raiseNarrow(result.map((column) => column.width), available - sum, COLUMN_FLOOR);
+      result.forEach((column, index) => {
+        column.width = raised[index];
+      });
+      sum = Math.min(available, raised.reduce((value, width) => value + width, 0));
+      if (available - sum < 0.01) sum = available;
+      result.forEach((column) => {
+        column.ratio = column.width / sum;
+      });
+    }
+    const tableWidth = sized ? Math.max(target, sum) : sum;
+    table.classList.add("doc-table--auto");
+    table.style.width = sized && tableWidth <= available + 4 ? "100%" : `${tableWidth}px`;
+    if (wrapper) setAttribute(wrapper, "data-doc-min-width", String(Math.ceil(result.reduce((value, column) => value + column.softMinWidth, 0) + border + padding)));
+    if (wrapper && !sized) wrapper.style.width = tableWidth >= available - 0.01 ? "100%" : `${tableWidth + border + padding}px`;
+    writeColgroup(table, result.map((column) => ({ width: `${column.ratio * 100}%`, key: column.key })));
+    result.forEach((column, index) => {
+      for (const cell of [headers[index], ...rows.map((row) => row.cells[index])].filter(Boolean)) {
+        setAttribute(cell, "data-column-kind", column.kind);
+        const width = column.ratio * tableWidth;
+        if (measuredCells.get(cell) > width + 0.5) setAttribute(cell, "data-column-wrap", (cell.tagName === "TH" || column.kind === "compact") && measureCell.word(cell) <= width + 0.5 ? "words" : "");
+        else cell.removeAttribute("data-column-wrap");
+        markRunWrap(cell, width, measureCell);
+      }
+    });
+    layouts.set(table, result.map((column) => ({ ...column, width: column.ratio * tableWidth })));
+  }
+  function queueLayout(table) {
+    pendingLayouts.add(table);
+    if (layoutFrame) return;
+    layoutFrame = requestAnimationFrame(() => {
+      layoutFrame = 0;
+      const tables = [...pendingLayouts];
+      pendingLayouts.clear();
+      tables.filter((table2) => table2.isConnected).forEach(refreshLayout);
+    });
+  }
+  var idleLayouts = /* @__PURE__ */ new Set();
+  var idleQueued = false;
+  function idleLayout(table) {
+    idleLayouts.add(table);
+    if (idleQueued) return;
+    idleQueued = true;
+    const run = () => {
+      idleQueued = false;
+      const tables = [...idleLayouts];
+      idleLayouts.clear();
+      tables.forEach(queueLayout);
+    };
+    if (globalThis.requestIdleCallback) requestIdleCallback(run, { timeout: 1e3 });
+    else setTimeout(run, 50);
+  }
+  function applyColumnWidths(table, { layout = true } = {}) {
+    if (!layoutObservers.has(table)) {
+      const previous = /* @__PURE__ */ new WeakMap();
+      const observer = new ResizeObserver((entries) => {
+        for (const { target, contentRect } of entries) {
+          if (contentRect.width !== previous.get(target)) {
+            previous.set(target, contentRect.width);
+            queueLayout(table);
+          }
+        }
+      });
+      const wrapper = wrapperOf(table);
+      const parent = wrapper ? wrapper.parentElement : table.parentElement;
+      if (parent) observer.observe(parent);
+      if (wrapper) observer.observe(wrapper);
+      layoutObservers.set(table, observer);
+      if (wrapper) drawScrollbars(wrapper, table);
+    }
+    if (layout) queueLayout(table);
+  }
+  function applyLayoutDefaults(table, options) {
+    applyColumnWidths(table, options);
+    return table;
+  }
+
+  // src/render/kit/words.js
+  var TABLES = {
+    "sorted-ascending": { zh: "{0}\uFF1A\u5F53\u524D\u5347\u5E8F\uFF0C\u70B9\u51FB\u5207\u6362", en: "{0}: sorted ascending, click to switch" },
+    "sorted-descending": { zh: "{0}\uFF1A\u5F53\u524D\u964D\u5E8F\uFF0C\u70B9\u51FB\u5207\u6362", en: "{0}: sorted descending, click to switch" },
+    "sort-ascending": { zh: "{0}\uFF1A\u70B9\u51FB\u6309\u5347\u5E8F\u6392\u5E8F", en: "{0}: click to sort ascending" },
+    "sort-descending": { zh: "{0}\uFF1A\u70B9\u51FB\u6309\u964D\u5E8F\u6392\u5E8F", en: "{0}: click to sort descending" },
+    "status-ascending": { zh: "\u5F53\u524D\u6392\u5E8F\uFF1A{0} \xB7 \u5347\u5E8F", en: "Sorted by {0} \xB7 ascending" },
+    "status-descending": { zh: "\u5F53\u524D\u6392\u5E8F\uFF1A{0} \xB7 \u964D\u5E8F", en: "Sorted by {0} \xB7 descending" },
+    "original-order": { zh: "\u539F\u59CB\u987A\u5E8F", en: "Original order" }
+  };
+  var UI_LANGUAGE = "data-ge-language";
+  function kitLanguage(root = globalThis.document?.documentElement) {
+    const ui = root?.getAttribute(UI_LANGUAGE) ?? null;
+    const english = ui !== null ? ui === "en" : /^en(?:-|$)/i.test(root?.getAttribute("lang") ?? "");
+    return english ? "en" : "zh";
+  }
+  function wordIn(table, language, key, ...values) {
+    const entry = table[key];
+    if (!entry) throw new Error(`The kit has no word "${key}" here (src/render/kit/words.js).`);
+    const text = entry[language] ?? entry.zh;
+    return values.length === 0 ? text : text.replace(/\{(\d+)\}/g, (whole, index) => index < values.length ? String(values[index]) : whole);
+  }
+  var sayer = (table) => (key, ...values) => wordIn(table, kitLanguage(), key, ...values);
+  var sayTables = /* @__PURE__ */ sayer(TABLES);
+  var ENGLISH_ROOT = `:root[${UI_LANGUAGE}="en"], :root:not([${UI_LANGUAGE}])[lang|="en" i]`;
+
+  // src/render/kit/tables/sort.js
+  var collator = new Intl.Collator("zh-CN", {
+    numeric: true,
+    sensitivity: "base"
+  });
+  var controllers = /* @__PURE__ */ new WeakMap();
+  var heldOrder = () => document.documentElement.getAttribute("data-ge-order") === "file";
+  function compareValues(left, right, direction) {
+    if (left == null && right == null) return 0;
+    if (left == null) return 1;
+    if (right == null) return -1;
+    const comparison = typeof left === "number" && typeof right === "number" ? left - right : collator.compare(String(left), String(right));
+    return direction === "asc" ? comparison : -comparison;
+  }
+  function statusElement(table) {
+    const selector = table.dataset.sortStatus;
+    if (!selector) return null;
+    try {
+      return document.querySelector(selector);
+    } catch {
+      return null;
+    }
+  }
+  function controlFor(header) {
+    const button = document.createElement("button");
+    button.type = "button";
+    button.className = "doc-table-sort-button";
+    button.setAttribute("contenteditable", "false");
+    header.append(button);
+    return button;
+  }
+  function makeSortable(target) {
+    const table = elementFor(target);
+    const known = controllers.get(table);
+    if (known) {
+      known.sync();
+      return table;
+    }
+    applyLayoutDefaults(table);
+    inferColumnSemantics(table);
+    const body = table.tBodies[0];
+    if (!body || mergedCells(table) || sortableColumns(table).length === 0) return table;
+    let columns = [];
+    const originalOrder = /* @__PURE__ */ new WeakMap();
+    let next = 0;
+    const orderOf = (row) => {
+      if (!originalOrder.has(row)) originalOrder.set(row, next++);
+      return originalOrder.get(row);
+    };
+    Array.from(body.rows).forEach(orderOf);
+    let current = null;
+    const listeners = /* @__PURE__ */ new Set();
+    const getState = () => ({ sort: current ? { column: current.index, key: current.header.dataset.sortKey || null, direction: current.direction } : null });
+    const notify = () => {
+      for (const listener of listeners) listener(getState());
+      table.dispatchEvent(new CustomEvent("doc-table-sort", { detail: getState().sort }));
+    };
+    function updateHeaders() {
+      for (const column of columns) {
+        const active = current?.header === column.header;
+        const direction = active ? current.direction : column.defaultDirection;
+        column.header.setAttribute(
+          "aria-sort",
+          active ? direction === "asc" ? "ascending" : "descending" : "none"
+        );
+        const ascending = direction === "asc";
+        column.button.setAttribute(
+          "aria-label",
+          sayTables(active ? ascending ? "sorted-ascending" : "sorted-descending" : ascending ? "sort-ascending" : "sort-descending", column.label)
+        );
+        column.button.dataset.docSortArrow = direction;
+      }
+    }
+    function updateStatus(column, direction) {
+      const status = statusElement(table);
+      if (status) status.textContent = sayTables(direction === "asc" ? "status-ascending" : "status-descending", column.label);
+    }
+    function updateRanks() {
+      Array.from(body.rows).forEach((row, index) => {
+        const rank = row.querySelector("[data-sort-rank]");
+        if (rank) rank.textContent = String(index + 1);
+      });
+    }
+    function sortBy(column, requestedDirection) {
+      if (mergedCells(table)) return;
+      const direction = requestedDirection || (current?.header === column.header ? current.direction === "asc" ? "desc" : "asc" : column.defaultDirection);
+      if (current?.header === column.header && current.direction === direction) return;
+      const rows = Array.from(body.rows);
+      rows.sort((leftRow, rightRow) => {
+        const comparison = compareValues(
+          parsedValue(leftRow.cells[column.index], column.type),
+          parsedValue(rightRow.cells[column.index], column.type),
+          direction
+        );
+        return comparison || orderOf(leftRow) - orderOf(rightRow);
+      });
+      const fragment = document.createDocumentFragment();
+      rows.forEach((row) => fragment.appendChild(row));
+      body.appendChild(fragment);
+      current = { header: column.header, index: column.index, direction };
+      updateHeaders();
+      updateRanks();
+      updateStatus(column, direction);
+      notify();
+    }
+    function sync() {
+      const wanted = mergedCells(table) ? [] : sortableColumns(table);
+      for (const column of columns) {
+        if (wanted.some((each) => each.header === column.header)) continue;
+        column.header.removeAttribute("aria-sort");
+      }
+      columns = wanted.map((column) => {
+        const kept = columns.find((each) => each.header === column.header);
+        const button = kept?.button.isConnected && kept.button.parentElement === column.header ? kept.button : controlFor(column.header);
+        if (button.nextSibling) column.header.append(button);
+        return { ...column, button };
+      });
+      const buttons = new Set(columns.map((column) => column.button));
+      table.querySelectorAll(".doc-table-sort-button").forEach((button) => {
+        if (!buttons.has(button)) button.remove();
+      });
+      if (current) {
+        const column = columns.find((each) => each.header === current.header);
+        current = column ? { ...current, index: column.index } : null;
+      }
+      for (const column of columns) {
+        if (column.type !== "number") continue;
+        column.header.classList.add("number");
+        Array.from(body.rows).forEach((row) => row.cells[column.index]?.classList.add("number"));
+      }
+      Array.from(body.rows).forEach(orderOf);
+      updateHeaders();
+    }
+    table.addEventListener("click", (event) => {
+      const button = event.target.closest?.(".doc-table-sort-button");
+      const column = button && columns.find((each) => each.button === button);
+      if (column) sortBy(column);
+    });
+    controllers.set(table, {
+      getState,
+      sync,
+      setState(next2) {
+        if (!next2 || !("sort" in next2)) throw new Error("Table state requires sort.");
+        if (next2.sort === null) {
+          if (!current) return;
+          [...body.rows].sort((a, b) => orderOf(a) - orderOf(b)).forEach((row) => body.append(row));
+          current = null;
+          updateHeaders();
+          updateRanks();
+          const status = statusElement(table);
+          if (status) status.textContent = sayTables("original-order");
+          notify();
+          return;
+        }
+        const column = columns.find((entry) => entry.index === next2.sort.column);
+        if (!column || !["asc", "desc"].includes(next2.sort.direction)) throw new Error("Invalid table sort column or direction.");
+        sortBy(column, next2.sort.direction);
+      },
+      subscribe(listener) {
+        if (typeof listener !== "function") throw new Error("Table subscribe requires a function.");
+        listeners.add(listener);
+        return () => listeners.delete(listener);
+      }
+    });
+    table.dataset.docSortableReady = "true";
+    sync();
+    const defaultColumn = columns.find((column) => column.header.hasAttribute("data-sort-default"));
+    if (defaultColumn && !heldOrder()) sortBy(defaultColumn, defaultColumn.defaultDirection);
+    return table;
+  }
+  function sortableColumns(table) {
+    return Array.from(table.tHead?.rows[0]?.cells || []).map((header, index) => ({
+      header,
+      index,
+      type: header.dataset.sortType,
+      label: header.textContent.trim(),
+      defaultDirection: header.dataset.sortDefault || (header.dataset.sortType === "text" ? "asc" : "desc")
+    })).filter((column) => column.type && !column.header.hasAttribute("data-sort-ignore"));
+  }
+
+  // src/render/kit/tables/index.js
+  var global2 = globalThis;
+  function enhance(target, { layout = true } = {}) {
+    const table = elementFor(target);
+    splitCodeRuns(table);
+    applyLayoutDefaults(table, { layout });
+    inferColumnSemantics(table);
+    if (table.hasAttribute("data-doc-table-static")) return table;
+    return makeSortable(table);
+  }
+  function controllerFor(target) {
+    const table = enhance(target);
+    const controller = controllers.get(table);
+    if (!controller) throw new Error("Table state requires a sortable table.");
+    return controller;
+  }
+  global2.DocTables = Object.freeze({
+    getState: (target) => controllerFor(target).getState(),
+    setState: (target, state) => controllerFor(target).setState(state),
+    subscribe: (target, listener) => controllerFor(target).subscribe(listener),
+    allocateColumnWidths,
+    /** Force measurement after custom content/layout changes; returns a detached snapshot. */
+    layout(target) {
+      const table = elementFor(target);
+      enhance(table);
+      forgetMeasures(table);
+      refreshLayout(table);
+      return (layouts.get(table) || []).map((column) => ({ ...column }));
+    }
+  });
+  global2.ReportTables = global2.DocTables;
+  if (!global2.DocKit) throw new Error("DocTables requires /kit/runtime.js to be loaded first.");
+  function ownChange(record) {
+    const element = record.target.nodeType === 1 ? record.target : record.target.parentElement;
+    if (element?.closest("colgroup[data-doc-columns]")) return true;
+    const nodes = [...record.addedNodes, ...record.removedNodes];
+    return nodes.length > 0 && nodes.every((node) => node.nodeType === 1 && (node.tagName === "COLGROUP" || node.classList.contains("doc-table-sort-button")));
+  }
+  function bindSort(table, signal) {
+    const key = table.getAttribute("data-doc-bind")?.trim();
+    const controller = controllers.get(table);
+    if (!key || !controller) return;
+    const store = global2.DocKit.bindings;
+    const show = () => {
+      const value = store.get(key);
+      controller.setState(value && typeof value === "object" ? value : { sort: null });
+    };
+    const stopTable = controller.subscribe((state) => store.set(key, state));
+    const stopKey = store.subscribe((changed) => changed === key && show());
+    signal.addEventListener("abort", () => {
+      stopTable();
+      stopKey();
+    });
+    if (!heldOrder()) show();
+  }
+  global2.DocKit.component({
+    id: "table",
+    selector: "table.doc-table, table[data-sortable-table]",
+    on: ["content", "reveal", "layout", "viewport", "fonts"],
+    mount(table, { signal }) {
+      enhance(table);
+      markEdges(table);
+      bindSort(table, signal);
+      const switched = new MutationObserver(() => {
+        enhance(table);
+        queueLayout(table);
+      });
+      for (const node of [table, wrapperOf(table)]) if (node) switched.observe(node, { attributes: true, attributeFilter: ["data-number-columns"] });
+      signal.addEventListener("abort", () => switched.disconnect());
+      return {
+        update(reason, detail, { quiet = false } = {}) {
+          if (reason === "layout") {
+            if (layoutObservers.has(table)) queueLayout(table);
+          } else if (reason === "fonts") {
+            const change = fontsChange(table, detail);
+            if (change === "words") forgetMeasures(table);
+            if (change) queueLayout(table);
+          } else if (reason !== "content" || detail.some((record) => !ownChange(record))) {
+            if (reason === "content" && controllers.has(table)) enhance(table, { layout: false });
+            if (reason === "content") markEdges(table);
+            if (quiet) idleLayout(table);
+            else queueLayout(table);
+          }
+        },
+        destroy() {
+          layoutObservers.get(table)?.disconnect();
+          layoutObservers.delete(table);
+          pendingLayouts.delete(table);
+        }
+      };
+    },
+    // An export of the view: the sort controls taken out (their headers' words are untouched), the widths the layout
+    // set taken off (tables.js lays the copy out again), its cells' code joined from its runs.
+    dehydrate(table) {
+      if (table.classList.contains("doc-table--auto")) {
+        table.style.removeProperty("width");
+        wrapperOf(table)?.style.removeProperty("width");
+        if (table.getAttribute("style") === "") table.removeAttribute("style");
+      }
+      table.querySelectorAll(".doc-table-sort-button").forEach((button) => button.remove());
+      joinCodeRuns(table);
+    }
+  });
+})();