@tenphi/tasty 0.0.0-snapshot.27b6708 → 0.0.0-snapshot.28eb83c

package/dist/chunks/debug-Vyauml7U.js

@@ -0,0 +1,583 @@
+import { j as tastyClassRegex } from "./css-definitions-BZ9vm0ci.js";
+import { j as CHUNK_NAMES } from "./style-engine-CBuOt1e4.js";
+import { S as injector, V as getNamePrefix, X as flushStyles, g as getCSSTextForNode } from "./runtime-engine-DQ5laRou.js";
+//#region src/debug.ts
+function fmtSize(bytes) {
+	return bytes > 1024 ? `${(bytes / 1024).toFixed(1)}KB` : `${bytes}B`;
+}
+function countRules(css) {
+	return (css.match(/\{[^}]*\}/g) || []).length;
+}
+function sortTastyClasses(classes) {
+	return Array.from(classes).sort((a, b) => a.localeCompare(b));
+}
+/**
+* The root these helpers read, or `null` where there is no DOM.
+*
+* `document` used to be a default parameter value, and a default is evaluated
+* at the call site — so every read below threw a bare `ReferenceError` under
+* Node, taking out five of the eight public methods. A debug utility must not
+* be able to fail an SSR render because a call was left in, so the DOM-less
+* case reports an empty result and says why.
+*/
+function defaultRoot() {
+	return typeof document === "undefined" ? null : document;
+}
+let warnedNoDom = false;
+/** Say once why the numbers are empty. Silent under `{ raw: true }`. */
+function warnNoDom(raw) {
+	if (raw || warnedNoDom) return;
+	warnedNoDom = true;
+	console.warn("[Tasty] tastyDebug reads the DOM and this environment has none, so the result is empty. During SSR, read the ServerStyleCollector instead.");
+}
+/**
+* The registry for `root`, with every queued write landed first.
+*
+* Every injector read API is a flush point, and the reads below reach past
+* those APIs straight into the registry and the sheet manager. Without this
+* they would report a batch window's contents as absent — a rule that is
+* enqueued but not yet in a sheet is missing from `globalRules`, from the
+* sheets, and from anything counting either.
+*/
+function getRegistry(root = defaultRoot()) {
+	if (!root) return void 0;
+	flushStyles();
+	return injector.instance._sheetManager?.getRegistry(root);
+}
+function findDomTastyClasses(root = defaultRoot()) {
+	if (!root) return [];
+	const classes = /* @__PURE__ */ new Set();
+	const elements = root.querySelectorAll?.("[class]") || [];
+	const classRegex = tastyClassRegex(getNamePrefix());
+	elements.forEach((el) => {
+		const attr = el.getAttribute("class");
+		if (attr) {
+			for (const cls of attr.split(/\s+/)) if (classRegex.test(cls)) classes.add(cls);
+		}
+	});
+	return sortTastyClasses(classes);
+}
+/**
+* Everything this injector holds in `root`, in the order the engine applies it,
+* with the sources kept byte-for-byte — trimming would report a total smaller
+* than one of its own parts whenever raw CSS has edge whitespace.
+*/
+function getAllCSS(root = defaultRoot()) {
+	const registry = getRegistry(root);
+	const sheetManager = injector.instance._sheetManager;
+	if (!root || !registry || !sheetManager) return "";
+	return sheetManager.getOwnedCSSInOrder(registry, root).join("\n");
+}
+/**
+* The injector's own readers fall back to `document` when `root` is omitted, so
+* they have to be reached with a real root or not at all.
+*/
+function cssTextForClasses(classNames, root) {
+	if (!root) return "";
+	return injector.instance.getCSSTextForClasses(classNames, { root });
+}
+function getInjectorMetrics(root) {
+	if (!root) return null;
+	return injector.instance.getMetrics({ root });
+}
+/**
+* Injected classes that no element carries and nobody pinned — the exact set
+* `gc({ force: true })` would delete.
+*
+* Deliberately borrowed from the injector rather than recomputed here: the two
+* drifted apart once before, when this file still read "unused" off the pin
+* counts the render path had stopped maintaining.
+*/
+function getUnusedClasses(root = defaultRoot()) {
+	if (!root) return [];
+	return sortTastyClasses(injector.instance.getUnusedClasses({ root }));
+}
+/** Every class this injector holds CSS for in `root`. */
+function getOwnedClasses(root = defaultRoot()) {
+	const registry = getRegistry(root);
+	if (!registry) return [];
+	const owned = [];
+	for (const [className, info] of registry.rules) if (info.sheetIndex >= 0) owned.push(className);
+	return sortTastyClasses(owned);
+}
+function prettifyCSS(css) {
+	if (!css || !css.trim()) return "";
+	const out = [];
+	let depth = 0;
+	const indent = () => "  ".repeat(depth);
+	let normalized = css.replace(/\s+/g, " ").trim();
+	normalized = normalized.replace(/\s*\{\s*/g, " { ");
+	normalized = normalized.replace(/\s*\}\s*/g, " } ");
+	normalized = normalized.replace(/;\s*/g, "; ");
+	const tokens = normalized.split(/\s+/);
+	let buf = "";
+	for (const t of tokens) if (t === "{") {
+		const header = buf.trim();
+		if (header) {
+			const parts = splitOutsideParens(header, ",");
+			if (parts.length > 1) out.push(parts.map((p, idx) => idx === 0 ? `${indent()}${p.trim()},` : `${indent()}${p.trim()}${idx < parts.length - 1 ? "," : ""}`).join("\n") + " {");
+			else out.push(`${indent()}${header} {`);
+		} else out.push(`${indent()}{`);
+		depth++;
+		buf = "";
+	} else if (t === "}") {
+		if (buf.trim()) {
+			for (const decl of buf.split(";").filter((s) => s.trim())) out.push(`${indent()}${decl.trim()};`);
+			buf = "";
+		}
+		depth = Math.max(0, depth - 1);
+		out.push(`${indent()}}`);
+	} else if (t.endsWith(";")) {
+		buf += ` ${t}`;
+		const full = buf.trim();
+		if (full) out.push(`${indent()}${full}`);
+		buf = "";
+	} else buf += ` ${t}`;
+	if (buf.trim()) out.push(buf.trim());
+	return out.filter((l) => l.trim()).join("\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+/** Split `str` by `sep` only when not inside parentheses */
+function splitOutsideParens(str, sep) {
+	const parts = [];
+	let depth = 0;
+	let start = 0;
+	for (let i = 0; i < str.length; i++) {
+		const ch = str[i];
+		if (ch === "(") depth++;
+		else if (ch === ")") depth--;
+		else if (depth === 0 && str.startsWith(sep, i)) {
+			parts.push(str.slice(start, i));
+			start = i + sep.length;
+		}
+	}
+	parts.push(str.slice(start));
+	return parts;
+}
+function extractChunkName(cacheKey) {
+	for (const part of cacheKey.split("\0")) {
+		if (part.startsWith("[states:")) continue;
+		if (!part.includes(":") && part.length > 0) return part;
+	}
+	return null;
+}
+function getChunkForClass(className, root = defaultRoot()) {
+	const registry = getRegistry(root);
+	if (!registry) return null;
+	for (const [key, cn] of registry.cacheKeyToClassName) if (cn === className) return extractChunkName(key);
+	return null;
+}
+function buildChunkBreakdown(root = defaultRoot()) {
+	const registry = getRegistry(root);
+	if (!root || !registry) return {
+		byChunk: {},
+		totalChunkTypes: 0,
+		totalClasses: 0
+	};
+	const byChunk = {};
+	for (const [cacheKey, className] of registry.cacheKeyToClassName) {
+		const chunk = extractChunkName(cacheKey) || "unknown";
+		if (!byChunk[chunk]) byChunk[chunk] = {
+			classes: [],
+			cssSize: 0,
+			ruleCount: 0
+		};
+		byChunk[chunk].classes.push(className);
+		const css = injector.instance.getCSSTextForClasses([className], { root });
+		byChunk[chunk].cssSize += css.length;
+		byChunk[chunk].ruleCount += countRules(css);
+	}
+	for (const entry of Object.values(byChunk)) entry.classes = sortTastyClasses(entry.classes);
+	const totalClasses = Object.values(byChunk).reduce((s, e) => s + e.classes.length, 0);
+	return {
+		byChunk,
+		totalChunkTypes: Object.keys(byChunk).length,
+		totalClasses
+	};
+}
+/**
+* Every prefix `registry.globalRules` is keyed by. Anything missing here is a
+* rule the summary would hold but never count, which is how the totals stopped
+* adding up the first time.
+*/
+const GLOBAL_RULE_PREFIXES = {
+	global: "global:",
+	property: "property:",
+	fontFace: "fontface:",
+	counterStyle: "counterstyle:",
+	function: "function:"
+};
+function getGlobalTypeCSS(type, root = defaultRoot()) {
+	const registry = getRegistry(root);
+	if (!root || !registry) return {
+		css: "",
+		ruleCount: 0,
+		size: 0
+	};
+	const chunks = [];
+	let rc = 0;
+	if (type === "raw") {
+		const css = injector.instance.getRawCSSText({ root });
+		const sheetManager = injector.instance._sheetManager;
+		return {
+			css: prettifyCSS(css),
+			ruleCount: sheetManager?.getRawRuleCount(root) ?? 0,
+			size: css.length
+		};
+	}
+	if (type === "keyframes") for (const [, entry] of registry.keyframesCache) {
+		const info = entry.info;
+		const sheetInfo = registry.sheets[info.sheetIndex];
+		const sm = injector.instance._sheetManager;
+		const ss = sheetInfo && sm ? sm.getCSSSheet(sheetInfo) : null;
+		if (ss && info.ruleIndex < ss.cssRules.length) {
+			const rule = ss.cssRules[info.ruleIndex];
+			if (rule) {
+				chunks.push(rule.cssText);
+				rc++;
+			}
+		} else if (info.cssText) {
+			chunks.push(info.cssText);
+			rc++;
+		}
+	}
+	else {
+		const prefix = GLOBAL_RULE_PREFIXES[type];
+		for (const [key, ri] of registry.globalRules) {
+			if (!key.startsWith(prefix)) continue;
+			const sheetInfo = registry.sheets[ri.sheetIndex];
+			const sm = injector.instance._sheetManager;
+			const ss = sheetInfo && sm ? sm.getCSSSheet(sheetInfo) : null;
+			if (ss) {
+				const start = Math.max(0, ri.ruleIndex);
+				const end = Math.min(ss.cssRules.length - 1, ri.endRuleIndex ?? ri.ruleIndex);
+				if (start >= 0 && end >= start && start < ss.cssRules.length) for (let i = start; i <= end; i++) {
+					const rule = ss.cssRules[i];
+					if (rule) {
+						chunks.push(rule.cssText);
+						rc++;
+					}
+				}
+			} else if (ri.cssText?.length) {
+				chunks.push(...ri.cssText);
+				rc += ri.cssText.length;
+			}
+		}
+	}
+	const raw = chunks.join("\n");
+	return {
+		css: prettifyCSS(raw),
+		ruleCount: rc,
+		size: raw.length
+	};
+}
+function getSourceCssForClasses(classNames, root = defaultRoot()) {
+	const registry = getRegistry(root);
+	if (!registry) return null;
+	const chunks = [];
+	let found = false;
+	for (const cls of classNames) {
+		const info = registry.rules.get(cls);
+		if (info?.cssText?.length) {
+			chunks.push(...info.cssText);
+			found = true;
+		}
+	}
+	return found ? chunks.join("\n") : null;
+}
+function getDefs(root = defaultRoot()) {
+	const registry = getRegistry(root);
+	let properties = [];
+	if (registry?.injectedProperties) properties = Array.from(registry.injectedProperties.keys()).sort();
+	const keyframes = [];
+	if (registry) {
+		for (const entry of registry.keyframesCache.values()) keyframes.push({
+			name: entry.name,
+			refCount: entry.refCount
+		});
+		keyframes.sort((a, b) => a.name.localeCompare(b.name));
+	}
+	return {
+		properties,
+		keyframes
+	};
+}
+const CHUNK_ORDER = [
+	CHUNK_NAMES.COMBINED,
+	CHUNK_NAMES.APPEARANCE,
+	CHUNK_NAMES.FONT,
+	CHUNK_NAMES.DIMENSION,
+	CHUNK_NAMES.DISPLAY,
+	CHUNK_NAMES.LAYOUT,
+	CHUNK_NAMES.POSITION,
+	CHUNK_NAMES.MISC,
+	CHUNK_NAMES.SUBCOMPONENTS
+];
+const tastyDebug = {
+	css(target, opts) {
+		const { root = defaultRoot(), prettify = true, raw = false, source = false } = opts || {};
+		if (!root) {
+			warnNoDom(raw);
+			return "";
+		}
+		let css = "";
+		const classRegex = tastyClassRegex(getNamePrefix());
+		if (source && typeof target === "string" && classRegex.test(target)) {
+			const src = getSourceCssForClasses([target], root);
+			if (src) css = src;
+			else {
+				if (!raw) console.warn("[Tasty] source CSS not available (requires dev mode or TASTY_DEBUG=true). Falling back to live CSSOM.");
+				css = injector.instance.getCSSTextForClasses([target], { root });
+			}
+		} else if (source && Array.isArray(target)) {
+			const src = getSourceCssForClasses(target, root);
+			if (src) css = src;
+			else {
+				if (!raw) console.warn("[Tasty] source CSS not available. Falling back to live CSSOM.");
+				css = injector.instance.getCSSTextForClasses(target, { root });
+			}
+		} else if (typeof target === "string") if (target === "all") css = getAllCSS(root);
+		else if (target === "global") {
+			css = getGlobalTypeCSS("global", root).css;
+			return css;
+		} else if (target === "active") {
+			const active = findDomTastyClasses(root);
+			css = injector.instance.getCSSTextForClasses(active, { root });
+		} else if (target === "unused") {
+			const unused = getUnusedClasses(root);
+			css = injector.instance.getCSSTextForClasses(unused, { root });
+		} else if (target === "page") css = getPageCSS(root);
+		else if (classRegex.test(target)) css = injector.instance.getCSSTextForClasses([target], { root });
+		else {
+			const el = root.querySelector?.(target);
+			if (el) css = getCSSTextForNode(el, { root });
+		}
+		else if (Array.isArray(target)) css = injector.instance.getCSSTextForClasses(target, { root });
+		else if (target instanceof Element) css = getCSSTextForNode(target, { root });
+		const result = prettify ? prettifyCSS(css) : css;
+		if (!raw) {
+			const label = Array.isArray(target) ? `[${target.join(", ")}]` : target;
+			const rc = countRules(css);
+			console.group(`CSS for ${label} (${rc} rules, ${fmtSize(css.length)})`);
+			console.log(result || "(empty)");
+			console.groupEnd();
+		}
+		return result;
+	},
+	inspect(target, opts) {
+		const { root = defaultRoot(), raw = false } = opts || {};
+		const element = !root ? null : typeof target === "string" ? root.querySelector?.(target) : target;
+		if (!root) warnNoDom(raw);
+		if (!element) {
+			const empty = {
+				element: null,
+				classes: [],
+				chunks: [],
+				css: "",
+				size: 0,
+				rules: 0
+			};
+			if (!raw && root) console.warn("[Tasty] debug.inspect: element not found");
+			return empty;
+		}
+		const classList = element.getAttribute("class") || "";
+		const classRegex = tastyClassRegex(getNamePrefix());
+		const tastyClasses = classList.split(/\s+/).filter((cls) => classRegex.test(cls));
+		const chunks = tastyClasses.map((className) => ({
+			className,
+			chunkName: getChunkForClass(className, root)
+		}));
+		const css = getCSSTextForNode(element, { root: root ?? void 0 });
+		const rules = countRules(css);
+		const result = {
+			element,
+			classes: tastyClasses,
+			chunks,
+			css: prettifyCSS(css),
+			size: css.length,
+			rules
+		};
+		if (!raw) {
+			const tag = element.tagName.toLowerCase();
+			const id = element.id ? `#${element.id}` : "";
+			console.group(`inspect ${tag}${id} — ${tastyClasses.length} classes, ${rules} rules, ${fmtSize(css.length)}`);
+			if (chunks.length) console.log("Chunks:", chunks.map((c) => `${c.className}→${c.chunkName || "?"}`).join(", "));
+			console.groupCollapsed("CSS");
+			console.log(result.css || "(empty)");
+			console.groupEnd();
+			console.groupEnd();
+		}
+		return result;
+	},
+	summary(opts) {
+		const { root = defaultRoot(), raw = false } = opts || {};
+		if (!root) warnNoDom(raw);
+		const activeClasses = findDomTastyClasses(root);
+		const unusedClasses = getUnusedClasses(root);
+		const ownedClasses = getOwnedClasses(root);
+		const totalStyledClasses = sortTastyClasses(new Set([...activeClasses, ...ownedClasses]));
+		const unusedSet = new Set(unusedClasses);
+		const activeSet = new Set(activeClasses);
+		const hotClasses = ownedClasses.filter((className) => !activeSet.has(className) && !unusedSet.has(className));
+		const hotCSS = cssTextForClasses(hotClasses, root);
+		const activeCSS = cssTextForClasses(activeClasses, root);
+		const unusedCSS = cssTextForClasses(unusedClasses, root);
+		const allCSS = getAllCSS(root);
+		const activeRuleCount = countRules(activeCSS);
+		const unusedRuleCount = countRules(unusedCSS);
+		const globalData = getGlobalTypeCSS("global", root);
+		const rawData = getGlobalTypeCSS("raw", root);
+		const kfData = getGlobalTypeCSS("keyframes", root);
+		const propData = getGlobalTypeCSS("property", root);
+		const atRuleData = [
+			"fontFace",
+			"counterStyle",
+			"function"
+		].reduce((all, type) => {
+			const data = getGlobalTypeCSS(type, root);
+			return {
+				css: data.css ? `${all.css}\n${data.css}`.trim() : all.css,
+				ruleCount: all.ruleCount + data.ruleCount,
+				size: all.size + data.size
+			};
+		}, {
+			css: "",
+			ruleCount: 0,
+			size: 0
+		});
+		const totalRuleCount = activeRuleCount + unusedRuleCount + countRules(hotCSS) + globalData.ruleCount + atRuleData.ruleCount + rawData.ruleCount + kfData.ruleCount + propData.ruleCount;
+		const metrics = getInjectorMetrics(root);
+		const defs = getDefs(root);
+		const chunkBreakdown = buildChunkBreakdown(root);
+		const summary = {
+			activeClasses,
+			unusedClasses,
+			hotClasses,
+			totalStyledClasses,
+			activeCSSSize: activeCSS.length,
+			unusedCSSSize: unusedCSS.length,
+			globalCSSSize: globalData.size + atRuleData.size,
+			rawCSSSize: rawData.size,
+			keyframesCSSSize: kfData.size,
+			propertyCSSSize: propData.size,
+			totalCSSSize: allCSS.length,
+			activeRuleCount,
+			unusedRuleCount,
+			globalRuleCount: globalData.ruleCount + atRuleData.ruleCount,
+			rawRuleCount: rawData.ruleCount,
+			keyframesRuleCount: kfData.ruleCount,
+			propertyRuleCount: propData.ruleCount,
+			totalRuleCount,
+			metrics,
+			definedProperties: defs.properties,
+			definedKeyframes: defs.keyframes,
+			chunkBreakdown
+		};
+		if (!raw) {
+			console.group("Tasty Summary");
+			console.log(`Active:   ${activeClasses.length} classes, ${activeRuleCount} rules, ${fmtSize(activeCSS.length)}`);
+			console.log(`Unused:   ${unusedClasses.length} classes, ${unusedRuleCount} rules, ${fmtSize(unusedCSS.length)}`);
+			if (hotClasses.length) console.log(`Held:     ${hotClasses.length} classes, ${countRules(hotCSS)} rules, ${fmtSize(hotCSS.length)} (not rendered, not yet collectable)`);
+			console.log(`Global:   ${globalData.ruleCount + atRuleData.ruleCount} rules, ${fmtSize(globalData.size + atRuleData.size)}`);
+			if (rawData.ruleCount) console.log(`Raw:      ${rawData.ruleCount} rules, ${fmtSize(rawData.size)}`);
+			if (kfData.ruleCount) console.log(`Keyframes: ${kfData.ruleCount} rules, ${fmtSize(kfData.size)}`);
+			if (propData.ruleCount) console.log(`@property: ${propData.ruleCount} rules, ${fmtSize(propData.size)}`);
+			console.log(`Total:    ${totalStyledClasses.length} classes, ${totalRuleCount} rules, ${fmtSize(allCSS.length)}`);
+			if (metrics) {
+				const total = metrics.hits + metrics.misses;
+				const rate = total > 0 ? (metrics.hits / total * 100).toFixed(1) : 0;
+				console.log(`Cache:    ${rate}% hit rate (${total} lookups)`);
+			}
+			if (chunkBreakdown.totalChunkTypes > 0) {
+				console.groupCollapsed(`Chunks (${chunkBreakdown.totalChunkTypes} types, ${chunkBreakdown.totalClasses} classes)`);
+				for (const name of CHUNK_ORDER) {
+					const d = chunkBreakdown.byChunk[name];
+					if (d) console.log(`  ${name}: ${d.classes.length} cls, ${d.ruleCount} rules, ${fmtSize(d.cssSize)}`);
+				}
+				for (const [name, d] of Object.entries(chunkBreakdown.byChunk)) if (!CHUNK_ORDER.includes(name)) console.log(`  ${name}: ${d.classes.length} cls, ${d.ruleCount} rules, ${fmtSize(d.cssSize)}`);
+				console.groupEnd();
+			}
+			if (defs.properties.length || defs.keyframes.length) console.log(`Defs:     ${defs.properties.length} @property, ${defs.keyframes.length} @keyframes`);
+			console.groupEnd();
+		}
+		return summary;
+	},
+	chunks(opts) {
+		const { root = defaultRoot(), raw = false } = opts || {};
+		if (!root) warnNoDom(raw);
+		const breakdown = buildChunkBreakdown(root);
+		if (!raw) {
+			console.group(`Chunks (${breakdown.totalChunkTypes} types, ${breakdown.totalClasses} classes)`);
+			for (const name of CHUNK_ORDER) {
+				const d = breakdown.byChunk[name];
+				if (d) console.log(`  ${name}: ${d.classes.length} cls, ${d.ruleCount} rules, ${fmtSize(d.cssSize)}`);
+			}
+			for (const [name, d] of Object.entries(breakdown.byChunk)) if (!CHUNK_ORDER.includes(name)) console.log(`  ${name}: ${d.classes.length} cls, ${d.ruleCount} rules, ${fmtSize(d.cssSize)}`);
+			console.groupEnd();
+		}
+		return breakdown;
+	},
+	cache(opts) {
+		const { root = defaultRoot(), raw = false } = opts || {};
+		if (!root) warnNoDom(raw);
+		const active = findDomTastyClasses(root);
+		const unused = getUnusedClasses(root);
+		const metrics = getInjectorMetrics(root);
+		const status = {
+			classes: {
+				active,
+				unused,
+				all: sortTastyClasses(new Set([...active, ...getOwnedClasses(root)]))
+			},
+			metrics
+		};
+		if (!raw) {
+			console.group("Cache");
+			console.log(`Active: ${active.length}, Unused: ${unused.length}`);
+			if (metrics) {
+				const total = metrics.hits + metrics.misses;
+				const rate = total > 0 ? (metrics.hits / total * 100).toFixed(1) : 0;
+				console.log(`Hits: ${metrics.hits}, Misses: ${metrics.misses}, Rate: ${rate}%`);
+			}
+			console.groupEnd();
+		}
+		return status;
+	},
+	cleanup(opts) {
+		const root = opts?.root ?? defaultRoot();
+		if (!root) return;
+		injector.instance.cleanup(root);
+	},
+	help() {
+		console.log(`tastyDebug API:
+  .summary()            — overview (classes, rules, sizes)
+  .css("active")        — CSS for classes in DOM
+  .css("t42")           — CSS for a specific class
+  .css("t42",{source:1})— original CSS before browser parsing (dev only)
+  .css(".selector")     — CSS for a DOM element
+  .inspect(".selector") — element details (classes, chunks, rules)
+  .chunks()             — style chunk breakdown
+  .cache()              — cache status and metrics
+  .cleanup()            — force unused style cleanup
+Options: { raw: true } suppresses logging, { root: shadowRoot } targets Shadow DOM`);
+	},
+	install() {
+		if (typeof window !== "undefined" && window.tastyDebug !== tastyDebug) {
+			window.tastyDebug = tastyDebug;
+			console.log("tastyDebug installed. Run tastyDebug.help() for commands.");
+		}
+	}
+};
+function getPageCSS(root = defaultRoot()) {
+	if (!root) return "";
+	const chunks = [];
+	try {
+		if ("styleSheets" in root) for (const sheet of Array.from(root.styleSheets)) try {
+			if (sheet.cssRules) chunks.push(Array.from(sheet.cssRules).map((r) => r.cssText).join("\n"));
+		} catch {}
+	} catch {}
+	return chunks.join("\n");
+}
+//#endregion
+export { tastyDebug as t };
+
+//# sourceMappingURL=debug-Vyauml7U.js.map