@cssxio/babel-plugin 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 CSSX contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,30 @@
+# @cssxio/babel-plugin
+
+This plugin compiles CSSX calls imported from `@cssxio/cssx`. That is the default `importSource`.
+
+```js
+// babel.config.js
+export default {
+  plugins: ['@cssxio/babel-plugin'],
+};
+```
+
+It supports namespace, default, and named `create`, `props`, and `sx` imports. Named imports are called directly. Namespace and default imports must use dot notation, such as `cssx.create(...)`; computed API calls such as `cssx['create'](...)` are rejected.
+
+`create` must be declared at module scope. It needs one plain object with non-computed keys. Values must be string literals or unchanged local constants initialized with string literals. Spreads, changed values, and other dynamic values produce an error at the source location.
+
+The plugin replaces `create` with compiled styles. It folds a `props` call only when every input is a local compiled style, a nested array of supported inputs, `false`, or `null`. Static props folding does not accept `undefined`. Other `props` calls stay at runtime.
+
+The plugin also compiles static strings in `sx` calls. It supports static strings, `false`, `null`, nested arrays without spreads, logical-and expressions, and conditional expressions. Unsupported nested input leaves the `sx` call at runtime.
+
+The plugin removes unused CSSX imports. It writes CSS data to Babel file metadata as `cssx`. `cssx.candidates` maps each reachable source candidate to its atomic class, `cssx.composites` maps each emitted composite class to its winning atomic classes, and `cssx.atomicClasses` identifies atoms still needed for dynamic runtime composition. `cssx.origins` stores the first source location for each reachable candidate. Origin lines and columns are zero-based. A direct style-key reference keeps that key's candidates; dynamic or non-member style use keeps every candidate from that style map.
+
+Use `importSource` to target a custom runtime re-export:
+
+```js
+export default {
+  plugins: [['@cssxio/babel-plugin', { importSource: '@app/cssx' }]],
+};
+```
+
+The plugin accepts an optional `theme` string containing CSS text with CSSX `@theme` input. Use `themeFile` in the CSSX adapter when the build tool should read theme CSS text from a file.

package/dist/index.cjs

