@tenphi/tasty 0.0.0-snapshot.db103fd → 0.0.0-snapshot.dc62ea3

package/dist/injector/index.d.ts

@@ -1,183 +0,0 @@
-import { CacheMetrics, CounterStyleDescriptors, DisposeFunction, FontFaceDescriptors, FontFaceInput, GlobalInjectResult, InjectResult, KeyframesCacheEntry, KeyframesInfo, KeyframesResult, KeyframesSteps, PropertyDefinition, RawCSSResult, RootRegistry, RuleInfo, SheetInfo, StyleInjectorConfig, StyleRule } from "./types.js";
-import { StyleResult } from "../pipeline/index.js";
-import { SheetManager } from "./sheet-manager.js";
-import { StyleInjector } from "./injector.js";
-
-//#region src/injector/index.d.ts
-/**
- * Allocate a className for a cacheKey without injecting styles yet
- */
-declare function allocateClassName(cacheKey: string, options?: {
-  root?: Document | ShadowRoot;
-}): {
-  className: string;
-  isNewAllocation: boolean;
-};
-/**
- * Track a reference to an already-injected cacheKey (refCount + dispose).
- * Used on cache hits (SSR hydration or runtime reuse) where the pipeline
- * was skipped. Returns null if the cacheKey is not in the cache.
- */
-declare function trackRef(cacheKey: string, options?: {
-  root?: Document | ShadowRoot;
-}): InjectResult | null;
-/**
- * Inject styles and return className with dispose function
- */
-declare function inject(rules: StyleResult[], options?: {
-  root?: Document | ShadowRoot;
-  cacheKey?: string;
-}): InjectResult;
-/**
- * Inject global rules that should not reserve tasty class names
- */
-declare function injectGlobal(rules: StyleResult[], options?: {
-  root?: Document | ShadowRoot;
-}): GlobalInjectResult;
-/**
- * Inject raw CSS text directly without parsing
- * This is a low-overhead method for injecting raw CSS that doesn't need tasty processing.
- * The CSS is inserted into a separate style element to avoid conflicts with tasty's chunking.
- *
- * @example
- * ```tsx
- * // Inject raw CSS
- * const { dispose } = injectRawCSS(`
- *   body { margin: 0; padding: 0; }
- *   .my-class { color: red; }
- * `);
- *
- * // Later, remove the injected CSS
- * dispose();
- * ```
- */
-declare function injectRawCSS(css: string, options?: {
-  root?: Document | ShadowRoot;
-}): {
-  dispose: () => void;
-};
-/**
- * Get raw CSS text for SSR
- */
-declare function getRawCSSText(options?: {
-  root?: Document | ShadowRoot;
-}): string;
-/**
- * Inject keyframes and return object with toString() and dispose()
- */
-declare function keyframes(steps: KeyframesSteps, nameOrOptions?: string | {
-  root?: Document | ShadowRoot;
-  name?: string;
-}): KeyframesResult;
-interface PropertyOptions {
-  /**
-   * CSS syntax string for the property (e.g., '<color>', '<length>', '<angle>')
-   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/@property/syntax
-   */
-  syntax?: string;
-  /**
-   * Whether the property inherits from parent elements
-   * @default true
-   */
-  inherits?: boolean;
-  /**
-   * Initial value for the property
-   */
-  initialValue?: string | number;
-  /**
-   * Shadow root or document to inject into
-   */
-  root?: Document | ShadowRoot;
-}
-/**
- * Define a CSS @property custom property.
- * This enables advanced features like animating custom properties.
- *
- * Note: @property rules are global and persistent once defined.
- * Re-registering the same property name is a no-op.
- *
- * @param name - The custom property name (must start with --)
- * @param options - Property configuration
- *
- * @example
- * ```ts
- * // Define a color property that can be animated
- * property('--my-color', {
- *   syntax: '<color>',
- *   initialValue: 'red',
- * });
- *
- * // Define an angle property
- * property('--rotation', {
- *   syntax: '<angle>',
- *   inherits: false,
- *   initialValue: '0deg',
- * });
- * ```
- */
-declare function property(name: string, options?: PropertyOptions): void;
-/**
- * Check if a CSS @property has already been defined
- *
- * @param name - The custom property name to check
- * @param options - Options including root
- */
-declare function isPropertyDefined(name: string, options?: {
-  root?: Document | ShadowRoot;
-}): boolean;
-/**
- * Inject a CSS @font-face rule.
- *
- * Permanent and global — no dispose or ref-counting.
- * Deduplicates by content hash (family + descriptors).
- */
-declare function fontFace(family: string, descriptors: FontFaceDescriptors, options?: {
-  root?: Document | ShadowRoot;
-}): void;
-/**
- * Inject a CSS @counter-style rule.
- *
- * Permanent and global — no dispose or ref-counting.
- * Deduplicates by name (first definition wins).
- */
-declare function counterStyle(name: string, descriptors: CounterStyleDescriptors, options?: {
-  root?: Document | ShadowRoot;
-}): void;
-/**
- * Get CSS text from all sheets (for SSR)
- */
-declare function getCssText(options?: {
-  root?: Document | ShadowRoot;
-}): string;
-/**
- * Collect only CSS used by a rendered subtree (like jest-styled-components).
- * Pass the container returned by render(...).
- */
-declare function getCssTextForNode(node: ParentNode | Element | DocumentFragment, options?: {
-  root?: Document | ShadowRoot;
-}): string;
-/**
- * Force cleanup of unused rules
- */
-declare function cleanup(root?: Document | ShadowRoot): void;
-/**
- * Check if we're currently running in a test environment
- */
-declare function getIsTestEnvironment(): boolean;
-/**
- * Get the global injector instance for debugging
- */
-declare const injector: {
-  readonly instance: StyleInjector;
-};
-/**
- * Destroy all resources and clean up
- */
-declare function destroy(root?: Document | ShadowRoot): void;
-/**
- * Create a new isolated injector instance
- */
-declare function createInjector(config?: Partial<StyleInjectorConfig>): StyleInjector;
-//#endregion
-export { PropertyOptions, allocateClassName, cleanup, counterStyle, createInjector, destroy, fontFace, getCssText, getCssTextForNode, getIsTestEnvironment, getRawCSSText, inject, injectGlobal, injectRawCSS, injector, isPropertyDefined, keyframes, property, trackRef };
-//# sourceMappingURL=index.d.ts.map

