bitboss-ui 3.0.0-beta.63 → 3.0.0-beta.64

package/dist/components/BbTable/estimatedFloors.golden.d.ts

@@ -0,0 +1,25 @@
+import { TrackEstimate, FittedFloors } from './utils';
+type Entry = {
+    kind: string;
+    column: string;
+    value: string;
+};
+type Estimate = (values: string[], label: string, padEm?: number, headerExtraEm?: number, labelType?: {
+    scale: number;
+    spacingEm: number;
+}, legacyPadEm?: number) => TrackEstimate;
+type Fit = (estimates: Record<string, TrackEstimate>, available: number) => FittedFloors;
+/** A small seeded generator (mulberry32): the same mixes on every run. */
+export declare const seeded: (seed: number) => () => number;
+export declare const goldenCases: (corpus: Entry[], estimate: Estimate, fit: Fit) => {
+    estimates: {
+        key: string;
+        e: TrackEstimate;
+    }[];
+    fits: {
+        keys: string[];
+        room: number;
+        fit: unknown;
+    }[];
+};
+export {};

package/dist/components/BbTable/measuredFloors.d.ts

@@ -0,0 +1,46 @@
+import { MeasureLookup, MeasuredLabel } from './utils';
+/** What the table tells about one estimated column. */
+export type MeasuredColumn = {
+    key: string;
+    /** Its data cell's index among a body row's children (structural cells
+     * first), the same index among the header row's cells. */
+    index: number;
+    /** The texts it shows (the sampled rows), as the cells render them. */
+    values: readonly string[];
+    placeholder?: string;
+    /** The profile says prose (`profileValues`): how its cells are held. */
+    prose: boolean;
+    /** Its own label, to measure; `undefined` when a slot or an affix renders
+     * the heading (the guard still reads the header as rendered). */
+    label?: string;
+    /** `td-class` or `row-class` is a function: rendered cells may differ in
+     * typography from one row to the next. */
+    dynamic: boolean;
+};
+export declare const createMeasuredFloors: (options: {
+    table: () => HTMLElement | null | undefined;
+    container: () => HTMLElement | null | undefined;
+    columns: () => MeasuredColumn[];
+    /** The body text's px (`--bb-fs`): the em of every estimate. */
+    em: () => number;
+    /** The fit, as a string: what a guard round has to change to count. */
+    plan: () => string;
+}) => {
+    version: import('vue').Ref<number, number>;
+    lookup: (key: string) => MeasureLookup | undefined;
+    labelOf: (key: string, extraEm: number) => MeasuredLabel | undefined;
+    extraPadOf: (key: string) => number;
+    measure: (mount?: boolean) => void;
+    checkTypography: () => void;
+    guard: (level: string, held: {
+        whole?: string;
+        word?: string;
+    }) => boolean;
+    /** The rows changed: measure their new texts on the next pass. */
+    rowsChanged: () => void;
+    /** How many widths this table keeps (tests: bounded by its rows). */
+    stored: () => number;
+    /** Called after a web font loads (the store is already cleared). */
+    onFontsChanged: (cb: () => void) => void;
+    dispose: () => void;
+};

package/dist/components/BbTable/measuredFloors.js