@@ -0,0 +1,640 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  default: () => cssxBabelPlugin
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/state-helpers.ts
+function recordCandidateOrigin(state, candidate, location) {
+  if (!location || state.candidateOrigins.has(candidate)) {
+    return;
+  }
+  state.candidateOrigins.set(candidate, { line: location.line - 1, column: location.column });
+}
+function markStyleKeyCandidates(state, candidatesByKey, key) {
+  for (const candidate of candidatesByKey[key] ?? []) {
+    state.liveCandidates.add(candidate);
+  }
+}
+function markAllCandidates(state, candidatesByKey) {
+  for (const candidates of Object.values(candidatesByKey)) {
+    for (const candidate of candidates) {
+      state.liveCandidates.add(candidate);
+    }
+  }
+}
+
+// src/ast-helpers.ts
+function memberPropertyName(member, t) {
+  if (!member.computed && t.isIdentifier(member.property)) {
+    return member.property.name;
+  }
+  if (member.computed && t.isStringLiteral(member.property)) {
+    return member.property.value;
+  }
+  return null;
+}
+function importedFunctionBinding(path, localName, importedName, t, importSource) {
+  const binding = path.scope.getBinding(localName);
+  const bindingPath = binding?.path;
+  if (!bindingPath?.isImportSpecifier()) {
+    return false;
+  }
+  const imported = bindingPath.node.imported;
+  const actualName = t.isIdentifier(imported) ? imported.name : imported.value;
+  return actualName === importedName && isCssxImport(bindingPath, importSource);
+}
+function importedNamespaceBinding(path, localName, importSource) {
+  const binding = path.scope.getBinding(localName);
+  const bindingPath = binding?.path;
+  if (!bindingPath || !bindingPath.isImportNamespaceSpecifier() && !bindingPath.isImportDefaultSpecifier()) {
+    return false;
+  }
+  return isCssxImport(bindingPath, importSource);
+}
+function isCssxImport(path, importSource) {
+  const parent = path.parentPath;
+  return parent?.isImportDeclaration() === true && parent.node.source.value === importSource;
+}
+function assertModuleScope(path) {
+  const statement = path.getStatementParent();
+  const statementParent = statement?.parentPath;
+  const isDirectProgramStatement = statementParent?.isProgram() || statementParent?.isExportNamedDeclaration();
+  if (!isDirectProgramStatement) {
+    throw diagnosticError(path, "cssx.create() must be declared at module scope.");
+  }
+}
+function assertNoComputedCssxApiCall(path, t, importSource) {
+  const callee = path.node.callee;
+  if (!t.isMemberExpression(callee) || !callee.computed || !t.isIdentifier(callee.object) || !t.isStringLiteral(callee.property)) {
+    return;
+  }
+  if ((callee.property.value === "create" || callee.property.value === "props" || callee.property.value === "sx") && importedNamespaceBinding(path, callee.object.name, importSource)) {
+    throw diagnosticError(path, "CSSX API calls must use dot notation, for example cssx.create(...).");
+  }
+}
+function diagnosticError(path, message) {
+  return process.env.NODE_ENV === "production" ? new Error(message) : path.buildCodeFrameError(message);
+}
+function readStaticString(path) {
+  if (path.isStringLiteral()) {
+    return path.node.value;
+  }
+  if (!path.isIdentifier()) {
+    return null;
+  }
+  const binding = path.scope.getBinding(path.node.name);
+  if (!binding?.constant || binding.constantViolations.length !== 0 || !binding.path.isVariableDeclarator()) {
+    return null;
+  }
+  const initializer = binding.path.get("init");
+  return initializer.isStringLiteral() ? initializer.node.value : null;
+}
+function propertyKey(key, t) {
+  return t.isValidIdentifier(key) ? t.identifier(key) : t.stringLiteral(key);
+}
+function packedStyleExpression(style, t) {
+  return t.valueToNode(style);
+}
+function objectPropertyName(property, t) {
+  if (t.isIdentifier(property.key)) {
+    return property.key.name;
+  }
+  if (t.isStringLiteral(property.key) || t.isNumericLiteral(property.key)) {
+    return String(property.key.value);
+  }
+  return null;
+}
+function isCreateCall(path, t, importSource) {
+  return isCssxApiCall(path, t, importSource, "create");
+}
+function isPropsCall(path, t, importSource) {
+  return isCssxApiCall(path, t, importSource, "props");
+}
+function isSxCall(path, t, importSource) {
+  return isCssxApiCall(path, t, importSource, "sx");
+}
+function isCssxApiCall(path, t, importSource, api) {
+  const callee = path.node.callee;
+  if (t.isIdentifier(callee)) {
+    return importedFunctionBinding(path, callee.name, api, t, importSource);
+  }
+  return t.isMemberExpression(callee) && !callee.computed && t.isIdentifier(callee.object) && t.isIdentifier(callee.property, { name: api }) && importedNamespaceBinding(path, callee.object.name, importSource);
+}
+
+// src/index.ts
+var import_compiler = require("@cssxio/compiler");
+var DEFAULT_IMPORT_SOURCE = "@cssxio/cssx";
+function cssxBabelPlugin(api, options = {}) {
+  api.assertVersion(7);
+  const t = api.types;
+  const importSource = options.importSource ?? DEFAULT_IMPORT_SOURCE;
+  let state;
+  let fileName = "";
+  let foldedProps = [];
+  return {
+    name: "@cssxio/babel-plugin",
+    visitor: {
+      Program: {
+        enter(_path, babelState) {
+          fileName = babelState.file.opts.filename ?? "";
+          state = {
+            classNameAllocator: options.classNameAllocator ?? (0, import_compiler.createClassNameAllocator)(options.className),
+            styles: /* @__PURE__ */ new Map(),
+            styleCandidates: /* @__PURE__ */ new Map(),
+            styleClasses: /* @__PURE__ */ new Map(),
+            classes: /* @__PURE__ */ new Map(),
+            candidateOrigins: /* @__PURE__ */ new Map(),
+            liveCandidates: /* @__PURE__ */ new Set(),
+            composites: /* @__PURE__ */ new Map(),
+            liveComposites: /* @__PURE__ */ new Set(),
+            liveFallbackClasses: /* @__PURE__ */ new Set(),
+            cssRanges: []
+          };
+          foldedProps = [];
+        },
+        exit(path, babelState) {
+          finalizeFoldedProps(path, t);
+          path.scope.crawl();
+          markReferencedStyleCandidates(path);
+          removeDeadStyleMaps(path);
+          compactLiveStyleRecords(path);
+          for (const statement of path.get("body")) {
+            if (!statement.isImportDeclaration() || statement.node.source.value !== importSource) {
+              continue;
+            }
+            for (const specifier of [...statement.get("specifiers")]) {
+              const local = specifier.node.local.name;
+              const binding = path.scope.getBinding(local);
+              if (binding?.referencePaths.length === 0) {
+                specifier.remove();
+              }
+            }
+            if (statement.node.specifiers.length === 0) {
+              statement.remove();
+            }
+          }
+          babelState.file.metadata.cssx = {
+            candidates: Object.fromEntries(
+              [...state.classes].filter(([candidate]) => state.liveCandidates.has(candidate))
+            ),
+            origins: Object.fromEntries(
+              [...state.candidateOrigins].filter(([candidate]) => state.liveCandidates.has(candidate))
+            ),
+            composites: Object.fromEntries(
+              [...state.composites].filter(([className]) => state.liveComposites.has(className))
+            ),
+            atomicClasses: [...state.liveFallbackClasses].sort(),
+            cssOnlySignature: cssOnlySignature(babelState.file.code, state.cssRanges)
+          };
+        }
+      },
+      CallExpression(path) {
+        assertNoComputedCssxApiCall(path, t, importSource);
+        if (isCreateCall(path, t, importSource)) {
+          assertModuleScope(path);
+          transformCreate(path, t);
+          return;
+        }
+        if (isPropsCall(path, t, importSource)) {
+          transformStaticProps(path, t);
+        }
+        if (isSxCall(path, t, importSource)) {
+          transformSx(path, t);
+        }
+      }
+    }
+  };
+  function transformCreate(path, types) {
+    if (path.node.arguments.length !== 1 || !types.isObjectExpression(path.node.arguments[0])) {
+      throw diagnosticError(path, "cssx.create() expects one object literal argument.");
+    }
+    const input = readStyleMap(path.get("arguments.0"), types);
+    let result;
+    try {
+      result = (0, import_compiler.compileStyleRecords)(input, {
+        theme: options.theme,
+        classNameAllocator: state.classNameAllocator,
+        reusabilityBudget: options.reusabilityBudget
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unable to compile CSSX styles.";
+      throw diagnosticError(path, message);
+    }
+    const parent = path.parentPath;
+    if (options.stableClassNames) {
+      const anchor = parent.isVariableDeclarator() && types.isIdentifier(parent.node.id) ? `map:${parent.node.id.name}` : `create:${path.node.loc.start.line}:${path.node.loc.start.column}`;
+      result = withStableCompositeNames(result, fileName, anchor);
+    }
+    for (const [candidate, className] of Object.entries(result.classes)) {
+      state.classes.set(candidate, className);
+      recordCandidateOrigin(state, candidate, path.node.loc?.start);
+    }
+    for (const [className, atomicClasses] of Object.entries(result.composites)) {
+      state.composites.set(className, atomicClasses);
+    }
+    const replacement = types.objectExpression(
+      Object.entries(result.styles).map(
+        ([key, style]) => types.objectProperty(propertyKey(key, types), packedStyleExpression(style, types))
+      )
+    );
+    if (parent.isVariableDeclarator() && types.isIdentifier(parent.node.id)) {
+      state.styles.set(parent.node.id.name, result.styles);
+      state.styleCandidates.set(parent.node.id.name, result.candidates);
+      state.styleClasses.set(parent.node.id.name, result.classNames);
+    }
+    path.replaceWith(replacement);
+  }
+  function transformStaticProps(path, types) {
+    const styles = [];
+    for (const argument of path.node.arguments) {
+      if (types.isSpreadElement(argument)) {
+        return;
+      }
+      const resolved = resolveStyleArgument(argument, types);
+      if (resolved === void 0) {
+        return;
+      }
+      if (resolved) {
+        styles.push(...resolved);
+      }
+    }
+    const singleStyle = styles.length === 1 ? styles[0] : void 0;
+    const composition = singleStyle ? void 0 : (0, import_compiler.composeCompiledStyles)(styles, state.classNameAllocator);
+    const className = singleStyle ? singleStyle.c : options.stableClassNames ? stableCompositeName(
+      fileName,
+      void 0,
+      `props:${styles.map((style) => style.c).sort().join("\0")}`
+    ) : composition.className;
+    if (composition) {
+      state.composites.set(className, composition.atomicClasses);
+    }
+    markEmittedClassNames(className);
+    foldedProps.push({ path, className });
+  }
+  function finalizeFoldedProps(program, types) {
+    if (foldedProps.length === 0) {
+      return;
+    }
+    const declarations = [];
+    const useHelper = foldedProps.length >= 4;
+    const helper = useHelper ? program.scope.generateUidIdentifier("cssxProps") : void 0;
+    if (helper) {
+      declarations.push(
+        types.variableDeclarator(
+          helper,
+          types.arrowFunctionExpression(
+            [types.identifier("className")],
+            types.objectExpression([
+              types.objectProperty(types.identifier("className"), types.identifier("className"))
+            ])
+          )
+        )
+      );
+    }
+    if (declarations.length > 0) {
+      program.unshiftContainer("body", types.variableDeclaration("const", declarations));
+    }
+    for (const { path, className } of foldedProps) {
+      path.replaceWith(
+        helper ? types.callExpression(helper, [types.stringLiteral(className)]) : types.objectExpression([
+          types.objectProperty(types.identifier("className"), types.stringLiteral(className))
+        ])
+      );
+    }
+  }
+  function transformSx(path, types) {
+    const staticSource = readStaticSxSource(path.node.arguments, types);
+    if (staticSource !== null) {
+      if (isGeneratedClassNames(staticSource)) {
+        return;
+      }
+      path.replaceWith(types.stringLiteral(compileSxString(staticSource, path.node.loc?.start)));
+      return;
+    }
+    const transformed = path.node.arguments.map(
+      (argument) => transformSxArgument(argument, types)
+    );
+    if (transformed.some((argument) => argument === void 0)) {
+      return;
+    }
+    const expressions = transformed.filter(
+      (argument) => argument !== void 0
+    );
+    path.node.arguments = expressions;
+  }
+  function transformSxArgument(node, types) {
+    if (types.isSpreadElement(node)) {
+      return void 0;
+    }
+    if (types.isStringLiteral(node)) {
+      if (isGeneratedClassNames(node.value)) {
+        return node;
+      }
+      return types.stringLiteral(compileSxString(node.value, node.loc?.start));
+    }
+    if (types.isNullLiteral(node) || types.isBooleanLiteral(node, { value: false })) {
+      return types.stringLiteral("");
+    }
+    if (types.isArrayExpression(node)) {
+      const elements = node.elements.map(
+        (element) => element && !types.isSpreadElement(element) ? transformSxArgument(element, types) : void 0
+      );
+      if (elements.some((element) => element === void 0)) {
+        return void 0;
+      }
+      const values = elements.filter((element) => element !== void 0);
+      return types.arrayExpression(values);
+    }
+    if (types.isLogicalExpression(node, { operator: "&&" })) {
+      const right = transformSxArgument(node.right, types);
+      return right ? types.logicalExpression("&&", node.left, right) : void 0;
+    }
+    if (types.isConditionalExpression(node)) {
+      const consequent = transformSxArgument(node.consequent, types);
+      const alternate = transformSxArgument(node.alternate, types);
+      return consequent && alternate ? types.conditionalExpression(node.test, consequent, alternate) : void 0;
+    }
+    return node;
+  }
+  function compileSxString(source, location) {
+    if (!source.trim()) {
+      return "";
+    }
+    let result;
+    try {
+      result = (0, import_compiler.compileStyleRecords)(
+        { inline: source },
+        {
+          theme: options.theme,
+          classNameAllocator: state.classNameAllocator,
+          reusabilityBudget: options.reusabilityBudget
+        }
+      );
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unable to compile CSSX sx() utilities.";
+      throw new Error(message);
+    }
+    const className = options.stableClassNames ? stableCompositeName(fileName, location, "sx") : result.classNames.inline;
+    for (const [candidate, candidateClassName] of Object.entries(result.classes)) {
+      state.classes.set(candidate, candidateClassName);
+      state.liveCandidates.add(candidate);
+      recordCandidateOrigin(state, candidate, location);
+    }
+    for (const [compositeClassName, atomicClasses] of Object.entries(result.composites)) {
+      state.composites.set(compositeClassName, atomicClasses);
+    }
+    if (options.stableClassNames) {
+      state.composites.set(className, atomicClassesForStyle(result.styles.inline));
+    }
+    markEmittedClassNames(className);
+    return className;
+  }
+  function isGeneratedClassNames(value) {
+    return /^s[0-9A-Za-z]+x(?:\s+s[0-9A-Za-z]+x)*$/.test(value);
+  }
+  function markReferencedStyleCandidates(program) {
+    for (const [styleName, candidatesByKey] of state.styleCandidates) {
+      const binding = program.scope.getBinding(styleName);
+      for (const reference of binding.referencePaths) {
+        const parent = reference.parentPath;
+        if (!parent?.isMemberExpression() || parent.node.object !== reference.node) {
+          markAllCandidates(state, candidatesByKey);
+          markAllStyleClasses(styleName);
+          markAllFallbackClasses(styleName);
+          continue;
+        }
+        const key = memberPropertyName(parent.node, t);
+        if (key === null) {
+          markAllCandidates(state, candidatesByKey);
+          markAllStyleClasses(styleName);
+          markAllFallbackClasses(styleName);
+        } else {
+          markStyleKeyCandidates(state, candidatesByKey, key);
+          markStyleClass(styleName, key);
+          markFallbackClasses(styleName, key);
+        }
+      }
+    }
+  }
+  function removeDeadStyleMaps(program) {
+    for (const styleName of state.styles.keys()) {
+      const binding = program.scope.getBinding(styleName);
+      if (binding && binding.referencePaths.length === 0 && binding.path.isVariableDeclarator()) {
+        binding.path.remove();
+      }
+    }
+  }
+  function compactLiveStyleRecords(program) {
+    for (const styleName of state.styles.keys()) {
+      const binding = program.scope.getBinding(styleName);
+      if (!binding?.path.isVariableDeclarator() || !binding.path.parentPath?.isVariableDeclaration()) {
+        continue;
+      }
+      const entries = /* @__PURE__ */ new Map();
+      const recordArrays = [];
+      const styles = binding.path.node.init;
+      for (const property of styles.properties) {
+        const style = property;
+        const records = style.value.properties.find(
+          (styleProperty) => t.isObjectProperty(styleProperty) && t.isIdentifier(styleProperty.key, { name: "_" })
+        );
+        const recordValues = records.value;
+        for (let index = 0; index < recordValues.elements.length; index++) {
+          const record = recordValues.elements[index];
+          const key = packedRecordKey(record);
+          const entry = entries.get(key) ?? { record, uses: 0 };
+          entry.uses++;
+          entries.set(key, entry);
+          recordArrays.push({ records: recordValues, index, record });
+        }
+      }
+      const interned = /* @__PURE__ */ new Map();
+      const declarations = [];
+      for (const [key, entry] of entries) {
+        if (entry.uses < 2) {
+          continue;
+        }
+        const identifier = program.scope.generateUidIdentifier("c");
+        interned.set(key, identifier);
+        declarations.push(t.variableDeclarator(identifier, entry.record));
+      }
+      if (declarations.length === 0) {
+        continue;
+      }
+      for (const { records, index, record } of recordArrays) {
+        const identifier = interned.get(packedRecordKey(record));
+        if (!identifier) {
+          continue;
+        }
+        records.elements[index] = t.identifier(identifier.name);
+      }
+      const declaration = binding.path.parentPath;
+      const statement = declaration.parentPath?.isExportNamedDeclaration() ? declaration.parentPath : declaration;
+      statement.insertBefore(t.variableDeclaration("const", declarations));
+    }
+  }
+  function packedRecordKey(record) {
+    return JSON.stringify(
+      record.elements.map(
+        (value) => t.isNullLiteral(value) ? null : value.value
+      )
+    );
+  }
+  function readStyleMap(path, types) {
+    const result = /* @__PURE__ */ Object.create(null);
+    for (const property of path.get("properties")) {
+      if (!property.isObjectProperty() || property.node.computed) {
+        throw diagnosticError(property, "cssx.create() only supports plain object properties.");
+      }
+      const key = objectPropertyName(property.node, types);
+      const value = property.get("value");
+      const utilityString = readStaticString(value);
+      if (!key || utilityString === null) {
+        throw diagnosticError(property, "Each cssx.create() value must be a static utility string.");
+      }
+      state.cssRanges.push({ start: value.node.start, end: value.node.end });
+      result[key] = utilityString;
+    }
+    return result;
+  }
+  function resolveStyleArgument(node, types) {
+    if (types.isNullLiteral(node) || types.isBooleanLiteral(node, { value: false })) {
+      return null;
+    }
+    if (types.isArrayExpression(node)) {
+      const styles = [];
+      for (const element of node.elements) {
+        if (!element || types.isSpreadElement(element)) {
+          return void 0;
+        }
+        const resolved = resolveStyleArgument(element, types);
+        if (resolved === void 0) {
+          return void 0;
+        }
+        if (resolved) {
+          styles.push(...resolved);
+        }
+      }
+      return styles;
+    }
+    if (!types.isMemberExpression(node) || node.computed || !types.isIdentifier(node.object) || !types.isIdentifier(node.property)) {
+      return void 0;
+    }
+    const map = state.styles.get(node.object.name);
+    const style = map?.[node.property.name];
+    const candidates = state.styleCandidates.get(node.object.name);
+    if (style && candidates) {
+      markStyleKeyCandidates(state, candidates, node.property.name);
+    }
+    return style ? [style] : void 0;
+  }
+  function markStyleClass(styleName, key) {
+    const className = state.styleClasses.get(styleName)?.[key];
+    if (className) {
+      markEmittedClassNames(className);
+    }
+  }
+  function markAllStyleClasses(styleName) {
+    for (const className of Object.values(state.styleClasses.get(styleName))) {
+      markEmittedClassNames(className);
+    }
+  }
+  function markEmittedClassNames(classNames) {
+    for (const className of classNames.split(/\s+/).filter(Boolean)) {
+      if (state.composites.has(className)) {
+        state.liveComposites.add(className);
+      } else {
+        state.liveFallbackClasses.add(className);
+      }
+    }
+  }
+  function markFallbackClasses(styleName, key) {
+    for (const record of state.styles.get(styleName)?.[key]?._ ?? []) {
+      if (record[0]) {
+        state.liveFallbackClasses.add(record[0]);
+      }
+    }
+  }
+  function markAllFallbackClasses(styleName) {
+    for (const key of Object.keys(state.styles.get(styleName))) {
+      markFallbackClasses(styleName, key);
+    }
+  }
+  function readStaticSxSource(nodes, types) {
+    const values = [];
+    for (const node of nodes) {
+      if (types.isStringLiteral(node)) {
+        values.push(node.value);
+      } else if (types.isNullLiteral(node) || types.isBooleanLiteral(node, { value: false })) {
+        continue;
+      } else if (types.isArrayExpression(node) && node.elements.every((element) => element !== null)) {
+        const nested = readStaticSxSource(
+          node.elements.filter((element) => element !== null),
+          types
+        );
+        if (nested === null) {
+          return null;
+        }
+        values.push(nested);
+      } else {
+        return null;
+      }
+    }
+    return values.filter(Boolean).join(" ");
+  }
+}
+function withStableCompositeNames(result, fileName, anchor) {
+  const styles = /* @__PURE__ */ Object.create(null);
+  const classNames = /* @__PURE__ */ Object.create(null);
+  const composites = /* @__PURE__ */ Object.create(null);
+  for (const [name, style] of Object.entries(result.styles)) {
+    const className = stableCompositeName(fileName, void 0, `${anchor}:style:${name}`);
+    styles[name] = { ...style, c: className };
+    classNames[name] = className;
+    composites[className] = atomicClassesForStyle(style);
+  }
+  return { ...result, styles, classNames, composites };
+}
+function atomicClassesForStyle(style) {
+  return [...new Set(style._.map((record) => record[0]).filter((className) => !!className))];
+}
+function stableCompositeName(fileName, location, kind) {
+  const anchor = `${fileName}\0${location?.line ?? 0}\0${location?.column ?? 0}\0${kind}`;
+  let hash = 0xcbf29ce484222325n;
+  for (let index = 0; index < anchor.length; index++) {
+    hash ^= BigInt(anchor.charCodeAt(index));
+    hash = BigInt.asUintN(64, hash * 0x100000001b3n);
+  }
+  return `d${hash.toString(36)}`;
+}
+function cssOnlySignature(source, ranges) {
+  const chunks = [];
+  let position = 0;
+  for (const { start, end } of [...ranges].sort((left, right) => left.start - right.start)) {
+    chunks.push(source.slice(position, start));
+    position = end;
+  }
+  chunks.push(source.slice(position));
+  return chunks.join("");
+}