windrunner 1.0.3 → 1.1.1

package/dist/index.d.ts

@@ -1,33 +1,62 @@
-export interface WindrunnerOptions {
-  id?: string;
-  autoStart?: boolean;
-  preflight?: boolean;
-  compatMode?: "none" | "full";
-  compatStyleId?: string;
-  compatGenerateCss?: (options: Record<string, any>) => string;
-  theme?: Record<string, any>;
-  onReady?: () => void;
-  [key: string]: any;
-}
-
-export interface Runtime {
-  processClassName(className: string): string | undefined;
-  processClassList(classList: string | string[] | ArrayLike<string>): string[];
-  processElement(el: Element | null): void;
-  scan(root?: Document | Element): void;
-  observe(root?: Element): void;
-  flush(): void;
-  start(): void;
-  disconnect(): void;
-  isCompatLoaded(): boolean;
-  getCacheSize(): number;
-  getInsertedRuleCount(): number;
-}
-
-export function createWindrunner(options?: WindrunnerOptions): Runtime;
-export function compileRuntimeClassNameWithContext(className: string, context: any): string;
-export function compileClass(className: string, options?: any): string;
-export function parseClass(className: string, screens?: Record<string,string>, containers?: Record<string,string>): { original: string; baseToken: string; variants: string[]; breakpoint: string | null; containerBreakpoint: string | null; important: boolean; starting: boolean } | null;
-
-declare function windrunner(options?: WindrunnerOptions): Runtime;
-export default windrunner;
+// ─── Plugin Types ─────────────────────────────────────────────────────────────
+
+export interface PluginAPI {
+  addUtility(pattern: string | RegExp, handler: string | ((match: RegExpMatchArray, theme: any) => string)): void;
+  addUtilities(utilities: Record<string, string | ((match: RegExpMatchArray, theme: any) => string)>): void;
+  addVariant(name: string, handler: (selector: string) => string): void;
+  addVariants(variants: Record<string, (selector: string) => string>): void;
+  theme(key?: string): any;
+  config(): any;
+}
+
+export interface Plugin {
+  __isWindrunnerPlugin: true;
+  handler: (api: PluginAPI) => void;
+}
+
+export function plugin(handler: (api: PluginAPI) => void): Plugin;
+
+export function defineUtilities(definitions: Record<string, string | Record<string, string>>): Record<string, string>;
+
+export function defineResponsiveUtilities(
+  base: string,
+  values: Record<string, string>,
+  toDeclaration: (key: string, value: string) => string
+): Record<string, string>;
+
+// ─── Runtime Options with Plugins ─────────────────────────────────────────────
+
+export interface WindrunnerOptions {
+  id?: string;
+  autoStart?: boolean;
+  preflight?: boolean;
+  compatMode?: "none" | "full";
+  compatStyleId?: string;
+  compatGenerateCss?: (options: Record<string, any>) => string;
+  theme?: Record<string, any>;
+  plugins?: Plugin[];
+  onReady?: () => void;
+  [key: string]: any;
+}
+
+export interface Runtime {
+  processClassName(className: string): string | undefined;
+  processClassList(classList: string | string[] | ArrayLike<string>): string[];
+  processElement(el: Element | null): void;
+  scan(root?: Document | Element): void;
+  observe(root?: Element): void;
+  flush(): void;
+  start(): void;
+  disconnect(): void;
+  isCompatLoaded(): boolean;
+  getCacheSize(): number;
+  getInsertedRuleCount(): number;
+}
+
+export function createWindrunner(options?: WindrunnerOptions): Runtime;
+export function compileRuntimeClassNameWithContext(className: string, context: any): string;
+export function compileClass(className: string, options?: any): string;
+export function parseClass(className: string, screens?: Record<string,string>, containers?: Record<string,string>): { original: string; baseToken: string; variants: string[]; breakpoint: string | null; containerBreakpoint: string | null; important: boolean; starting: boolean } | null;
+
+declare function windrunner(options?: WindrunnerOptions): Runtime;
+export default windrunner;

package/dist/index.esm.js

@@ -1436,6 +1436,13 @@ function getConfigOptions(options = {}, pluginKeys = []) {
   };
 }
 