@@ -0,0 +1,322 @@
+import { breakRuns as e, measureCandidates as t, reservePx as n, textEm as r } from "./utils.js";
+import { measureTexts as i, onFontsChanged as a, typographySignature as o } from "./textRuler.js";
+import { ref as s } from "vue";
+//#region src/components/BbTable/measuredFloors.ts
+var c = () => ({
+	whole: /* @__PURE__ */ new Map(),
+	runs: /* @__PURE__ */ new Map()
+}), l = (e, t, r) => {
+	let i = e.get(t);
+	return i === void 0 || r > i ? (e.set(t, r), i === void 0 || n(r) > n(i)) : !1;
+}, u = 1500, d = 8e3, f = 1200, p = 3, m = ":scope > .bb-table__body > [role=\"row\"].bb-table__row", h = ":scope > .bb-table__head > [role=\"row\"]", g = /^bb-table__(cell--(edge-start|edge-end|value|placeholder|line|token|word|outlier)|row--(highlighted|highlightable|expanded|disabled|drag-source|lifted))$/, _ = (e) => {
+	let t = getComputedStyle(e), n = parseFloat(t.width);
+	t.boxSizing !== "border-box" && (n += parseFloat(t.paddingLeft) + parseFloat(t.paddingRight) + parseFloat(t.borderLeftWidth) + parseFloat(t.borderRightWidth));
+	let r = e.getBoundingClientRect().width;
+	return n > 0 && r > 0 ? r / n : 1;
+}, v = (e) => {
+	let t = [], n = (e) => {
+		for (let r of e.childNodes) {
+			if (r instanceof Text) {
+				r.data.trim() && t.push(r);
+				continue;
+			}
+			if (!(r instanceof Element) || r.classList.contains("bb-table-header__resizer")) continue;
+			let e = getComputedStyle(r).display;
+			if (e !== "none") {
+				if (e === "contents") {
+					if (!n(r)) return !1;
+					continue;
+				}
+				if (!e.startsWith("inline")) return !1;
+				t.push(r);
+			}
+		}
+		return !0;
+	};
+	return n(e) ? t : void 0;
+}, y = (y) => {
+	let b = s(0), x = /* @__PURE__ */ new Map(), S = /* @__PURE__ */ new Map(), C = /* @__PURE__ */ new Map(), w = /* @__PURE__ */ new Map(), T = /* @__PURE__ */ new Map(), E = /* @__PURE__ */ new Map(), D = /* @__PURE__ */ new Set(), O = 0, k, A = () => {
+		D = /* @__PURE__ */ new Set(), O = 0, k = void 0;
+	}, j = !0, M = 0, N = () => {
+		M++, x = /* @__PURE__ */ new Map(), S = /* @__PURE__ */ new Map(), C = /* @__PURE__ */ new Map(), w = /* @__PURE__ */ new Map(), T = /* @__PURE__ */ new Map(), A(), j = !0;
+	}, P = (t) => {
+		let r = y.em(), i = x.get(t), a = S.get(t);
+		if (!r || !i && !a) return;
+		let o = (e, t) => Math.max(i?.[e].get(t) ?? 0, a?.[e].get(t) ?? 0);
+		return (t) => {
+			let i = o("whole", t), a = 0;
+			for (let n of e(t)) a = Math.max(a, o("runs", n));
+			if (!(!i && !a)) return {
+				whole: i ? n(i) / r : void 0,
+				word: a ? n(a) / r : void 0
+			};
+		};
+	}, F = (e) => {
+		let t = y.em();
+		return t ? (E.get(e) ?? 0) / t : 0;
+	}, I = (e, t) => {
+		let r = y.em(), i = C.get(e), a = w.get(e);
+		if (!r || !i && a === void 0) return;
+		let o = a === void 0 ? 0 : a / r - t;
+		return {
+			one: Math.max(i ? n(i.one) / r : 0, o),
+			two: i ? n(i.two) / r : 0
+		};
+	}, L = (e) => [...e.querySelectorAll(m)], R = (e) => !e.matches(".bb-table__row--highlighted, .bb-table__row--expanded, [aria-selected=\"true\"], :hover, :focus-within"), z = (e, t, n = !1) => {
+		let r, i, a;
+		for (let o of e) {
+			let e = o.children[t];
+			if (e && (!r && e.classList.contains("bb-table__cell--value") ? (i ??= e, R(o) && (r = e)) : n && !a && e.classList.contains("bb-table__cell--placeholder") && (a = e), r && (a || !n))) break;
+		}
+		let o = r ?? i ?? a;
+		return {
+			value: o,
+			placeholder: a ?? o
+		};
+	}, B = (e, t) => e.querySelector(h)?.children[t]?.querySelector(".bb-table-header__content") ?? void 0, V = (e, t) => [
+		...e.classList,
+		"|",
+		...t.classList
+	].filter((e) => !g.test(e)).join(" "), H = (e) => {
+		let t = getComputedStyle(e);
+		return parseFloat(t.paddingLeft) + parseFloat(t.paddingRight);
+	}, U = (e, t) => {
+		let n = !1, r = e.querySelector(h);
+		for (let e of y.columns()) {
+			let i = z(t, e.index).value, a = r?.children[e.index], o = i && a ? Math.max(0, H(i) - H(a)) : 0;
+			Math.abs(o - (E.get(e.key) ?? 0)) > .01 && (E.set(e.key, o), n = !0);
+		}
+		return n;
+	}, W = (n) => {
+		let r = L(n);
+		U(n, r) && b.value++;
+		let i = [];
+		for (let a of y.columns()) {
+			let s = z(r, a.index, !!a.placeholder);
+			s.value && T.set(a.key, o(s.value));
+			let { whole: c, runs: l } = t(a.placeholder ? a.values.filter((e) => e !== a.placeholder) : a.values, a.prose);
+			if (s.value && (i.push({
+				key: a.key,
+				kind: "whole",
+				group: {
+					host: s.value,
+					texts: c
+				}
+			}), i.push({
+				key: a.key,
+				kind: "runs",
+				group: {
+					host: s.value,
+					texts: l
+				}
+			})), a.placeholder && s.placeholder) {
+				let t = a.placeholder.trim();
+				i.push({
+					key: a.key,
+					kind: "whole",
+					group: {
+						host: s.placeholder,
+						texts: [t]
+					}
+				}), i.push({
+					key: a.key,
+					kind: "runs",
+					group: {
+						host: s.placeholder,
+						texts: e(t)
+					}
+				});
+			}
+			if (a.dynamic) {
+				let t = /* @__PURE__ */ new Map();
+				for (let e of r) {
+					let n = e.children[a.index];
+					if (!n?.classList.contains("bb-table__cell--fluid")) continue;
+					let r = V(n, e), i = t.get(r);
+					i || t.set(r, i = {
+						host: n,
+						texts: /* @__PURE__ */ new Set()
+					});
+					let o = n.textContent?.trim();
+					o && i.texts.add(o);
+				}
+				for (let { host: n, texts: r } of t.values()) i.push({
+					key: a.key,
+					kind: "whole",
+					group: {
+						host: n,
+						texts: r
+					}
+				}), i.push({
+					key: a.key,
+					kind: "runs",
+					group: {
+						host: n,
+						texts: [...r].flatMap(e)
+					}
+				});
+			}
+			let u = a.label ? B(n, a.index) : void 0;
+			if (a.label && u) {
+				let t = e(a.label), n = [a.label];
+				for (let e = 1; e < t.length; e++) n.push(t.slice(0, e).join(" "), t.slice(e).join(" "));
+				i.push({
+					key: a.key,
+					kind: "label",
+					group: {
+						host: u,
+						texts: n
+					},
+					label: a.label
+				});
+			}
+		}
+		return i;
+	}, G = (t, r, i) => {
+		let a = !1, o = i ? /* @__PURE__ */ new Map() : x;
+		return t.forEach((t, i) => {
+			let s = r[i];
+			if (t.kind === "label") {
+				let r = t.label, i = e(r), o = s.get(r) ?? 0, c = o;
+				for (let e = 1; e < i.length; e++) {
+					let t = s.get(i.slice(0, e).join(" ")) ?? 0, n = s.get(i.slice(e).join(" ")) ?? 0;
+					c = Math.min(c, Math.max(t, n));
+				}
+				let l = C.get(t.key);
+				(!l || n(o) > n(l.one) || n(c) > n(l.two)) && (C.set(t.key, {
+					one: Math.max(o, l?.one ?? 0),
+					two: Math.max(c, l?.two ?? 0)
+				}), a = !0);
+				return;
+			}
+			let u = o.get(t.key);
+			u || o.set(t.key, u = c());
+			for (let [e, r] of s) {
+				let i = x.get(t.key)?.[t.kind].get(e);
+				l(u[t.kind], e, r), (i === void 0 || n(r) > n(i)) && (a = !0);
+			}
+		}), x = o, a;
+	}, K = () => {
+		let t = new Map(y.columns().map((e) => [e.key, e.values]));
+		for (let [n, r] of S) {
+			let i = t.get(n);
+			if (!i) {
+				S.delete(n);
+				continue;
+			}
+			let a = new Set(i.map((e) => e.trim())), o = new Set([...a].flatMap(e));
+			for (let e of r.whole.keys()) a.has(e) || r.whole.delete(e);
+			for (let e of r.runs.keys()) o.has(e) || r.runs.delete(e);
+		}
+	}, q = (e, t) => {
+		let n = e.some((e, n) => {
+			for (let r of e.group.texts) if (r && !t[n].has(r)) return !0;
+			return !1;
+		});
+		return n && (j = !0), !n;
+	}, J = 0, Y = (e = !1) => {
+		let t = y.table();
+		if (!t?.isConnected || !j) return;
+		j = !1, A();
+		let n = W(t), r = i(n.map((e) => e.group), e ? d : u);
+		if (K(), r) {
+			G(n, r, q(n, r)) && b.value++;
+			return;
+		}
+		let a = n.map(() => /* @__PURE__ */ new Map()), o = n.flatMap((e, t) => [...e.group.texts].map((e) => ({
+			i: t,
+			text: e
+		}))), s = ++M;
+		cancelAnimationFrame(J);
+		let c = () => {
+			if (s !== M || !t.isConnected) return;
+			let e = o.splice(0, f), r = /* @__PURE__ */ new Map();
+			for (let { i: t, text: n } of e) {
+				let e = r.get(t);
+				e || r.set(t, e = []), e.push(n);
+			}
+			let l = [...r.keys()], u = i(l.map((e) => ({
+				host: n[e].group.host,
+				texts: r.get(e)
+			})));
+			l.forEach((e, t) => {
+				for (let [n, r] of u[t]) a[e].set(n, r);
+			}), o.length ? J = requestAnimationFrame(c) : G(n, a, q(n, a)) && b.value++;
+		};
+		J = requestAnimationFrame(c);
+	}, X = () => {
+		let e = y.table();
+		if (!e?.isConnected || !T.size) return;
+		let t = L(e);
+		U(e, t) && b.value++;
+		for (let e of y.columns()) {
+			let n = T.get(e.key), r = z(t, e.index).value;
+			if (n && r && o(r) !== n) {
+				N();
+				return;
+			}
+		}
+	}, Z = (t, i) => {
+		let a = y.table(), o = y.container();
+		if (!a?.isConnected || !o || k === t || o.scrollWidth <= o.clientWidth || O >= p) return !1;
+		let s = y.plan(), u = document.createRange(), d = 0, f = (e) => (d ||= _(e), u.getBoundingClientRect().width / d), m = !1, g = L(a);
+		for (let t of y.columns()) {
+			let o = S.get(t.key);
+			for (let n of g) {
+				let a = n.children[t.index];
+				if (!a) continue;
+				let s = !!i.whole && a.matches(i.whole), d = !s && !!i.word && a.matches(i.word);
+				if (!s && !d) continue;
+				let p = a.textContent?.trim() ?? "", h = `${t.key}\u0001${p}\u0001${a.className}\u0001${s ? "whole" : "word"}`;
+				if (!p || D.has(h)) continue;
+				if (D.add(h), o || S.set(t.key, o = c()), s) {
+					u.selectNodeContents(a), l(o.whole, p, f(a)) && (m = !0);
+					continue;
+				}
+				let g = "";
+				for (let t of e(p)) r(t) > r(g) && (g = t);
+				let _ = [...a.childNodes].find((e) => e instanceof Text && e.data.includes(g));
+				if (!g || !_) continue;
+				let v = _.data.indexOf(g);
+				u.setStart(_, v), u.setEnd(_, v + g.length), l(o.runs, g, f(a)) && (m = !0);
+			}
+			let s = a.querySelector(h)?.children[t.index];
+			if (s && !s.classList.contains("bb-table__cell-column-header--wrap")) {
+				let e = v(s), r = `${t.key}\u0001header\u0001${s.textContent}`;
+				if (e?.length && !D.has(r)) {
+					D.add(r), u.setStartBefore(e[0]), u.setEndAfter(e.at(-1));
+					let i = f(s), a = w.get(t.key);
+					(a === void 0 || n(i) > n(a)) && (w.set(t.key, Math.max(i, a ?? 0)), m = !0);
+				}
+			}
+		}
+		return m && (b.value++, y.plan() !== s) ? (O++, !0) : (k = t, !1);
+	}, Q = a(() => {
+		N(), $?.();
+	}), $;
+	return {
+		version: b,
+		lookup: P,
+		labelOf: I,
+		extraPadOf: F,
+		measure: Y,
+		checkTypography: X,
+		guard: Z,
+		rowsChanged: () => {
+			j = !0, A();
+		},
+		stored: () => {
+			let e = 0;
+			for (let t of [x, S]) for (let n of t.values()) e += n.whole.size + n.runs.size;
+			return e;
+		},
+		onFontsChanged: (e) => {
+			$ = e;
+		},
+		dispose: () => {
+			Q(), M++, cancelAnimationFrame(J);
+		}
+	};
+};
+//#endregion
+export { y as createMeasuredFloors };

