@tenphi/tasty 0.0.0-snapshot.05c1c22

package/dist/core/index.js

@@ -0,0 +1,26 @@
+import { getNamedColorHex, getRgbValuesFromRgbaString, hexToRgb, hslToRgbValues, strToRgb } from "../utils/color-math.js";
+import { Bucket } from "../parser/types.js";
+import { StyleParser } from "../parser/parser.js";
+import { okhslFunc, okhslPlugin } from "../plugins/okhsl-plugin.js";
+import { CUSTOM_UNITS, DIRECTIONS, customFunc, filterMods, getGlobalFuncs, getGlobalParser, getGlobalPredefinedTokens, normalizeColorTokenValue, parseColor, parseStyle, resetGlobalPredefinedTokens, setGlobalPredefinedTokens, stringifyStyles } from "../utils/styles.js";
+import { deprecationWarning, warn } from "../utils/warnings.js";
+import { styleHandlers } from "../styles/predefined.js";
+import { SheetManager } from "../injector/sheet-manager.js";
+import { StyleInjector } from "../injector/injector.js";
+import { createStateParserContext, getGlobalPredefinedStates, setGlobalPredefinedStates } from "../states/index.js";
+import { parseStateKey } from "../pipeline/parseStateKey.js";
+import { isSelector, renderStyles } from "../pipeline/index.js";
+import { configure, getConfig, getGlobalCounterStyle, getGlobalFontFace, getGlobalKeyframes, getGlobalRecipes, hasGlobalKeyframes, hasGlobalRecipes, hasStylesGenerated, isConfigLocked, isTestEnvironment, resetConfig } from "../config.js";
+import { CHUNK_NAMES, STYLE_TO_CHUNK, categorizeStyleKeys } from "../chunks/definitions.js";
+import { BASE_STYLES, BLOCK_INNER_STYLES, BLOCK_OUTER_STYLES, BLOCK_STYLES, COLOR_STYLES, CONTAINER_STYLES, DIMENSION_STYLES, FLOW_STYLES, INNER_STYLES, OUTER_STYLES, POSITION_STYLES, TEXT_STYLES } from "../styles/list.js";
+import { allocateClassName, cleanup, counterStyle, createInjector, destroy, fontFace, getCssText, getCssTextForNode, getIsTestEnvironment, getRawCSSText, inject, injectGlobal, injectRawCSS, injector, isPropertyDefined, keyframes, property, trackRef } from "../injector/index.js";
+import { filterBaseProps } from "../utils/filter-base-props.js";
+import { color } from "../utils/colors.js";
+import { _modAttrs } from "../utils/mod-attrs.js";
+import { dotize } from "../utils/dotize.js";
+import { mergeStyles } from "../utils/merge-styles.js";
+import { resolveRecipes } from "../utils/resolve-recipes.js";
+import { processTokens, stringifyTokens } from "../utils/process-tokens.js";
+import { generateTypographyTokens } from "../utils/typography.js";
+import { tastyDebug } from "../debug.js";
+export { BASE_STYLES, BLOCK_INNER_STYLES, BLOCK_OUTER_STYLES, BLOCK_STYLES, Bucket, CHUNK_NAMES, COLOR_STYLES, CONTAINER_STYLES, CUSTOM_UNITS, DIMENSION_STYLES, DIRECTIONS, FLOW_STYLES, INNER_STYLES, OUTER_STYLES, POSITION_STYLES, STYLE_TO_CHUNK, SheetManager, StyleInjector, StyleParser, TEXT_STYLES, allocateClassName, categorizeStyleKeys, cleanup, color, configure, counterStyle, createInjector, createStateParserContext, customFunc, deprecationWarning, destroy, dotize, filterBaseProps, filterMods, fontFace, generateTypographyTokens, getConfig, getCssText, getCssTextForNode, getGlobalCounterStyle, getGlobalFontFace, getGlobalFuncs, getGlobalKeyframes, getGlobalParser, getGlobalPredefinedStates, getGlobalPredefinedTokens, getGlobalRecipes, getIsTestEnvironment, getNamedColorHex, getRawCSSText, getRgbValuesFromRgbaString, hasGlobalKeyframes, hasGlobalRecipes, hasStylesGenerated, hexToRgb, hslToRgbValues, inject, injectGlobal, injectRawCSS, injector, isConfigLocked, isPropertyDefined, isSelector, isTestEnvironment, keyframes, mergeStyles, _modAttrs as modAttrs, normalizeColorTokenValue, okhslFunc, okhslPlugin, parseColor, parseStateKey, parseStyle, processTokens, property, renderStyles, resetConfig, resetGlobalPredefinedTokens, resolveRecipes, setGlobalPredefinedStates, setGlobalPredefinedTokens, strToRgb, stringifyStyles, stringifyTokens, styleHandlers, tastyDebug, trackRef, warn };