+// src/constants.js
+var TIME_VALUE_WITH_UNIT_REGEX = /^\d+(?:\.\d+)?(?:ms|s)$/;
+var TIME_VALUE_NUMERIC_REGEX = /^\d+(?:\.\d+)?$/;
+var CSS_ESCAPE_BACKSLASH_REGEX = /\\/g;
+var CSS_ESCAPE_SPECIAL_CHARS_REGEX = /([ !"#$%&'()*+,./:;<=>?@[\\\]^`{|}~])/g;
+var CSS_ESCAPE_LEADING_DIGIT_REGEX = /^(\d)/;
+
 // src/resolvers.js
 function resolveArbitraryValue(valueKey) {
   if (valueKey.startsWith("[") && valueKey.endsWith("]")) {
@@ -1455,8 +1462,8 @@ function resolveThemeValue(scale, valueKey) {
 function resolveTimeValue(valueKey) {
   const arbitrary = resolveArbitraryValue(valueKey);
   if (arbitrary !== void 0) return arbitrary;
-  if (/^\d+(?:\.\d+)?(?:ms|s)$/.test(valueKey)) return valueKey;
-  if (/^\d+(?:\.\d+)?$/.test(valueKey)) return `${valueKey}ms`;
+  if (TIME_VALUE_WITH_UNIT_REGEX.test(valueKey)) return valueKey;
+  if (TIME_VALUE_NUMERIC_REGEX.test(valueKey)) return `${valueKey}ms`;
   return void 0;
 }
 function resolveColorValue(colors, colorKey) {
@@ -1492,15 +1499,21 @@ function resolveColorWithOpacity(colors, rawKey) {
   const color = resolveColorValue(colors, colorKey);
   if (color === void 0) return void 0;
   const arbOpacity = resolveArbitraryValue(opacityStr);
-  const opacityVal = arbOpacity !== void 0 ? arbOpacity : String(parseFloat(opacityStr) / 100);
-  if (!opacityVal || opacityVal === "NaN") return void 0;
-  return `color-mix(in oklch, ${color} ${parseFloat(opacityStr)}%, transparent)`;
+  if (arbOpacity !== void 0) {
+    const opacityVal = parseFloat(arbOpacity);
+    if (isNaN(opacityVal)) return void 0;
+    const finalOpacity = opacityVal <= 1 ? opacityVal * 100 : opacityVal;
+    return `color-mix(in oklch, ${color} ${finalOpacity}%, transparent)`;
+  }
+  const opacityNum = parseFloat(opacityStr);
+  if (isNaN(opacityNum)) return void 0;
+  return `color-mix(in oklch, ${color} ${opacityNum}%, transparent)`;
 }
 function escapeCssIdentifier(value) {
   if (typeof CSS !== "undefined" && typeof CSS.escape === "function") {
     return CSS.escape(value);
   }
-  return String(value).replace(/\\/g, "\\\\").replace(/([ !"#$%&'()*+,./:;<=>?@[\\\]^`{|}~])/g, "\\$1").replace(/^(\d)/, "\\3$1 ");
+  return String(value).replace(CSS_ESCAPE_BACKSLASH_REGEX, "\\\\").replace(CSS_ESCAPE_SPECIAL_CHARS_REGEX, "\\$1").replace(CSS_ESCAPE_LEADING_DIGIT_REGEX, "\\3$1 ");
 }
 function appendImportant(declaration, isImportant) {
   if (!isImportant) return declaration;
@@ -3260,13 +3273,340 @@ function buildDivideDeclaration(baseToken, theme2) {
   return void 0;
 }
 
+// src/plugins.js
+var PluginRegistry = class {
+  constructor() {
+    this.utilities = /* @__PURE__ */ new Map();
+    this.variants = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Register a custom utility
+   * @param {string|RegExp} pattern - Class name pattern (e.g., "glass" or /^glass-(.+)$/)
+   * @param {Function|string} handler - Function that returns CSS or CSS string
+   */
+  addUtility(pattern, handler) {
+    this.utilities.set(pattern, handler);
+  }
+  /**
+   * Register multiple utilities at once
+   * @param {Object} utilities - Object mapping patterns to handlers
+   */
+  addUtilities(utilities) {
+    Object.entries(utilities).forEach(([pattern, handler]) => {
+      this.addUtility(pattern, handler);
+    });
+  }
+  /**
+   * Register a custom variant
+   * @param {string} name - Variant name (e.g., "parent-hover")
+   * @param {Function} handler - Function that transforms selector
+   */
+  addVariant(name, handler) {
+    this.variants.set(name, handler);
+  }
+  /**
+   * Register multiple variants at once
+   * @param {Object} variants - Object mapping names to handlers
+   */
+  addVariants(variants2) {
+    Object.entries(variants2).forEach(([name, handler]) => {
+      this.addVariant(name, handler);
+    });
+  }
+  /**
+   * Check if a token matches any custom utility pattern
+   * @param {string} token - The base token to match
+   * @returns {Object|null} - { handler, match } or null
+   */
+  matchUtility(token) {
+    for (const [pattern, handler] of this.utilities) {
+      if (pattern instanceof RegExp) {
+        const match = pattern.exec(token);
+        if (match) {
+          return { handler, match };
+        }
+      } else if (pattern === token) {
+        return { handler, match: [token] };
+      }
+    }
+    return null;
+  }
+  /**
+   * Check if a variant name matches any custom variant
+   * @param {string} variantName - The variant to check
+   * @returns {Function|null} - Handler function or null
+   */
+  matchVariant(variantName) {
+    return this.variants.get(variantName) || null;
+  }
+  /**
+   * Get all registered utility patterns (for debugging)
+   */
+  getUtilities() {
+    return Array.from(this.utilities.keys());
+  }
+  /**
+   * Get all registered variant names (for debugging)
+   */
+  getVariants() {
+    return Array.from(this.variants.keys());
+  }
+  /**
+   * Clear all registered plugins
+   */
+  clear() {
+    this.utilities.clear();
+    this.variants.clear();
+  }
+};
+function plugin(handler) {
+  if (typeof handler !== "function") {
+    throw new Error("Plugin handler must be a function");
+  }
+  return {
+    __isWindrunnerPlugin: true,
+    handler
+  };
+}
+function isPlugin(obj) {
+  return obj && obj.__isWindrunnerPlugin === true && typeof obj.handler === "function";
+}
+function defineUtilities(definitions) {
+  const utilities = {};
+  Object.entries(definitions).forEach(([className, css]) => {
+    utilities[className] = typeof css === "string" ? css : objectToCss(css);
+  });
+  return utilities;
+}
+function defineResponsiveUtilities(base, values, toDeclaration) {
+  const utilities = {};
+  Object.entries(values).forEach(([key, value]) => {
+    const className = key === "DEFAULT" ? base : `${base}-${key}`;
+    utilities[className] = toDeclaration(key, value);
+  });
+  return utilities;
+}
+function objectToCss(obj) {
+  return Object.entries(obj).map(([prop, value]) => `${prop}: ${value};`).join(" ");
+}
+
 // src/compiler.js
-function compileBaseToken(baseToken, theme2) {
+var PREFIX_ROUTER = {
+  // Layout & Display
+  "block": [buildLayoutDeclaration],
+  "inline": [buildLayoutDeclaration],
+  "flex": [buildFlexGridDeclaration, buildLayoutDeclaration],
+  "grid": [buildFlexGridDeclaration, buildLayoutDeclaration],
+  "hidden": [buildLayoutDeclaration],
+  "table": [buildLayoutDeclaration],
+  "flow": [buildLayoutDeclaration],
+  // Position
+  "static": [buildLayoutDeclaration],
+  "fixed": [buildLayoutDeclaration],
+  "absolute": [buildLayoutDeclaration],
+  "relative": [buildLayoutDeclaration],
+  "sticky": [buildLayoutDeclaration],
+  "inset": [buildPositionInsetDeclaration, buildInsetShadowDeclaration, buildInsetRingDeclaration],
+  "top": [buildPositionInsetDeclaration],
+  "right": [buildPositionInsetDeclaration],
+  "bottom": [buildPositionInsetDeclaration],
+  "left": [buildPositionInsetDeclaration],
+  "start": [buildPositionInsetDeclaration],
+  "end": [buildPositionInsetDeclaration],
+  "z": [buildLayoutDeclaration],
+  // Spacing
+  "m": [buildSpacingDeclaration],
+  "mx": [buildSpacingDeclaration],
+  "my": [buildSpacingDeclaration],
+  "mt": [buildSpacingDeclaration],
+  "mr": [buildSpacingDeclaration],
+  "mb": [buildSpacingDeclaration],
+  "ml": [buildSpacingDeclaration],
+  "ms": [buildSpacingDeclaration],
+  "me": [buildSpacingDeclaration],
+  "p": [buildSpacingDeclaration],
+  "px": [buildSpacingDeclaration],
+  "py": [buildSpacingDeclaration],
+  "pt": [buildSpacingDeclaration],
+  "pr": [buildSpacingDeclaration],
+  "pb": [buildSpacingDeclaration],
+  "pl": [buildSpacingDeclaration],
+  "ps": [buildSpacingDeclaration],
+  "pe": [buildSpacingDeclaration],
+  "space": [buildSpaceBetweenDeclaration],
+  // Sizing
+  "w": [buildDimensionDeclaration],
+  "h": [buildDimensionDeclaration],
+  "min": [buildDimensionDeclaration],
+  "max": [buildDimensionDeclaration],
+  "size": [buildDimensionDeclaration],
+  // Typography
+  "text": [buildTypographyDeclaration, buildColorDeclaration],
+  "font": [buildTypographyDeclaration],
+  "leading": [buildTypographyDeclaration],
+  "tracking": [buildTypographyDeclaration],
+  "line": [buildTypographyDeclaration],
+  "whitespace": [buildTypographyDeclaration],
+  "break": [buildTypographyDeclaration],
+  "hyphens": [buildTypographyDeclaration],
+  "list": [buildTypographyDeclaration],
+  "italic": [buildTypographyDeclaration],
+  "underline": [buildTypographyDeclaration],
+  "overline": [buildTypographyDeclaration],
+  "uppercase": [buildTypographyDeclaration],
+  "lowercase": [buildTypographyDeclaration],
+  "capitalize": [buildTypographyDeclaration],
+  "normal": [buildTypographyDeclaration, buildLayoutDeclaration],
+  "truncate": [buildTypographyDeclaration],
+  // Colors & Backgrounds
+  "bg": [buildBackgroundDeclaration, buildColorDeclaration, buildGradientDeclaration],
+  "from": [buildGradientDeclaration],
+  "via": [buildGradientDeclaration],
+  "to": [buildGradientDeclaration],
+  "fill": [buildColorDeclaration],
+  "stroke": [buildColorDeclaration],
+  // Borders
+  "border": [buildBorderDeclaration, buildColorDeclaration],
+  "rounded": [buildBorderRadiusDeclaration],
+  "divide": [buildDivideDeclaration],
+  // Effects
+  "shadow": [buildShadowDeclaration, buildTextShadowDeclaration],
+  "opacity": [buildOpacityDeclaration],
+  "ring": [buildRingDeclaration, buildRingOffsetDeclaration],
+  // Transforms
+  "scale": [buildTransformDeclaration],
+  "rotate": [buildTransformDeclaration],
+  "translate": [buildTransformDeclaration],
+  "skew": [buildTransformDeclaration],
+  "origin": [buildTransformDeclaration],
+  "transform": [buildTransformDeclaration],
+  // Filters
+  "blur": [buildFilterDeclaration],
+  "brightness": [buildFilterDeclaration],
+  "contrast": [buildFilterDeclaration],
+  "grayscale": [buildFilterDeclaration],
+  "hue": [buildFilterDeclaration],
+  "invert": [buildFilterDeclaration],
+  "saturate": [buildFilterDeclaration],
+  "sepia": [buildFilterDeclaration],
+  "drop": [buildFilterDeclaration],
+  "backdrop": [buildFilterDeclaration],
+  // Transitions & Animations
+  "transition": [buildTransitionDeclaration],
+  "duration": [buildTransitionDeclaration],
+  "ease": [buildTransitionDeclaration],
+  "delay": [buildTransitionDeclaration],
+  "animate": [buildAnimationDeclaration],
+  // Interactivity
+  "cursor": [buildInteractivityDeclaration],
+  "pointer": [buildInteractivityDeclaration],
+  "resize": [buildInteractivityDeclaration],
+  "select": [buildInteractivityDeclaration],
+  "appearance": [buildInteractivityDeclaration],
+  "outline": [buildColorDeclaration, buildInteractivityDeclaration],
+  "caret": [buildColorDeclaration],
+  "accent": [buildColorDeclaration],
+  // Flexbox & Grid specific
+  "items": [buildFlexGridDeclaration],
+  "justify": [buildFlexGridDeclaration],
+  "place": [buildFlexGridDeclaration],
+  "content": [buildFlexGridDeclaration, buildTypographyDeclaration],
+  "self": [buildFlexGridDeclaration],
+  "order": [buildFlexGridDeclaration],
+  "gap": [buildGapDeclaration],
+  "grow": [buildFlexGridDeclaration],
+  "shrink": [buildFlexGridDeclaration],
+  "basis": [buildFlexGridDeclaration],
+  "cols": [buildFlexGridDeclaration],
+  "rows": [buildFlexGridDeclaration],
+  "col": [buildFlexGridDeclaration],
+  "row": [buildFlexGridDeclaration],
+  "auto": [buildFlexGridDeclaration, buildLayoutDeclaration],
+  // Misc
+  "overflow": [buildLayoutDeclaration],
+  "overscroll": [buildInteractivityDeclaration],
+  "scroll": [buildScrollSnapDeclaration, buildInteractivityDeclaration],
+  "snap": [buildScrollSnapDeclaration],
+  "touch": [buildInteractivityDeclaration],
+  "will": [buildInteractivityDeclaration],
+  "mix": [buildBlendingDeclaration],
+  "blend": [buildBlendingDeclaration],
+  "isolation": [buildLayoutDeclaration],
+  "object": [buildLayoutDeclaration],
+  "container": [buildContainerQueryDeclaration],
+  "columns": [buildLayoutDeclaration],
+  "aspect": [buildLayoutDeclaration],
+  "clear": [buildLayoutDeclaration],
+  "float": [buildLayoutDeclaration],
+  "box": [buildLayoutDeclaration],
+  "visible": [buildLayoutDeclaration],
+  "invisible": [buildLayoutDeclaration],
+  "collapse": [buildLayoutDeclaration],
+  "mask": [buildMaskDeclaration],
+  "forced": [buildForcedColorDeclaration],
+  "field": [buildInteractivityDeclaration],
+  "placeholder": [buildColorDeclaration],
+  "sr": [buildAccessibilityDeclaration],
+  "not": [buildAccessibilityDeclaration]
+};
+function extractPrefix(token) {
+  const dashIndex = token.indexOf("-");
+  if (dashIndex === -1) return token;
+  const prefix = token.slice(0, dashIndex);
+  const secondDashIndex = token.indexOf("-", dashIndex + 1);
+  if (secondDashIndex !== -1) {
+    const twoPartPrefix = token.slice(0, secondDashIndex);
+    if (PREFIX_ROUTER[twoPartPrefix]) return twoPartPrefix;
+  }
+  return prefix;
+}
+function checkAllBuilders(baseToken, theme2) {
   return buildLayoutDeclaration(baseToken, theme2) || buildPositionInsetDeclaration(baseToken, theme2) || buildSpacingDeclaration(baseToken, theme2) || buildSpaceBetweenDeclaration(baseToken, theme2) || buildGapDeclaration(baseToken, theme2) || buildDimensionDeclaration(baseToken, theme2) || buildFlexGridDeclaration(baseToken, theme2) || buildBorderDeclaration(baseToken, theme2) || buildBorderRadiusDeclaration(baseToken, theme2) || buildBorderSpacingDeclaration(baseToken, theme2) || buildDivideDeclaration(baseToken, theme2) || buildOpacityDeclaration(baseToken, theme2) || buildShadowDeclaration(baseToken, theme2) || buildInsetShadowDeclaration(baseToken, theme2) || buildInsetRingDeclaration(baseToken, theme2) || buildRingDeclaration(baseToken, theme2) || buildRingOffsetDeclaration(baseToken, theme2) || buildTextShadowDeclaration(baseToken, theme2) || buildTransitionDeclaration(baseToken) || buildTransformDeclaration(baseToken, theme2) || buildFilterDeclaration(baseToken, theme2) || buildBackgroundDeclaration(baseToken, theme2) || buildGradientDeclaration(baseToken, theme2) || buildColorDeclaration(baseToken, theme2) || buildTypographyDeclaration(baseToken, theme2) || buildBlendingDeclaration(baseToken) || buildInteractivityDeclaration(baseToken, theme2) || buildAnimationDeclaration(baseToken) || buildMaskDeclaration(baseToken) || buildContainerQueryDeclaration(baseToken) || buildScrollSnapDeclaration(baseToken) || buildAccessibilityDeclaration(baseToken) || buildZoomDeclaration(baseToken, theme2) || buildForcedColorDeclaration(baseToken);
 }
-function applyVariants(selector, variants2) {
+function compileBaseToken(baseToken, theme2, pluginRegistry) {
+  if (pluginRegistry) {
+    const pluginMatch = pluginRegistry.matchUtility(baseToken);
+    if (pluginMatch) {
+      const { handler, match } = pluginMatch;
+      try {
+        if (typeof handler === "function") {
+          const result = handler(match, theme2);
+          if (result) return result;
+        } else if (typeof handler === "string") {
+          return handler;
+        }
+      } catch (error) {
+        console.warn(`[Windrunner] Plugin utility handler error for "${baseToken}":`, error);
+      }
+    }
+  }
+  const prefix = extractPrefix(baseToken);
+  const builders = PREFIX_ROUTER[prefix];
+  if (builders) {
+    for (let i = 0; i < builders.length; i += 1) {
+      const result = builders[i](baseToken, theme2);
+      if (result) return result;
+    }
+  }
+  return checkAllBuilders(baseToken, theme2);
+}
+function applyVariants(selector, variants2, pluginRegistry) {
   let currentSelector = selector;
   for (const variant of variants2) {
+    if (pluginRegistry) {
+      const customHandler = pluginRegistry.matchVariant(variant);
+      if (customHandler) {
+        try {
+          const result = customHandler(currentSelector);
+          if (result) {
+            currentSelector = result;
+            continue;
+          }
+        } catch (error) {
+          console.warn(`[Windrunner] Plugin variant handler error for "${variant}":`, error);
+        }
+      }
+    }
     switch (variant) {
       case "dark":
         currentSelector = `.dark ${currentSelector}`;
@@ -3307,15 +3647,66 @@ function applyVariants(selector, variants2) {
       case "invalid":
         currentSelector = `${currentSelector}:invalid`;
         break;
+      case "target":
+        currentSelector = `${currentSelector}:target`;
+        break;
+      case "enabled":
+        currentSelector = `${currentSelector}:enabled`;
+        break;
+      case "default":
+        currentSelector = `${currentSelector}:default`;
+        break;
+      case "optional":
+        currentSelector = `${currentSelector}:optional`;
+        break;
+      case "user-valid":
+        currentSelector = `${currentSelector}:user-valid`;
+        break;
+      case "user-invalid":
+        currentSelector = `${currentSelector}:user-invalid`;
+        break;
+      case "in-range":
+        currentSelector = `${currentSelector}:in-range`;
+        break;
+      case "out-of-range":
+        currentSelector = `${currentSelector}:out-of-range`;
+        break;
+      case "placeholder-shown":
+        currentSelector = `${currentSelector}:placeholder-shown`;
+        break;
+      case "autofill":
+        currentSelector = `${currentSelector}:autofill`;
+        break;
+      case "details-content":
+        currentSelector = `${currentSelector}:details-content`;
+        break;
       case "placeholder":
         currentSelector = `${currentSelector}::placeholder`;
         break;
+      case "backdrop":
+        currentSelector = `${currentSelector}::backdrop`;
+        break;
       case "before":
         currentSelector = `${currentSelector}::before`;
         break;
       case "after":
         currentSelector = `${currentSelector}::after`;
         break;
+      case "first-letter":
+        currentSelector = `${currentSelector}::first-letter`;
+        break;
+      case "first-line":
+        currentSelector = `${currentSelector}::first-line`;
+        break;
+      case "marker":
+        currentSelector = `${currentSelector}::marker`;
+        break;
+      case "selection":
+        currentSelector = `${currentSelector}::selection`;
+        break;
+      case "file":
+        currentSelector = `${currentSelector}::file-selector-button`;
+        break;
       case "first":
         currentSelector = `${currentSelector}:first-child`;
         break;
@@ -3396,21 +3787,63 @@ function applyVariants(selector, variants2) {
 }
 function resolveRuntimeContext(options = {}) {
   const config = getConfigOptions(options, []);
+  const pluginRegistry = new PluginRegistry();
+  if (options.plugins && Array.isArray(options.plugins)) {
+    options.plugins.forEach((pluginDef) => {
+      if (isPlugin(pluginDef)) {
+        try {
+          pluginDef.handler({
+            addUtility: (pattern, handler) => pluginRegistry.addUtility(pattern, handler),
+            addUtilities: (utilities) => pluginRegistry.addUtilities(utilities),
+            addVariant: (name, handler) => pluginRegistry.addVariant(name, handler),
+            addVariants: (variants2) => pluginRegistry.addVariants(variants2),
+            theme: (key) => {
+              if (!key) return config.theme || {};
+              const keys = key.split(".");
+              let value = config.theme || {};
+              for (const k of keys) {
+                value = value[k];
+                if (value === void 0) break;
+              }
+              return value;
+            },
+            config: () => config
+          });
+        } catch (error) {
+          console.error("[Windrunner] Plugin initialization error:", error);
+        }
+      }
+    });
+  }
   return {
     config,
     theme: config.theme || {},
     screens: config.theme && config.theme.screens || config.screens || {},
-    containers: config.theme && config.theme.containers || config.containers || {}
+    containers: config.theme && config.theme.containers || config.containers || {},
+    plugins: pluginRegistry
   };
 }
 function getBaseTailwindOptions(options = {}) {
   const { id, autoStart, compatMode, compatStyleId, compatGenerateCss, ...tailwindOptions } = options;
   return tailwindOptions;
 }
+var parseCache = /* @__PURE__ */ new Map();
+var PARSE_CACHE_MAX_SIZE = 2e3;
+function getConfigHash(screens, containers) {
+  const screensEmpty = !screens || Object.keys(screens).length === 0;
+  const containersEmpty = !containers || Object.keys(containers).length === 0;
+  if (screensEmpty && containersEmpty) return "default";
+  return `${Object.keys(screens || {}).join(",")}|${Object.keys(containers || {}).join(",")}`;
+}
 function parseClass(className, screens = {}, containers = {}) {
   if (typeof className !== "string") return null;
   const token = className.trim();
   if (!token) return null;
+  const configHash = getConfigHash(screens, containers);
+  const cacheKey = `${token}:${configHash}`;
+  if (parseCache.has(cacheKey)) {
+    return parseCache.get(cacheKey);
+  }
   const important = token.startsWith("!");
   const normalized = important ? token.slice(1) : token;
   const parts = splitByVariantDelimiter(normalized);
@@ -3439,15 +3872,21 @@ function parseClass(className, screens = {}, containers = {}) {
     }
     variants2.push(part);
   }
-  return { original: token, baseToken, variants: variants2, breakpoint, containerBreakpoint, important, starting };
+  const result = { original: token, baseToken, variants: variants2, breakpoint, containerBreakpoint, important, starting };
+  if (parseCache.size >= PARSE_CACHE_MAX_SIZE) {
+    const firstKey = parseCache.keys().next().value;
+    parseCache.delete(firstKey);
+  }
+  parseCache.set(cacheKey, result);
+  return result;
 }
 function compileRuntimeClassNameWithContext(className, context) {
   const parsed = parseClass(className, context.screens, context.containers);
   if (!parsed) return "";
-  const declaration = compileBaseToken(parsed.baseToken, context.theme);
+  const declaration = compileBaseToken(parsed.baseToken, context.theme, context.plugins);
   if (!declaration) return "";
   const selector = `.${escapeCssIdentifier(parsed.original)}`;
-  const variantSelector = applyVariants(selector, parsed.variants);
+  const variantSelector = applyVariants(selector, parsed.variants, context.plugins);
   if (!variantSelector) return "";
   const finalDeclaration = appendImportant(
     isChildScoped(declaration) ? declaration.declaration : declaration,
@@ -3737,6 +4176,9 @@ function windrunner(options = {}) {
 export {
   compileClass,
   createWindrunner,
+  defineResponsiveUtilities,
+  defineUtilities,
   parseClass,
+  plugin,
   windrunner
 };