@salty-css/core 0.1.0-alpha.3 → 0.1.0-alpha.31

package/parsers/index.js

@@ -1,10 +1,42 @@
-import { p as parseAndJoinStyles } from "../parse-styles-BTIoYnBr.js";
-import { a, c, d, b } from "../parse-styles-BTIoYnBr.js";
+import { i as isRichTemplateNode, p as parseAndJoinStyles } from "../parse-styles-BBJ3PWyV.js";
+import { a, d, e, c, r } from "../parse-styles-BBJ3PWyV.js";
 import { d as dashCase } from "../dash-case-DblXvymC.js";
 import { t as toHash } from "../to-hash-DAN2LcHK.js";
+const RICH_META_KEYS = /* @__PURE__ */ new Set(["base", "variants", "defaultVariants", "compoundVariants", "anyOfVariants"]);
+const isChildEntry = (key, value) => {
+  if (RICH_META_KEYS.has(key)) return false;
+  return !!value && typeof value === "object" && !Array.isArray(value);
+};
 const parseTemplates = async (obj, path = []) => {
   if (!obj) return "";
   const classes = [];
+  if (isRichTemplateNode(obj)) {
+    const rich = obj;
+    const baseClassName = path.map((p) => dashCase(String(p))).join("-");
+    if (rich.base) {
+      const hashClass = "t_" + toHash(baseClassName, 4);
+      const result = await parseAndJoinStyles(rich.base, `.${baseClassName}, .${hashClass}`);
+      classes.push(result);
+    }
+    if (rich.variants) {
+      for (const [axis, valueMap] of Object.entries(rich.variants)) {
+        if (!valueMap || typeof valueMap !== "object") continue;
+        for (const [value, styles] of Object.entries(valueMap)) {
+          if (!styles || typeof styles !== "object") continue;
+          const variantClassName = `${baseClassName}-${dashCase(axis)}-${dashCase(value)}`;
+          const variantHashClass = "tv_" + toHash(variantClassName, 4);
+          const result = await parseAndJoinStyles(styles, `.${variantClassName}, .${variantHashClass}`);
+          classes.push(result);
+        }
+      }
+    }
+    for (const [key, value] of Object.entries(rich)) {
+      if (!isChildEntry(key, value)) continue;
+      const result = await parseTemplates(value, [...path, key.trim()]);
+      classes.push(result);
+    }
+    return classes.join("\n");
+  }
   const levelStyles = {};
   for (const [key, value] of Object.entries(obj)) {
     if (typeof value === "function") ;
@@ -17,7 +49,7 @@ const parseTemplates = async (obj, path = []) => {
     }
   }
   if (Object.keys(levelStyles).length) {
-    const className = path.map(dashCase).join("-");
+    const className = path.map((p) => dashCase(String(p))).join("-");
     const hashClass = "t_" + toHash(className, 4);
     const result = await parseAndJoinStyles(levelStyles, `.${className}, .${hashClass}`);
     classes.push(result);
@@ -39,21 +71,79 @@ const getTemplateTypes = (templates) => {
 };
 const getTemplateTokens = (templates, parent = "", templateTokens = /* @__PURE__ */ new Set()) => {
   if (!templates) return [];
+  if (isRichTemplateNode(templates)) {
+    if (parent) templateTokens.add(parent);
+    Object.entries(templates).forEach(([key, value]) => {
+      if (!isChildEntry(key, value)) return;
+      const keyValue = parent ? `${parent}.${key}` : key;
+      getTemplateTokens(value, keyValue, templateTokens);
+    });
+    return [...templateTokens];
+  }
   Object.entries(templates).forEach(([key, value]) => {
     const keyValue = parent ? `${parent}.${key}` : key;
-    if (typeof value === "object") return getTemplateTokens(value, keyValue, templateTokens);
+    if (value && typeof value === "object") return getTemplateTokens(value, keyValue, templateTokens);
     return templateTokens.add(parent);
   });
   return [...templateTokens];
 };
+const getTemplateVariantMaps = (templates) => {
+  const result = {};
+  if (!templates) return result;
+  for (const [topKey, topNode] of Object.entries(templates)) {
+    if (!topNode || typeof topNode !== "object" || typeof topNode === "function") continue;
+    walk(topNode, [], result[topKey] || (result[topKey] = {}), {});
+  }
+  return result;
+};
+const mergeAxes = (inherited, node) => {
+  const next = {};
+  for (const [axis, vals] of Object.entries(inherited)) {
+    next[axis] = { ...vals };
+  }
+  if (isRichTemplateNode(node) && node.variants) {
+    for (const [axis, valueMap] of Object.entries(node.variants)) {
+      next[axis] = next[axis] || {};
+      for (const value of Object.keys(valueMap)) next[axis][value] = true;
+    }
+  }
+  return next;
+};
+const walk = (node, path, out, inheritedAxes) => {
+  if (!node || typeof node !== "object" || Array.isArray(node)) return;
+  const axes = mergeAxes(inheritedAxes, node);
+  const dot = path.join(".");
+  if (path.length && (isRichTemplateNode(node) || Object.keys(axes).length)) {
+    const axisMap = {};
+    for (const [axis, valSet] of Object.entries(axes)) {
+      const values = Object.keys(valSet);
+      const isBooleanOnly = values.length === 1 && values[0] === "true";
+      axisMap[axis] = isBooleanOnly ? "boolean" : values.map((v) => `"${v}"`).join(" | ");
+    }
+    if (Object.keys(axisMap).length) out[dot] = axisMap;
+  }
+  if (isRichTemplateNode(node)) {
+    for (const [key, value] of Object.entries(node)) {
+      if (!isChildEntry(key, value)) continue;
+      walk(value, [...path, key.trim()], out, axes);
+    }
+    return;
+  }
+  for (const [key, value] of Object.entries(node)) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+    walk(value, [...path, key.trim()], out, axes);
+  }
+};
 export {
   getTemplateKeys,
   getTemplateTokens,
   getTemplateTypes,
+  getTemplateVariantMaps,
   parseAndJoinStyles,
   a as parseStyles,
   parseTemplates,
-  c as parseValueModifiers,
-  d as parseValueTokens,
-  b as parseVariableTokens
+  d as parseValueModifiers,
+  e as parseValueTokens,
+  c as parseVariableTokens,
+  r as reportParserIssue
 };

package/parsers/parse-templates.d.ts

@@ -2,3 +2,13 @@ export declare const parseTemplates: <T extends object>(obj: T, path?: PropertyK
 export declare const getTemplateKeys: <T extends object>(templates: T) => string[];
 export declare const getTemplateTypes: <T extends object>(templates: T) => Record<string, string>;
 export declare const getTemplateTokens: <T extends object>(templates: T, parent?: string, templateTokens?: Set<string>) => string[];
+/**
+ * Walk every rich-template path in a templates root and emit, for each reachable dot-path, the set of
+ * variant axes valid at that path (axis name → union of value names, with `boolean` for axes whose only
+ * declared value is `true`).
+ *
+ * Inheritance: a leaf's axis enum is the union of its own values and every ancestor's values for the
+ * same axis. Matches the resolver's bottom-up lookup semantics — anything reachable via fallback is a
+ * valid call-site value.
+ */
+export declare const getTemplateVariantMaps: (templates: Record<string, any>) => Record<string, Record<string, Record<string, string>>>;

package/parsers/parser-regexes.d.ts

@@ -0,0 +1,3 @@
+export declare const pseudoTypoRegex: RegExp;
+export declare const templateLiteralLeftoverRegex: RegExp;
+export declare const bareAtRuleRegex: RegExp;

package/parsers/resolve-template-variants.d.ts

@@ -0,0 +1,21 @@
+import { RichTemplateNode } from '../types/config-types';
+export type TemplateCallSite = {
+    path: string[];
+    variants: Record<string, string | boolean>;
+};
+export declare const isRichTemplateNode: (node: unknown) => node is RichTemplateNode;
+/**
+ * Parse a template call-site value into its dot-path and the axis values requested at the call site.
+ *
+ * String form:  `'heading.large@weight=heavy&emphasis=loud&italic'`
+ * Object form:  `{ name: 'heading.large', weight: 'heavy', emphasis: 'loud', italic: true }`
+ */
+export declare const parseTemplateCallSite: (value: unknown) => TemplateCallSite | undefined;
+export declare const pathHasRichNode: (root: any, path: string[]) => boolean;
+/**
+ * Resolve a rich-template invocation into a flat CSS-in-JS object.
+ * Implements docs/template-variants-spec.md §5 (parent-to-leaf inheritance, replace semantics).
+ *
+ * Returns `undefined` if the path doesn't resolve. Emits console.warn for unknown axes / values.
+ */
+export declare const resolveRichTemplate: (root: any, path: string[], callSiteVariants: Record<string, string | boolean>, templateName: string) => Record<string, any> | undefined;

package/parsers/strict.d.ts

@@ -0,0 +1,2 @@
+export type StrictMode = boolean | 'warn' | undefined;
+export declare const reportParserIssue: (strict: StrictMode, message: string) => void;

package/runtime/index.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const parseStyles = require("../parse-styles-CA3TP5n1.cjs");
+const parseStyles = require("../parse-styles-lOMGe_c5.cjs");
 const defineRuntime = (config) => {
   const getDynamicStylesCss = async (styles, scope) => {
     const parsed = await parseStyles.parseStyles(styles, scope, config);

package/runtime/index.js

@@ -1,4 +1,4 @@
-import { a as parseStyles } from "../parse-styles-BTIoYnBr.js";
+import { a as parseStyles } from "../parse-styles-BBJ3PWyV.js";
 const defineRuntime = (config) => {
   const getDynamicStylesCss = async (styles, scope) => {
     const parsed = await parseStyles(styles, scope, config);

package/{salty.config-cqavVm2t.cjs → salty.config-DogY_sSQ.cjs}

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const salty_config = "import { defineConfig } from '@salty-css/core/config';\n\nexport const config = defineConfig({\n  // Add your custom config here\n  externalModules: ['react', 'react-dom']\n});\n";
+const salty_config = "import { defineConfig } from '@salty-css/core/config';\n\nexport const config = defineConfig({\n  strict: true,\n  externalModules: ['react', 'react-dom']\n});\n";
 exports.default = salty_config;

package/salty.config-GV37Q-D2.js

@@ -0,0 +1,4 @@
+const salty_config = "import { defineConfig } from '@salty-css/core/config';\n\nexport const config = defineConfig({\n  strict: true,\n  externalModules: ['react', 'react-dom']\n});\n";
+export {
+  salty_config as default
+};

package/styled-file-BzmB9_Ez.cjs

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const styledFile = `import { styled } from "@salty-css/astro/styled";
+
+export const <%- name %> = styled('<%- tag %>', {
+  <% if(className) { %>className: '<%- className %>',<% } %>
+  base: {
+    // Add your styles here
+  }
+})
+`;
+exports.default = styledFile;

package/{react-styled-file-U02jek-B.cjs → styled-file-CPd_rTW2.cjs}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const reactStyledFile = `import { styled } from "@salty-css/react/styled";
+const styledFile = `import { styled } from "@salty-css/react/styled";
 
 export const <%- name %> = styled('<%- tag %>', {
   <% if(className) { %>className: '<%- className %>',<% } %>
@@ -8,4 +8,4 @@ export const <%- name %> = styled('<%- tag %>', {
     // Add your styles here
   }
 })`;
-exports.default = reactStyledFile;
+exports.default = styledFile;

package/{react-styled-file-B99mwk0w.js → styled-file-Cda3EeR6.js}

@@ -1,4 +1,4 @@
-const reactStyledFile = `import { styled } from "@salty-css/react/styled";
+const styledFile = `import { styled } from "@salty-css/react/styled";
 
 export const <%- name %> = styled('<%- tag %>', {
   <% if(className) { %>className: '<%- className %>',<% } %>
@@ -7,5 +7,5 @@ export const <%- name %> = styled('<%- tag %>', {
   }
 })`;
 export {
-  reactStyledFile as default
+  styledFile as default
 };

package/styled-file-DLcgYmGN.js

@@ -0,0 +1,12 @@
+const styledFile = `import { styled } from "@salty-css/astro/styled";
+
+export const <%- name %> = styled('<%- tag %>', {
+  <% if(className) { %>className: '<%- className %>',<% } %>
+  base: {
+    // Add your styles here
+  }
+})
+`;
+export {
+  styledFile as default
+};

package/types/config-types.d.ts

@@ -1,5 +1,6 @@
 import { BaseStyles, CssStyles, MediaQueryStyles } from '../types';
 import { OrString } from '../types/util-types';
+export * from './font-types';
 export type GlobalStyles = Record<string, BaseStyles>;
 export type CssVariableTokensObject = Record<string, unknown>;
 export interface CssResponsiveVariables {
@@ -15,7 +16,38 @@ export interface SaltyVariables {
     conditional?: CssConditionalVariables;
     [key: string]: undefined | string | number | CssVariableTokensObject;
 }
-type CssTemplate = MediaQueryStyles | CssStyles | {
+/**
+ * A variant axis value bundle: a map from axis name to a map from value name (string keys or `'true'`)
+ * to a CSS-in-JS block. `name` is reserved as the call-site object form's path key and cannot be used
+ * as an axis name (build-time error).
+ */
+export type CssVariantAxes = {
+    [axis: string]: {
+        [value: string]: CssStyles;
+    };
+} & {
+    name?: never;
+};
+export interface CssCompoundVariant {
+    css: CssStyles;
+    [axis: string]: any;
+}
+/**
+ * A "rich" template node: declares its own base styles, named variant bundles, defaults, and compound rules.
+ * May coexist with child template nodes (descendants) as additional sibling keys.
+ */
+export type RichTemplateNode = {
+    base?: CssStyles;
+    variants?: CssVariantAxes;
+    defaultVariants?: {
+        [axis: string]: string | boolean;
+    };
+    compoundVariants?: CssCompoundVariant[];
+    anyOfVariants?: CssCompoundVariant[];
+} & {
+    [key: PropertyKey]: any;
+};
+type CssTemplate = MediaQueryStyles | CssStyles | RichTemplateNode | {
     [key: PropertyKey]: CssTemplate;
 };
 export interface CssTemplateObject {
@@ -68,6 +100,14 @@ export interface SaltyConfig {
      * Define modules that should not be bundled when generating the css file. This improves the performance of the css generation and can help with issues relared to external packages being imported in an environment that does not support them.
      */
     externalModules?: ('react' | 'react-dom' | OrString)[];
+    /**
+     * Controls how the parser reacts to suspicious or malformed input
+     * (typos, invalid value types, malformed selectors, etc.).
+     * - `true` — throw on issues (recommended for new projects)
+     * - `'warn'` — log a warning and continue
+     * - `false` / undefined — silent, behave like prior versions
+     */
+    strict?: boolean | 'warn';
     /**
      * default unit for px based properties when providing a number value. Default is 'px'.
      */
@@ -78,8 +118,8 @@ export interface CachedConfig {
     staticVariables: Record<string, any>;
     mediaQueries: Record<string, string>;
     modifiers?: CssModifiers;
+    strict?: boolean | 'warn';
     templatePaths: {
         [key: string]: string;
     };
 }
-export {};

package/types/font-types.d.ts

@@ -0,0 +1,53 @@
+export type FontDisplay = 'auto' | 'block' | 'swap' | 'fallback' | 'optional';
+export type FontFormat = 'woff2' | 'woff' | 'truetype' | 'opentype' | 'embedded-opentype' | 'svg' | 'collection';
+export type FontStyle = 'normal' | 'italic' | 'oblique' | (string & {});
+export type FontWeight = number | 'normal' | 'bold' | 'lighter' | 'bolder' | (string & {});
+export interface FontSrc {
+    url: string;
+    format?: FontFormat;
+    /** Optional `tech(...)` descriptor passed straight through to @font-face. */
+    tech?: string;
+}
+export interface FontVariant {
+    weight?: FontWeight;
+    style?: FontStyle;
+    stretch?: string;
+    display?: FontDisplay;
+    unicodeRange?: string;
+    ascentOverride?: string;
+    descentOverride?: string;
+    lineGapOverride?: string;
+    sizeAdjust?: string;
+    /**
+     * One or more font sources. Strings are treated as URLs and the `format()`
+     * descriptor is auto-detected from the file extension when possible. Use
+     * the `{ url, format }` object form for CDN/extensionless URLs where the
+     * format must be set explicitly.
+     */
+    src: string | FontSrc | (string | FontSrc)[];
+}
+interface DefineFontBase {
+    /** CSS `font-family` value users will see in styles. */
+    name: string;
+    /**
+     * CSS variable name. Accepts `--font-inter` or `font-inter`; we normalize.
+     * Optional — when omitted, a deterministic name is derived from the other
+     * inputs as `--font-<name>-<hash>`.
+     */
+    variable?: string;
+    /** Default `font-display` applied to variants that don't set their own. */
+    display?: FontDisplay;
+    /** Family fallback(s) appended after `name` in the generated `font-family` string. */
+    fallback?: string;
+}
+export interface DefineFontVariantsOptions extends DefineFontBase {
+    variants: FontVariant[];
+    import?: never;
+}
+export interface DefineFontImportOptions extends DefineFontBase {
+    /** Remote stylesheet URL (e.g. Google Fonts). Emitted as `@import url(...)`. */
+    import: string;
+    variants?: never;
+}
+export type DefineFontOptions = DefineFontVariantsOptions | DefineFontImportOptions;
+export {};

package/{react-vanilla-file-D9px70iK.js → vanilla-file-1kOqbCIM.js}

@@ -1,4 +1,4 @@
-const reactVanillaFile = `import { <%- styledComponentName %> } from "./<%- fileName %>.css";
+const vanillaFile = `import { <%- styledComponentName %> } from "./<%- fileName %>.css";
 
 interface <%- componentName %>Props {
   text?: string;
@@ -14,5 +14,5 @@ export const <%- componentName %> = ({ text = 'Lorem ipsum' }: <%- componentName
 
 export default <%- componentName %>;`;
 export {
-  reactVanillaFile as default
+  vanillaFile as default
 };

package/{react-vanilla-file-Bj6XC8GS.cjs → vanilla-file-r0fp2q_m.cjs}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const reactVanillaFile = `import { <%- styledComponentName %> } from "./<%- fileName %>.css";
+const vanillaFile = `import { <%- styledComponentName %> } from "./<%- fileName %>.css";
 
 interface <%- componentName %>Props {
   text?: string;
@@ -15,4 +15,4 @@ export const <%- componentName %> = ({ text = 'Lorem ipsum' }: <%- componentName
 };
 
 export default <%- componentName %>;`;
-exports.default = reactVanillaFile;
+exports.default = vanillaFile;

package/parse-styles-BTIoYnBr.js

@@ -1,232 +0,0 @@
-import { d as dashCase } from "./dash-case-DblXvymC.js";
-import { d as defineViewportClamp } from "./viewport-clamp-K553uXu3.js";
-const parseValueModifiers = (modifiers) => (value) => {
-  if (typeof value !== "string") return void 0;
-  if (!modifiers) return void 0;
-  let transformed = value;
-  const additionalCss = [];
-  Object.values(modifiers).forEach((modifier) => {
-    const { pattern, transform } = modifier;
-    transformed = transformed.replace(pattern, (match) => {
-      const { value: _value, css } = transform(match);
-      if (css) additionalCss.push(css);
-      return _value;
-    });
-  });
-  return { transformed, additionalCss };
-};
-const parseValueTokens = (tokenNames) => (value) => {
-  if (typeof value !== "string") return void 0;
-  const hasToken = /\{[^{}]+\}/g.test(value);
-  if (!hasToken) return void 0;
-  const transformed = value.replace(/\{([^{}]+)\}/g, (...args) => {
-    const variable = dashCase(args[1].replaceAll(".", "-"));
-    if (tokenNames && !tokenNames.includes(variable)) console.warn(`Token ${variable} might not exist`);
-    if (variable.startsWith("-")) return `-${variable}`;
-    return `var(--${variable})`;
-  });
-  return { transformed };
-};
-const parseVariableTokens = parseValueTokens();
-const pxProperties = [
-  "top",
-  "right",
-  "bottom",
-  "left",
-  "min-width",
-  /.*width.*/,
-  /^[^line]*height.*/,
-  // Exclude line-height
-  /padding.*/,
-  /margin.*/,
-  /border.*/,
-  /inset.*/,
-  /.*radius.*/,
-  /.*spacing.*/,
-  /.*gap.*/,
-  /.*indent.*/,
-  /.*offset.*/,
-  /.*size.*/,
-  /.*thickness.*/,
-  /.*font-size.*/
-];
-const addUnit = (key, value, config) => {
-  const isPxProperty = pxProperties.some((pxProperty) => {
-    return typeof pxProperty === "string" ? pxProperty === key : pxProperty.test(key);
-  });
-  if (isPxProperty) {
-    const unit = (config == null ? void 0 : config.defaultUnit) || "px";
-    const isClamp = unit.startsWith("viewport-clamp:");
-    if (isClamp) {
-      try {
-        const screenSize = unit.split(":")[1];
-        const viewportClamp = defineViewportClamp({
-          screenSize: parseInt(screenSize)
-        });
-        return viewportClamp(Number(value));
-      } catch (error) {
-        console.error(error);
-        throw new Error(`Invalid viewport-clamp value: ${unit}`);
-      }
-    }
-    return `${value}${unit}`;
-  }
-  return `${value}`;
-};
-const vendorPrefixes = ["Webkit", "Moz", "ms", "O"];
-const propertyNameCheck = (key) => {
-  if (key.startsWith("-")) return key;
-  if (vendorPrefixes.some((prefix) => key.startsWith(prefix))) return `-${dashCase(key)}`;
-  return dashCase(key);
-};
-const parseStyles = async (styles, currentScope = "", config, omitTemplates = false) => {
-  if (!styles) throw new Error("No styles provided to parseStyles function!");
-  const cssStyles = /* @__PURE__ */ new Set();
-  const entries = Object.entries(styles);
-  const processStyleEntry = async ([key, value]) => {
-    var _a, _b;
-    const _key = key.trim().replace(/^\?+/g, "");
-    const propertyName = propertyNameCheck(_key);
-    const toString = (val, eol = ";") => `${propertyName}:${val}${eol}`;
-    const context = { scope: currentScope, config };
-    if (typeof value === "function") return processStyleEntry([key, value(context)]);
-    if (value instanceof Promise) return processStyleEntry([key, await value]);
-    if ((config == null ? void 0 : config.templates) && ((_a = config.templatePaths) == null ? void 0 : _a[_key])) {
-      try {
-        const [name, path] = config.templatePaths[_key].split(";;");
-        const functions = await import(
-          /* webpackIgnore: true */
-          /* @vite-ignore */
-          path
-        );
-        const isSaltyConfig = path.includes("salty.config");
-        const values = isSaltyConfig ? functions[name].templates : functions[name];
-        const template = isSaltyConfig ? values[_key] : values.params[_key];
-        if (values && typeof template === "function") {
-          const templateStyles = await template(value);
-          const [result] = await parseStyles(templateStyles, "");
-          return result;
-        }
-      } catch (error) {
-        console.error(`Error loading template "${_key}" from path "${config.templatePaths[_key]}"`, error);
-        return void 0;
-      }
-    }
-    if ((config == null ? void 0 : config.templates) && config.templates[_key]) {
-      if (omitTemplates) return void 0;
-      const path = value.split(".");
-      const templateStyles = path.reduce((acc, key2) => acc[key2], config.templates[_key]);
-      if (templateStyles) {
-        const [result] = await parseStyles(templateStyles, "");
-        return result;
-      }
-      console.warn(`Template "${_key}" with path of "${value}" was not found in config!`);
-      return void 0;
-    }
-    if (typeof value === "object") {
-      if (!value) return void 0;
-      if (value.isColor) return toString(value.toString());
-      if (_key === "defaultVariants") return void 0;
-      if (_key === "variants") {
-        const variantEntries = Object.entries(value);
-        for (const [prop, conditions] of variantEntries) {
-          if (!conditions) continue;
-          const entries2 = Object.entries(conditions);
-          for (const [val, styles2] of entries2) {
-            if (!styles2) continue;
-            const scope2 = `${currentScope}.${prop}-${val}`;
-            const results2 = await parseStyles(styles2, scope2, config);
-            results2.forEach((res) => cssStyles.add(res));
-          }
-        }
-        return void 0;
-      }
-      if (_key === "compoundVariants") {
-        for (const variant of value) {
-          const { css: css2, ...rest } = variant;
-          const scope2 = Object.entries(rest).reduce((acc, [prop, val]) => {
-            return `${acc}.${prop}-${val}`;
-          }, currentScope);
-          const results2 = await parseStyles(css2, scope2, config);
-          results2.forEach((res) => cssStyles.add(res));
-        }
-        return void 0;
-      }
-      if (_key === "anyOfVariants") {
-        for (const variant of value) {
-          const { css: css2, ...rest } = variant;
-          const scopes = Object.entries(rest).map(([prop, val]) => {
-            return `.${prop}-${val}`;
-          });
-          const scope2 = `${currentScope}:where(${scopes.join(", ")})`;
-          console.log(`Union variant scope: ${scope2}`);
-          const results2 = await parseStyles(css2, scope2, config);
-          results2.forEach((res) => cssStyles.add(res));
-        }
-        return void 0;
-      }
-      if (_key.startsWith("@")) {
-        const mediaQuery = ((_b = config == null ? void 0 : config.mediaQueries) == null ? void 0 : _b[_key]) || _key;
-        const results2 = await parseAndJoinStyles(value, currentScope, config);
-        const query = `${mediaQuery} { ${results2} }`;
-        cssStyles.add(query);
-        return void 0;
-      }
-      const scope = key.includes("&") ? _key.replaceAll("&", currentScope) : _key.startsWith(":") ? `${currentScope}${_key}` : `${currentScope} ${_key}`;
-      const results = await parseStyles(value, scope, config);
-      results.forEach((result) => cssStyles.add(result));
-      return void 0;
-    }
-    if (typeof value === "number") {
-      const withUnit = addUnit(propertyName, value, config);
-      return toString(withUnit);
-    }
-    if (typeof value !== "string") {
-      if ("toString" in value) value = value.toString();
-      else throw new Error(`Invalid value type for property ${propertyName}`);
-    }
-    return toString(value);
-  };
-  const promises = entries.map(processStyleEntry);
-  const { modifiers } = config || {};
-  const afterFunctions = [parseValueTokens(), parseValueModifiers(modifiers)];
-  const resolved = await Promise.all(promises).then((styles2) => {
-    return Promise.all(
-      styles2.map((str) => {
-        return afterFunctions.reduce(async (acc, fn) => {
-          const current = await acc;
-          if (!current) return current;
-          const result = await fn(current);
-          if (!result) return current;
-          const { transformed, additionalCss } = result;
-          let before = "";
-          if (additionalCss) {
-            for (const css2 of additionalCss) {
-              before += await parseAndJoinStyles(css2, "");
-            }
-          }
-          return `${before}${transformed}`;
-        }, Promise.resolve(str));
-      })
-    );
-  });
-  const mapped = resolved.filter((value) => value !== void 0).join("\n	");
-  if (!mapped.trim()) return Array.from(cssStyles);
-  const css = currentScope ? `${currentScope} {
-	${mapped}
-}` : mapped;
-  const alreadyExists = cssStyles.has(css);
-  if (alreadyExists) return Array.from(cssStyles);
-  return [css, ...cssStyles];
-};
-const parseAndJoinStyles = async (styles, currentClass, config, omitTemplates = false) => {
-  const css = await parseStyles(styles, currentClass, config, omitTemplates);
-  return css.join("\n");
-};
-export {
-  parseStyles as a,
-  parseVariableTokens as b,
-  parseValueModifiers as c,
-  parseValueTokens as d,
-  parseAndJoinStyles as p
-};