package/dist/counter-style/index.js

@@ -0,0 +1,51 @@
+//#region src/counter-style/index.ts
+const COUNTER_STYLE_KEY = "@counterStyle";
+/**
+* Check if styles object has local @counterStyle definition.
+*/
+function hasLocalCounterStyle(styles) {
+	return COUNTER_STYLE_KEY in styles;
+}
+/**
+* Extract local @counterStyle from styles object.
+* Returns null if no local counter styles (fast path).
+*/
+function extractLocalCounterStyle(styles) {
+	const counterStyle = styles[COUNTER_STYLE_KEY];
+	if (!counterStyle || typeof counterStyle !== "object") return null;
+	return counterStyle;
+}
+const COUNTER_STYLE_DESCRIPTOR_MAP = {
+	system: "system",
+	symbols: "symbols",
+	additiveSymbols: "additive-symbols",
+	prefix: "prefix",
+	suffix: "suffix",
+	negative: "negative",
+	range: "range",
+	pad: "pad",
+	fallback: "fallback",
+	speakAs: "speak-as"
+};
+/**
+* Format the inner declarations of a @counter-style rule (no wrapper).
+* Used by the injector which needs selector and declarations separately.
+*/
+function formatCounterStyleDeclarations(descriptors) {
+	const parts = [];
+	for (const [key, cssName] of Object.entries(COUNTER_STYLE_DESCRIPTOR_MAP)) {
+		const value = descriptors[key];
+		if (value !== void 0) parts.push(`${cssName}: ${value};`);
+	}
+	return parts.join(" ");
+}
+/**
+* Format a @counter-style rule as CSS.
+*/
+function formatCounterStyleRule(name, descriptors) {
+	return `@counter-style ${name} { ${formatCounterStyleDeclarations(descriptors)} }`;
+}
+//#endregion
+export { extractLocalCounterStyle, formatCounterStyleDeclarations, formatCounterStyleRule, hasLocalCounterStyle };
+
+//# sourceMappingURL=index.js.map

package/dist/counter-style/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/counter-style/index.ts"],"sourcesContent":["/**\n * Counter Style Utilities\n *\n * Utilities for extracting and processing CSS @counter-style definitions in styles.\n * Counter-style rules are permanent once injected and do not need cleanup.\n */\n\nimport type { CounterStyleDescriptors } from '../injector/types';\nimport type { Styles } from '../styles/types';\n\n// ============================================================================\n// Constants\n// ============================================================================\n\nconst COUNTER_STYLE_KEY = '@counterStyle';\n\n// ============================================================================\n// Extraction Functions\n// ============================================================================\n\n/**\n * Check if styles object has local @counterStyle definition.\n */\nexport function hasLocalCounterStyle(styles: Styles): boolean {\n  return COUNTER_STYLE_KEY in styles;\n}\n\n/**\n * Extract local @counterStyle from styles object.\n * Returns null if no local counter styles (fast path).\n */\nexport function extractLocalCounterStyle(\n  styles: Styles,\n): Record<string, CounterStyleDescriptors> | null {\n  const counterStyle = styles[COUNTER_STYLE_KEY];\n  if (!counterStyle || typeof counterStyle !== 'object') {\n    return null;\n  }\n  return counterStyle as Record<string, CounterStyleDescriptors>;\n}\n\n// ============================================================================\n// CSS Formatting\n// ============================================================================\n\nconst COUNTER_STYLE_DESCRIPTOR_MAP: Record<string, string> = {\n  system: 'system',\n  symbols: 'symbols',\n  additiveSymbols: 'additive-symbols',\n  prefix: 'prefix',\n  suffix: 'suffix',\n  negative: 'negative',\n  range: 'range',\n  pad: 'pad',\n  fallback: 'fallback',\n  speakAs: 'speak-as',\n};\n\n/**\n * Format the inner declarations of a @counter-style rule (no wrapper).\n * Used by the injector which needs selector and declarations separately.\n */\nexport function formatCounterStyleDeclarations(\n  descriptors: CounterStyleDescriptors,\n): string {\n  const parts: string[] = [];\n\n  for (const [key, cssName] of Object.entries(COUNTER_STYLE_DESCRIPTOR_MAP)) {\n    const value = descriptors[key as keyof CounterStyleDescriptors];\n    if (value !== undefined) {\n      parts.push(`${cssName}: ${value};`);\n    }\n  }\n\n  return parts.join(' ');\n}\n\n/**\n * Format a @counter-style rule as CSS.\n */\nexport function formatCounterStyleRule(\n  name: string,\n  descriptors: CounterStyleDescriptors,\n): string {\n  return `@counter-style ${name} { ${formatCounterStyleDeclarations(descriptors)} }`;\n}\n"],"mappings":";AAcA,MAAM,oBAAoB;;;;AAS1B,SAAgB,qBAAqB,QAAyB;AAC5D,QAAO,qBAAqB;;;;;;AAO9B,SAAgB,yBACd,QACgD;CAChD,MAAM,eAAe,OAAO;AAC5B,KAAI,CAAC,gBAAgB,OAAO,iBAAiB,SAC3C,QAAO;AAET,QAAO;;AAOT,MAAM,+BAAuD;CAC3D,QAAQ;CACR,SAAS;CACT,iBAAiB;CACjB,QAAQ;CACR,QAAQ;CACR,UAAU;CACV,OAAO;CACP,KAAK;CACL,UAAU;CACV,SAAS;CACV;;;;;AAMD,SAAgB,+BACd,aACQ;CACR,MAAM,QAAkB,EAAE;AAE1B,MAAK,MAAM,CAAC,KAAK,YAAY,OAAO,QAAQ,6BAA6B,EAAE;EACzE,MAAM,QAAQ,YAAY;AAC1B,MAAI,UAAU,KAAA,EACZ,OAAM,KAAK,GAAG,QAAQ,IAAI,MAAM,GAAG;;AAIvC,QAAO,MAAM,KAAK,IAAI;;;;;AAMxB,SAAgB,uBACd,MACA,aACQ;AACR,QAAO,kBAAkB,KAAK,KAAK,+BAA+B,YAAY,CAAC"}