package/dist/components/BbTable/measuredFloorsTestKit.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Helpers for the measured content floors suites (Q9.1b, measured floors).
+ * Not part of the package: imported by `*.test.ts` files only.
+ */
+/** Three frames: the floors' rAF, the re-render, and the layout after it. */
+export declare const settle: (frames?: number) => Promise<void>;
+/** How many lines a cell's text takes (distinct line tops of its text). */
+export declare const linesOf: (cell: Element) => number;
+/** The table's sideways overflow, in px (0 when it fits). */
+export declare const overflowOf: (root: Element) => number;
+/** The body cells of the column whose heading reads `label`. */
+export declare const columnCells: (root: Element, label: string) => HTMLElement[];
+/** The texts of a column's cells that take more than one line. */
+export declare const brokenIn: (root: Element, label: string) => string[];
+/** The table's hold level (`units`, `core`, `words`), or `none`. */
+export declare const holdOf: (root: Element) => string;
+export declare const heldCells: (root: Element) => {
+    whole: HTMLElement[];
+    word: HTMLElement[];
+};
+/** Held WHOLE cells that take more than one line. */
+export declare const brokenHeld: (root: Element) => string[];
+/** Counts "ResizeObserver loop" errors until `stop()`. */
+export declare const watchResizeObserverErrors: () => {
+    readonly count: number;
+    stop: () => void;
+};

