@bettercms-ai/kit 0.1.1 → 1.0.0

package/schema/table.js

@@ -0,0 +1,1198 @@
+//#region src/kit/schema/table.ts
+var TABLE_COLUMN_TYPES = [
+	{
+		value: "text",
+		label: "Text",
+		description: "Plain words"
+	},
+	{
+		value: "number",
+		label: "Number",
+		description: "With an optional unit (kg, %, min)"
+	},
+	{
+		value: "money",
+		label: "Money",
+		description: "An amount in one currency"
+	},
+	{
+		value: "boolean",
+		label: "Yes / no",
+		description: "Written as Included / Not included"
+	},
+	{
+		value: "rating",
+		label: "Rating",
+		description: "Out of 5"
+	},
+	{
+		value: "link",
+		label: "Link",
+		description: "Label + URL"
+	},
+	{
+		value: "richtext-inline",
+		label: "Rich text",
+		description: "Bold, italic, links, code"
+	},
+	{
+		value: "reference",
+		label: "Reference",
+		description: "A page or entry, by id"
+	}
+];
+/**
+* CPO D52: a table with no `table` options (a rich-text table, the Visuals Table block, a schema field without `table`) is a
+* general table of any kind, so every setting is offered. Setting `table` on a field narrows it to that kind.
+*/
+var GENERAL_TABLE = {
+	jsonLd: [
+		"ItemList",
+		"Dataset",
+		"Offers"
+	],
+	settings: {
+		sort: true,
+		search: true
+	}
+};
+var seq = 0;
+var tkey = (p) => `${p}${Date.now().toString(36).slice(-4)}${(seq++).toString(36)}${Math.random().toString(36).slice(2, 5)}`;
+function emptyTable(cols = 3, rows = 2) {
+	const columns = Array.from({ length: cols }, () => ({
+		_key: tkey("c"),
+		label: "",
+		type: "text"
+	}));
+	return {
+		id: tkey("tbl"),
+		caption: "",
+		headerRow: true,
+		headerColumn: false,
+		columns,
+		rows: Array.from({ length: rows }, () => ({
+			_key: tkey("r"),
+			cells: {}
+		})),
+		design: { responsive: "scroll" }
+	};
+}
+var isObjLike = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+var isCellObject = (c) => isObjLike(c) && "value" in c;
+var isTableValue = (v) => isObjLike(v) && Array.isArray(v.columns) && Array.isArray(v.rows);
+/** Repair anything loaded (missing keys, missing arrays) so editors and renderers can trust the shape. */
+function normalizeTable(v) {
+	if (!isTableValue(v)) return emptyTable();
+	const used = /* @__PURE__ */ new Set();
+	const uniq = (k, p) => {
+		let key = typeof k === "string" && k ? k : tkey(p);
+		while (used.has(key)) key = tkey(p);
+		used.add(key);
+		return key;
+	};
+	const columns = v.columns.filter(isObjLike).map((c) => ({
+		...c,
+		_key: uniq(c._key, "c"),
+		label: String(c.label ?? ""),
+		type: TABLE_COLUMN_TYPES.some((t) => t.value === c.type) ? c.type : "text"
+	}));
+	const rows = v.rows.filter(isObjLike).map((r) => ({
+		...r,
+		_key: uniq(r._key, "r"),
+		cells: isObjLike(r.cells) ? r.cells : {}
+	}));
+	return {
+		...v,
+		id: typeof v.id === "string" && v.id ? v.id : tkey("tbl"),
+		caption: String(v.caption ?? ""),
+		headerRow: v.headerRow !== false,
+		headerColumn: !!v.headerColumn,
+		columns,
+		rows,
+		columnGroups: (v.columnGroups ?? []).filter(isObjLike).map((g) => ({
+			...g,
+			_key: uniq(g._key, "g")
+		})),
+		rowGroups: (v.rowGroups ?? []).filter(isObjLike).map((g) => ({
+			...g,
+			_key: uniq(g._key, "rg")
+		})),
+		footnotes: (v.footnotes ?? []).filter(isObjLike).map((f) => ({
+			...f,
+			_key: uniq(f._key, "f")
+		}))
+	};
+}
+var cellValue = (c) => c === void 0 ? null : isCellObject(c) ? c.value : c;
+var cellNote = (c) => isCellObject(c) ? c.note : void 0;
+var cellType = (col, row, c) => isCellObject(c) && c.type || row?.type || col.type;
+/** Write a value back, keeping the cell's per-cell type and footnote. */
+function withValue(c, value) {
+	if (isCellObject(c)) return {
+		...c,
+		value
+	};
+	return value;
+}
+var isEmptyCell = (v) => v == null || v === "" || isObjLike(v) && !("ref" in v ? v.ref : v.label || v.href);
+var strip = (s) => s.replace(/<[^>]*>/g, "").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, "\"").replace(/&#39;/g, "'");
+function boolLabels(col) {
+	return {
+		yes: col.trueLabel || "Included",
+		no: col.falseLabel || "Not included"
+	};
+}
+function formatNumber(n, decimals) {
+	return new Intl.NumberFormat("en-US", decimals != null ? {
+		minimumFractionDigits: decimals,
+		maximumFractionDigits: decimals
+	} : { maximumFractionDigits: 6 }).format(n);
+}
+function formatMoney(n, currency = "USD", decimals) {
+	try {
+		const whole = Number.isInteger(n) && decimals == null;
+		return new Intl.NumberFormat("en-US", {
+			style: "currency",
+			currency,
+			minimumFractionDigits: whole ? 0 : decimals ?? 2,
+			maximumFractionDigits: whole ? 0 : decimals ?? 2
+		}).format(n);
+	} catch {
+		return `${formatNumber(n, decimals)} ${currency}`;
+	}
+}
+var toNumber = (v) => {
+	if (typeof v === "number") return Number.isFinite(v) ? v : null;
+	if (typeof v !== "string") return null;
+	const s = v.replace(/[,\s]/g, "").replace(/[^\d.+-]/g, "");
+	if (!s || !/^[+-]?\d*\.?\d+$/.test(s)) return null;
+	return Number(s);
+};
+/** The words a cell says, for Markdown, CSV, sorting, search and screen readers. Empty → "". */
+function cellText(col, row, c, resolveRef) {
+	const v = cellValue(c);
+	if (isEmptyCell(v)) return "";
+	switch (cellType(col, row, c)) {
+		case "boolean": {
+			const b = toBool(v);
+			return b == null ? strip(String(v)) : b ? boolLabels(col).yes : boolLabels(col).no;
+		}
+		case "number": {
+			const n = toNumber(v);
+			return n == null ? strip(String(v)) : `${formatNumber(n, col.decimals)}${col.unit ? /^[%°]/.test(col.unit) ? col.unit : ` ${col.unit}` : ""}`;
+		}
+		case "money": {
+			const n = toNumber(v);
+			return n == null ? strip(String(v)) : formatMoney(n, col.currency || "USD", col.decimals);
+		}
+		case "rating": {
+			const n = toNumber(v);
+			return n == null ? strip(String(v)) : `${formatNumber(n, 1).replace(/\.0$/, "")} out of ${col.max ?? 5}`;
+		}
+		case "link": return isObjLike(v) ? String(v.label || v.href || "") : strip(String(v));
+		case "reference": {
+			if (!isObjLike(v)) return strip(String(v));
+			const r = v;
+			return resolveRef?.(r.ref)?.label ?? r.label ?? r.ref;
+		}
+		default: return isObjLike(v) ? String(v.label ?? "") : strip(String(v)).replace(/\s+/g, " ").trim();
+	}
+}
+function toBool(v) {
+	if (typeof v === "boolean") return v;
+	if (typeof v !== "string") return null;
+	const s = strip(v).trim().toLowerCase();
+	if (TRUE_WORDS.has(s)) return true;
+	if (FALSE_WORDS.has(s)) return false;
+	return null;
+}
+var TRUE_WORDS = new Set([
+	"✓",
+	"✔",
+	"✔️",
+	"☑",
+	"✅",
+	"yes",
+	"y",
+	"true",
+	"included",
+	"available",
+	"supported",
+	"x ✓",
+	"check",
+	"●"
+]);
+var FALSE_WORDS = new Set([
+	"✗",
+	"✕",
+	"✖",
+	"❌",
+	"×",
+	"x",
+	"no",
+	"n",
+	"false",
+	"not included",
+	"unavailable",
+	"not available",
+	"unsupported",
+	"—",
+	"–",
+	"-",
+	"○"
+]);
+var esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+var escAttr = (s) => esc(s).replace(/"/g, "&quot;");
+var safeHref = (h) => /^\s*(javascript|vbscript|data):/i.test(h) ? "#" : h;
+var INLINE_TAGS = new Set([
+	"strong",
+	"b",
+	"em",
+	"i",
+	"u",
+	"s",
+	"del",
+	"code",
+	"a",
+	"br",
+	"sup",
+	"sub",
+	"mark",
+	"small",
+	"abbr"
+]);
+/** Inline rich text in a cell: only inline marks and safe links survive (string-based, no DOM). */
+function sanitizeInline(html) {
+	return html.replace(/<(script|style|iframe|object|embed|template)\b[\s\S]*?<\/\1>/gi, "").replace(/<\/?([a-z][a-z0-9]*)\b([^>]*)>/gi, (m, tag, attrs) => {
+		const t = tag.toLowerCase();
+		if (!INLINE_TAGS.has(t)) return "";
+		if (m.startsWith("</")) return `</${t === "b" ? "strong" : t === "i" ? "em" : t}>`;
+		if (t === "a") {
+			const href = attrs.match(/href\s*=\s*("([^"]*)"|'([^']*)')/i);
+			return `<a href="${escAttr(safeHref(href ? href[2] ?? href[3] ?? "" : ""))}">`;
+		}
+		if (t === "abbr") {
+			const title = attrs.match(/title\s*=\s*"([^"]*)"/i);
+			return title ? `<abbr title="${escAttr(title[1])}">` : "<abbr>";
+		}
+		return `<${t === "b" ? "strong" : t === "i" ? "em" : t}>`;
+	});
+}
+var alignOf = (col, t) => col.align ?? (t === "number" || t === "money" || t === "rating" ? "end" : "start");
+var footnoteIndex = (t) => new Map((t.footnotes ?? []).map((f, i) => [f._key, i + 1]));
+/** Inner HTML of one cell + its typed attributes. */
+function cellHtml(t, col, row, c, o, fn, asHeader) {
+	const v = cellValue(c);
+	const type = cellType(col, row, c);
+	const marks = o.marks !== false;
+	const typeAttr = marks && isCellObject(c) && c.type ? ` data-type="${c.type}"` : "";
+	const note = cellNote(c);
+	const n = note ? fn.get(note) : void 0;
+	const sup = n ? `<sup><a href="#${escAttr(t.id ?? "tbl")}-fn-${n}" aria-label="Note ${n}">${n}</a></sup>` : "";
+	const noteAttr = marks && note ? ` data-note="${escAttr(note)}"` : "";
+	let inner = "";
+	let valueAttr = "";
+	if (isEmptyCell(v)) {
+		inner = asHeader ? "" : `<span aria-hidden="true" class="bt-dash">—</span><span class="bt-sr">No value</span>`;
+		valueAttr = marks ? ` data-empty=""` : "";
+	} else switch (type) {
+		case "boolean": {
+			const b = toBool(v);
+			if (b == null) inner = esc(strip(String(v)));
+			else {
+				const { yes, no } = boolLabels(col);
+				inner = `<span aria-hidden="true" class="bt-bool" data-bool="${b}">${b ? "✓" : "–"}</span><span class="bt-sr">${esc(b ? yes : no)}</span>`;
+				valueAttr = marks ? ` data-value="${b}"` : "";
+			}
+			break;
+		}
+		case "number":
+		case "money": {
+			const num = toNumber(v);
+			inner = esc(cellText(col, row, c));
+			if (num != null && marks) valueAttr = ` data-value="${num}"`;
+			break;
+		}
+		case "rating": {
+			const num = toNumber(v);
+			if (num == null) inner = esc(strip(String(v)));
+			else {
+				const max = col.max ?? 5;
+				inner = `<span aria-hidden="true" class="bt-star">★</span> ${esc(formatNumber(num, 1).replace(/\.0$/, ""))}<span class="bt-dim"> / ${max}</span>`;
+				if (marks) valueAttr = ` data-value="${num}"`;
+			}
+			break;
+		}
+		case "link": {
+			const l = isObjLike(v) ? v : {
+				label: String(v),
+				href: ""
+			};
+			const rel = [l.newTab ? "noopener" : "", l.rel && l.rel !== "follow" ? l.rel : ""].filter(Boolean).join(" ");
+			inner = l.href ? `<a href="${escAttr(safeHref(l.href))}"${l.newTab ? " target=\"_blank\"" : ""}${rel ? ` rel="${rel}"` : ""}>${esc(l.label || l.href)}</a>` : esc(l.label);
+			break;
+		}
+		case "reference": {
+			const r = isObjLike(v) ? v : { ref: String(v) };
+			const live = o.resolveRef?.(r.ref);
+			const label = live?.label ?? r.label ?? r.ref;
+			const href = live?.href ?? r.href;
+			inner = href ? `<a href="${escAttr(safeHref(href))}">${esc(label)}</a>` : esc(label);
+			if (marks) valueAttr = ` data-ref="${escAttr(r.ref)}"`;
+			break;
+		}
+		case "richtext-inline":
+			inner = sanitizeInline(String(isObjLike(v) ? v.label ?? "" : v));
+			break;
+		default: inner = esc(isObjLike(v) ? String(v.label ?? "") : strip(String(v)));
+	}
+	const align = alignOf(col, type);
+	const alignAttr = align !== "start" ? ` data-align="${align}"` : "";
+	return {
+		inner: inner + sup,
+		attrs: `${typeAttr}${valueAttr}${noteAttr}${alignAttr}`
+	};
+}
+/** Rows in display order: body rows (ungrouped first, then each row group in its order), footer rows. */
+function orderedRows(t) {
+	const groups = t.rowGroups ?? [];
+	const known = new Set(groups.map((g) => g._key));
+	const body = t.rows.filter((r) => !r.footer);
+	const loose = body.filter((r) => !r.group || !known.has(r.group));
+	const bodies = [];
+	if (loose.length || !groups.length) bodies.push({ rows: loose });
+	for (const g of groups) {
+		const rows = body.filter((r) => r.group === g._key);
+		if (rows.length) bodies.push({
+			group: g,
+			rows
+		});
+	}
+	return {
+		bodies,
+		foot: t.rows.filter((r) => r.footer)
+	};
+}
+/** Sort comparator over a column (numbers numerically, booleans true first, text by locale). */
+function sortRows(t, rows, key, dir) {
+	const col = t.columns.find((c) => c._key === key);
+	if (!col) return rows;
+	const val = (r) => {
+		const c = r.cells[key];
+		const ty = cellType(col, r, c);
+		const v = cellValue(c);
+		if (ty === "number" || ty === "money" || ty === "rating") return toNumber(v);
+		if (ty === "boolean") return toBool(v) == null ? null : toBool(v) ? 1 : 0;
+		return cellText(col, r, c).toLowerCase() || null;
+	};
+	return [...rows].sort((a, b) => {
+		const x = val(a);
+		const y = val(b);
+		if (x == null && y == null) return 0;
+		if (x == null) return 1;
+		if (y == null) return -1;
+		return (typeof x === "number" && typeof y === "number" ? x - y : String(x).localeCompare(String(y), "en", { numeric: true })) * dir;
+	});
+}
+/** The table as semantic HTML: <figure data-rt="table"> › <table> (caption, colgroup, thead, tbody…, tfoot) + notes. */
+function renderTableHtml(input, o = {}) {
+	const t = normalizeTable(input);
+	const marks = o.marks !== false;
+	const id = t.id;
+	const cols = t.columns;
+	const n = cols.length;
+	const fn = footnoteIndex(t);
+	const groups = (t.columnGroups ?? []).filter((g) => cols.some((c) => c.group === g._key));
+	const describedBy = t.notes || (t.footnotes ?? []).length ? ` aria-describedby="${escAttr(id)}-notes"` : "";
+	const fig = [];
+	const figAttrs = [
+		`data-rt="table"`,
+		`data-id="${escAttr(id)}"`,
+		`class="bt-table"`,
+		marks ? `data-header-row="${t.headerRow}"` : "",
+		t.headerColumn ? `data-header-col="true"` : "",
+		`data-responsive="${t.design?.responsive ?? "scroll"}"`,
+		t.design?.sticky ? `data-sticky="true"` : "",
+		t.design?.striped ? `data-striped="true"` : "",
+		t.design?.density === "compact" ? `data-density="compact"` : "",
+		t.design?.hideCaption ? `data-caption="hidden"` : "",
+		marks && t.filterable ? `data-filter="true"` : "",
+		marks && t.jsonLd && t.jsonLd.type !== "none" ? `data-jsonld="${t.jsonLd.type}"${t.jsonLd.axis ? ` data-jsonld-axis="${t.jsonLd.axis}"` : ""}${t.jsonLd.priceRow ? ` data-jsonld-price="${escAttr(t.jsonLd.priceRow)}"` : ""}` : ""
+	].filter(Boolean);
+	fig.push(`<figure ${figAttrs.join(" ")}>`);
+	fig.push(`<div class="bt-scroll" role="region" tabindex="0" aria-labelledby="${escAttr(id)}-caption">`);
+	fig.push(`<table${describedBy}>`);
+	fig.push(`<caption id="${escAttr(id)}-caption"${t.design?.hideCaption ? ` class="bt-sr"` : ""}>${esc(t.caption || "Table")}</caption>`);
+	if (marks || groups.length) fig.push(`<colgroup>${cols.map((c) => {
+		if (!marks) return "<col>";
+		return `<col ${[
+			`data-key="${escAttr(c._key)}"`,
+			`data-type="${c.type}"`,
+			c.unit ? `data-unit="${escAttr(c.unit)}"` : "",
+			c.currency ? `data-currency="${escAttr(c.currency)}"` : "",
+			c.decimals != null ? `data-decimals="${c.decimals}"` : "",
+			c.align ? `data-align="${c.align}"` : "",
+			c.sortable ? `data-sortable="true"` : "",
+			c.group ? `data-group="${escAttr(c.group)}"` : "",
+			c.trueLabel ? `data-true="${escAttr(c.trueLabel)}"` : "",
+			c.falseLabel ? `data-false="${escAttr(c.falseLabel)}"` : "",
+			c.max != null ? `data-max="${c.max}"` : "",
+			c.refTo?.length ? `data-ref-to="${escAttr(c.refTo.join(","))}"` : "",
+			c.description ? `data-description="${escAttr(c.description)}"` : "",
+			c.highlight ? `data-highlight="true"` : ""
+		].filter(Boolean).join(" ")}>`;
+	}).join("")}</colgroup>`);
+	if (t.headerRow) {
+		fig.push("<thead>");
+		if (groups.length) {
+			const cells = [];
+			for (let i = 0; i < n;) {
+				const g = cols[i].group && groups.find((x) => x._key === cols[i].group);
+				if (!g) {
+					cells.push(`<td></td>`);
+					i++;
+					continue;
+				}
+				let span = 1;
+				while (i + span < n && cols[i + span].group === g._key) span++;
+				cells.push(`<th scope="colgroup"${span > 1 ? ` colspan="${span}"` : ""}${marks ? ` data-group="${escAttr(g._key)}"` : ""}>${esc(g.label)}</th>`);
+				i += span;
+			}
+			fig.push(`<tr${marks ? " data-groups" : ""}>${cells.join("")}</tr>`);
+		}
+		fig.push(`<tr>${cols.map((c, i) => {
+			const type = c.type;
+			const align = alignOf(c, type);
+			const sortable = o.interactive && c.sortable;
+			const dir = o.sort?.key === c._key ? o.sort.dir : 0;
+			const ariaSort = sortable ? ` aria-sort="${dir === 1 ? "ascending" : dir === -1 ? "descending" : "none"}"` : "";
+			if (i === 0 && t.headerColumn && !c.label.trim()) return `<td${marks ? ` data-col="${escAttr(c._key)}"` : ""}></td>`;
+			const label = esc(c.label || `Column ${i + 1}`);
+			const title = c.description ? ` title="${escAttr(c.description)}"` : "";
+			const content = sortable ? `<button type="button" class="bt-sort" data-sort-key="${escAttr(c._key)}">${label}<span aria-hidden="true" class="bt-sort-icon">${dir === 1 ? "↑" : dir === -1 ? "↓" : "↕"}</span></button>` : label;
+			return `<th scope="col"${marks ? ` data-col="${escAttr(c._key)}"` : ""}${align !== "start" ? ` data-align="${align}"` : ""}${c.highlight ? ` data-highlight="true"` : ""}${title}${ariaSort}>${content}</th>`;
+		}).join("")}</tr>`);
+		fig.push("</thead>");
+	}
+	const rowHtml = (r) => {
+		const cells = cols.map((c, i) => {
+			const asTh = t.headerColumn && i === 0;
+			const { inner, attrs } = cellHtml(t, c, r, r.cells[c._key], o, fn, asTh);
+			const label = ` data-label="${escAttr(c.label || `Column ${i + 1}`)}"${c.highlight ? ` data-highlight="true"` : ""}`;
+			return asTh ? `<th scope="row"${marks ? ` data-col="${escAttr(c._key)}"` : ""}${attrs}>${inner}</th>` : `<td${marks ? ` data-col="${escAttr(c._key)}"` : ""}${label}${attrs}>${inner}</td>`;
+		});
+		return `<tr${marks ? ` data-key="${escAttr(r._key)}"` : ""}${marks && r.type ? ` data-type="${r.type}"` : ""}${r.highlight ? ` data-highlight="true"` : ""}>${cells.join("")}</tr>`;
+	};
+	const { bodies, foot } = orderedRows(t);
+	const vis = (rows) => {
+		const kept = o.visibleRows ? rows.filter((r) => o.visibleRows.has(r._key)) : rows;
+		return o.sort ? sortRows(t, kept, o.sort.key, o.sort.dir) : kept;
+	};
+	for (const b of bodies) {
+		const rows = vis(b.rows);
+		if (b.group) {
+			fig.push(`<tbody${marks ? ` data-key="${escAttr(b.group._key)}" data-label="${escAttr(b.group.label)}"` : ""}>`);
+			fig.push(`<tr class="bt-group"${marks ? " data-group-row" : ""}><th scope="rowgroup" colspan="${n}">${esc(b.group.label)}</th></tr>`);
+		} else fig.push("<tbody>");
+		fig.push(rows.map(rowHtml).join(""));
+		fig.push("</tbody>");
+	}
+	if (foot.length) fig.push(`<tfoot>${foot.map(rowHtml).join("")}</tfoot>`);
+	fig.push("</table></div>");
+	if (t.notes || (t.footnotes ?? []).length) {
+		fig.push(`<div class="bt-notes" id="${escAttr(id)}-notes">`);
+		if (t.notes) fig.push(`<p${marks ? " data-notes" : ""}>${esc(t.notes)}</p>`);
+		if ((t.footnotes ?? []).length) fig.push(`<ol${marks ? " data-footnotes" : ""}>${t.footnotes.map((f, i) => `<li id="${escAttr(id)}-fn-${i + 1}"${marks ? ` data-key="${escAttr(f._key)}"` : ""}>${esc(f.text)}</li>`).join("")}</ol>`);
+		fig.push("</div>");
+	}
+	fig.push("</figure>");
+	const html = fig.join("");
+	return t.design?.responsive === "stack" || t.design?.responsive === "cards" ? withTableRoles(html) : html;
+}
+/**
+* Stack / Cards change `display` on table parts, which makes some engines drop table semantics. The fix (Adrian
+* Roselli, "Tables, CSS Display Properties, and ARIA") restates the SAME roles explicitly — semantics unchanged.
+* Cell contents are sanitized inline HTML, so these tag patterns only ever match the table's own structure.
+*/
+function withTableRoles(html) {
+	return html.replace(/<table(?=[\s>])/, "<table role=\"table\"").replace(/<(thead|tbody|tfoot)(?=[\s>])/g, "<$1 role=\"rowgroup\"").replace(/<tr(?=[\s>])/g, "<tr role=\"row\"").replace(/<th scope="(col|colgroup)"/g, "<th role=\"columnheader\" scope=\"$1\"").replace(/<th scope="(row|rowgroup)"/g, "<th role=\"rowheader\" scope=\"$1\"").replace(/<td(?=[\s>])/g, "<td role=\"cell\"");
+}
+var mdCell = (s) => s.replace(/\\/g, "\\\\").replace(/\|/g, "\\|").replace(/\s*\n\s*/g, " ").trim();
+function inlineMd(html) {
+	return strip(sanitizeInline(html).replace(/<(strong)>([\s\S]*?)<\/\1>/g, "**$2**").replace(/<(em)>([\s\S]*?)<\/\1>/g, "_$2_").replace(/<code>([\s\S]*?)<\/code>/g, "`$1`").replace(/<a href="([^"]*)">([\s\S]*?)<\/a>/g, (_m, h, l) => `[${l}](${h.replace(/&amp;/g, "&")})`).replace(/<br>/g, " "));
+}
+/**
+* GFM has one header row and no spans, so: column groups prefix their columns ("Sizes · Chest"), row groups become a
+* bold label row, the caption is a bold line above, notes and footnotes follow. Booleans say their words, never ✓.
+*/
+function tableToMarkdown(input, o = {}) {
+	const t = normalizeTable(input);
+	const cols = t.columns;
+	if (!cols.length) return "";
+	const groups = new Map((t.columnGroups ?? []).map((g) => [g._key, g.label]));
+	const fn = footnoteIndex(t);
+	const pfx = (t.id ?? "t").replace(/[^\w-]/g, "");
+	const head = cols.map((c, i) => mdCell([c.group && groups.get(c.group), c.label || (i === 0 && t.headerColumn ? "" : `Column ${i + 1}`)].filter(Boolean).join(" · ")) || " ");
+	const sep = cols.map((c) => alignOf(c, c.type) === "end" ? "---:" : alignOf(c, c.type) === "center" ? ":---:" : "---");
+	const line = (cells) => `| ${cells.join(" | ")} |`;
+	const row = (r) => line(cols.map((c, i) => {
+		const cell = r.cells[c._key];
+		const v = cellValue(cell);
+		const ty = cellType(c, r, cell);
+		let s = ty === "richtext-inline" && typeof v === "string" ? inlineMd(v) : cellText(c, r, cell, o.resolveRef);
+		if (ty === "link" && isObjLike(v) && v.href) s = `[${s}](${o.abs ? o.abs(v.href) : v.href})`;
+		if (ty === "reference" && isObjLike(v)) {
+			const href = o.resolveRef?.(v.ref)?.href ?? v.href;
+			if (href) s = `[${s}](${o.abs ? o.abs(href) : href})`;
+		}
+		if (!s && !(t.headerColumn && i === 0)) s = "—";
+		if (t.headerColumn && i === 0 && s) s = `**${s}**`;
+		const note = cellNote(cell);
+		if (note && fn.get(note)) s += `[^${pfx}-${fn.get(note)}]`;
+		return mdCell(s) || " ";
+	}));
+	const out = [];
+	out.push(`**${mdCell(t.caption || "Table")}**`, "");
+	out.push(line(head), line(sep));
+	const { bodies, foot } = orderedRows(t);
+	for (const b of bodies) {
+		if (b.group) out.push(line([`**${mdCell(b.group.label)}**`, ...cols.slice(1).map(() => " ")]));
+		b.rows.forEach((r) => out.push(row(r)));
+	}
+	foot.forEach((r) => out.push(row(r)));
+	const after = [];
+	if (t.notes) after.push(t.notes);
+	const described = cols.filter((c) => c.description);
+	if (described.length) after.push(described.map((c) => `${c.label}: ${c.description}`).join(". ") + ".");
+	if ((t.footnotes ?? []).length) after.push(t.footnotes.map((f, i) => `[^${pfx}-${i + 1}]: ${f.text}`).join("\n"));
+	return [out.join("\n"), ...after].join("\n\n");
+}
+/** RFC 4180 parser; the delimiter is a tab when the text has one (Excel / Sheets copy), else `;` or `,` by count. */
+function parseDelimited(text, delim) {
+	const src = text.replace(/\r\n?/g, "\n").replace(/\n+$/, "");
+	if (!src.trim()) return [];
+	const firstLine = src.split("\n")[0];
+	const d = delim ?? (firstLine.includes("	") ? "	" : (firstLine.match(/;/g)?.length ?? 0) > (firstLine.match(/,/g)?.length ?? 0) ? ";" : ",");
+	const rows = [];
+	let row = [];
+	let cell = "";
+	let q = false;
+	for (let i = 0; i < src.length; i++) {
+		const ch = src[i];
+		if (q) if (ch === "\"" && src[i + 1] === "\"") {
+			cell += "\"";
+			i++;
+		} else if (ch === "\"") q = false;
+		else cell += ch;
+		else if (ch === "\"" && cell === "") q = true;
+		else if (ch === d) {
+			row.push(cell);
+			cell = "";
+		} else if (ch === "\n") {
+			row.push(cell);
+			rows.push(row);
+			row = [];
+			cell = "";
+		} else cell += ch;
+	}
+	row.push(cell);
+	rows.push(row);
+	const w = Math.max(...rows.map((r) => r.length));
+	return rows.map((r) => [...r.map((c) => c.trim()), ...Array(w - r.length).fill("")]);
+}
+function toDelimited(rows, delim = ",") {
+	return rows.map((r) => r.map((c) => /[",\n\t;]/.test(c) ? `"${c.replace(/"/g, "\"\"")}"` : c).join(delim)).join("\n");
+}
+/** Header + body rows as text (CSV export, "Copy as CSV"). */
+function tableToRows(input, resolveRef) {
+	const t = normalizeTable(input);
+	const { bodies, foot } = orderedRows(t);
+	const all = [...bodies.flatMap((b) => b.rows), ...foot];
+	return [t.columns.map((c) => c.label), ...all.map((r) => t.columns.map((c) => cellText(c, r, r.cells[c._key], resolveRef)))];
+}
+var CURRENCY = {
+	$: "USD",
+	"€": "EUR",
+	"£": "GBP",
+	"¥": "JPY",
+	"₹": "INR",
+	"A$": "AUD",
+	"C$": "CAD",
+	"CHF": "CHF"
+};
+var MONEY_RX = /^(A\$|C\$|CHF|[$€£¥₹])\s?-?[\d,]*\.?\d+$|^-?[\d,]*\.?\d+\s?(USD|EUR|GBP|JPY|INR|AUD|CAD|CHF)$/i;
+var NUM_RX = /^([+-]?[\d,]*\.?\d+)\s?([a-zA-Z%°][a-zA-Z%°²³/]*)?$/;
+var RATING_RX = /^(\d(?:\.\d)?)\s?(?:\/\s?(5|10)|★|stars?|out of (5|10))$/i;
+/** Look at a column's non-empty values and pick the narrowest type every value fits. */
+function inferColumn(values) {
+	const vs = values.map((v) => v.trim()).filter(Boolean);
+	if (!vs.length) return { type: "text" };
+	const txt = vs.map((v) => strip(v).trim());
+	if (txt.every((v) => toBool(v) != null) && txt.some((v) => toBool(v) === true)) return { type: "boolean" };
+	if (txt.every((v) => MONEY_RX.test(v))) {
+		const sym = txt[0].match(/^(A\$|C\$|CHF|[$€£¥₹])/)?.[1] ?? txt[0].match(/(USD|EUR|GBP|JPY|INR|AUD|CAD|CHF)$/i)?.[1]?.toUpperCase();
+		const cur = sym ? CURRENCY[sym] ?? sym : "USD";
+		if (txt.every((v) => (v.match(/^(A\$|C\$|CHF|[$€£¥₹])/)?.[1] ?? v.match(/(USD|EUR|GBP|JPY|INR|AUD|CAD|CHF)$/i)?.[1]?.toUpperCase()) === sym)) return {
+			type: "money",
+			currency: cur
+		};
+	}
+	const rating = txt.map((v) => v.match(RATING_RX));
+	if (rating.every(Boolean)) return {
+		type: "rating",
+		max: Number(rating[0][2] || rating[0][3] || 5)
+	};
+	const nums = txt.map((v) => v.match(NUM_RX));
+	if (nums.every(Boolean)) {
+		const units = new Set(nums.map((m) => m[2] ?? ""));
+		if (units.size === 1) return {
+			type: "number",
+			...[...units][0] ? { unit: [...units][0] } : {}
+		};
+	}
+	if (vs.every((v) => /^<a\s[^>]*href=/i.test(v) && /<\/a>\s*$/i.test(v) && (v.match(/<a\s/gi)?.length ?? 0) === 1)) return { type: "link" };
+	if (vs.some((v) => /<(strong|b|em|i|a|code|sup|sub|br)\b/i.test(v))) return { type: "richtext-inline" };
+	return { type: "text" };
+}
+/** A raw string (CSV / paste / HTML cell) → a value of `type`. */
+function coerce(raw, col) {
+	const s = raw.trim();
+	const plain = strip(s).trim();
+	if (!plain && col.type !== "richtext-inline") return null;
+	switch (col.type) {
+		case "boolean": return toBool(plain) ?? plain;
+		case "number":
+		case "money": return toNumber(plain.replace(/(USD|EUR|GBP|JPY|INR|AUD|CAD|CHF)$/i, "")) ?? plain;
+		case "rating": {
+			const m = plain.match(/(\d+(?:\.\d+)?)/);
+			return m ? Number(m[1]) : plain;
+		}
+		case "link": {
+			const m = s.match(/<a\s[^>]*href\s*=\s*"([^"]*)"[^>]*>([\s\S]*?)<\/a>/i);
+			if (m) return {
+				label: strip(m[2]).trim(),
+				href: m[1].replace(/&amp;/g, "&")
+			};
+			return /^(https?:|\/|mailto:)/.test(plain) ? {
+				label: plain,
+				href: plain
+			} : {
+				label: plain,
+				href: ""
+			};
+		}
+		case "richtext-inline": return sanitizeInline(s);
+		default: return plain;
+	}
+}
+/** Text rows (CSV, TSV, a pasted range) → a table. `header`: first row holds the column labels. */
+function tableFromRows(rows, opts = {}) {
+	const header = opts.header ?? true;
+	const width = Math.max(1, ...rows.map((r) => r.length));
+	const labels = header ? rows[0] ?? [] : [];
+	const body = header ? rows.slice(1) : rows;
+	const columns = Array.from({ length: width }, (_, i) => {
+		const inf = inferColumn(body.map((r) => r[i] ?? ""));
+		return {
+			_key: tkey("c"),
+			label: strip(labels[i] ?? "").trim(),
+			...inf
+		};
+	});
+	const out = emptyTable(0, 0);
+	out.caption = opts.caption ?? "";
+	out.columns = columns;
+	out.headerColumn = header && !!rows.length && !strip(labels[0] ?? "").trim() && columns[0]?.type === "text" && width > 1;
+	out.rows = body.filter((r) => r.some((c) => c.trim())).map((r) => ({
+		_key: tkey("r"),
+		cells: Object.fromEntries(columns.map((c, i) => [c._key, coerce(r[i] ?? "", c)]))
+	}));
+	return out;
+}
+/** Paste a text range into a table at (row, col), growing rows / columns as needed. Values coerce to column types. */
+function pasteRange(input, at, grid, opts = {}) {
+	const t = normalizeTable(input);
+	const columns = [...t.columns];
+	const rows = t.rows.map((r) => ({
+		...r,
+		cells: { ...r.cells }
+	}));
+	let r0 = at.row;
+	let g = grid;
+	if (r0 < 0) {
+		(g[0] ?? []).forEach((l, j) => {
+			const ci = at.col + j;
+			if (ci >= columns.length) {
+				if (opts.lockColumns) return;
+				columns.push({
+					_key: tkey("c"),
+					label: "",
+					type: "text"
+				});
+			}
+			columns[ci] = {
+				...columns[ci],
+				label: strip(l).trim()
+			};
+		});
+		g = g.slice(1);
+		r0 = 0;
+	}
+	const need = at.col + Math.max(0, ...g.map((r) => r.length));
+	while (!opts.lockColumns && columns.length < need) columns.push({
+		_key: tkey("c"),
+		label: "",
+		type: "text"
+	});
+	g.forEach((line, i) => {
+		const ri = r0 + i;
+		while (rows.length <= ri) rows.push({
+			_key: tkey("r"),
+			cells: {}
+		});
+		line.forEach((raw, j) => {
+			const col = columns[at.col + j];
+			if (!col) return;
+			rows[ri].cells[col._key] = withValue(rows[ri].cells[col._key], coerce(raw, {
+				type: cellType(col, rows[ri], rows[ri].cells[col._key]),
+				max: col.max
+			}));
+		});
+	});
+	return {
+		...t,
+		columns,
+		rows
+	};
+}
+/**
+* Read a DOM <table> (or our <figure data-rt="table">) into the model. Our own data-* marks round-trip losslessly;
+* any other table is inferred: header rows from thead / th, row headers from tbody th[scope=row] or a th first cell,
+* caption from <caption> / figcaption / aria-label, groups from thead colspans and multiple <tbody> / rowgroup rows,
+* footer from <tfoot>, types from cell text (✓/✗ → boolean, $ → money, 4.5/5 → rating), footnote marks kept as notes.
+* Body cells with colspan/rowspan are expanded (copied) — the model has no merged body cells.
+*/
+function parseTableElement(el) {
+	const fig = el.matches("figure") ? el : el.closest("figure[data-rt=table]");
+	const table = el.matches("table") ? el : el.querySelector("table");
+	const out = emptyTable(0, 0);
+	if (!table) return emptyTable();
+	const ds = fig?.dataset ?? {};
+	out.id = ds.id || out.id;
+	out.caption = (table.querySelector(":scope > caption")?.textContent ?? fig?.querySelector(":scope > figcaption")?.textContent ?? table.getAttribute("aria-label") ?? "").trim();
+	out.notes = (fig?.querySelector("[data-notes]")?.textContent ?? "").trim() || void 0;
+	out.footnotes = Array.from(fig?.querySelectorAll("[data-footnotes] > li") ?? []).map((li) => ({
+		_key: li.dataset.key || tkey("f"),
+		text: (li.textContent ?? "").trim()
+	}));
+	if (!out.footnotes.length) delete out.footnotes;
+	const fnByIndex = new Map((out.footnotes ?? []).map((f, i) => [i + 1, f._key]));
+	if (ds.responsive === "stack" || ds.responsive === "cards") out.design = {
+		...out.design,
+		responsive: ds.responsive
+	};
+	if (ds.sticky === "true") out.design = {
+		...out.design,
+		sticky: true
+	};
+	if (ds.striped === "true") out.design = {
+		...out.design,
+		striped: true
+	};
+	if (ds.density === "compact") out.design = {
+		...out.design,
+		density: "compact"
+	};
+	if (ds.caption === "hidden") out.design = {
+		...out.design,
+		hideCaption: true
+	};
+	if (ds.filter === "true") out.filterable = true;
+	if (ds.jsonld) out.jsonLd = {
+		type: ds.jsonld,
+		...ds.jsonldAxis ? { axis: ds.jsonldAxis } : {},
+		...ds.jsonldPrice ? { priceRow: ds.jsonldPrice } : {}
+	};
+	const expand = (trs) => {
+		const grid = [];
+		trs.forEach((tr, ri) => {
+			grid[ri] ??= [];
+			let ci = 0;
+			for (const c of Array.from(tr.cells)) {
+				while (grid[ri][ci]) ci++;
+				const cs = Math.max(1, Math.min(50, c.colSpan || 1));
+				const rs = Math.max(1, Math.min(200, c.rowSpan || 1));
+				for (let dr = 0; dr < rs; dr++) for (let dc = 0; dc < cs; dc++) {
+					grid[ri + dr] ??= [];
+					grid[ri + dr][ci + dc] = {
+						el: c,
+						th: c.tagName === "TH",
+						origin: dr === 0 && dc === 0
+					};
+				}
+				ci += cs;
+			}
+		});
+		return grid;
+	};
+	const theadRows = Array.from(table.tHead?.rows ?? []);
+	const bodies = Array.from(table.tBodies);
+	const footRows = Array.from(table.tFoot?.rows ?? []);
+	let bodyRows = bodies.flatMap((b) => Array.from(b.rows).map((tr) => ({
+		tr,
+		body: b
+	})));
+	const head = [...theadRows];
+	if (!head.length) while (bodyRows.length && Array.from(bodyRows[0].tr.cells).every((c) => c.tagName === "TH") && bodyRows[0].tr.cells.length > 1) {
+		head.push(bodyRows[0].tr);
+		bodyRows = bodyRows.slice(1);
+	}
+	const hgrid = expand(head);
+	const width = Math.max(1, ...hgrid.map((r) => r.length), ...expand(bodyRows.map((b) => b.tr)).map((r) => r.length));
+	out.headerRow = head.length > 0;
+	const cols = Array.from(table.querySelectorAll(":scope > colgroup > col"));
+	const lastHead = hgrid[hgrid.length - 1] ?? [];
+	const columns = Array.from({ length: width }, (_, i) => {
+		const d = cols[i]?.dataset ?? {};
+		const hc = lastHead[i]?.el;
+		const label = hc ? cleanText(hc) : "";
+		const c = {
+			_key: d.key || hc?.dataset?.col || tkey("c"),
+			label,
+			type: d.type || "text"
+		};
+		if (d.unit) c.unit = d.unit;
+		if (d.currency) c.currency = d.currency;
+		if (d.decimals) c.decimals = Number(d.decimals);
+		if (d.align) c.align = d.align;
+		if (d.sortable === "true") c.sortable = true;
+		if (d.true) c.trueLabel = d.true;
+		if (d.false) c.falseLabel = d.false;
+		if (d.max) c.max = Number(d.max);
+		if (d.refTo) c.refTo = d.refTo.split(",");
+		if (d.highlight === "true") c.highlight = true;
+		if (d.description) c.description = d.description;
+		else if (hc?.getAttribute("title")) c.description = hc.getAttribute("title");
+		return c;
+	});
+	if (hgrid.length > 1) {
+		const top = hgrid[0];
+		const groups = [];
+		for (let i = 0; i < width;) {
+			const cell = top[i];
+			let span = 1;
+			while (cell && i + span < width && top[i + span]?.el === cell.el) span++;
+			const text = cell && cell.el !== lastHead[i]?.el ? cleanText(cell.el) : "";
+			if (text) {
+				const key = cell.el.dataset.group || tkey("g");
+				groups.push({
+					_key: key,
+					label: text
+				});
+				for (let k = 0; k < span; k++) columns[i + k].group = key;
+			}
+			i += span;
+		}
+		if (groups.length) out.columnGroups = groups;
+	}
+	const rowGroups = [];
+	const known = !!cols.length && cols.some((c) => c.dataset.type);
+	const rawRows = [];
+	let currentGroup;
+	let lastBody = null;
+	const bgrid = expand(bodyRows.map((b) => b.tr));
+	bodyRows.forEach(({ tr, body }, ri) => {
+		if (body !== lastBody) {
+			lastBody = body;
+			const label = body.dataset.label;
+			currentGroup = label ? body.dataset.key || tkey("rg") : void 0;
+			if (label && currentGroup) rowGroups.push({
+				_key: currentGroup,
+				label
+			});
+		}
+		const cells = bgrid[ri] ?? [];
+		if (tr.cells.length === 1 && (tr.cells[0].colSpan >= width || tr.cells[0].getAttribute("scope") === "rowgroup") || tr.hasAttribute("data-group-row")) {
+			if (!(tr.hasAttribute("data-group-row") && body.dataset.label)) {
+				currentGroup = tkey("rg");
+				rowGroups.push({
+					_key: currentGroup,
+					label: cleanText(tr.cells[0])
+				});
+			}
+			return;
+		}
+		rawRows.push({
+			key: tr.dataset.key || tkey("r"),
+			group: currentGroup,
+			type: tr.dataset.type || void 0,
+			highlight: tr.dataset.highlight === "true",
+			cells
+		});
+	});
+	expand(footRows).forEach((cells, i) => rawRows.push({
+		key: footRows[i].dataset.key || tkey("r"),
+		footer: true,
+		cells
+	}));
+	out.headerColumn = ds.headerCol === "true" || rawRows.length > 0 && rawRows.every((r) => r.cells[0]?.th && r.cells[0].el.getAttribute("scope") !== "col");
+	if (!known) columns.forEach((c, i) => {
+		if (out.headerColumn && i === 0) return;
+		const inf = inferColumn(rawRows.map((r) => r.cells[i] ? cellSource(r.cells[i].el) : ""));
+		Object.assign(c, inf);
+	});
+	out.columns = columns;
+	out.rows = rawRows.map((r) => ({
+		_key: r.key,
+		...r.group ? { group: r.group } : {},
+		...r.footer ? { footer: true } : {},
+		...r.type ? { type: r.type } : {},
+		...r.highlight ? { highlight: true } : {},
+		cells: Object.fromEntries(columns.map((c, i) => {
+			const cell = r.cells[i];
+			if (!cell) return [c._key, null];
+			return [c._key, readCell(cell.el, c, r.type, fnByIndex)];
+		}))
+	}));
+	if (rowGroups.length) out.rowGroups = rowGroups;
+	return out;
+}
+/** Visible text of a header/cell minus visually-hidden helpers and footnote marks. */
+function cleanText(el) {
+	const c = el.cloneNode(true);
+	c.querySelectorAll("sup, .bt-sort-icon, [aria-hidden=true]").forEach((n) => n.remove());
+	return (c.textContent ?? "").replace(/\s+/g, " ").trim();
+}
+/** A cell's source for inference: inner HTML minus footnote marks, decorative icons and sr helpers kept as words. */
+function cellSource(el) {
+	const c = el.cloneNode(true);
+	c.querySelectorAll("sup").forEach((n) => n.remove());
+	const sr = c.querySelector(".bt-sr, .sr-only, .visually-hidden, .screen-reader-text");
+	if (sr && !(c.textContent ?? "").replace(sr.textContent ?? "", "").replace(/[✓✔✗✕–—\s]/g, "")) return (sr.textContent ?? "").trim();
+	const labelled = c.querySelector("[aria-label]");
+	if (labelled && !(c.textContent ?? "").trim()) return labelled.getAttribute("aria-label") ?? "";
+	const img = c.querySelector("img[alt]");
+	if (img && !(c.textContent ?? "").trim()) return img.getAttribute("alt") ?? "";
+	c.querySelectorAll("[aria-hidden=true]").forEach((n) => n.remove());
+	const html = c.innerHTML.trim();
+	return /<(a|strong|b|em|i|code|br)\b/i.test(html) ? html : (c.textContent ?? "").replace(/\s+/g, " ").trim();
+}
+function readCell(el, col, rowType, fn) {
+	const d = el.dataset;
+	const type = d.type || rowType || col.type;
+	let value;
+	if (d.empty != null) value = null;
+	else if (d.ref) value = {
+		ref: d.ref,
+		label: cleanText(el) || void 0,
+		href: el.querySelector("a")?.getAttribute("href") ?? void 0
+	};
+	else if (d.value != null && (type === "boolean" || type === "number" || type === "money" || type === "rating")) value = type === "boolean" ? d.value === "true" : Number(d.value);
+	else if (type === "richtext-inline") {
+		const c = el.cloneNode(true);
+		c.querySelectorAll("sup").forEach((n) => n.remove());
+		value = sanitizeInline(c.innerHTML.trim());
+	} else value = coerce(cellSource(el), {
+		type,
+		max: col.max
+	});
+	const supN = Number(el.querySelector("sup a, sup")?.textContent?.trim());
+	const note = d.note || (supN ? fn.get(supN) : void 0);
+	if (d.type || note) return {
+		value,
+		...d.type ? { type: d.type } : {},
+		...note ? { note } : {}
+	};
+	return value;
+}
+/**
+* Dataset  — a report or spec table (name = caption, description = notes, variableMeasured = columns).
+* ItemList — a comparison: the things compared (row headers, or column labels) in order.
+* Offers   — a pricing matrix: one Offer per plan (columns), price from the money row `priceRow`.
+* Returns null when the table can't honestly support the type (no caption, no items, no prices).
+*/
+function tableJsonLd(input, o = {}) {
+	const t = normalizeTable(input);
+	const kind = t.jsonLd?.type ?? "none";
+	if (kind === "none" || !t.caption.trim()) return null;
+	const body = t.rows.filter((r) => !r.footer);
+	if (kind === "Dataset") return {
+		"@context": "https://schema.org",
+		"@type": "Dataset",
+		name: t.caption,
+		description: t.notes || t.caption,
+		...o.url ? { url: o.url } : {},
+		variableMeasured: t.columns.filter((_c, i) => !(t.headerColumn && i === 0)).map((c) => ({
+			"@type": "PropertyValue",
+			name: c.label,
+			...c.unit ? { unitText: c.unit } : {},
+			...c.description ? { description: c.description } : {}
+		}))
+	};
+	const axis = t.jsonLd?.axis ?? "rows";
+	if (kind === "ItemList") {
+		const items = (axis === "rows" ? body.map((r) => cellText(t.columns[0], r, r.cells[t.columns[0]._key], o.resolveRef)) : t.columns.slice(t.headerColumn ? 1 : 0).map((c) => c.label)).filter(Boolean);
+		if (!items.length) return null;
+		return {
+			"@context": "https://schema.org",
+			"@type": "ItemList",
+			name: t.caption,
+			numberOfItems: items.length,
+			itemListElement: items.map((name, i) => ({
+				"@type": "ListItem",
+				position: i + 1,
+				name
+			}))
+		};
+	}
+	const priceRow = t.rows.find((r) => r._key === t.jsonLd?.priceRow) ?? body.find((r) => t.columns.some((c) => cellType(c, r, r.cells[c._key]) === "money"));
+	if (!priceRow) return null;
+	const offers = t.columns.slice(t.headerColumn ? 1 : 0).map((c) => {
+		const cell = priceRow.cells[c._key];
+		const n = toNumber(cellValue(cell));
+		return n == null ? null : {
+			"@type": "Offer",
+			name: c.label,
+			price: n,
+			priceCurrency: c.currency || "USD",
+			...o.url ? { url: o.url } : {}
+		};
+	}).filter(Boolean);
+	if (!offers.length) return null;
+	const prices = offers.map((x) => x.price);
+	return {
+		"@context": "https://schema.org",
+		"@type": "Product",
+		name: t.caption,
+		...t.notes ? { description: t.notes } : {},
+		offers: {
+			"@type": "AggregateOffer",
+			lowPrice: Math.min(...prices),
+			highPrice: Math.max(...prices),
+			priceCurrency: offers[0].priceCurrency,
+			offerCount: offers.length,
+			offers
+		}
+	};
+}
+function tableIssues(input, opts = {}) {
+	if (!isTableValue(input)) return [];
+	const t = input;
+	const out = [];
+	if (!t.caption?.trim() && opts.requireCaption !== false) out.push({
+		level: "error",
+		message: "Give the table a title that says what it compares.",
+		at: "caption"
+	});
+	if (!t.headerRow) out.push({
+		level: "warning",
+		message: "Show the column names: turn on Show column names in Table settings."
+	});
+	if (t.headerRow) {
+		const empty = t.columns.filter((c, i) => !c.label.trim() && !(t.headerColumn && i === 0));
+		if (empty.length) out.push({
+			level: "error",
+			message: `Name ${empty.length === 1 ? "the empty column" : `the ${empty.length} empty columns`}.`,
+			at: `col:${empty[0]._key}`
+		});
+	}
+	const keys = /* @__PURE__ */ new Set();
+	for (const c of t.columns) {
+		if (keys.has(c._key)) out.push({
+			level: "error",
+			message: "Two columns are the same column. Delete one and add it again.",
+			at: `col:${c._key}`
+		});
+		keys.add(c._key);
+	}
+	if (opts.maxColumns && t.columns.length > opts.maxColumns) out.push({
+		level: "error",
+		message: `Use at most ${opts.maxColumns} columns.`
+	});
+	const body = t.rows.filter((r) => !r.footer);
+	if (opts.minRows && body.length < opts.minRows) out.push({
+		level: "error",
+		message: `Add at least ${opts.minRows} rows.`
+	});
+	if (opts.maxRows && body.length > opts.maxRows) out.push({
+		level: "error",
+		message: `Use at most ${opts.maxRows} rows.`
+	});
+	let mismatch = null;
+	let mismatches = 0;
+	for (const r of t.rows) for (const c of t.columns) {
+		const cell = r.cells?.[c._key];
+		const v = cellValue(cell);
+		if (isEmptyCell(v)) continue;
+		const ty = cellType(c, r, cell);
+		if ((ty === "number" || ty === "money" || ty === "rating") && toNumber(v) == null || ty === "boolean" && toBool(v) == null) {
+			mismatches++;
+			mismatch ??= {
+				row: r._key,
+				col: c._key,
+				label: c.label
+			};
+		}
+	}
+	if (mismatch) out.push({
+		level: "warning",
+		message: `${mismatches} ${mismatches === 1 ? "cell doesn't" : "cells don't"} match the column type (first in “${mismatch.label || "a column"}”). Change the column type or set the cell's own type.`,
+		at: `cell:${mismatch.row}:${mismatch.col}`
+	});
+	if (t.headerColumn && body.some((r) => isEmptyCell(cellValue(r.cells?.[t.columns[0]?._key])))) out.push({
+		level: "warning",
+		message: "Every row needs a name in the first column."
+	});
+	if (t.jsonLd?.type === "Dataset" && (t.notes ?? "").length < 50) out.push({
+		level: "warning",
+		message: "To be read as a data report, write a note under the table (a sentence or two)."
+	});
+	if (t.jsonLd?.type === "Offers" && !tableJsonLd(t)) out.push({
+		level: "warning",
+		message: "To be read as a price list, add a row of prices, one per plan column."
+	});
+	if (t.columns.length > 8 && t.design?.responsive !== "scroll") out.push({
+		level: "warning",
+		message: "More than 8 columns don't fit on phones as a list. In Table settings, set On phones to Scroll."
+	});
+	return out;
+}
+/** "4 rows × 3 columns" (array rows, summaries, breadcrumbs). */
+function tableSummary(v) {
+	if (!isTableValue(v)) return "";
+	const r = v.rows.length;
+	const c = v.columns.length;
+	return [v.caption?.trim(), `${r} ${r === 1 ? "row" : "rows"} × ${c} ${c === 1 ? "column" : "columns"}`].filter(Boolean).join(" · ");
+}
+/** Build a table in code (seed data, Kit Library, migrations): header labels + rows of display strings. */
+function tableFrom(caption, columns, rows, extra = {}) {
+	const cols = columns.map((c, i) => ({
+		type: "text",
+		...c,
+		_key: c._key ?? `c${i + 1}`
+	}));
+	return {
+		id: extra.id ?? `tbl_${caption.toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 32).replace(/-$/, "")}`,
+		caption,
+		headerRow: true,
+		headerColumn: false,
+		design: { responsive: "scroll" },
+		...extra,
+		columns: cols,
+		rows: rows.map((r, ri) => {
+			const def = Array.isArray(r) ? { cells: r } : r;
+			return {
+				_key: `r${ri + 1}`,
+				...def.group ? { group: def.group } : {},
+				...def.footer ? { footer: true } : {},
+				...def.type ? { type: def.type } : {},
+				...def.highlight ? { highlight: true } : {},
+				cells: Object.fromEntries(cols.map((c, ci) => [c._key, def.cells[ci] ?? null]))
+			};
+		})
+	};
+}
+//#endregion
+export { GENERAL_TABLE, TABLE_COLUMN_TYPES, boolLabels, cellNote, cellText, cellType, cellValue, coerce, emptyTable, formatMoney, formatNumber, inferColumn, isCellObject, isEmptyCell, isObjLike, isTableValue, normalizeTable, orderedRows, parseDelimited, parseTableElement, pasteRange, renderTableHtml, sanitizeInline, sortRows, tableFrom, tableFromRows, tableIssues, tableJsonLd, tableSummary, tableToMarkdown, tableToRows, tkey, toBool, toDelimited, toNumber, withValue };
+
+//# sourceMappingURL=table.js.map