package/dist/debug.d.ts

@@ -0,0 +1,89 @@
+import { CacheMetrics } from "./injector/types.js";
+
+//#region src/debug.d.ts
+declare global {
+  interface Window {
+    tastyDebug?: typeof tastyDebug;
+  }
+}
+type CSSTarget = 'all' | 'global' | 'active' | 'unused' | 'page' | string | string[] | Element;
+interface DebugOptions {
+  root?: Document | ShadowRoot;
+  /** Suppress console logging and return data only (default: false) */
+  raw?: boolean;
+}
+interface CssOptions extends DebugOptions {
+  prettify?: boolean;
+  /** Read from stored source CSS (dev-mode only) instead of live CSSOM */
+  source?: boolean;
+}
+interface ChunkInfo {
+  className: string;
+  chunkName: string | null;
+}
+interface InspectResult {
+  element?: Element | null;
+  classes: string[];
+  chunks: ChunkInfo[];
+  css: string;
+  size: number;
+  rules: number;
+}
+interface CacheStatus {
+  classes: {
+    active: string[];
+    unused: string[];
+    all: string[];
+  };
+  metrics: CacheMetrics | null;
+}
+interface ChunkBreakdown {
+  byChunk: Record<string, {
+    classes: string[];
+    cssSize: number;
+    ruleCount: number;
+  }>;
+  totalChunkTypes: number;
+  totalClasses: number;
+}
+interface Summary {
+  activeClasses: string[];
+  unusedClasses: string[];
+  totalStyledClasses: string[];
+  activeCSSSize: number;
+  unusedCSSSize: number;
+  globalCSSSize: number;
+  rawCSSSize: number;
+  keyframesCSSSize: number;
+  propertyCSSSize: number;
+  totalCSSSize: number;
+  activeRuleCount: number;
+  unusedRuleCount: number;
+  globalRuleCount: number;
+  rawRuleCount: number;
+  keyframesRuleCount: number;
+  propertyRuleCount: number;
+  totalRuleCount: number;
+  metrics: CacheMetrics | null;
+  definedProperties: string[];
+  definedKeyframes: {
+    name: string;
+    refCount: number;
+  }[];
+  chunkBreakdown: ChunkBreakdown;
+}
+declare const tastyDebug: {
+  css(target: CSSTarget, opts?: CssOptions): string;
+  inspect(target: string | Element, opts?: DebugOptions): InspectResult;
+  summary(opts?: DebugOptions): Summary;
+  chunks(opts?: DebugOptions): ChunkBreakdown;
+  cache(opts?: DebugOptions): CacheStatus;
+  cleanup(opts?: {
+    root?: Document | ShadowRoot;
+  }): void;
+  help(): void;
+  install(): void;
+};
+//#endregion
+export { tastyDebug };
+//# sourceMappingURL=debug.d.ts.map

package/dist/debug.js