package/dist/components/BbTable/textRuler.d.ts

@@ -0,0 +1,71 @@
+/**
+ * THE TEXT RULER (measured content floors). BbTable estimates its content
+ * floors from a character table close to Arial; a wider UI font (Geist,
+ * Inter…) draws a date or an amount wider than that, and a floor short by
+ * two pixels breaks "20/10/2026" in two. After mount the table measures the
+ * values it holds, here, in the font they render in.
+ *
+ * - MIRROR, not cascade: each group of texts is measured under a wrapper that
+ *   carries a rendered cell's own computed text properties (font-*, letter-
+ *   and word-spacing, text-transform, numeric and feature settings, writing
+ *   mode, direction, lang), copied with `!important`. So container queries,
+ *   `:has()`, a row's `:nth-child`, a consumer's `td-class` all reach the
+ *   ruler as their RESULT, and a consumer rule cannot reach it at all. The
+ *   transform is applied by CSS, never re-implemented in JS (`capitalize`
+ *   capitalises after a hyphen too).
+ * - OUTSIDE the table: on `document.body` (or the ShadowRoot the table lives
+ *   in, where the library CSS is). Any node added under the table's root, a
+ *   `display: grid` scroller, re-lays out every row (243-404ms at 2000x10);
+ *   an isolated `contain: strict` box at the top of the document costs
+ *   0-0.4ms.
+ * - No `innerHTML`, no style attribute: the DOM is built with
+ *   `createElement`, `cloneNode` and `textContent`, and styled through the
+ *   CSSOM only, so it works under Trusted Types and a strict `style-src`.
+ * - One 100px reference block gives the scale of the page (a CSS `zoom` on
+ *   `html` or `body`): every width is divided by it.
+ * - The widths are cached per typography (`typographySignature`), across
+ *   tables and remounts; a font that finishes loading clears the cache
+ *   (`onFontsChanged`).
+ *
+ * The node lives for one synchronous read, `aria-hidden` and `inert`; a
+ * consumer's MutationObserver on `body` sees it come and go. The class
+ * `bb-table-ruler` is internal, not public API.
+ */
+/** What sets one rendered text's width apart from another's, as a string:
+ * the same signature measures the same. */
+export declare const typographySignature: (host: Element) => string;
+/** Forgets every width (a font loaded, or a test starts clean). */
+export declare const clearRulerCache: () => void;
+/**
+ * Calls `callback` after any web font finishes loading (or fails), with the
+ * cache already cleared: the widths measured before were the fallback's.
+ * Not every font change fires this (a `FontFace` built from a buffer, or a
+ * `local()` face in WebKit, fire nothing): the table's overflow guard covers
+ * those. Returns the unsubscribe.
+ */
+export declare const onFontsChanged: (callback: () => void) => (() => void);
+/** What the ruler did (tests: a resize must not touch it, new rows measure
+ * only their new texts): DOM builds, texts measured, time spent (ms). */
+export declare const rulerStats: {
+    builds: number;
+    texts: number;
+    ms: number;
+};
+export type RulerGroup = {
+    /** A rendered element whose text the group's texts are drawn like. */
+    host: Element;
+    texts: Iterable<string>;
+};
+/**
+ * Measure each group's texts on one line, under its host's typography, in
+ * one layout. Returns, per group (same order), each text's width in CSS px
+ * of the host's own coordinates (a zoomed page's scale divided out).
+ * Cached texts cost no DOM work. A text the ruler could not lay out (its
+ * root not rendered) is missing from its map, and nothing is cached.
+ *
+ * With `maxMisses`: more new texts than that measure nothing and return
+ * `undefined` (the caller measures them in frames instead), so a call that
+ * finds most texts cached stays one synchronous read.
+ */
+export declare function measureTexts(groups: readonly RulerGroup[]): Array<Map<string, number>>;
+export declare function measureTexts(groups: readonly RulerGroup[], maxMisses: number): Array<Map<string, number>> | undefined;