package/dist/injector/index.js

@@ -1,179 +0,0 @@
-import "./sheet-manager.js";
-import { StyleInjector } from "./injector.js";
-import { getConfig, getGlobalInjector, isTestEnvironment, markStylesGenerated } from "../config.js";
-//#region src/injector/index.ts
-/**
-* Allocate a className for a cacheKey without injecting styles yet
-*/
-function allocateClassName(cacheKey, options) {
-	return getGlobalInjector().allocateClassName(cacheKey, options);
-}
-/**
-* Track a reference to an already-injected cacheKey (refCount + dispose).
-* Used on cache hits (SSR hydration or runtime reuse) where the pipeline
-* was skipped. Returns null if the cacheKey is not in the cache.
-*/
-function trackRef(cacheKey, options) {
-	return getGlobalInjector().trackRef(cacheKey, options);
-}
-/**
-* Inject styles and return className with dispose function
-*/
-function inject(rules, options) {
-	markStylesGenerated();
-	return getGlobalInjector().inject(rules, options);
-}
-/**
-* Inject global rules that should not reserve tasty class names
-*/
-function injectGlobal(rules, options) {
-	return getGlobalInjector().injectGlobal(rules, options);
-}
-/**
-* Inject raw CSS text directly without parsing
-* This is a low-overhead method for injecting raw CSS that doesn't need tasty processing.
-* The CSS is inserted into a separate style element to avoid conflicts with tasty's chunking.
-*
-* @example
-* ```tsx
-* // Inject raw CSS
-* const { dispose } = injectRawCSS(`
-*   body { margin: 0; padding: 0; }
-*   .my-class { color: red; }
-* `);
-*
-* // Later, remove the injected CSS
-* dispose();
-* ```
-*/
-function injectRawCSS(css, options) {
-	return getGlobalInjector().injectRawCSS(css, options);
-}
-/**
-* Get raw CSS text for SSR
-*/
-function getRawCSSText(options) {
-	return getGlobalInjector().getRawCSSText(options);
-}
-/**
-* Inject keyframes and return object with toString() and dispose()
-*/
-function keyframes(steps, nameOrOptions) {
-	return getGlobalInjector().keyframes(steps, nameOrOptions);
-}
-/**
-* Define a CSS @property custom property.
-* This enables advanced features like animating custom properties.
-*
-* Note: @property rules are global and persistent once defined.
-* Re-registering the same property name is a no-op.
-*
-* @param name - The custom property name (must start with --)
-* @param options - Property configuration
-*
-* @example
-* ```ts
-* // Define a color property that can be animated
-* property('--my-color', {
-*   syntax: '<color>',
-*   initialValue: 'red',
-* });
-*
-* // Define an angle property
-* property('--rotation', {
-*   syntax: '<angle>',
-*   inherits: false,
-*   initialValue: '0deg',
-* });
-* ```
-*/
-function property(name, options) {
-	return getGlobalInjector().property(name, options);
-}
-/**
-* Check if a CSS @property has already been defined
-*
-* @param name - The custom property name to check
-* @param options - Options including root
-*/
-function isPropertyDefined(name, options) {
-	return getGlobalInjector().isPropertyDefined(name, options);
-}
-/**
-* Inject a CSS @font-face rule.
-*
-* Permanent and global — no dispose or ref-counting.
-* Deduplicates by content hash (family + descriptors).
-*/
-function fontFace(family, descriptors, options) {
-	return getGlobalInjector().fontFace(family, descriptors, options);
-}
-/**
-* Inject a CSS @counter-style rule.
-*
-* Permanent and global — no dispose or ref-counting.
-* Deduplicates by name (first definition wins).
-*/
-function counterStyle(name, descriptors, options) {
-	return getGlobalInjector().counterStyle(name, descriptors, options);
-}
-/**
-* Get CSS text from all sheets (for SSR)
-*/
-function getCssText(options) {
-	return getGlobalInjector().getCssText(options);
-}
-/**
-* Collect only CSS used by a rendered subtree (like jest-styled-components).
-* Pass the container returned by render(...).
-*/
-function getCssTextForNode(node, options) {
-	const classSet = /* @__PURE__ */ new Set();
-	const readClasses = (el) => {
-		const cls = el.getAttribute("class");
-		if (!cls) return;
-		for (const token of cls.split(/\s+/)) if (/^t\d+$/.test(token)) classSet.add(token);
-	};
-	if (node.getAttribute) readClasses(node);
-	const elements = node.querySelectorAll ? node.querySelectorAll("[class]") : [];
-	if (elements) elements.forEach(readClasses);
-	return getGlobalInjector().getCssTextForClasses(classSet, options);
-}
-/**
-* Force cleanup of unused rules
-*/
-function cleanup(root) {
-	return getGlobalInjector().cleanup(root);
-}
-/**
-* Check if we're currently running in a test environment
-*/
-function getIsTestEnvironment() {
-	return isTestEnvironment();
-}
-/**
-* Get the global injector instance for debugging
-*/
-const injector = { get instance() {
-	return getGlobalInjector();
-} };
-/**
-* Destroy all resources and clean up
-*/
-function destroy(root) {
-	return getGlobalInjector().destroy(root);
-}
-/**
-* Create a new isolated injector instance
-*/
-function createInjector(config = {}) {
-	return new StyleInjector({
-		...getConfig(),
-		forceTextInjection: config.forceTextInjection ?? isTestEnvironment(),
-		...config
-	});
-}
-//#endregion
-export { allocateClassName, cleanup, counterStyle, createInjector, destroy, fontFace, getCssText, getCssTextForNode, getIsTestEnvironment, getRawCSSText, inject, injectGlobal, injectRawCSS, injector, isPropertyDefined, keyframes, property, trackRef };
-
-//# sourceMappingURL=index.js.map