@@ -0,0 +1,453 @@
+import { isDevEnv } from "./utils/is-dev-env.js";
+import { CHUNK_NAMES } from "./chunks/definitions.js";
+import { getCssTextForNode, injector } from "./injector/index.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) => parseInt(a.slice(1)) - parseInt(b.slice(1)));
+}
+function getRegistry(root = document) {
+	return injector.instance._sheetManager?.getRegistry(root);
+}
+function getUnusedClasses(root = document) {
+	const registry = getRegistry(root);
+	if (!registry) return [];
+	const result = [];
+	for (const [cls, rc] of registry.refCounts) if (rc === 0) result.push(cls);
+	return sortTastyClasses(result);
+}
+function findDomTastyClasses(root = document) {
+	const classes = /* @__PURE__ */ new Set();
+	(root.querySelectorAll?.("[class]") || []).forEach((el) => {
+		const attr = el.getAttribute("class");
+		if (attr) {
+			for (const cls of attr.split(/\s+/)) if (/^t\d+$/.test(cls)) classes.add(cls);
+		}
+	});
+	return sortTastyClasses(classes);
+}
+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 = document) {
+	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 = document) {
+	const registry = getRegistry(root);
+	if (!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
+	};
+}
+function getGlobalTypeCSS(type, root = document) {
+	const registry = getRegistry(root);
+	if (!registry) return {
+		css: "",
+		ruleCount: 0,
+		size: 0
+	};
+	const chunks = [];
+	let rc = 0;
+	if (type === "keyframes") for (const [, entry] of registry.keyframesCache) {
+		const info = entry.info;
+		const ss = registry.sheets[info.sheetIndex]?.sheet?.sheet;
+		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 = type === "global" ? "global:" : type === "raw" ? "raw:" : "property:";
+		for (const [key, ri] of registry.globalRules) {
+			if (!key.startsWith(prefix)) continue;
+			const ss = registry.sheets[ri.sheetIndex]?.sheet?.sheet;
+			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 = document) {
+	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 = document) {
+	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 = document, prettify = true, raw = false, source = false } = opts || {};
+		let css = "";
+		if (source && typeof target === "string" && /^t\d+$/.test(target)) {
+			const src = getSourceCssForClasses([target], root);
+			if (src) css = src;
+			else {
+				if (!raw) console.warn("tastyDebug: 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("tastyDebug: source CSS not available. Falling back to live CSSOM.");
+				css = injector.instance.getCssTextForClasses(target, { root });
+			}
+		} else if (typeof target === "string") if (target === "all") css = injector.instance.getCssText({ 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 (/^t\d+$/.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 = document, raw = false } = opts || {};
+		const element = typeof target === "string" ? root.querySelector?.(target) : target;
+		if (!element) {
+			const empty = {
+				element: null,
+				classes: [],
+				chunks: [],
+				css: "",
+				size: 0,
+				rules: 0
+			};
+			if (!raw) console.warn("tastyDebug.inspect: element not found");
+			return empty;
+		}
+		const tastyClasses = (element.getAttribute("class") || "").split(/\s+/).filter((cls) => /^t\d+$/.test(cls));
+		const chunks = tastyClasses.map((className) => ({
+			className,
+			chunkName: getChunkForClass(className, root)
+		}));
+		const css = getCssTextForNode(element, { root });
+		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 = document, raw = false } = opts || {};
+		const activeClasses = findDomTastyClasses(root);
+		const unusedClasses = getUnusedClasses(root);
+		const totalStyledClasses = [...activeClasses, ...unusedClasses];
+		const activeCSS = injector.instance.getCssTextForClasses(activeClasses, { root });
+		const unusedCSS = injector.instance.getCssTextForClasses(unusedClasses, { root });
+		const allCSS = injector.instance.getCssText({ 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 totalRuleCount = activeRuleCount + unusedRuleCount + globalData.ruleCount + rawData.ruleCount + kfData.ruleCount + propData.ruleCount;
+		const metrics = injector.instance.getMetrics({ root });
+		const defs = getDefs(root);
+		const chunkBreakdown = buildChunkBreakdown(root);
+		const summary = {
+			activeClasses,
+			unusedClasses,
+			totalStyledClasses,
+			activeCSSSize: activeCSS.length,
+			unusedCSSSize: unusedCSS.length,
+			globalCSSSize: globalData.size,
+			rawCSSSize: rawData.size,
+			keyframesCSSSize: kfData.size,
+			propertyCSSSize: propData.size,
+			totalCSSSize: allCSS.length,
+			activeRuleCount,
+			unusedRuleCount,
+			globalRuleCount: globalData.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)}`);
+			console.log(`Global:   ${globalData.ruleCount} rules, ${fmtSize(globalData.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 = document, raw = false } = opts || {};
+		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 = document, raw = false } = opts || {};
+		const active = findDomTastyClasses(root);
+		const unused = getUnusedClasses(root);
+		const metrics = injector.instance.getMetrics({ root });
+		const status = {
+			classes: {
+				active,
+				unused,
+				all: [...active, ...unused]
+			},
+			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) {
+		injector.instance.cleanup(opts?.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 = document) {
+	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");
+}
+if (typeof window !== "undefined" && isDevEnv()) tastyDebug.install();
+//#endregion
+export { tastyDebug };
+
+//# sourceMappingURL=debug.js.map