@seyuna/postcss 1.0.0-canary.20 → 1.0.0-canary.21

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [1.0.0-canary.21](https://github.com/seyuna-corp/seyuna-postcss/compare/v1.0.0-canary.20...v1.0.0-canary.21) (2026-01-10)
+
+
+### Bug Fixes
+
+* resolve deadlock by switching to CJS and lazy initialization ([5ae6db2](https://github.com/seyuna-corp/seyuna-postcss/commit/5ae6db23e8fdc630787e2feb4c062af0187bf8c4))
+
 # [1.0.0-canary.20](https://github.com/seyuna-corp/seyuna-postcss/compare/v1.0.0-canary.19...v1.0.0-canary.20) (2026-01-10)
 
 

package/dist/at-rules/color-scheme.d.ts

@@ -1,4 +1,4 @@
-import { AtRule } from "postcss";
+import type { AtRule } from "postcss";
 import { PluginContext } from "../types.js";
 export declare const light: (atRule: AtRule, context: PluginContext) => void;
 export declare const dark: (atRule: AtRule, context: PluginContext) => void;

package/dist/at-rules/color-scheme.js

@@ -1,4 +1,10 @@
-import { Rule, AtRule } from "postcss";
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dark = exports.light = void 0;
+const postcss_1 = __importDefault(require("postcss"));
 /**
  * Custom PostCSS plugin handler factory for `@light` and `@dark` at-rules.
  */
@@ -14,7 +20,7 @@ function createColorSchemeHandler(scheme) {
         /**
          * Rule 1: [data-mode="scheme"] & { ... } (Explicit mode)
          */
-        const explicitRule = new Rule({
+        const explicitRule = new postcss_1.default.Rule({
             selector: `[${modeAttribute}="${scheme}"] &`,
             source: atRule.source,
         });
@@ -22,12 +28,12 @@ function createColorSchemeHandler(scheme) {
         /**
          * Rule 2: @media (prefers-color-scheme: scheme) { [data-mode="system"] & { ... } } (System preference)
          */
-        const mediaAtRule = new AtRule({
+        const mediaAtRule = new postcss_1.default.AtRule({
             name: "media",
             params: `(prefers-color-scheme: ${scheme})`,
             source: atRule.source,
         });
-        const systemRule = new Rule({
+        const systemRule = new postcss_1.default.Rule({
             selector: `[${modeAttribute}="system"] &`,
             source: atRule.source,
         });
@@ -39,5 +45,5 @@ function createColorSchemeHandler(scheme) {
         atRule.replaceWith(mediaAtRule, explicitRule);
     };
 }
-export const light = createColorSchemeHandler('light');
-export const dark = createColorSchemeHandler('dark');
+exports.light = createColorSchemeHandler('light');
+exports.dark = createColorSchemeHandler('dark');

package/dist/at-rules/color.d.ts

@@ -1,4 +1,4 @@
-import { AtRule } from "postcss";
+import type { AtRule } from "postcss";
 import { PluginContext } from "../types.js";
 /**
  * Handler for @each-standard-color

package/dist/at-rules/color.js

@@ -1,11 +1,15 @@
-import { generateRules } from "../helpers.js";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eachStandardColor = eachStandardColor;
+exports.eachFixedColor = eachFixedColor;
+const helpers_js_1 = require("../helpers.js");
 /**
  * Handler for @each-standard-color
  */
-export function eachStandardColor(atRule, context) {
+function eachStandardColor(atRule, context) {
     const { config } = context;
     const hueNames = config.ui ? Object.keys(config.ui.theme.hues) : [];
-    const rules = generateRules(hueNames, atRule, context);
+    const rules = (0, helpers_js_1.generateRules)(hueNames, atRule, context);
     if (rules.length)
         atRule.replaceWith(...rules);
     else
@@ -14,7 +18,7 @@ export function eachStandardColor(atRule, context) {
 /**
  * Handler for @each-fixed-color
  */
-export function eachFixedColor(atRule, context) {
+function eachFixedColor(atRule, context) {
     const { config } = context;
     const mergedNames = [
         ...new Set([
@@ -22,7 +26,7 @@ export function eachFixedColor(atRule, context) {
             ...(config.ui ? Object.keys(config.ui.theme.dark.colors) : []),
         ]),
     ];
-    const rules = generateRules(mergedNames, atRule, context);
+    const rules = (0, helpers_js_1.generateRules)(mergedNames, atRule, context);
     if (rules.length)
         atRule.replaceWith(...rules);
     else

package/dist/at-rules/container.d.ts

@@ -1,4 +1,4 @@
-import { AtRule } from "postcss";
+import type { AtRule } from "postcss";
 import { PluginContext } from "../types.js";
 /**
  * Custom PostCSS plugin handler for responsive at-rules.

package/dist/at-rules/container.js

@@ -1,4 +1,10 @@
-import { AtRule } from "postcss";
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = container;
+const postcss_1 = __importDefault(require("postcss"));
 /**
  * Custom PostCSS plugin handler for responsive at-rules.
  *
@@ -15,7 +21,8 @@ import { AtRule } from "postcss";
  *   }
  *
  */
-export default function container(atRule, context) {
+function container(atRule, context) {
+    var _a, _b;
     const { config } = context;
     // Default breakpoints
     const defaultBreakpoints = {
@@ -29,7 +36,7 @@ export default function container(atRule, context) {
     // Merge with config if available (assuming config.ui.breakpoints exists)
     const breakpoints = {
         ...defaultBreakpoints,
-        ...(config.ui?.theme?.breakpoints || {}),
+        ...(((_b = (_a = config.ui) === null || _a === void 0 ? void 0 : _a.theme) === null || _b === void 0 ? void 0 : _b.breakpoints) || {}),
     };
     if (Object.keys(breakpoints).includes(atRule.name)) {
         const minWidth = breakpoints[atRule.name];
@@ -37,7 +44,7 @@ export default function container(atRule, context) {
         atRule.each((node) => {
             clonedNodes.push(node.clone());
         });
-        const containerAtRule = new AtRule({
+        const containerAtRule = new postcss_1.default.AtRule({
             name: "container",
             params: `(min-width: ${minWidth})`,
             source: atRule.source,

package/dist/at-rules/index.d.ts

@@ -1,4 +1,4 @@
-import { AtRule } from "postcss";
+import type { AtRule } from "postcss";
 import { PluginContext } from "../types.js";
 export interface AtRuleHandler {
     name: string;

package/dist/at-rules/index.js

@@ -1,16 +1,22 @@
-import { eachStandardColor, eachFixedColor } from "./color.js";
-import container from "./container.js";
-import { light, dark } from "./color-scheme.js";
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.atRuleHandlers = void 0;
+const color_js_1 = require("./color.js");
+const container_js_1 = __importDefault(require("./container.js"));
+const color_scheme_js_1 = require("./color-scheme.js");
 // Ordered array ensures execution order
-export const atRuleHandlers = [
-    { name: "each-standard-color", handler: eachStandardColor },
-    { name: "each-fixed-color", handler: eachFixedColor },
-    { name: "light", handler: light },
-    { name: "dark", handler: dark },
-    { name: "xs", handler: container },
-    { name: "sm", handler: container },
-    { name: "md", handler: container },
-    { name: "lg", handler: container },
-    { name: "xl", handler: container },
-    { name: "2xl", handler: container },
+exports.atRuleHandlers = [
+    { name: "each-standard-color", handler: color_js_1.eachStandardColor },
+    { name: "each-fixed-color", handler: color_js_1.eachFixedColor },
+    { name: "light", handler: color_scheme_js_1.light },
+    { name: "dark", handler: color_scheme_js_1.dark },
+    { name: "xs", handler: container_js_1.default },
+    { name: "sm", handler: container_js_1.default },
+    { name: "md", handler: container_js_1.default },
+    { name: "lg", handler: container_js_1.default },
+    { name: "xl", handler: container_js_1.default },
+    { name: "2xl", handler: container_js_1.default },
 ];

package/dist/config.js

@@ -1,5 +1,11 @@
-import fs from 'fs';
-import path from 'path';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
 const DEFAULT_OPTIONS = {
     configPath: 'seyuna.json',
     modeAttribute: 'data-mode',
@@ -9,18 +15,18 @@ const DEFAULT_OPTIONS = {
 };
 let cachedConfig = null;
 let cachedConfigPath = null;
-export function loadConfig(options = {}) {
+function loadConfig(options = {}) {
     const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
     if (mergedOptions.config) {
         return { config: mergedOptions.config, options: mergedOptions };
     }
-    const configPath = path.resolve(process.cwd(), mergedOptions.configPath);
+    const configPath = path_1.default.resolve(process.cwd(), mergedOptions.configPath);
     // Cache config if it's the same path
     if (cachedConfig && cachedConfigPath === configPath) {
         return { config: cachedConfig, options: mergedOptions };
     }
     try {
-        if (!fs.existsSync(configPath)) {
+        if (!fs_1.default.existsSync(configPath)) {
             if (mergedOptions.strict) {
                 throw new Error(`Seyuna config not found at ${configPath}`);
             }
@@ -29,7 +35,7 @@ export function loadConfig(options = {}) {
                 options: mergedOptions,
             };
         }
-        const data = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        const data = JSON.parse(fs_1.default.readFileSync(configPath, 'utf-8'));
         cachedConfig = data;
         cachedConfigPath = configPath;
         return { config: data, options: mergedOptions };

package/dist/errors.js

@@ -1,4 +1,8 @@
-export function reportError(message, node, context, options = {}) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reportError = reportError;
+exports.reportWarning = reportWarning;
+function reportError(message, node, context, options = {}) {
     const { options: pluginOptions } = context;
     const formattedMessage = `[Seyuna PostCSS] ${message}`;
     if (pluginOptions.strict) {
@@ -8,7 +12,7 @@ export function reportError(message, node, context, options = {}) {
         reportWarning(formattedMessage, node);
     }
 }
-export function reportWarning(message, node) {
+function reportWarning(message, node) {
     const result = node.root().toResult();
     node.warn(result, `[Seyuna PostCSS] ${message}`);
 }

package/dist/functions/color.js

@@ -1,12 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sc = sc;
+exports.fc = fc;
+exports.alpha = alpha;
+exports.lighten = lighten;
+exports.darken = darken;
+exports.contrast = contrast;
 /**
  * Resolves a color name to its CSS variables based on its type (standard or fixed)
  */
 function getColorVariables(context, color, type) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
     const { config } = context;
-    const hues = config?.ui?.theme?.hues || {};
-    const colors = config?.ui?.theme?.colors || {};
-    const lightColors = config?.ui?.theme?.light?.colors || {};
-    const darkColors = config?.ui?.theme?.dark?.colors || {};
+    const hues = ((_b = (_a = config === null || config === void 0 ? void 0 : config.ui) === null || _a === void 0 ? void 0 : _a.theme) === null || _b === void 0 ? void 0 : _b.hues) || {};
+    const colors = ((_d = (_c = config === null || config === void 0 ? void 0 : config.ui) === null || _c === void 0 ? void 0 : _c.theme) === null || _d === void 0 ? void 0 : _d.colors) || {};
+    const lightColors = ((_g = (_f = (_e = config === null || config === void 0 ? void 0 : config.ui) === null || _e === void 0 ? void 0 : _e.theme) === null || _f === void 0 ? void 0 : _f.light) === null || _g === void 0 ? void 0 : _g.colors) || {};
+    const darkColors = ((_k = (_j = (_h = config === null || config === void 0 ? void 0 : config.ui) === null || _h === void 0 ? void 0 : _h.theme) === null || _j === void 0 ? void 0 : _j.dark) === null || _k === void 0 ? void 0 : _k.colors) || {};
     const isStandard = color in hues;
     const isFixed = color in colors || color in lightColors || color in darkColors;
     if (type === 'sc' && !isStandard) {
@@ -31,33 +40,33 @@ function getColorVariables(context, color, type) {
     }
     throw new Error(`Color '${color}' not found in seyuna.json`);
 }
-export function sc(context, name, alpha, lightness, chroma) {
+function sc(context, name, alpha, lightness, chroma) {
     const vars = getColorVariables(context, name, 'sc');
     const a = alpha && alpha !== "null" ? alpha : "1";
     const l = lightness && lightness !== "null" ? lightness : vars.l;
     const c = chroma && chroma !== "null" ? chroma : vars.c;
     return `oklch(${l} ${c} ${vars.h} / ${a})`;
 }
-export function fc(context, name, alpha, lightness, chroma) {
+function fc(context, name, alpha, lightness, chroma) {
     const vars = getColorVariables(context, name, 'fc');
     const a = alpha && alpha !== "null" ? alpha : "1";
     const l = lightness && lightness !== "null" ? lightness : vars.l;
     const c = chroma && chroma !== "null" ? chroma : vars.c;
     return `oklch(${l} ${c} ${vars.h} / ${a})`;
 }
-export function alpha(context, color, value) {
+function alpha(context, color, value) {
     const { l, c, h } = getColorVariables(context, color);
     return `oklch(${l} ${c} ${h} / ${value})`;
 }
-export function lighten(context, color, amount) {
+function lighten(context, color, amount) {
     const { l, c, h } = getColorVariables(context, color);
     return `oklch(calc(${l} + ${amount}) ${c} ${h} / 1)`;
 }
-export function darken(context, color, amount) {
+function darken(context, color, amount) {
     const { l, c, h } = getColorVariables(context, color);
     return `oklch(calc(${l} - ${amount}) ${c} ${h} / 1)`;
 }
-export function contrast(context, color) {
+function contrast(context, color) {
     const { l } = getColorVariables(context, color);
     return `oklch(calc((${l} - 0.6) * -1000) 0 0)`;
 }

package/dist/functions/index.js

@@ -1,11 +1,14 @@
-import { sc, fc, alpha, lighten, darken, contrast } from "./color.js";
-import { theme } from "./theme.js";
-export const functions = {
-    sc,
-    fc,
-    alpha,
-    lighten,
-    darken,
-    contrast,
-    theme,
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.functions = void 0;
+const color_js_1 = require("./color.js");
+const theme_js_1 = require("./theme.js");
+exports.functions = {
+    sc: color_js_1.sc,
+    fc: color_js_1.fc,
+    alpha: color_js_1.alpha,
+    lighten: color_js_1.lighten,
+    darken: color_js_1.darken,
+    contrast: color_js_1.contrast,
+    theme: theme_js_1.theme,
 };

package/dist/functions/theme.js

@@ -1,8 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.theme = theme;
 /**
  * Accesses values from the Seyuna configuration using dot notation
  * Example: theme(ui.theme.breakpoints.tablet)
  */
-export function theme(context, path) {
+function theme(context, path) {
     const parts = path.split('.');
     let current = context.config;
     for (const part of parts) {

package/dist/helpers.d.ts

@@ -1,4 +1,5 @@
-import { Rule, ChildNode, AtRule } from "postcss";
+import postcss from "postcss";
+import type { ChildNode, AtRule } from "postcss";
 import { PluginContext } from './types.js';
 /**
  * Helper: clone nodes and replace {name} placeholders safely
@@ -8,4 +9,4 @@ export declare function cloneNodes(nodes: ChildNode[], name: string, context: Pl
 /**
  * Generate CSS rules from a list of names
  */
-export declare function generateRules(names: string[], atRule: AtRule, context: PluginContext): Rule[];
+export declare function generateRules(names: string[], atRule: AtRule, context: PluginContext): postcss.Rule[];

package/dist/helpers.js

@@ -1,10 +1,17 @@
-import { Rule } from "postcss";
-import { processFunctions } from "./parser.js";
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cloneNodes = cloneNodes;
+exports.generateRules = generateRules;
+const postcss_1 = __importDefault(require("postcss"));
+const parser_js_1 = require("./parser.js");
 /**
  * Helper: clone nodes and replace {name} placeholders safely
  * Returns only valid Rules or Declarations (never raw AtRules)
  */
-export function cloneNodes(nodes, name, context) {
+function cloneNodes(nodes, name, context) {
     const { functions: fnMap } = context;
     return nodes.flatMap((node) => {
         const cloned = node.clone();
@@ -12,7 +19,7 @@ export function cloneNodes(nodes, name, context) {
             const decl = cloned;
             let value = decl.value.replace(/\{name\}/g, name);
             // Process functions using the robust parser
-            decl.value = processFunctions(value, fnMap, decl, context);
+            decl.value = (0, parser_js_1.processFunctions)(value, fnMap, decl, context);
             return decl;
         }
         if (cloned.type === "rule") {
@@ -33,16 +40,18 @@ export function cloneNodes(nodes, name, context) {
 /**
  * Generate CSS rules from a list of names
  */
-export function generateRules(names, atRule, context) {
-    const nodes = atRule.nodes ?? [];
+function generateRules(names, atRule, context) {
+    var _a;
+    const nodes = (_a = atRule.nodes) !== null && _a !== void 0 ? _a : [];
     const generatedRules = [];
     for (const name of names) {
-        const rule = new Rule({
+        const rule = new postcss_1.default.Rule({
             selector: `&.${name}`,
             source: atRule.source,
         });
         cloneNodes(nodes, name, context).forEach((n) => {
-            if (n.type === "rule" && n.selector && n.nodes?.length)
+            var _a;
+            if (n.type === "rule" && n.selector && ((_a = n.nodes) === null || _a === void 0 ? void 0 : _a.length))
                 rule.append(n);
             if (n.type === "decl")
                 rule.append(n);

package/dist/index.js

@@ -1,8 +1,10 @@
-import { dynamicFunctionsPlugin } from './plugin.js';
-import { functions } from './functions/index.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const plugin_js_1 = require("./plugin.js");
+const index_js_1 = require("./functions/index.js");
 // CommonJS-friendly export
-const plugin = Object.assign(dynamicFunctionsPlugin, {
+const plugin = Object.assign(plugin_js_1.dynamicFunctionsPlugin, {
     postcss: true,
-    functions
+    functions: index_js_1.functions
 });
-export default plugin;
+exports.default = plugin;

package/dist/parser.js

@@ -1,7 +1,13 @@
-import valueParser from 'postcss-value-parser';
-import { reportError } from './errors.js';
-export function processFunctions(value, fnMap, node, context) {
-    const parsed = valueParser(value);
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processFunctions = processFunctions;
+const postcss_value_parser_1 = __importDefault(require("postcss-value-parser"));
+const errors_js_1 = require("./errors.js");
+function processFunctions(value, fnMap, node, context) {
+    const parsed = (0, postcss_value_parser_1.default)(value);
     // Helper to process nodes recursively (inner-first)
     function processNode(parsedValue) {
         parsedValue.walk((nodeIter) => {
@@ -31,7 +37,7 @@ export function processFunctions(value, fnMap, node, context) {
                                 currentArg = '';
                             }
                             else {
-                                currentArg += valueParser.stringify(argNode);
+                                currentArg += postcss_value_parser_1.default.stringify(argNode);
                             }
                         });
                         if (currentArg) {
@@ -46,7 +52,7 @@ export function processFunctions(value, fnMap, node, context) {
                             nodeIter.nodes = []; // Clear children
                         }
                         catch (error) {
-                            reportError(`Failed to process function "${nodeIter.value}": ${error instanceof Error ? error.message : String(error)}`, node, context);
+                            (0, errors_js_1.reportError)(`Failed to process function "${nodeIter.value}": ${error instanceof Error ? error.message : String(error)}`, node, context);
                         }
                     }
                 }

package/dist/plugin.d.ts

@@ -1,3 +1,3 @@
-import { PluginCreator } from "postcss";
+import type { PluginCreator } from "postcss";
 import { PluginOptions } from "./types.js";
 export declare const dynamicFunctionsPlugin: PluginCreator<PluginOptions>;

package/dist/plugin.js

@@ -1,24 +1,35 @@
-import { functions } from "./functions/index.js";
-import { atRuleHandlers } from "./at-rules/index.js";
-import { loadConfig } from "./config.js";
-import { processFunctions } from "./parser.js";
-export const dynamicFunctionsPlugin = (opts = {}) => {
-    const { config, options } = loadConfig(opts);
-    const fnMap = { ...functions, ...opts.functions };
-    const context = {
-        config,
-        options,
-        functions: fnMap,
-    };
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dynamicFunctionsPlugin = void 0;
+const index_js_1 = require("./functions/index.js");
+const index_js_2 = require("./at-rules/index.js");
+const config_js_1 = require("./config.js");
+const parser_js_1 = require("./parser.js");
+const dynamicFunctionsPlugin = (opts = {}) => {
+    let context;
+    let fnMap;
     return {
         postcssPlugin: "postcss-dynamic-functions",
+        Once() {
+            const { config, options } = (0, config_js_1.loadConfig)(opts);
+            fnMap = { ...index_js_1.functions, ...opts.functions };
+            context = {
+                config,
+                options,
+                functions: fnMap,
+            };
+        },
         Declaration(decl) {
-            decl.value = processFunctions(decl.value, fnMap, decl, context);
+            if (!context || !fnMap)
+                return;
+            decl.value = (0, parser_js_1.processFunctions)(decl.value, fnMap, decl, context);
         },
         // Override AtRule handler to ensure ordered execution
         AtRule(atRule) {
+            if (!context)
+                return;
             // Iterate over handlers in order (array) instead of object spread
-            for (const { name, handler } of atRuleHandlers) {
+            for (const { name, handler } of index_js_2.atRuleHandlers) {
                 if (atRule.name === name) {
                     handler(atRule, context);
                 }
@@ -26,4 +37,5 @@ export const dynamicFunctionsPlugin = (opts = {}) => {
         },
     };
 };
-dynamicFunctionsPlugin.postcss = true;
+exports.dynamicFunctionsPlugin = dynamicFunctionsPlugin;
+exports.dynamicFunctionsPlugin.postcss = true;

package/dist/types.js

@@ -1,3 +1,4 @@
+"use strict";
 // Local type definitions to avoid @seyuna/cli runtime import
 // The @seyuna/cli package imports Deno polyfills that conflict with Vite/Astro
-export {};
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,8 +1,7 @@
 {
   "name": "@seyuna/postcss",
-  "version": "1.0.0-canary.20",
+  "version": "1.0.0-canary.21",
   "description": "Seyuna UI's postcss plugin",
-  "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {

package/src/at-rules/color-scheme.ts

@@ -1,4 +1,5 @@
-import { Rule, AtRule, ChildNode } from "postcss";
+import postcss from "postcss";
+import type { AtRule, ChildNode } from "postcss";
 import { PluginContext } from "../types.js";
 
 /**
@@ -18,7 +19,7 @@ function createColorSchemeHandler(scheme: 'light' | 'dark') {
     /**
      * Rule 1: [data-mode="scheme"] & { ... } (Explicit mode)
      */
-    const explicitRule = new Rule({
+    const explicitRule = new postcss.Rule({
       selector: `[${modeAttribute}="${scheme}"] &`,
       source: atRule.source,
     });
@@ -27,13 +28,13 @@ function createColorSchemeHandler(scheme: 'light' | 'dark') {
     /**
      * Rule 2: @media (prefers-color-scheme: scheme) { [data-mode="system"] & { ... } } (System preference)
      */
-    const mediaAtRule = new AtRule({
+    const mediaAtRule = new postcss.AtRule({
       name: "media",
       params: `(prefers-color-scheme: ${scheme})`,
       source: atRule.source,
     });
 
-    const systemRule = new Rule({
+    const systemRule = new postcss.Rule({
       selector: `[${modeAttribute}="system"] &`,
       source: atRule.source,
     });

package/src/at-rules/color.ts

@@ -1,4 +1,4 @@
-import { AtRule } from "postcss";
+import type { AtRule } from "postcss";
 import { PluginContext } from "../types.js";
 import { generateRules } from "../helpers.js";
 

package/src/at-rules/container.ts

@@ -1,4 +1,5 @@
-import { AtRule, ChildNode } from "postcss";
+import postcss from "postcss";
+import type { AtRule, ChildNode } from "postcss";
 import { PluginContext } from "../types.js";
 
 /**
@@ -44,7 +45,7 @@ export default function container(atRule: AtRule, context: PluginContext) {
       clonedNodes.push(node.clone());
     });
 
-    const containerAtRule = new AtRule({
+    const containerAtRule = new postcss.AtRule({
       name: "container",
       params: `(min-width: ${minWidth})`,
       source: atRule.source,

package/src/at-rules/index.ts

@@ -1,4 +1,4 @@
-import { AtRule } from "postcss";
+import type { AtRule } from "postcss";
 import { eachStandardColor, eachFixedColor } from "./color.js";
 import container from "./container.js";
 import { light, dark } from "./color-scheme.js";

package/src/helpers.ts

@@ -1,4 +1,5 @@
-import { Rule, ChildNode, Declaration, AtRule } from "postcss";
+import postcss from "postcss";
+import type { ChildNode, Declaration, AtRule } from "postcss";
 import { processFunctions } from "./parser.js";
 import { PluginContext } from './types.js';
 
@@ -27,7 +28,7 @@ export function cloneNodes(
     }
 
     if (cloned.type === "rule") {
-      const rule = cloned as Rule;
+      const rule = cloned as postcss.Rule;
       if (!rule.selector) return [];
 
       rule.selector = rule.selector.replace(/\{name\}/g, name);
@@ -53,17 +54,17 @@ export function generateRules(
   names: string[],
   atRule: AtRule,
   context: PluginContext
-): Rule[] {
+): postcss.Rule[] {
   const nodes = atRule.nodes ?? [];
-  const generatedRules: Rule[] = [];
+  const generatedRules: postcss.Rule[] = [];
 
   for (const name of names) {
-    const rule = new Rule({
+    const rule = new postcss.Rule({
       selector: `&.${name}`,
       source: atRule.source,
     });
     cloneNodes(nodes, name, context).forEach((n) => {
-      if (n.type === "rule" && n.selector && n.nodes?.length) rule.append(n);
+      if (n.type === "rule" && n.selector && (n as postcss.Rule).nodes?.length) rule.append(n);
       if (n.type === "decl") rule.append(n);
     });
 

package/src/plugin.ts

@@ -1,4 +1,4 @@
-import { PluginCreator } from "postcss";
+import type { PluginCreator } from "postcss";
 import { functions } from "./functions/index.js";
 import { atRuleHandlers } from "./at-rules/index.js";
 import { loadConfig } from "./config.js";
@@ -8,23 +8,30 @@ import { processFunctions } from "./parser.js";
 export const dynamicFunctionsPlugin: PluginCreator<PluginOptions> = (
   opts = {}
 ) => {
-  const { config, options } = loadConfig(opts);
-  const fnMap: FunctionMap = { ...functions, ...opts.functions };
-  const context: PluginContext = {
-    config,
-    options,
-    functions: fnMap,
-  };
+  let context: PluginContext | undefined;
+  let fnMap: FunctionMap | undefined;
 
   return {
     postcssPlugin: "postcss-dynamic-functions",
 
+    Once() {
+      const { config, options } = loadConfig(opts);
+      fnMap = { ...functions, ...opts.functions };
+      context = {
+        config,
+        options,
+        functions: fnMap,
+      };
+    },
+
     Declaration(decl) {
+      if (!context || !fnMap) return;
       decl.value = processFunctions(decl.value, fnMap, decl, context);
     },
 
     // Override AtRule handler to ensure ordered execution
     AtRule(atRule) {
+      if (!context) return;
       // Iterate over handlers in order (array) instead of object spread
       for (const { name, handler } of atRuleHandlers) {
         if (atRule.name === name) {

package/tsconfig.json

@@ -1,12 +1,12 @@
 {
   "compilerOptions": {
-    "target": "ES2020",
-    "module": "NodeNext",
+    "target": "ES2019",
+    "module": "CommonJS",
     "lib": ["ES2020"],
     "declaration": true,
     "outDir": "dist",
     "strict": true,
-    "moduleResolution": "NodeNext",
+    "moduleResolution": "Node",
     "esModuleInterop": true,
     "skipLibCheck": true
   },