package/dist/injector/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../src/injector/index.ts"],"sourcesContent":["import {\n  getConfig,\n  getGlobalInjector,\n  isTestEnvironment,\n  markStylesGenerated,\n} from '../config';\nimport type { StyleResult } from '../pipeline';\n\nimport { StyleInjector } from './injector';\nimport type {\n  CounterStyleDescriptors,\n  FontFaceDescriptors,\n  GlobalInjectResult,\n  InjectResult,\n  KeyframesResult,\n  KeyframesSteps,\n  StyleInjectorConfig,\n} from './types';\n\n/**\n * Allocate a className for a cacheKey without injecting styles yet\n */\nexport function allocateClassName(\n  cacheKey: string,\n  options?: { root?: Document | ShadowRoot },\n): { className: string; isNewAllocation: boolean } {\n  return getGlobalInjector().allocateClassName(cacheKey, options);\n}\n\n/**\n * Track a reference to an already-injected cacheKey (refCount + dispose).\n * Used on cache hits (SSR hydration or runtime reuse) where the pipeline\n * was skipped. Returns null if the cacheKey is not in the cache.\n */\nexport function trackRef(\n  cacheKey: string,\n  options?: { root?: Document | ShadowRoot },\n): InjectResult | null {\n  return getGlobalInjector().trackRef(cacheKey, options);\n}\n\n/**\n * Inject styles and return className with dispose function\n */\nexport function inject(\n  rules: StyleResult[],\n  options?: { root?: Document | ShadowRoot; cacheKey?: string },\n): InjectResult {\n  // Mark that styles have been generated (prevents configuration changes)\n  markStylesGenerated();\n\n  return getGlobalInjector().inject(rules, options);\n}\n\n/**\n * Inject global rules that should not reserve tasty class names\n */\nexport function injectGlobal(\n  rules: StyleResult[],\n  options?: { root?: Document | ShadowRoot },\n): GlobalInjectResult {\n  return getGlobalInjector().injectGlobal(rules, options);\n}\n\n/**\n * Inject raw CSS text directly without parsing\n * This is a low-overhead method for injecting raw CSS that doesn't need tasty processing.\n * The CSS is inserted into a separate style element to avoid conflicts with tasty's chunking.\n *\n * @example\n * ```tsx\n * // Inject raw CSS\n * const { dispose } = injectRawCSS(`\n *   body { margin: 0; padding: 0; }\n *   .my-class { color: red; }\n * `);\n *\n * // Later, remove the injected CSS\n * dispose();\n * ```\n */\nexport function injectRawCSS(\n  css: string,\n  options?: { root?: Document | ShadowRoot },\n): { dispose: () => void } {\n  return getGlobalInjector().injectRawCSS(css, options);\n}\n\n/**\n * Get raw CSS text for SSR\n */\nexport function getRawCSSText(options?: {\n  root?: Document | ShadowRoot;\n}): string {\n  return getGlobalInjector().getRawCSSText(options);\n}\n\n/**\n * Inject keyframes and return object with toString() and dispose()\n */\nexport function keyframes(\n  steps: KeyframesSteps,\n  nameOrOptions?: string | { root?: Document | ShadowRoot; name?: string },\n): KeyframesResult {\n  return getGlobalInjector().keyframes(steps, nameOrOptions);\n}\n\nexport interface PropertyOptions {\n  /**\n   * CSS syntax string for the property (e.g., '<color>', '<length>', '<angle>')\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/@property/syntax\n   */\n  syntax?: string;\n  /**\n   * Whether the property inherits from parent elements\n   * @default true\n   */\n  inherits?: boolean;\n  /**\n   * Initial value for the property\n   */\n  initialValue?: string | number;\n  /**\n   * Shadow root or document to inject into\n   */\n  root?: Document | ShadowRoot;\n}\n\n/**\n * Define a CSS @property custom property.\n * This enables advanced features like animating custom properties.\n *\n * Note: @property rules are global and persistent once defined.\n * Re-registering the same property name is a no-op.\n *\n * @param name - The custom property name (must start with --)\n * @param options - Property configuration\n *\n * @example\n * ```ts\n * // Define a color property that can be animated\n * property('--my-color', {\n *   syntax: '<color>',\n *   initialValue: 'red',\n * });\n *\n * // Define an angle property\n * property('--rotation', {\n *   syntax: '<angle>',\n *   inherits: false,\n *   initialValue: '0deg',\n * });\n * ```\n */\nexport function property(name: string, options?: PropertyOptions): void {\n  return getGlobalInjector().property(name, options);\n}\n\n/**\n * Check if a CSS @property has already been defined\n *\n * @param name - The custom property name to check\n * @param options - Options including root\n */\nexport function isPropertyDefined(\n  name: string,\n  options?: { root?: Document | ShadowRoot },\n): boolean {\n  return getGlobalInjector().isPropertyDefined(name, options);\n}\n\n/**\n * Inject a CSS @font-face rule.\n *\n * Permanent and global — no dispose or ref-counting.\n * Deduplicates by content hash (family + descriptors).\n */\nexport function fontFace(\n  family: string,\n  descriptors: FontFaceDescriptors,\n  options?: { root?: Document | ShadowRoot },\n): void {\n  return getGlobalInjector().fontFace(family, descriptors, options);\n}\n\n/**\n * Inject a CSS @counter-style rule.\n *\n * Permanent and global — no dispose or ref-counting.\n * Deduplicates by name (first definition wins).\n */\nexport function counterStyle(\n  name: string,\n  descriptors: CounterStyleDescriptors,\n  options?: { root?: Document | ShadowRoot },\n): void {\n  return getGlobalInjector().counterStyle(name, descriptors, options);\n}\n\n/**\n * Get CSS text from all sheets (for SSR)\n */\nexport function getCssText(options?: { root?: Document | ShadowRoot }): string {\n  return getGlobalInjector().getCssText(options);\n}\n\n/**\n * Collect only CSS used by a rendered subtree (like jest-styled-components).\n * Pass the container returned by render(...).\n */\nexport function getCssTextForNode(\n  node: ParentNode | Element | DocumentFragment,\n  options?: { root?: Document | ShadowRoot },\n): string {\n  // Collect tasty-generated class names (t<number>) from the subtree\n  const classSet = new Set<string>();\n\n  const readClasses = (el: Element) => {\n    const cls = el.getAttribute('class');\n    if (!cls) return;\n    for (const token of cls.split(/\\s+/)) {\n      if (/^t\\d+$/.test(token)) classSet.add(token);\n    }\n  };\n\n  // Include node itself if it's an Element\n  if ((node as Element).getAttribute) {\n    readClasses(node as Element);\n  }\n  // Walk descendants\n  const elements = (node as ParentNode).querySelectorAll\n    ? (node as ParentNode).querySelectorAll('[class]')\n    : ([] as unknown as NodeListOf<Element>);\n  if (elements) elements.forEach(readClasses);\n\n  return getGlobalInjector().getCssTextForClasses(classSet, options);\n}\n\n/**\n * Force cleanup of unused rules\n */\nexport function cleanup(root?: Document | ShadowRoot): void {\n  return getGlobalInjector().cleanup(root);\n}\n\n/**\n * Check if we're currently running in a test environment\n */\nexport function getIsTestEnvironment(): boolean {\n  return isTestEnvironment();\n}\n\n/**\n * Get the global injector instance for debugging\n */\nexport const injector = {\n  get instance() {\n    return getGlobalInjector();\n  },\n};\n\n/**\n * Destroy all resources and clean up\n */\nexport function destroy(root?: Document | ShadowRoot): void {\n  return getGlobalInjector().destroy(root);\n}\n\n/**\n * Create a new isolated injector instance\n */\nexport function createInjector(\n  config: Partial<StyleInjectorConfig> = {},\n): StyleInjector {\n  const defaultConfig = getConfig();\n\n  const fullConfig: StyleInjectorConfig = {\n    ...defaultConfig,\n    // Auto-enable forceTextInjection in test environments\n    forceTextInjection: config.forceTextInjection ?? isTestEnvironment(),\n    ...config,\n  };\n\n  return new StyleInjector(fullConfig);\n}\n\n// Re-export types\nexport type {\n  StyleInjectorConfig,\n  InjectResult,\n  DisposeFunction,\n  RuleInfo,\n  SheetInfo,\n  RootRegistry,\n  StyleRule,\n  KeyframesInfo,\n  KeyframesResult,\n  KeyframesSteps,\n  KeyframesCacheEntry,\n  CacheMetrics,\n  RawCSSResult,\n  PropertyDefinition,\n  FontFaceDescriptors,\n  FontFaceInput,\n  CounterStyleDescriptors,\n} from './types';\n\nexport { StyleInjector } from './injector';\nexport { SheetManager } from './sheet-manager';\n"],"mappings":";;;;;;;AAsBA,SAAgB,kBACd,UACA,SACiD;AACjD,QAAO,mBAAmB,CAAC,kBAAkB,UAAU,QAAQ;;;;;;;AAQjE,SAAgB,SACd,UACA,SACqB;AACrB,QAAO,mBAAmB,CAAC,SAAS,UAAU,QAAQ;;;;;AAMxD,SAAgB,OACd,OACA,SACc;AAEd,sBAAqB;AAErB,QAAO,mBAAmB,CAAC,OAAO,OAAO,QAAQ;;;;;AAMnD,SAAgB,aACd,OACA,SACoB;AACpB,QAAO,mBAAmB,CAAC,aAAa,OAAO,QAAQ;;;;;;;;;;;;;;;;;;;AAoBzD,SAAgB,aACd,KACA,SACyB;AACzB,QAAO,mBAAmB,CAAC,aAAa,KAAK,QAAQ;;;;;AAMvD,SAAgB,cAAc,SAEnB;AACT,QAAO,mBAAmB,CAAC,cAAc,QAAQ;;;;;AAMnD,SAAgB,UACd,OACA,eACiB;AACjB,QAAO,mBAAmB,CAAC,UAAU,OAAO,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkD5D,SAAgB,SAAS,MAAc,SAAiC;AACtE,QAAO,mBAAmB,CAAC,SAAS,MAAM,QAAQ;;;;;;;;AASpD,SAAgB,kBACd,MACA,SACS;AACT,QAAO,mBAAmB,CAAC,kBAAkB,MAAM,QAAQ;;;;;;;;AAS7D,SAAgB,SACd,QACA,aACA,SACM;AACN,QAAO,mBAAmB,CAAC,SAAS,QAAQ,aAAa,QAAQ;;;;;;;;AASnE,SAAgB,aACd,MACA,aACA,SACM;AACN,QAAO,mBAAmB,CAAC,aAAa,MAAM,aAAa,QAAQ;;;;;AAMrE,SAAgB,WAAW,SAAoD;AAC7E,QAAO,mBAAmB,CAAC,WAAW,QAAQ;;;;;;AAOhD,SAAgB,kBACd,MACA,SACQ;CAER,MAAM,2BAAW,IAAI,KAAa;CAElC,MAAM,eAAe,OAAgB;EACnC,MAAM,MAAM,GAAG,aAAa,QAAQ;AACpC,MAAI,CAAC,IAAK;AACV,OAAK,MAAM,SAAS,IAAI,MAAM,MAAM,CAClC,KAAI,SAAS,KAAK,MAAM,CAAE,UAAS,IAAI,MAAM;;AAKjD,KAAK,KAAiB,aACpB,aAAY,KAAgB;CAG9B,MAAM,WAAY,KAAoB,mBACjC,KAAoB,iBAAiB,UAAU,GAC/C,EAAE;AACP,KAAI,SAAU,UAAS,QAAQ,YAAY;AAE3C,QAAO,mBAAmB,CAAC,qBAAqB,UAAU,QAAQ;;;;;AAMpE,SAAgB,QAAQ,MAAoC;AAC1D,QAAO,mBAAmB,CAAC,QAAQ,KAAK;;;;;AAM1C,SAAgB,uBAAgC;AAC9C,QAAO,mBAAmB;;;;;AAM5B,MAAa,WAAW,EACtB,IAAI,WAAW;AACb,QAAO,mBAAmB;GAE7B;;;;AAKD,SAAgB,QAAQ,MAAoC;AAC1D,QAAO,mBAAmB,CAAC,QAAQ,KAAK;;;;;AAM1C,SAAgB,eACd,SAAuC,EAAE,EAC1B;AAUf,QAAO,IAAI,cAP6B;EACtC,GAHoB,WAAW;EAK/B,oBAAoB,OAAO,sBAAsB,mBAAmB;EACpE,GAAG;EACJ,CAEmC"}

package/dist/injector/injector.d.ts

@@ -1,166 +0,0 @@
-import { CacheMetrics, CounterStyleDescriptors, FontFaceDescriptors, GlobalInjectResult, InjectResult, KeyframesResult, KeyframesSteps, PropertyDefinition, RawCSSResult, StyleInjectorConfig } from "./types.js";
-import { StyleResult } from "../pipeline/index.js";
-import { SheetManager } from "./sheet-manager.js";
-
-//#region src/injector/injector.d.ts
-declare class StyleInjector {
-  private sheetManager;
-  private config;
-  private cleanupScheduled;
-  private globalRuleCounter;
-  /** @internal — exposed for debug utilities only */
-  get _sheetManager(): SheetManager;
-  constructor(config?: StyleInjectorConfig);
-  /**
-   * Allocate a className for a cacheKey without injecting styles yet.
-   * This allows separating className allocation (render phase) from style injection (insertion phase).
-   */
-  allocateClassName(cacheKey: string, options?: {
-    root?: Document | ShadowRoot;
-  }): {
-    className: string;
-    isNewAllocation: boolean;
-  };
-  /**
-   * Inject styles from StyleResult objects
-   */
-  inject(rules: StyleResult[], options?: {
-    root?: Document | ShadowRoot;
-    cacheKey?: string;
-  }): InjectResult;
-  /**
-   * 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: StyleResult[], options?: {
-    root?: Document | ShadowRoot;
-  }): GlobalInjectResult;
-  /**
-   * 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: string, options?: {
-    root?: Document | ShadowRoot;
-  }): RawCSSResult;
-  /**
-   * Get raw CSS text for SSR
-   */
-  getRawCSSText(options?: {
-    root?: Document | ShadowRoot;
-  }): string;
-  /**
-   * Increment refCount for an already-injected cacheKey and return a dispose.
-   * Used by useStyles on cache hits (hydration or runtime reuse) where
-   * the pipeline was skipped but refCount tracking is still needed.
-   * Returns null if the cacheKey is not found.
-   */
-  trackRef(cacheKey: string, options?: {
-    root?: Document | ShadowRoot;
-  }): InjectResult | null;
-  /**
-   * Dispose of a className
-   */
-  private dispose;
-  /**
-   * Force bulk cleanup of unused styles
-   */
-  cleanup(root?: Document | ShadowRoot): void;
-  /**
-   * Get CSS text from all sheets (for SSR)
-   */
-  getCssText(options?: {
-    root?: Document | ShadowRoot;
-  }): string;
-  /**
-   * Get CSS only for the provided tasty classNames (e.g., ["t0","t3"])
-   */
-  getCssTextForClasses(classNames: Iterable<string>, options?: {
-    root?: Document | ShadowRoot;
-  }): string;
-  /**
-   * Get cache performance metrics
-   */
-  getMetrics(options?: {
-    root?: Document | ShadowRoot;
-  }): CacheMetrics | null;
-  /**
-   * Reset cache performance metrics
-   */
-  resetMetrics(options?: {
-    root?: Document | ShadowRoot;
-  }): void;
-  /**
-   * 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: string, options?: PropertyDefinition & {
-    root?: Document | ShadowRoot;
-  }): void;
-  /**
-   * 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: string, options?: {
-    root?: Document | ShadowRoot;
-  }): boolean;
-  /**
-   * Inject a CSS @font-face rule.
-   *
-   * Permanent and global — no dispose or ref-counting.
-   * Deduplicates by content hash (family + descriptors).
-   */
-  fontFace(family: string, descriptors: FontFaceDescriptors, options?: {
-    root?: Document | ShadowRoot;
-  }): void;
-  /**
-   * Inject a CSS @counter-style rule.
-   *
-   * Permanent and global — no dispose or ref-counting.
-   * Deduplicates by name (first definition wins).
-   */
-  counterStyle(name: string, descriptors: CounterStyleDescriptors, options?: {
-    root?: Document | ShadowRoot;
-  }): void;
-  /**
-   * 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: KeyframesSteps, nameOrOptions?: string | {
-    root?: Document | ShadowRoot;
-    name?: string;
-  }): KeyframesResult;
-  /**
-   * Dispose keyframes
-   */
-  private disposeKeyframes;
-  /**
-   * Destroy all resources for a root
-   */
-  destroy(root?: Document | ShadowRoot): void;
-}
-//#endregion
-export { StyleInjector };
-//# sourceMappingURL=injector.d.ts.map