package/dist/components/BbTable/textRuler.js

@@ -0,0 +1,121 @@
+//#region src/components/BbTable/textRuler.ts
+var e = /^(font|letter-spacing|word-spacing|text-transform|text-rendering|text-autospace|text-spacing-trim|text-orientation|writing-mode|direction|unicode-bidi|tab-size|-webkit-locale)/, t = /* @__PURE__ */ new Set([
+	"font",
+	"font-variant",
+	"font-synthesis"
+]), n, r = (r) => {
+	if (!n) {
+		let i = [];
+		for (let n of Array.from(r)) e.test(n) && !t.has(n) && i.push(n);
+		n = i.sort();
+	}
+	return n;
+}, i = (e) => {
+	let t = getComputedStyle(e), n = r(t).map((e) => [e, t.getPropertyValue(e)]), i = e.closest("[lang]")?.getAttribute("lang") ?? "", a = Math.round((globalThis.devicePixelRatio || 1) * 100) / 100;
+	return {
+		signature: `${n.map(([, e]) => e).join("|")}|${i}|${a}`,
+		properties: n,
+		lang: i
+	};
+}, a = (e) => i(e).signature, o = /* @__PURE__ */ new Map(), s = 0, c = 5e4, l = () => {
+	o.clear(), s = 0;
+}, u = /* @__PURE__ */ new Set(), d = !1, f = (e) => {
+	let t = typeof document < "u" ? document.fonts : void 0;
+	if (!t?.addEventListener) return () => {};
+	if (!d) {
+		d = !0;
+		let e = () => {
+			l();
+			for (let e of [...u]) e();
+		};
+		t.addEventListener("loadingdone", e), t.addEventListener("loadingerror", e);
+	}
+	return u.add(e), () => u.delete(e);
+}, p = {
+	builds: 0,
+	texts: 0,
+	ms: 0
+}, m = (e, t, n) => e.style.setProperty(t, n, "important"), h = (e) => {
+	let t = e.getRootNode();
+	return typeof ShadowRoot < "u" && t instanceof ShadowRoot ? t : e.ownerDocument?.body ?? null;
+};
+function g(e, t = Infinity) {
+	s > c && l();
+	let n = e.map((e) => ({
+		group: e,
+		typography: i(e.host),
+		texts: [...new Set(e.texts)]
+	})), r = /* @__PURE__ */ new Map();
+	for (let { group: e, typography: t, texts: i } of n) {
+		let n = o.get(t.signature);
+		for (let a of i) {
+			if (!a || n?.has(a)) continue;
+			let i = r.get(t.signature);
+			i || r.set(t.signature, i = {
+				typography: t,
+				host: e.host,
+				texts: /* @__PURE__ */ new Set()
+			}), i.texts.add(a);
+		}
+	}
+	let a = 0;
+	for (let e of r.values()) a += e.texts.size;
+	if (!(a > t)) return r.size && _([...r.values()]), n.map(({ typography: e, texts: t }) => {
+		let n = o.get(e.signature), r = /* @__PURE__ */ new Map();
+		for (let e of t) {
+			let t = n?.get(e);
+			t !== void 0 && r.set(e, t);
+		}
+		return r;
+	});
+}
+var _ = (e) => {
+	let t = h(e[0].host), n = e[0].host.ownerDocument;
+	if (!t || !n) return;
+	p.builds++;
+	let r = performance.now(), i = n.createElement("div");
+	i.className = "bb-table-ruler", i.setAttribute("aria-hidden", "true"), i.setAttribute("inert", "");
+	for (let [e, t] of [
+		["position", "absolute"],
+		["top", "0"],
+		["left", "0"],
+		["width", "0"],
+		["height", "0"],
+		["overflow", "hidden"],
+		["contain", "strict"],
+		["visibility", "hidden"],
+		["pointer-events", "none"]
+	]) m(i, e, t);
+	let a = n.createElement("div");
+	m(a, "width", "100px"), m(a, "height", "0"), i.append(a);
+	let c = n.createElement("bb-ruler-line"), l = [];
+	for (let { typography: t, texts: r } of e) {
+		let e = n.createElement("div");
+		for (let [n, r] of t.properties) r && m(e, n, r);
+		m(e, "white-space", "nowrap"), t.lang && e.setAttribute("lang", t.lang);
+		for (let n of r) {
+			let r = c.cloneNode();
+			r.textContent = n, e.append(r), l.push({
+				signature: t.signature,
+				text: n,
+				node: r.firstChild
+			});
+		}
+		i.append(e);
+	}
+	t.append(i);
+	try {
+		let e = a.getBoundingClientRect().width / 100;
+		if (!e) return;
+		let t = n.createRange();
+		for (let { signature: n, text: r, node: i } of l) {
+			t.selectNodeContents(i);
+			let a = o.get(n);
+			a || o.set(n, a = /* @__PURE__ */ new Map()), a.set(r, t.getBoundingClientRect().width / e), s++;
+		}
+	} finally {
+		i.remove(), p.texts += l.length, p.ms += performance.now() - r;
+	}
+};
+//#endregion
+export { l as clearRulerCache, g as measureTexts, f as onFontsChanged, p as rulerStats, a as typographySignature };