@tenphi/tasty 0.1.0

package/dist/injector/injector.mjs

@@ -0,0 +1,404 @@
+import { parseStyle } from "../utils/styles.mjs";
+import { colorInitialValueToRgb, getEffectiveDefinition, normalizePropertyDefinition } from "../properties/index.mjs";
+import { isDevEnv } from "../utils/is-dev-env.mjs";
+import { SheetManager } from "./sheet-manager.mjs";
+
+//#region src/injector/injector.ts
+/**
+* Generate sequential class name with format t{number}
+*/
+function generateClassName(counter) {
+	return `t${counter}`;
+}
+var StyleInjector = class {
+	sheetManager;
+	config;
+	cleanupScheduled = false;
+	globalRuleCounter = 0;
+	/** @internal — exposed for debug utilities only */
+	get _sheetManager() {
+		return this.sheetManager;
+	}
+	constructor(config = {}) {
+		this.config = config;
+		this.sheetManager = new SheetManager(config);
+	}
+	/**
+	* Allocate a className for a cacheKey without injecting styles yet.
+	* This allows separating className allocation (render phase) from style injection (insertion phase).
+	*/
+	allocateClassName(cacheKey, options) {
+		const root = options?.root || document;
+		const registry = this.sheetManager.getRegistry(root);
+		if (registry.cacheKeyToClassName.has(cacheKey)) return {
+			className: registry.cacheKeyToClassName.get(cacheKey),
+			isNewAllocation: false
+		};
+		const className = generateClassName(registry.classCounter++);
+		const placeholderRuleInfo = {
+			className,
+			ruleIndex: -1,
+			sheetIndex: -1
+		};
+		registry.rules.set(className, placeholderRuleInfo);
+		registry.cacheKeyToClassName.set(cacheKey, className);
+		return {
+			className,
+			isNewAllocation: true
+		};
+	}
+	/**
+	* Inject styles from StyleResult objects
+	*/
+	inject(rules, options) {
+		const root = options?.root || document;
+		const registry = this.sheetManager.getRegistry(root);
+		if (rules.length === 0) return {
+			className: "",
+			dispose: () => {}
+		};
+		const cacheKey = options?.cacheKey;
+		let className;
+		let isPreAllocated = false;
+		if (cacheKey && registry.cacheKeyToClassName.has(cacheKey)) {
+			className = registry.cacheKeyToClassName.get(cacheKey);
+			const existingRuleInfo = registry.rules.get(className);
+			isPreAllocated = existingRuleInfo.ruleIndex === -1 && existingRuleInfo.sheetIndex === -1;
+			if (!isPreAllocated) {
+				const currentRefCount = registry.refCounts.get(className) || 0;
+				registry.refCounts.set(className, currentRefCount + 1);
+				if (registry.metrics) registry.metrics.hits++;
+				return {
+					className,
+					dispose: () => this.dispose(className, registry)
+				};
+			}
+		} else className = generateClassName(registry.classCounter++);
+		const rulesToInsert = rules.map((rule) => {
+			let newSelector = rule.selector;
+			if (rule.needsClassName) {
+				const selectorParts = newSelector ? newSelector.split("|||") : [""];
+				const classPrefix = `.${className}.${className}`;
+				newSelector = selectorParts.map((part) => {
+					const classSelector = part ? `${classPrefix}${part}` : classPrefix;
+					if (rule.rootPrefix) return `${rule.rootPrefix} ${classSelector}`;
+					return classSelector;
+				}).join(", ");
+			}
+			return {
+				...rule,
+				selector: newSelector,
+				needsClassName: void 0,
+				rootPrefix: void 0
+			};
+		});
+		const colorPropRegex = /^\s*(--[a-z0-9-]+-color)\s*:/i;
+		for (const rule of rulesToInsert) {
+			if (!rule.declarations) continue;
+			const parts = rule.declarations.split(/;+\s*/);
+			for (const part of parts) {
+				if (!part) continue;
+				const match = colorPropRegex.exec(part);
+				if (match) {
+					const propName = match[1];
+					if (!this.isPropertyDefined(propName, { root })) this.property(propName, {
+						syntax: "<color>",
+						initialValue: "transparent",
+						root
+					});
+				}
+			}
+		}
+		const ruleInfo = this.sheetManager.insertRule(registry, rulesToInsert, className, root);
+		if (!ruleInfo) {
+			if (registry.metrics) registry.metrics.misses++;
+			return {
+				className,
+				dispose: () => {}
+			};
+		}
+		registry.refCounts.set(className, 1);
+		if (isPreAllocated) registry.rules.set(className, ruleInfo);
+		else {
+			registry.rules.set(className, ruleInfo);
+			if (cacheKey) registry.cacheKeyToClassName.set(cacheKey, className);
+		}
+		if (registry.metrics) {
+			registry.metrics.totalInsertions++;
+			registry.metrics.misses++;
+		}
+		return {
+			className,
+			dispose: () => this.dispose(className, registry)
+		};
+	}
+	/**
+	* Inject global styles (rules without a generated tasty class selector)
+	* This ensures we don't reserve a tasty class name (t{number}) for global rules,
+	* which could otherwise collide with element-level styles and break lookups.
+	*/
+	injectGlobal(rules, options) {
+		const root = options?.root || document;
+		const registry = this.sheetManager.getRegistry(root);
+		if (!rules || rules.length === 0) return { dispose: () => {} };
+		const key = `global:${this.globalRuleCounter++}`;
+		const info = this.sheetManager.insertGlobalRule(registry, rules, key, root);
+		if (registry.metrics) registry.metrics.totalInsertions++;
+		return { dispose: () => {
+			if (info) this.sheetManager.deleteGlobalRule(registry, key);
+		} };
+	}
+	/**
+	* Inject raw CSS text directly without parsing
+	* This is a low-overhead alternative to createGlobalStyle for raw CSS
+	* The CSS is inserted into a separate style element to avoid conflicts with tasty's chunking
+	*/
+	injectRawCSS(css, options) {
+		const root = options?.root || document;
+		return this.sheetManager.injectRawCSS(css, root);
+	}
+	/**
+	* Get raw CSS text for SSR
+	*/
+	getRawCSSText(options) {
+		const root = options?.root || document;
+		return this.sheetManager.getRawCSSText(root);
+	}
+	/**
+	* Dispose of a className
+	*/
+	dispose(className, registry) {
+		const currentRefCount = registry.refCounts.get(className);
+		if (currentRefCount == null || currentRefCount <= 0) return;
+		const newRefCount = currentRefCount - 1;
+		registry.refCounts.set(className, newRefCount);
+		if (newRefCount === 0) {
+			if (registry.metrics) registry.metrics.totalUnused++;
+			this.sheetManager.checkCleanupNeeded(registry);
+		}
+	}
+	/**
+	* Force bulk cleanup of unused styles
+	*/
+	cleanup(root) {
+		const registry = this.sheetManager.getRegistry(root || document);
+		this.sheetManager.forceCleanup(registry);
+	}
+	/**
+	* Get CSS text from all sheets (for SSR)
+	*/
+	getCssText(options) {
+		const root = options?.root || document;
+		const registry = this.sheetManager.getRegistry(root);
+		return this.sheetManager.getCssText(registry);
+	}
+	/**
+	* Get CSS only for the provided tasty classNames (e.g., ["t0","t3"])
+	*/
+	getCssTextForClasses(classNames, options) {
+		const root = options?.root || document;
+		const registry = this.sheetManager.getRegistry(root);
+		const cssChunks = [];
+		for (const cls of classNames) {
+			const info = registry.rules.get(cls);
+			if (info) {
+				const styleSheet = registry.sheets[info.sheetIndex]?.sheet?.sheet;
+				if (styleSheet) {
+					const start = Math.max(0, info.ruleIndex);
+					const end = Math.min(styleSheet.cssRules.length - 1, info.endRuleIndex ?? info.ruleIndex);
+					if (start >= 0 && end >= start && start < styleSheet.cssRules.length) for (let i = start; i <= end; i++) {
+						const rule = styleSheet.cssRules[i];
+						if (rule) cssChunks.push(rule.cssText);
+					}
+				} else if (info.cssText && info.cssText.length) cssChunks.push(...info.cssText);
+			}
+		}
+		return cssChunks.join("\n");
+	}
+	/**
+	* Get cache performance metrics
+	*/
+	getMetrics(options) {
+		const root = options?.root || document;
+		const registry = this.sheetManager.getRegistry(root);
+		return this.sheetManager.getMetrics(registry);
+	}
+	/**
+	* Reset cache performance metrics
+	*/
+	resetMetrics(options) {
+		const root = options?.root || document;
+		const registry = this.sheetManager.getRegistry(root);
+		this.sheetManager.resetMetrics(registry);
+	}
+	/**
+	* Define a CSS @property custom property.
+	*
+	* Accepts tasty token syntax for the property name:
+	* - `$name` → defines `--name`
+	* - `#name` → defines `--name-color` (auto-sets syntax: '<color>', defaults initialValue: 'transparent')
+	* - `--name` → defines `--name` (legacy format)
+	*
+	* Example:
+	* @property --rotation { syntax: "<angle>"; inherits: false; initial-value: 45deg; }
+	*
+	* Note: No caching or dispose — this defines a global property.
+	*
+	* If the same property is registered with different options, a warning is emitted
+	* but the original definition is preserved (CSS @property cannot be redefined).
+	*/
+	property(name, options) {
+		const root = options?.root || document;
+		const registry = this.sheetManager.getRegistry(root);
+		const effectiveResult = getEffectiveDefinition(name, {
+			syntax: options?.syntax,
+			inherits: options?.inherits,
+			initialValue: options?.initialValue
+		});
+		if (!effectiveResult.isValid) {
+			if (isDevEnv()) console.warn(`[Tasty] property(): ${effectiveResult.error}. Got: "${name}"`);
+			return;
+		}
+		const cssName = effectiveResult.cssName;
+		const definition = effectiveResult.definition;
+		const normalizedDef = normalizePropertyDefinition(definition);
+		const existingDef = registry.injectedProperties.get(cssName);
+		if (existingDef !== void 0) {
+			if (existingDef !== normalizedDef) {
+				if (isDevEnv()) console.warn(`[Tasty] @property ${cssName} was already defined with a different declaration. The new declaration will be ignored. Original: ${existingDef}, New: ${normalizedDef}`);
+			}
+			return;
+		}
+		const parts = [];
+		if (definition.syntax != null) {
+			let syntax = String(definition.syntax).trim();
+			if (!/^['"]/u.test(syntax)) syntax = `"${syntax}"`;
+			parts.push(`syntax: ${syntax};`);
+		}
+		const inherits = definition.inherits ?? true;
+		parts.push(`inherits: ${inherits ? "true" : "false"};`);
+		if (definition.initialValue != null) {
+			let initialValueStr;
+			if (typeof definition.initialValue === "number") initialValueStr = String(definition.initialValue);
+			else initialValueStr = parseStyle(definition.initialValue).output;
+			parts.push(`initial-value: ${initialValueStr};`);
+		}
+		const declarations = parts.join(" ").trim();
+		const rule = {
+			selector: `@property ${cssName}`,
+			declarations
+		};
+		if (!this.sheetManager.insertGlobalRule(registry, [rule], `property:${name}`, root)) return;
+		registry.injectedProperties.set(cssName, normalizedDef);
+		if (effectiveResult.isColor) {
+			const rgbCssName = `${cssName}-rgb`;
+			if (!this.isPropertyDefined(rgbCssName, { root })) this.property(rgbCssName, {
+				syntax: "<number>+",
+				inherits: definition.inherits,
+				initialValue: colorInitialValueToRgb(definition.initialValue),
+				root
+			});
+		}
+	}
+	/**
+	* Check whether a given @property name was already injected by this injector.
+	*
+	* Accepts tasty token syntax:
+	* - `$name` → checks `--name`
+	* - `#name` → checks `--name-color`
+	* - `--name` → checks `--name` (legacy format)
+	*/
+	isPropertyDefined(name, options) {
+		const root = options?.root || document;
+		const registry = this.sheetManager.getRegistry(root);
+		const effectiveResult = getEffectiveDefinition(name, {});
+		if (!effectiveResult.isValid) return false;
+		return registry.injectedProperties.has(effectiveResult.cssName);
+	}
+	/**
+	* Inject keyframes and return object with toString() and dispose()
+	*
+	* Keyframes are cached by content (steps). If the same content is injected
+	* multiple times with different provided names, the first injected name is reused.
+	*
+	* If the same name is provided with different content (collision), a unique
+	* name is generated to avoid overwriting the existing keyframes.
+	*/
+	keyframes(steps, nameOrOptions) {
+		const isStringName = typeof nameOrOptions === "string";
+		const providedName = isStringName ? nameOrOptions : nameOrOptions?.name;
+		const root = isStringName ? document : nameOrOptions?.root || document;
+		const registry = this.sheetManager.getRegistry(root);
+		if (Object.keys(steps).length === 0) return {
+			toString: () => "",
+			dispose: () => {}
+		};
+		const contentHash = JSON.stringify(steps);
+		const existing = registry.keyframesCache.get(contentHash);
+		if (existing) {
+			existing.refCount++;
+			return {
+				toString: () => existing.name,
+				dispose: () => this.disposeKeyframes(contentHash, registry)
+			};
+		}
+		let actualName;
+		if (providedName) {
+			const existingContentForName = registry.keyframesNameToContent.get(providedName);
+			if (existingContentForName && existingContentForName !== contentHash) actualName = `${providedName}-k${registry.keyframesCounter++}`;
+			else {
+				actualName = providedName;
+				registry.keyframesNameToContent.set(providedName, contentHash);
+			}
+		} else actualName = `k${registry.keyframesCounter++}`;
+		const info = this.sheetManager.insertKeyframes(registry, steps, actualName, root);
+		if (!info) return {
+			toString: () => "",
+			dispose: () => {}
+		};
+		registry.keyframesCache.set(contentHash, {
+			name: actualName,
+			refCount: 1,
+			info
+		});
+		if (registry.metrics) {
+			registry.metrics.totalInsertions++;
+			registry.metrics.misses++;
+		}
+		return {
+			toString: () => actualName,
+			dispose: () => this.disposeKeyframes(contentHash, registry)
+		};
+	}
+	/**
+	* Dispose keyframes
+	*/
+	disposeKeyframes(contentHash, registry) {
+		const entry = registry.keyframesCache.get(contentHash);
+		if (!entry) return;
+		entry.refCount--;
+		if (entry.refCount <= 0) {
+			this.sheetManager.deleteKeyframes(registry, entry.info);
+			registry.keyframesCache.delete(contentHash);
+			for (const [name, hash] of registry.keyframesNameToContent.entries()) if (hash === contentHash) {
+				registry.keyframesNameToContent.delete(name);
+				break;
+			}
+			if (registry.metrics) {
+				registry.metrics.totalUnused++;
+				registry.metrics.stylesCleanedUp++;
+			}
+		}
+	}
+	/**
+	* Destroy all resources for a root
+	*/
+	destroy(root) {
+		const targetRoot = root || document;
+		this.sheetManager.cleanup(targetRoot);
+	}
+};
+
+//#endregion
+export { StyleInjector };
+//# sourceMappingURL=injector.mjs.map

package/dist/injector/injector.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"injector.mjs","names":[],"sources":["../../src/injector/injector.ts"],"sourcesContent":["/**\n * Style injector that works with structured style objects\n * Eliminates CSS string parsing for better performance\n */\n\nimport type { StyleResult } from '../pipeline';\nimport {\n  colorInitialValueToRgb,\n  getEffectiveDefinition,\n  normalizePropertyDefinition,\n} from '../properties';\nimport { isDevEnv } from '../utils/is-dev-env';\nimport type { StyleValue } from '../utils/styles';\nimport { parseStyle } from '../utils/styles';\n\nimport { SheetManager } from './sheet-manager';\nimport type {\n  CacheMetrics,\n  GlobalInjectResult,\n  InjectResult,\n  KeyframesResult,\n  KeyframesSteps,\n  PropertyDefinition,\n  RawCSSResult,\n  RootRegistry,\n  StyleInjectorConfig,\n  StyleRule,\n} from './types';\n\n/**\n * Generate sequential class name with format t{number}\n */\nfunction generateClassName(counter: number): string {\n  return `t${counter}`;\n}\n\nexport class StyleInjector {\n  private sheetManager: SheetManager;\n  private config: StyleInjectorConfig;\n  private cleanupScheduled = false;\n  private globalRuleCounter = 0;\n\n  /** @internal — exposed for debug utilities only */\n  get _sheetManager(): SheetManager {\n    return this.sheetManager;\n  }\n\n  constructor(config: StyleInjectorConfig = {}) {\n    this.config = config;\n    this.sheetManager = new SheetManager(config);\n  }\n\n  /**\n   * Allocate a className for a cacheKey without injecting styles yet.\n   * This allows separating className allocation (render phase) from style injection (insertion phase).\n   */\n  allocateClassName(\n    cacheKey: string,\n    options?: { root?: Document | ShadowRoot },\n  ): { className: string; isNewAllocation: boolean } {\n    const root = options?.root || document;\n    const registry = this.sheetManager.getRegistry(root);\n\n    // Check if we can reuse existing className for this cache key\n    if (registry.cacheKeyToClassName.has(cacheKey)) {\n      const className = registry.cacheKeyToClassName.get(cacheKey)!;\n      return {\n        className,\n        isNewAllocation: false,\n      };\n    }\n\n    // Generate new className and reserve it\n    const className = generateClassName(registry.classCounter++);\n\n    // Create placeholder RuleInfo to reserve the className\n    const placeholderRuleInfo = {\n      className,\n      ruleIndex: -1, // Placeholder - will be set during actual injection\n      sheetIndex: -1, // Placeholder - will be set during actual injection\n    };\n\n    // Store RuleInfo only once by className, and map cacheKey separately\n    registry.rules.set(className, placeholderRuleInfo);\n    registry.cacheKeyToClassName.set(cacheKey, className);\n\n    return {\n      className,\n      isNewAllocation: true,\n    };\n  }\n\n  /**\n   * Inject styles from StyleResult objects\n   */\n  inject(\n    rules: StyleResult[],\n    options?: { root?: Document | ShadowRoot; cacheKey?: string },\n  ): InjectResult {\n    const root = options?.root || document;\n    const registry = this.sheetManager.getRegistry(root);\n\n    if (rules.length === 0) {\n      return {\n        className: '',\n        dispose: () => { /* noop */ },\n      };\n    }\n\n    // Rules are now in StyleRule format directly\n\n    // Check if we can reuse based on cache key\n    const cacheKey = options?.cacheKey;\n    let className: string;\n    let isPreAllocated = false;\n\n    if (cacheKey && registry.cacheKeyToClassName.has(cacheKey)) {\n      // Reuse existing class for this cache key\n      className = registry.cacheKeyToClassName.get(cacheKey)!;\n      const existingRuleInfo = registry.rules.get(className)!;\n\n      // Check if this is a placeholder (pre-allocated but not yet injected)\n      isPreAllocated =\n        existingRuleInfo.ruleIndex === -1 && existingRuleInfo.sheetIndex === -1;\n\n      if (!isPreAllocated) {\n        // Already injected - just increment refCount\n        const currentRefCount = registry.refCounts.get(className) || 0;\n        registry.refCounts.set(className, currentRefCount + 1);\n\n        // Update metrics\n        if (registry.metrics) {\n          registry.metrics.hits++;\n        }\n\n        return {\n          className,\n          dispose: () => this.dispose(className, registry),\n        };\n      }\n    } else {\n      // Generate new className\n      className = generateClassName(registry.classCounter++);\n    }\n\n    // Process rules: handle needsClassName flag and apply specificity\n    const rulesToInsert = rules.map((rule) => {\n      let newSelector = rule.selector;\n\n      // If rule needs className prepended\n      if (rule.needsClassName) {\n        // Handle multiple selectors (separated by ||| for OR conditions)\n        const selectorParts = newSelector ? newSelector.split('|||') : [''];\n\n        const classPrefix = `.${className}.${className}`;\n\n        newSelector = selectorParts\n          .map((part) => {\n            const classSelector = part ? `${classPrefix}${part}` : classPrefix;\n\n            // If there's a root prefix, add it before the class selector\n            if (rule.rootPrefix) {\n              return `${rule.rootPrefix} ${classSelector}`;\n            }\n            return classSelector;\n          })\n          .join(', ');\n      }\n\n      return {\n        ...rule,\n        selector: newSelector,\n        needsClassName: undefined, // Remove the flag after processing\n        rootPrefix: undefined, // Remove rootPrefix after processing\n      };\n    });\n\n    // Before inserting, auto-register @property for any color custom properties being defined.\n    // Fast parse: split declarations by ';' and match \"--*-color:\"\n    // Do this only when we actually insert (i.e., no cache hit above)\n    const colorPropRegex = /^\\s*(--[a-z0-9-]+-color)\\s*:/i;\n    for (const rule of rulesToInsert) {\n      // Skip if no declarations\n      if (!rule.declarations) continue;\n      const parts = rule.declarations.split(/;+\\s*/);\n      for (const part of parts) {\n        if (!part) continue;\n        const match = colorPropRegex.exec(part);\n        if (match) {\n          const propName = match[1];\n          // Register @property only if not already defined for this root\n          if (!this.isPropertyDefined(propName, { root })) {\n            this.property(propName, {\n              syntax: '<color>',\n              initialValue: 'transparent',\n              root,\n            });\n          }\n        }\n      }\n    }\n\n    // Insert rules using existing sheet manager\n    const ruleInfo = this.sheetManager.insertRule(\n      registry,\n      rulesToInsert,\n      className,\n      root,\n    );\n\n    if (!ruleInfo) {\n      // Update metrics\n      if (registry.metrics) {\n        registry.metrics.misses++;\n      }\n\n      return {\n        className,\n        dispose: () => { /* noop */ },\n      };\n    }\n\n    // Store in registry\n    registry.refCounts.set(className, 1);\n\n    if (isPreAllocated) {\n      // Update the existing placeholder entry with real rule info\n      registry.rules.set(className, ruleInfo);\n      // cacheKey mapping already exists from allocation\n    } else {\n      // Store new entries\n      registry.rules.set(className, ruleInfo);\n      if (cacheKey) {\n        registry.cacheKeyToClassName.set(cacheKey, className);\n      }\n    }\n\n    // Update metrics\n    if (registry.metrics) {\n      registry.metrics.totalInsertions++;\n      registry.metrics.misses++;\n    }\n\n    return {\n      className,\n      dispose: () => this.dispose(className, registry),\n    };\n  }\n\n  /**\n   * Inject global styles (rules without a generated tasty class selector)\n   * This ensures we don't reserve a tasty class name (t{number}) for global rules,\n   * which could otherwise collide with element-level styles and break lookups.\n   */\n  injectGlobal(\n    rules: StyleResult[],\n    options?: { root?: Document | ShadowRoot },\n  ): GlobalInjectResult {\n    const root = options?.root || document;\n    const registry = this.sheetManager.getRegistry(root);\n\n    if (!rules || rules.length === 0) {\n      return { dispose: () => { /* noop */ } };\n    }\n\n    // Use a non-tasty identifier to avoid any collisions with .t{number} classes\n    const key = `global:${this.globalRuleCounter++}`;\n\n    const info = this.sheetManager.insertGlobalRule(\n      registry,\n      rules as unknown as StyleRule[],\n      key,\n      root,\n    );\n\n    if (registry.metrics) {\n      registry.metrics.totalInsertions++;\n    }\n\n    return {\n      dispose: () => {\n        if (info) this.sheetManager.deleteGlobalRule(registry, key);\n      },\n    };\n  }\n\n  /**\n   * Inject raw CSS text directly without parsing\n   * This is a low-overhead alternative to createGlobalStyle for raw CSS\n   * The CSS is inserted into a separate style element to avoid conflicts with tasty's chunking\n   */\n  injectRawCSS(\n    css: string,\n    options?: { root?: Document | ShadowRoot },\n  ): RawCSSResult {\n    const root = options?.root || document;\n    return this.sheetManager.injectRawCSS(css, root);\n  }\n\n  /**\n   * Get raw CSS text for SSR\n   */\n  getRawCSSText(options?: { root?: Document | ShadowRoot }): string {\n    const root = options?.root || document;\n    return this.sheetManager.getRawCSSText(root);\n  }\n\n  /**\n   * Dispose of a className\n   */\n  private dispose(className: string, registry: RootRegistry): void {\n    const currentRefCount = registry.refCounts.get(className);\n    // Guard against stale double-dispose or mismatched lifecycle\n    if (currentRefCount == null || currentRefCount <= 0) {\n      return;\n    }\n\n    const newRefCount = currentRefCount - 1;\n    registry.refCounts.set(className, newRefCount);\n\n    if (newRefCount === 0) {\n      // Update metrics\n      if (registry.metrics) {\n        registry.metrics.totalUnused++;\n      }\n\n      // Check if cleanup should be scheduled\n      this.sheetManager.checkCleanupNeeded(registry);\n    }\n  }\n\n  /**\n   * Force bulk cleanup of unused styles\n   */\n  cleanup(root?: Document | ShadowRoot): void {\n    const registry = this.sheetManager.getRegistry(root || document);\n    // Clean up ALL unused rules regardless of batch ratio\n    this.sheetManager.forceCleanup(registry);\n  }\n\n  /**\n   * Get CSS text from all sheets (for SSR)\n   */\n  getCssText(options?: { root?: Document | ShadowRoot }): string {\n    const root = options?.root || document;\n    const registry = this.sheetManager.getRegistry(root);\n    return this.sheetManager.getCssText(registry);\n  }\n\n  /**\n   * Get CSS only for the provided tasty classNames (e.g., [\"t0\",\"t3\"])\n   */\n  getCssTextForClasses(\n    classNames: Iterable<string>,\n    options?: { root?: Document | ShadowRoot },\n  ): string {\n    const root = options?.root || document;\n    const registry = this.sheetManager.getRegistry(root);\n\n    const cssChunks: string[] = [];\n    for (const cls of classNames) {\n      const info = registry.rules.get(cls);\n      if (info) {\n        // Always prefer reading from the live stylesheet, since indices can change\n        const sheet = registry.sheets[info.sheetIndex];\n        const styleSheet = sheet?.sheet?.sheet;\n        if (styleSheet) {\n          const start = Math.max(0, info.ruleIndex);\n          const end = Math.min(\n            styleSheet.cssRules.length - 1,\n            (info.endRuleIndex as number) ?? info.ruleIndex,\n          );\n          // Additional validation: ensure indices are valid and in correct order\n          if (\n            start >= 0 &&\n            end >= start &&\n            start < styleSheet.cssRules.length\n          ) {\n            for (let i = start; i <= end; i++) {\n              const rule = styleSheet.cssRules[i] as CSSRule | undefined;\n              if (rule) cssChunks.push(rule.cssText);\n            }\n          }\n        } else if (info.cssText && info.cssText.length) {\n          // Fallback in environments without CSSOM access\n          cssChunks.push(...info.cssText);\n        }\n      }\n    }\n    return cssChunks.join('\\n');\n  }\n\n  /**\n   * Get cache performance metrics\n   */\n  getMetrics(options?: { root?: Document | ShadowRoot }): CacheMetrics | null {\n    const root = options?.root || document;\n    const registry = this.sheetManager.getRegistry(root);\n    return this.sheetManager.getMetrics(registry);\n  }\n\n  /**\n   * Reset cache performance metrics\n   */\n  resetMetrics(options?: { root?: Document | ShadowRoot }): void {\n    const root = options?.root || document;\n    const registry = this.sheetManager.getRegistry(root);\n    this.sheetManager.resetMetrics(registry);\n  }\n\n  /**\n   * Define a CSS @property custom property.\n   *\n   * Accepts tasty token syntax for the property name:\n   * - `$name` → defines `--name`\n   * - `#name` → defines `--name-color` (auto-sets syntax: '<color>', defaults initialValue: 'transparent')\n   * - `--name` → defines `--name` (legacy format)\n   *\n   * Example:\n   * @property --rotation { syntax: \"<angle>\"; inherits: false; initial-value: 45deg; }\n   *\n   * Note: No caching or dispose — this defines a global property.\n   *\n   * If the same property is registered with different options, a warning is emitted\n   * but the original definition is preserved (CSS @property cannot be redefined).\n   */\n  property(\n    name: string,\n    options?: PropertyDefinition & {\n      root?: Document | ShadowRoot;\n    },\n  ): void {\n    const root = options?.root || document;\n    const registry = this.sheetManager.getRegistry(root);\n\n    // Parse the token and get effective definition\n    // This handles $name, #name, --name formats and auto-sets syntax for colors\n    const userDefinition: PropertyDefinition = {\n      syntax: options?.syntax,\n      inherits: options?.inherits,\n      initialValue: options?.initialValue,\n    };\n\n    const effectiveResult = getEffectiveDefinition(name, userDefinition);\n\n    if (!effectiveResult.isValid) {\n      if (isDevEnv()) {\n        console.warn(\n          `[Tasty] property(): ${effectiveResult.error}. Got: \"${name}\"`,\n        );\n      }\n      return;\n    }\n\n    const cssName = effectiveResult.cssName;\n    const definition = effectiveResult.definition;\n\n    // Normalize the definition for comparison\n    const normalizedDef = normalizePropertyDefinition(definition);\n\n    // Check if already defined\n    const existingDef = registry.injectedProperties.get(cssName);\n    if (existingDef !== undefined) {\n      // Property already exists - check if definitions match\n      if (existingDef !== normalizedDef) {\n        // Different definition - warn but don't replace (CSS @property can't be redefined)\n        if (isDevEnv()) {\n          console.warn(\n            `[Tasty] @property ${cssName} was already defined with a different declaration. ` +\n              `The new declaration will be ignored. ` +\n              `Original: ${existingDef}, New: ${normalizedDef}`,\n          );\n        }\n      }\n      // Either exact match or warned - skip injection\n      return;\n    }\n\n    const parts: string[] = [];\n\n    if (definition.syntax != null) {\n      let syntax = String(definition.syntax).trim();\n      if (!/^['\"]/u.test(syntax)) syntax = `\"${syntax}\"`;\n      parts.push(`syntax: ${syntax};`);\n    }\n\n    // inherits is required by the CSS @property spec - default to true\n    const inherits = definition.inherits ?? true;\n    parts.push(`inherits: ${inherits ? 'true' : 'false'};`);\n\n    if (definition.initialValue != null) {\n      let initialValueStr: string;\n      if (typeof definition.initialValue === 'number') {\n        initialValueStr = String(definition.initialValue);\n      } else {\n        // Process via tasty parser to resolve custom units/functions\n        initialValueStr = parseStyle(definition.initialValue as StyleValue).output;\n      }\n      parts.push(`initial-value: ${initialValueStr};`);\n    }\n\n    const declarations = parts.join(' ').trim();\n\n    const rule: StyleRule = {\n      selector: `@property ${cssName}`,\n      declarations,\n    } as StyleRule;\n\n    // Insert as a global rule; only mark injected when insertion succeeds\n    const info = this.sheetManager.insertGlobalRule(\n      registry,\n      [rule],\n      `property:${name}`,\n      root,\n    );\n\n    if (!info) {\n      return;\n    }\n\n    // Track that this property was injected with its normalized definition\n    registry.injectedProperties.set(cssName, normalizedDef);\n\n    // Auto-register companion -rgb property for color properties.\n    // E.g. --white-color gets a companion --white-color-rgb with syntax: '<number>+'\n    if (effectiveResult.isColor) {\n      const rgbCssName = `${cssName}-rgb`;\n      if (!this.isPropertyDefined(rgbCssName, { root })) {\n        this.property(rgbCssName, {\n          syntax: '<number>+',\n          inherits: definition.inherits,\n          initialValue: colorInitialValueToRgb(definition.initialValue),\n          root,\n        });\n      }\n    }\n  }\n\n  /**\n   * Check whether a given @property name was already injected by this injector.\n   *\n   * Accepts tasty token syntax:\n   * - `$name` → checks `--name`\n   * - `#name` → checks `--name-color`\n   * - `--name` → checks `--name` (legacy format)\n   */\n  isPropertyDefined(\n    name: string,\n    options?: { root?: Document | ShadowRoot },\n  ): boolean {\n    const root = options?.root || document;\n    const registry = this.sheetManager.getRegistry(root);\n\n    // Parse the token to get the CSS property name\n    const effectiveResult = getEffectiveDefinition(name, {});\n    if (!effectiveResult.isValid) {\n      return false;\n    }\n\n    return registry.injectedProperties.has(effectiveResult.cssName);\n  }\n\n  /**\n   * Inject keyframes and return object with toString() and dispose()\n   *\n   * Keyframes are cached by content (steps). If the same content is injected\n   * multiple times with different provided names, the first injected name is reused.\n   *\n   * If the same name is provided with different content (collision), a unique\n   * name is generated to avoid overwriting the existing keyframes.\n   */\n  keyframes(\n    steps: KeyframesSteps,\n    nameOrOptions?: string | { root?: Document | ShadowRoot; name?: string },\n  ): KeyframesResult {\n    // Parse parameters\n    const isStringName = typeof nameOrOptions === 'string';\n    const providedName = isStringName ? nameOrOptions : nameOrOptions?.name;\n    const root = isStringName ? document : nameOrOptions?.root || document;\n    const registry = this.sheetManager.getRegistry(root);\n\n    if (Object.keys(steps).length === 0) {\n      return {\n        toString: () => '',\n        dispose: () => { /* noop */ },\n      };\n    }\n\n    // Generate content-based cache key (independent of provided name)\n    const contentHash = JSON.stringify(steps);\n\n    // Check if this exact content is already cached\n    const existing = registry.keyframesCache.get(contentHash);\n    if (existing) {\n      existing.refCount++;\n      return {\n        toString: () => existing.name,\n        dispose: () => this.disposeKeyframes(contentHash, registry),\n      };\n    }\n\n    // Determine the actual name to use\n    let actualName: string;\n\n    if (providedName) {\n      // Check if this name is already used with different content\n      const existingContentForName =\n        registry.keyframesNameToContent.get(providedName);\n\n      if (existingContentForName && existingContentForName !== contentHash) {\n        // Name collision: same name, different content\n        // Generate a unique name to avoid overwriting\n        actualName = `${providedName}-k${registry.keyframesCounter++}`;\n      } else {\n        // Name is available or used with same content\n        actualName = providedName;\n        // Track this name -> content mapping\n        registry.keyframesNameToContent.set(providedName, contentHash);\n      }\n    } else {\n      // No name provided, generate one\n      actualName = `k${registry.keyframesCounter++}`;\n    }\n\n    // Insert keyframes\n    const info = this.sheetManager.insertKeyframes(\n      registry,\n      steps,\n      actualName,\n      root,\n    );\n    if (!info) {\n      return {\n        toString: () => '',\n        dispose: () => { /* noop */ },\n      };\n    }\n\n    // Cache the result by content hash\n    registry.keyframesCache.set(contentHash, {\n      name: actualName,\n      refCount: 1,\n      info,\n    });\n\n    // Update metrics\n    if (registry.metrics) {\n      registry.metrics.totalInsertions++;\n      registry.metrics.misses++;\n    }\n\n    return {\n      toString: () => actualName,\n      dispose: () => this.disposeKeyframes(contentHash, registry),\n    };\n  }\n\n  /**\n   * Dispose keyframes\n   */\n  private disposeKeyframes(contentHash: string, registry: RootRegistry): void {\n    const entry = registry.keyframesCache.get(contentHash);\n    if (!entry) return;\n\n    entry.refCount--;\n    if (entry.refCount <= 0) {\n      // Dispose immediately - keyframes are global and safe to clean up right away\n      this.sheetManager.deleteKeyframes(registry, entry.info);\n      registry.keyframesCache.delete(contentHash);\n\n      // Clean up name-to-content mapping if this name was tracked\n      // Find and remove the mapping for this content hash\n      for (const [name, hash] of registry.keyframesNameToContent.entries()) {\n        if (hash === contentHash) {\n          registry.keyframesNameToContent.delete(name);\n          break;\n        }\n      }\n\n      // Update metrics\n      if (registry.metrics) {\n        registry.metrics.totalUnused++;\n        registry.metrics.stylesCleanedUp++;\n      }\n    }\n  }\n\n  /**\n   * Destroy all resources for a root\n   */\n  destroy(root?: Document | ShadowRoot): void {\n    const targetRoot = root || document;\n    this.sheetManager.cleanup(targetRoot);\n  }\n}\n"],"mappings":";;;;;;;;;AAgCA,SAAS,kBAAkB,SAAyB;AAClD,QAAO,IAAI;;AAGb,IAAa,gBAAb,MAA2B;CACzB,AAAQ;CACR,AAAQ;CACR,AAAQ,mBAAmB;CAC3B,AAAQ,oBAAoB;;CAG5B,IAAI,gBAA8B;AAChC,SAAO,KAAK;;CAGd,YAAY,SAA8B,EAAE,EAAE;AAC5C,OAAK,SAAS;AACd,OAAK,eAAe,IAAI,aAAa,OAAO;;;;;;CAO9C,kBACE,UACA,SACiD;EACjD,MAAM,OAAO,SAAS,QAAQ;EAC9B,MAAM,WAAW,KAAK,aAAa,YAAY,KAAK;AAGpD,MAAI,SAAS,oBAAoB,IAAI,SAAS,CAE5C,QAAO;GACL,WAFgB,SAAS,oBAAoB,IAAI,SAAS;GAG1D,iBAAiB;GAClB;EAIH,MAAM,YAAY,kBAAkB,SAAS,eAAe;EAG5D,MAAM,sBAAsB;GAC1B;GACA,WAAW;GACX,YAAY;GACb;AAGD,WAAS,MAAM,IAAI,WAAW,oBAAoB;AAClD,WAAS,oBAAoB,IAAI,UAAU,UAAU;AAErD,SAAO;GACL;GACA,iBAAiB;GAClB;;;;;CAMH,OACE,OACA,SACc;EACd,MAAM,OAAO,SAAS,QAAQ;EAC9B,MAAM,WAAW,KAAK,aAAa,YAAY,KAAK;AAEpD,MAAI,MAAM,WAAW,EACnB,QAAO;GACL,WAAW;GACX,eAAe;GAChB;EAMH,MAAM,WAAW,SAAS;EAC1B,IAAI;EACJ,IAAI,iBAAiB;AAErB,MAAI,YAAY,SAAS,oBAAoB,IAAI,SAAS,EAAE;AAE1D,eAAY,SAAS,oBAAoB,IAAI,SAAS;GACtD,MAAM,mBAAmB,SAAS,MAAM,IAAI,UAAU;AAGtD,oBACE,iBAAiB,cAAc,MAAM,iBAAiB,eAAe;AAEvE,OAAI,CAAC,gBAAgB;IAEnB,MAAM,kBAAkB,SAAS,UAAU,IAAI,UAAU,IAAI;AAC7D,aAAS,UAAU,IAAI,WAAW,kBAAkB,EAAE;AAGtD,QAAI,SAAS,QACX,UAAS,QAAQ;AAGnB,WAAO;KACL;KACA,eAAe,KAAK,QAAQ,WAAW,SAAS;KACjD;;QAIH,aAAY,kBAAkB,SAAS,eAAe;EAIxD,MAAM,gBAAgB,MAAM,KAAK,SAAS;GACxC,IAAI,cAAc,KAAK;AAGvB,OAAI,KAAK,gBAAgB;IAEvB,MAAM,gBAAgB,cAAc,YAAY,MAAM,MAAM,GAAG,CAAC,GAAG;IAEnE,MAAM,cAAc,IAAI,UAAU,GAAG;AAErC,kBAAc,cACX,KAAK,SAAS;KACb,MAAM,gBAAgB,OAAO,GAAG,cAAc,SAAS;AAGvD,SAAI,KAAK,WACP,QAAO,GAAG,KAAK,WAAW,GAAG;AAE/B,YAAO;MACP,CACD,KAAK,KAAK;;AAGf,UAAO;IACL,GAAG;IACH,UAAU;IACV,gBAAgB;IAChB,YAAY;IACb;IACD;EAKF,MAAM,iBAAiB;AACvB,OAAK,MAAM,QAAQ,eAAe;AAEhC,OAAI,CAAC,KAAK,aAAc;GACxB,MAAM,QAAQ,KAAK,aAAa,MAAM,QAAQ;AAC9C,QAAK,MAAM,QAAQ,OAAO;AACxB,QAAI,CAAC,KAAM;IACX,MAAM,QAAQ,eAAe,KAAK,KAAK;AACvC,QAAI,OAAO;KACT,MAAM,WAAW,MAAM;AAEvB,SAAI,CAAC,KAAK,kBAAkB,UAAU,EAAE,MAAM,CAAC,CAC7C,MAAK,SAAS,UAAU;MACtB,QAAQ;MACR,cAAc;MACd;MACD,CAAC;;;;EAOV,MAAM,WAAW,KAAK,aAAa,WACjC,UACA,eACA,WACA,KACD;AAED,MAAI,CAAC,UAAU;AAEb,OAAI,SAAS,QACX,UAAS,QAAQ;AAGnB,UAAO;IACL;IACA,eAAe;IAChB;;AAIH,WAAS,UAAU,IAAI,WAAW,EAAE;AAEpC,MAAI,eAEF,UAAS,MAAM,IAAI,WAAW,SAAS;OAElC;AAEL,YAAS,MAAM,IAAI,WAAW,SAAS;AACvC,OAAI,SACF,UAAS,oBAAoB,IAAI,UAAU,UAAU;;AAKzD,MAAI,SAAS,SAAS;AACpB,YAAS,QAAQ;AACjB,YAAS,QAAQ;;AAGnB,SAAO;GACL;GACA,eAAe,KAAK,QAAQ,WAAW,SAAS;GACjD;;;;;;;CAQH,aACE,OACA,SACoB;EACpB,MAAM,OAAO,SAAS,QAAQ;EAC9B,MAAM,WAAW,KAAK,aAAa,YAAY,KAAK;AAEpD,MAAI,CAAC,SAAS,MAAM,WAAW,EAC7B,QAAO,EAAE,eAAe,IAAgB;EAI1C,MAAM,MAAM,UAAU,KAAK;EAE3B,MAAM,OAAO,KAAK,aAAa,iBAC7B,UACA,OACA,KACA,KACD;AAED,MAAI,SAAS,QACX,UAAS,QAAQ;AAGnB,SAAO,EACL,eAAe;AACb,OAAI,KAAM,MAAK,aAAa,iBAAiB,UAAU,IAAI;KAE9D;;;;;;;CAQH,aACE,KACA,SACc;EACd,MAAM,OAAO,SAAS,QAAQ;AAC9B,SAAO,KAAK,aAAa,aAAa,KAAK,KAAK;;;;;CAMlD,cAAc,SAAoD;EAChE,MAAM,OAAO,SAAS,QAAQ;AAC9B,SAAO,KAAK,aAAa,cAAc,KAAK;;;;;CAM9C,AAAQ,QAAQ,WAAmB,UAA8B;EAC/D,MAAM,kBAAkB,SAAS,UAAU,IAAI,UAAU;AAEzD,MAAI,mBAAmB,QAAQ,mBAAmB,EAChD;EAGF,MAAM,cAAc,kBAAkB;AACtC,WAAS,UAAU,IAAI,WAAW,YAAY;AAE9C,MAAI,gBAAgB,GAAG;AAErB,OAAI,SAAS,QACX,UAAS,QAAQ;AAInB,QAAK,aAAa,mBAAmB,SAAS;;;;;;CAOlD,QAAQ,MAAoC;EAC1C,MAAM,WAAW,KAAK,aAAa,YAAY,QAAQ,SAAS;AAEhE,OAAK,aAAa,aAAa,SAAS;;;;;CAM1C,WAAW,SAAoD;EAC7D,MAAM,OAAO,SAAS,QAAQ;EAC9B,MAAM,WAAW,KAAK,aAAa,YAAY,KAAK;AACpD,SAAO,KAAK,aAAa,WAAW,SAAS;;;;;CAM/C,qBACE,YACA,SACQ;EACR,MAAM,OAAO,SAAS,QAAQ;EAC9B,MAAM,WAAW,KAAK,aAAa,YAAY,KAAK;EAEpD,MAAM,YAAsB,EAAE;AAC9B,OAAK,MAAM,OAAO,YAAY;GAC5B,MAAM,OAAO,SAAS,MAAM,IAAI,IAAI;AACpC,OAAI,MAAM;IAGR,MAAM,aADQ,SAAS,OAAO,KAAK,aACT,OAAO;AACjC,QAAI,YAAY;KACd,MAAM,QAAQ,KAAK,IAAI,GAAG,KAAK,UAAU;KACzC,MAAM,MAAM,KAAK,IACf,WAAW,SAAS,SAAS,GAC5B,KAAK,gBAA2B,KAAK,UACvC;AAED,SACE,SAAS,KACT,OAAO,SACP,QAAQ,WAAW,SAAS,OAE5B,MAAK,IAAI,IAAI,OAAO,KAAK,KAAK,KAAK;MACjC,MAAM,OAAO,WAAW,SAAS;AACjC,UAAI,KAAM,WAAU,KAAK,KAAK,QAAQ;;eAGjC,KAAK,WAAW,KAAK,QAAQ,OAEtC,WAAU,KAAK,GAAG,KAAK,QAAQ;;;AAIrC,SAAO,UAAU,KAAK,KAAK;;;;;CAM7B,WAAW,SAAiE;EAC1E,MAAM,OAAO,SAAS,QAAQ;EAC9B,MAAM,WAAW,KAAK,aAAa,YAAY,KAAK;AACpD,SAAO,KAAK,aAAa,WAAW,SAAS;;;;;CAM/C,aAAa,SAAkD;EAC7D,MAAM,OAAO,SAAS,QAAQ;EAC9B,MAAM,WAAW,KAAK,aAAa,YAAY,KAAK;AACpD,OAAK,aAAa,aAAa,SAAS;;;;;;;;;;;;;;;;;;CAmB1C,SACE,MACA,SAGM;EACN,MAAM,OAAO,SAAS,QAAQ;EAC9B,MAAM,WAAW,KAAK,aAAa,YAAY,KAAK;EAUpD,MAAM,kBAAkB,uBAAuB,MANJ;GACzC,QAAQ,SAAS;GACjB,UAAU,SAAS;GACnB,cAAc,SAAS;GACxB,CAEmE;AAEpE,MAAI,CAAC,gBAAgB,SAAS;AAC5B,OAAI,UAAU,CACZ,SAAQ,KACN,uBAAuB,gBAAgB,MAAM,UAAU,KAAK,GAC7D;AAEH;;EAGF,MAAM,UAAU,gBAAgB;EAChC,MAAM,aAAa,gBAAgB;EAGnC,MAAM,gBAAgB,4BAA4B,WAAW;EAG7D,MAAM,cAAc,SAAS,mBAAmB,IAAI,QAAQ;AAC5D,MAAI,gBAAgB,QAAW;AAE7B,OAAI,gBAAgB,eAElB;QAAI,UAAU,CACZ,SAAQ,KACN,qBAAqB,QAAQ,oGAEd,YAAY,SAAS,gBACrC;;AAIL;;EAGF,MAAM,QAAkB,EAAE;AAE1B,MAAI,WAAW,UAAU,MAAM;GAC7B,IAAI,SAAS,OAAO,WAAW,OAAO,CAAC,MAAM;AAC7C,OAAI,CAAC,SAAS,KAAK,OAAO,CAAE,UAAS,IAAI,OAAO;AAChD,SAAM,KAAK,WAAW,OAAO,GAAG;;EAIlC,MAAM,WAAW,WAAW,YAAY;AACxC,QAAM,KAAK,aAAa,WAAW,SAAS,QAAQ,GAAG;AAEvD,MAAI,WAAW,gBAAgB,MAAM;GACnC,IAAI;AACJ,OAAI,OAAO,WAAW,iBAAiB,SACrC,mBAAkB,OAAO,WAAW,aAAa;OAGjD,mBAAkB,WAAW,WAAW,aAA2B,CAAC;AAEtE,SAAM,KAAK,kBAAkB,gBAAgB,GAAG;;EAGlD,MAAM,eAAe,MAAM,KAAK,IAAI,CAAC,MAAM;EAE3C,MAAM,OAAkB;GACtB,UAAU,aAAa;GACvB;GACD;AAUD,MAAI,CAPS,KAAK,aAAa,iBAC7B,UACA,CAAC,KAAK,EACN,YAAY,QACZ,KACD,CAGC;AAIF,WAAS,mBAAmB,IAAI,SAAS,cAAc;AAIvD,MAAI,gBAAgB,SAAS;GAC3B,MAAM,aAAa,GAAG,QAAQ;AAC9B,OAAI,CAAC,KAAK,kBAAkB,YAAY,EAAE,MAAM,CAAC,CAC/C,MAAK,SAAS,YAAY;IACxB,QAAQ;IACR,UAAU,WAAW;IACrB,cAAc,uBAAuB,WAAW,aAAa;IAC7D;IACD,CAAC;;;;;;;;;;;CAaR,kBACE,MACA,SACS;EACT,MAAM,OAAO,SAAS,QAAQ;EAC9B,MAAM,WAAW,KAAK,aAAa,YAAY,KAAK;EAGpD,MAAM,kBAAkB,uBAAuB,MAAM,EAAE,CAAC;AACxD,MAAI,CAAC,gBAAgB,QACnB,QAAO;AAGT,SAAO,SAAS,mBAAmB,IAAI,gBAAgB,QAAQ;;;;;;;;;;;CAYjE,UACE,OACA,eACiB;EAEjB,MAAM,eAAe,OAAO,kBAAkB;EAC9C,MAAM,eAAe,eAAe,gBAAgB,eAAe;EACnE,MAAM,OAAO,eAAe,WAAW,eAAe,QAAQ;EAC9D,MAAM,WAAW,KAAK,aAAa,YAAY,KAAK;AAEpD,MAAI,OAAO,KAAK,MAAM,CAAC,WAAW,EAChC,QAAO;GACL,gBAAgB;GAChB,eAAe;GAChB;EAIH,MAAM,cAAc,KAAK,UAAU,MAAM;EAGzC,MAAM,WAAW,SAAS,eAAe,IAAI,YAAY;AACzD,MAAI,UAAU;AACZ,YAAS;AACT,UAAO;IACL,gBAAgB,SAAS;IACzB,eAAe,KAAK,iBAAiB,aAAa,SAAS;IAC5D;;EAIH,IAAI;AAEJ,MAAI,cAAc;GAEhB,MAAM,yBACJ,SAAS,uBAAuB,IAAI,aAAa;AAEnD,OAAI,0BAA0B,2BAA2B,YAGvD,cAAa,GAAG,aAAa,IAAI,SAAS;QACrC;AAEL,iBAAa;AAEb,aAAS,uBAAuB,IAAI,cAAc,YAAY;;QAIhE,cAAa,IAAI,SAAS;EAI5B,MAAM,OAAO,KAAK,aAAa,gBAC7B,UACA,OACA,YACA,KACD;AACD,MAAI,CAAC,KACH,QAAO;GACL,gBAAgB;GAChB,eAAe;GAChB;AAIH,WAAS,eAAe,IAAI,aAAa;GACvC,MAAM;GACN,UAAU;GACV;GACD,CAAC;AAGF,MAAI,SAAS,SAAS;AACpB,YAAS,QAAQ;AACjB,YAAS,QAAQ;;AAGnB,SAAO;GACL,gBAAgB;GAChB,eAAe,KAAK,iBAAiB,aAAa,SAAS;GAC5D;;;;;CAMH,AAAQ,iBAAiB,aAAqB,UAA8B;EAC1E,MAAM,QAAQ,SAAS,eAAe,IAAI,YAAY;AACtD,MAAI,CAAC,MAAO;AAEZ,QAAM;AACN,MAAI,MAAM,YAAY,GAAG;AAEvB,QAAK,aAAa,gBAAgB,UAAU,MAAM,KAAK;AACvD,YAAS,eAAe,OAAO,YAAY;AAI3C,QAAK,MAAM,CAAC,MAAM,SAAS,SAAS,uBAAuB,SAAS,CAClE,KAAI,SAAS,aAAa;AACxB,aAAS,uBAAuB,OAAO,KAAK;AAC5C;;AAKJ,OAAI,SAAS,SAAS;AACpB,aAAS,QAAQ;AACjB,aAAS,QAAQ;;;;;;;CAQvB,QAAQ,MAAoC;EAC1C,MAAM,aAAa,QAAQ;AAC3B,OAAK,aAAa,QAAQ,WAAW"}

package/dist/injector/sheet-manager.d.ts

@@ -0,0 +1,127 @@
+import { CacheMetrics, KeyframesInfo, KeyframesSteps, RawCSSResult, RootRegistry, RuleInfo, SheetInfo, StyleInjectorConfig, StyleRule } from "./types.js";
+
+//#region src/injector/sheet-manager.d.ts
+declare class SheetManager {
+  private rootRegistries;
+  private config;
+  /** Dedicated style elements for raw CSS per root */
+  private rawStyleElements;
+  /** Tracking for raw CSS blocks per root */
+  private rawCSSBlocks;
+  /** Counter for generating unique raw CSS IDs */
+  private rawCSSCounter;
+  constructor(config: StyleInjectorConfig);
+  /**
+   * Get or create registry for a root (Document or ShadowRoot)
+   */
+  getRegistry(root: Document | ShadowRoot): RootRegistry;
+  /**
+   * Create a new stylesheet for the registry
+   */
+  createSheet(registry: RootRegistry, root: Document | ShadowRoot): SheetInfo;
+  /**
+   * Create a style element and append to document
+   */
+  private createStyleElement;
+  /**
+   * Insert CSS rules as a single block
+   */
+  insertRule(registry: RootRegistry, flattenedRules: StyleRule[], className: string, root: Document | ShadowRoot): RuleInfo | null;
+  /**
+   * Insert global CSS rules
+   */
+  insertGlobalRule(registry: RootRegistry, flattenedRules: StyleRule[], globalKey: string, root: Document | ShadowRoot): RuleInfo | null;
+  /**
+   * Delete a global CSS rule by key
+   */
+  deleteGlobalRule(registry: RootRegistry, globalKey: string): void;
+  /**
+   * Adjust rule indices after deletion to account for shifting
+   */
+  private adjustIndicesAfterDeletion;
+  /**
+   * Delete a CSS rule from the sheet
+   */
+  deleteRule(registry: RootRegistry, ruleInfo: RuleInfo): void;
+  /**
+   * Find a sheet with available space or return null
+   */
+  private findAvailableSheet;
+  /**
+   * Find an available rule index in the sheet
+   */
+  findAvailableRuleIndex(sheet: SheetInfo): number;
+  /**
+   * Schedule bulk cleanup of all unused styles (non-stacking)
+   */
+  private scheduleBulkCleanup;
+  /**
+   * Force cleanup of unused styles
+   */
+  forceCleanup(registry: RootRegistry): void;
+  /**
+   * Perform bulk cleanup of all unused styles
+   */
+  private performBulkCleanup;
+  /**
+   * Get total number of rules across all sheets
+   */
+  getTotalRuleCount(registry: RootRegistry): number;
+  /**
+   * Get CSS text from all sheets (for SSR)
+   */
+  getCssText(registry: RootRegistry): string;
+  /**
+   * Get cache performance metrics
+   */
+  getMetrics(registry: RootRegistry): CacheMetrics | null;
+  /**
+   * Reset cache performance metrics
+   */
+  resetMetrics(registry: RootRegistry): void;
+  /**
+   * Convert keyframes steps to CSS string
+   */
+  private stepsToCSS;
+  /**
+   * Insert keyframes rule
+   */
+  insertKeyframes(registry: RootRegistry, steps: KeyframesSteps, name: string, root: Document | ShadowRoot): KeyframesInfo | null;
+  /**
+   * Delete keyframes rule
+   */
+  deleteKeyframes(registry: RootRegistry, info: KeyframesInfo): void;
+  /**
+   * Schedule async cleanup check (non-stacking)
+   */
+  checkCleanupNeeded(registry: RootRegistry): void;
+  /**
+   * Perform the actual cleanup check (called asynchronously)
+   */
+  private performCleanupCheck;
+  /**
+   * Clean up resources for a root
+   */
+  cleanup(root: Document | ShadowRoot): void;
+  /**
+   * Get or create a dedicated style element for raw CSS
+   * Raw CSS is kept separate from tasty-managed sheets to avoid index conflicts
+   */
+  private getOrCreateRawStyleElement;
+  /**
+   * Inject raw CSS text directly without parsing
+   * Returns a dispose function to remove the injected CSS
+   */
+  injectRawCSS(css: string, root: Document | ShadowRoot): RawCSSResult;
+  /**
+   * Remove a raw CSS block by ID
+   */
+  private disposeRawCSS;
+  /**
+   * Get the raw CSS content for SSR
+   */
+  getRawCSSText(root: Document | ShadowRoot): string;
+}
+//#endregion
+export { SheetManager };
+//# sourceMappingURL=sheet-manager.d.ts.map