@homebound/truss 2.0.0-next.11 → 2.0.0-next.13

package/build/plugin/index.js

@@ -5,7 +5,7 @@ import { resolve, dirname, isAbsolute } from "path";
 // src/plugin/transform.ts
 import { parse } from "@babel/parser";
 import _traverse2 from "@babel/traverse";
-import _generate from "@babel/generator";
+import _generate2 from "@babel/generator";
 import * as t4 from "@babel/types";
 
 // src/plugin/resolve-chain.ts
@@ -397,6 +397,7 @@ function resolveDelegateCall(abbr, entry, node, mapping, mediaQuery, pseudoClass
       pseudoElement,
       dynamicProps: targetEntry.props,
       incremented: false,
+      appendPx: true,
       dynamicExtraDefs: targetEntry.extraDefs,
       argNode: argAst
     };
@@ -882,6 +883,39 @@ function insertStylexNamespaceImport(ast, localName) {
   const idx = findLastImportIndex(ast);
   ast.program.body.splice(idx + 1, 0, stylexImport);
 }
+function findNamedImportBinding(ast, source, importedName) {
+  for (const node of ast.program.body) {
+    if (!t.isImportDeclaration(node) || node.source.value !== source) continue;
+    for (const spec of node.specifiers) {
+      if (t.isImportSpecifier(spec) && t.isIdentifier(spec.imported, { name: importedName })) {
+        return spec.local.name;
+      }
+    }
+  }
+  return null;
+}
+function upsertNamedImports(ast, source, imports) {
+  if (imports.length === 0) return;
+  for (const node of ast.program.body) {
+    if (!t.isImportDeclaration(node) || node.source.value !== source) continue;
+    for (const entry of imports) {
+      const exists = node.specifiers.some(function(spec) {
+        return t.isImportSpecifier(spec) && t.isIdentifier(spec.imported, { name: entry.importedName });
+      });
+      if (exists) continue;
+      node.specifiers.push(t.importSpecifier(t.identifier(entry.localName), t.identifier(entry.importedName)));
+    }
+    return;
+  }
+  const importDecl = t.importDeclaration(
+    imports.map(function(entry) {
+      return t.importSpecifier(t.identifier(entry.localName), t.identifier(entry.importedName));
+    }),
+    t.stringLiteral(source)
+  );
+  const idx = findLastImportIndex(ast);
+  ast.program.body.splice(idx + 1, 0, importDecl);
+}
 function extractChain(node, cssBinding) {
   const chain = [];
   let current = node;
@@ -1130,44 +1164,6 @@ function buildMaybeIncDeclaration(helperName, increment) {
     t2.variableDeclarator(t2.identifier(helperName), t2.arrowFunctionExpression([incParam], body))
   ]);
 }
-function buildMergePropsDeclaration(helperName, stylexNamespaceName) {
-  const explicitClassNameParam = t2.identifier("explicitClassName");
-  const stylesRestParam = t2.restElement(t2.identifier("styles"));
-  const sxId = t2.identifier("sx");
-  return t2.functionDeclaration(
-    t2.identifier(helperName),
-    [explicitClassNameParam, stylesRestParam],
-    t2.blockStatement([
-      t2.variableDeclaration("const", [
-        t2.variableDeclarator(
-          sxId,
-          t2.callExpression(t2.memberExpression(t2.identifier(stylexNamespaceName), t2.identifier("props")), [
-            t2.spreadElement(t2.identifier("styles"))
-          ])
-        )
-      ]),
-      t2.returnStatement(
-        t2.objectExpression([
-          t2.spreadElement(sxId),
-          t2.objectProperty(
-            t2.identifier("className"),
-            t2.callExpression(
-              t2.memberExpression(
-                t2.binaryExpression(
-                  "+",
-                  t2.binaryExpression("+", explicitClassNameParam, t2.stringLiteral(" ")),
-                  t2.logicalExpression("||", t2.memberExpression(sxId, t2.identifier("className")), t2.stringLiteral(""))
-                ),
-                t2.identifier("trim")
-              ),
-              []
-            )
-          )
-        ])
-      )
-    ])
-  );
-}
 function buildCreateDeclaration(createVarName, stylexNamespaceName, createProperties) {
   const createCall = t2.callExpression(t2.memberExpression(t2.identifier(stylexNamespaceName), t2.identifier("create")), [
     t2.objectExpression(createProperties)
@@ -1218,7 +1214,9 @@ function isValidIdentifier(s) {
 
 // src/plugin/rewrite-sites.ts
 import _traverse from "@babel/traverse";
+import _generate from "@babel/generator";
 import * as t3 from "@babel/types";
+var generate = _generate.default ?? _generate;
 var traverse = _traverse.default ?? _traverse;
 function rewriteExpressionSites(options) {
   for (const site of options.sites) {
@@ -1231,7 +1229,13 @@ function rewriteExpressionSites(options) {
       );
       cssAttrPath.replaceWith(
         t3.jsxSpreadAttribute(
-          buildCssSpreadExpression(cssAttrPath, propsCall, options.mergePropsHelperName, options.needsMergePropsHelper)
+          buildCssSpreadExpression(
+            cssAttrPath,
+            propsCall,
+            options.mergePropsHelperName,
+            options.needsMergePropsHelper,
+            options.stylexNamespaceName
+          )
         )
       );
       continue;
@@ -1243,7 +1247,10 @@ function rewriteExpressionSites(options) {
     options.ast,
     options.stylexNamespaceName,
     options.mergePropsHelperName,
-    options.needsMergePropsHelper
+    options.needsMergePropsHelper,
+    options.asStyleArrayHelperName,
+    options.needsAsStyleArrayHelper,
+    options.skippedCssPropMessages
   );
 }
 function getCssAttributePath(path) {
@@ -1311,6 +1318,12 @@ function buildPropsArgs(segments, options) {
         argExpr = t3.callExpression(t3.identifier(options.maybeIncHelperName), [seg.argNode]);
       } else if (seg.incremented) {
         argExpr = seg.argNode;
+      } else if (seg.appendPx) {
+        argExpr = t3.binaryExpression(
+          "+",
+          t3.callExpression(t3.identifier("String"), [seg.argNode]),
+          t3.stringLiteral("px")
+        );
       } else {
         argExpr = t3.callExpression(t3.identifier("String"), [seg.argNode]);
       }
@@ -1321,30 +1334,78 @@ function buildPropsArgs(segments, options) {
   }
   return args;
 }
-function rewriteCssAttributeExpressions(ast, stylexNamespaceName, mergePropsHelperName, needsMergePropsHelper) {
+function rewriteCssAttributeExpressions(ast, stylexNamespaceName, mergePropsHelperName, needsMergePropsHelper, asStyleArrayHelperName, needsAsStyleArrayHelper, skippedCssPropMessages) {
   traverse(ast, {
     JSXAttribute(path) {
       if (!t3.isJSXIdentifier(path.node.name, { name: "css" })) return;
       const value = path.node.value;
       if (!t3.isJSXExpressionContainer(value)) return;
       if (!t3.isExpression(value.expression)) return;
-      const propsArgs = buildStyleObjectPropsArgs(value.expression, path) ?? buildStyleArrayLikePropsArgsFromExpression(value.expression, path);
-      if (!propsArgs) return;
+      if (!isCssRewriteableExpression(value.expression, path)) {
+        skippedCssPropMessages.push({
+          message: explainSkippedCssRewrite(value.expression, path),
+          line: path.node.loc?.start.line ?? null
+        });
+        return;
+      }
+      const propsArgs = lowerCssExpressionToPropsArgs(
+        value.expression,
+        path,
+        asStyleArrayHelperName,
+        needsAsStyleArrayHelper
+      );
+      if (!propsArgs) {
+        skippedCssPropMessages.push({
+          message: explainSkippedCssRewrite(value.expression, path),
+          line: path.node.loc?.start.line ?? null
+        });
+        return;
+      }
       const propsCall = t3.callExpression(
         t3.memberExpression(t3.identifier(stylexNamespaceName), t3.identifier("props")),
         propsArgs
       );
       path.replaceWith(
-        t3.jsxSpreadAttribute(buildCssSpreadExpression(path, propsCall, mergePropsHelperName, needsMergePropsHelper))
+        t3.jsxSpreadAttribute(
+          buildCssSpreadExpression(path, propsCall, mergePropsHelperName, needsMergePropsHelper, stylexNamespaceName)
+        )
       );
     }
   });
 }
-function buildCssSpreadExpression(path, propsCall, mergePropsHelperName, needsMergePropsHelper) {
+function isCssRewriteableExpression(expr, path) {
+  return !!lowerCssExpressionToPropsArgs(expr, path, "asStyleArray", { current: false });
+}
+function lowerCssExpressionToPropsArgs(expr, path, asStyleArrayHelperName, needsAsStyleArrayHelper) {
+  return buildStyleObjectPropsArgs(expr, path, asStyleArrayHelperName, needsAsStyleArrayHelper) ?? buildStyleArrayLikePropsArgsFromExpression(expr, path, asStyleArrayHelperName, needsAsStyleArrayHelper) ?? buildUnknownCssValuePropsArgs(expr, asStyleArrayHelperName, needsAsStyleArrayHelper);
+}
+function explainSkippedCssRewrite(expr, path) {
+  if (t3.isObjectExpression(expr)) {
+    for (const prop of expr.properties) {
+      if (!t3.isSpreadElement(prop)) {
+        return `[truss] Unsupported pattern: Could not rewrite css prop: object contains a non-spread property (${formatNodeSnippet(expr)})`;
+      }
+      const normalizedArg = normalizeStyleArrayLikeExpression(prop.argument, path, /* @__PURE__ */ new Set());
+      if (!normalizedArg) {
+        return `[truss] Unsupported pattern: Could not rewrite css prop: spread argument is not style-array-like (${formatNodeSnippet(prop.argument)})`;
+      }
+    }
+    return `[truss] Unsupported pattern: Could not rewrite css prop: object spread composition was not recognized (${formatNodeSnippet(expr)})`;
+  }
+  return `[truss] Unsupported pattern: Could not rewrite css prop: expression is not style-array-like (${formatNodeSnippet(expr)})`;
+}
+function formatNodeSnippet(node) {
+  return generate(node, { compact: true, comments: true }).code;
+}
+function buildCssSpreadExpression(path, propsCall, mergePropsHelperName, needsMergePropsHelper, stylexNamespaceName) {
   const existingClassNameExpr = removeExistingClassNameAttribute(path);
   if (!existingClassNameExpr) return propsCall;
   needsMergePropsHelper.current = true;
-  return t3.callExpression(t3.identifier(mergePropsHelperName), [existingClassNameExpr, ...propsCall.arguments]);
+  return t3.callExpression(t3.identifier(mergePropsHelperName), [
+    t3.identifier(stylexNamespaceName),
+    existingClassNameExpr,
+    ...propsCall.arguments
+  ]);
 }
 function removeExistingClassNameAttribute(path) {
   const openingElement = path.parentPath;
@@ -1364,30 +1425,30 @@ function removeExistingClassNameAttribute(path) {
   }
   return null;
 }
-function buildStyleObjectPropsArgs(expr, path) {
+function buildStyleObjectPropsArgs(expr, path, asStyleArrayHelperName, needsAsStyleArrayHelper) {
   if (!t3.isObjectExpression(expr) || expr.properties.length === 0) return null;
-  let sawStyleArray = false;
   const propsArgs = [];
   for (const prop of expr.properties) {
     if (!t3.isSpreadElement(prop)) return null;
     const normalizedArg = normalizeStyleArrayLikeExpression(prop.argument, path, /* @__PURE__ */ new Set());
     if (!normalizedArg) {
-      propsArgs.push(t3.spreadElement(prop.argument));
+      propsArgs.push(
+        t3.spreadElement(
+          buildUnknownObjectSpreadFallback(prop.argument, asStyleArrayHelperName, needsAsStyleArrayHelper)
+        )
+      );
       continue;
     }
-    if (isStyleArrayLike(normalizedArg, path, /* @__PURE__ */ new Set())) {
-      sawStyleArray = true;
-    }
     const nestedArgs = buildStyleArrayLikePropsArgs(normalizedArg, path, /* @__PURE__ */ new Set());
     if (nestedArgs && t3.isArrayExpression(normalizedArg)) {
       propsArgs.push(...nestedArgs);
     } else {
-      propsArgs.push(t3.spreadElement(normalizedArg));
+      propsArgs.push(t3.spreadElement(buildSafeSpreadArgument(normalizedArg)));
     }
   }
-  return sawStyleArray ? propsArgs : null;
+  return propsArgs.length > 0 ? propsArgs : null;
 }
-function buildStyleArrayLikePropsArgsFromExpression(expr, path) {
+function buildStyleArrayLikePropsArgsFromExpression(expr, path, asStyleArrayHelperName, needsAsStyleArrayHelper) {
   const normalizedExpr = normalizeStyleArrayLikeExpression(expr, path, /* @__PURE__ */ new Set());
   if (!normalizedExpr) return null;
   return buildStyleArrayLikePropsArgs(normalizedExpr, path, /* @__PURE__ */ new Set());
@@ -1409,7 +1470,7 @@ function buildStyleArrayLikePropsArgs(expr, path, seen) {
         if (nestedArgs && t3.isArrayExpression(normalizedArg)) {
           propsArgs.push(...nestedArgs);
         } else {
-          propsArgs.push(t3.spreadElement(normalizedArg));
+          propsArgs.push(t3.spreadElement(buildSafeSpreadArgument(normalizedArg)));
         }
         continue;
       }
@@ -1418,10 +1479,14 @@ function buildStyleArrayLikePropsArgs(expr, path, seen) {
     return propsArgs;
   }
   if (t3.isIdentifier(expr) || t3.isMemberExpression(expr) || t3.isConditionalExpression(expr) || t3.isLogicalExpression(expr) || t3.isCallExpression(expr)) {
-    return [t3.spreadElement(expr)];
+    return [t3.spreadElement(buildSafeSpreadArgument(expr))];
   }
   return null;
 }
+function buildUnknownCssValuePropsArgs(expr, asStyleArrayHelperName, needsAsStyleArrayHelper) {
+  if (!(t3.isIdentifier(expr) || t3.isMemberExpression(expr) || t3.isCallExpression(expr))) return null;
+  return [t3.spreadElement(buildUnknownObjectSpreadFallback(expr, asStyleArrayHelperName, needsAsStyleArrayHelper))];
+}
 function rewriteStyleObjectExpressions(ast) {
   traverse(ast, {
     ObjectExpression(path) {
@@ -1446,16 +1511,17 @@ function tryBuildStyleArrayFromObject(path) {
       // I.e. `...Css.df.$`, `...(cond ? Css.df.$ : {})`, or `...styles.wrapper`
     );
     if (!normalizedArg) {
-      return null;
+      elements.push(t3.spreadElement(buildInlineAsStyleArrayExpression(prop.argument)));
+      continue;
     }
-    if (isStyleArrayLike(normalizedArg, path, /* @__PURE__ */ new Set())) {
+    if (isKnownStyleArrayLike(normalizedArg, path, /* @__PURE__ */ new Set())) {
       sawStyleArray = true;
     }
     if (t3.isArrayExpression(normalizedArg)) {
       elements.push(...normalizedArg.elements);
       continue;
     }
-    elements.push(t3.spreadElement(normalizedArg));
+    elements.push(t3.spreadElement(buildSafeSpreadArgument(normalizedArg)));
   }
   if (!sawStyleArray) return null;
   return t3.arrayExpression(elements);
@@ -1515,8 +1581,8 @@ function isStyleArrayLike(expr, path, seen) {
     return !!(init && isStyleArrayLike(init, bindingPath, seen));
   }
   if (t3.isCallExpression(expr)) {
-    const returnExpr = getLocalFunctionReturnExpression(expr, path);
-    return !!(returnExpr && isStyleArrayLike(returnExpr, path, seen));
+    const returnExpr = getCallStyleArrayLikeExpression(expr, path);
+    return returnExpr ? isStyleArrayLike(returnExpr, path, seen) : true;
   }
   if (t3.isMemberExpression(expr)) {
     const object = expr.object;
@@ -1537,6 +1603,49 @@ function isStyleArrayLike(expr, path, seen) {
   }
   return false;
 }
+function isKnownStyleArrayLike(expr, path, seen) {
+  if (seen.has(expr)) return false;
+  seen.add(expr);
+  if (t3.isArrayExpression(expr)) return true;
+  if (t3.isLogicalExpression(expr) && expr.operator === "&&") {
+    return isKnownStyleArrayLike(expr.right, path, seen);
+  }
+  if (t3.isLogicalExpression(expr) && (expr.operator === "||" || expr.operator === "??")) {
+    return isKnownStyleArrayLike(expr.left, path, seen) && isStyleArrayLikeBranch(expr.right, path, seen);
+  }
+  if (t3.isConditionalExpression(expr)) {
+    return isStyleArrayLikeBranch(expr.consequent, path, seen) && isStyleArrayLikeBranch(expr.alternate, path, seen);
+  }
+  if (t3.isIdentifier(expr)) {
+    const binding = path.scope.getBinding(expr.name);
+    const bindingPath = binding?.path;
+    if (!bindingPath || !bindingPath.isVariableDeclarator()) return false;
+    const init = bindingPath.node.init;
+    return !!(init && isKnownStyleArrayLike(init, bindingPath, seen));
+  }
+  if (t3.isCallExpression(expr)) {
+    const returnExpr = getCallStyleArrayLikeExpression(expr, path);
+    return !!(returnExpr && isKnownStyleArrayLike(returnExpr, path, seen));
+  }
+  if (t3.isMemberExpression(expr)) {
+    const object = expr.object;
+    if (!t3.isIdentifier(object)) return false;
+    const binding = path.scope.getBinding(object.name);
+    const bindingPath = binding?.path;
+    if (!bindingPath || !bindingPath.isVariableDeclarator()) return false;
+    const init = bindingPath.node.init;
+    if (!init || !t3.isObjectExpression(init)) return false;
+    const propertyName = getStaticMemberPropertyName(expr, path);
+    if (!propertyName) return false;
+    for (const prop of init.properties) {
+      if (!t3.isObjectProperty(prop) || prop.computed) continue;
+      if (!isMatchingPropertyName(prop.key, propertyName)) continue;
+      const value = prop.value;
+      return t3.isExpression(value) && isKnownStyleArrayLike(value, bindingPath, seen);
+    }
+  }
+  return false;
+}
 function isStyleArrayLikeBranch(expr, path, seen) {
   return isEmptyObjectExpression(expr) || isStyleArrayLike(expr, path, seen);
 }
@@ -1546,6 +1655,20 @@ function isMatchingPropertyName(key, name) {
 function isEmptyObjectExpression(expr) {
   return t3.isObjectExpression(expr) && expr.properties.length === 0;
 }
+function buildUnknownObjectSpreadFallback(expr, asStyleArrayHelperName, needsAsStyleArrayHelper) {
+  needsAsStyleArrayHelper.current = true;
+  return t3.callExpression(t3.identifier(asStyleArrayHelperName), [expr]);
+}
+function buildInlineAsStyleArrayExpression(expr) {
+  return t3.conditionalExpression(
+    t3.callExpression(t3.memberExpression(t3.identifier("Array"), t3.identifier("isArray")), [expr]),
+    expr,
+    t3.conditionalExpression(expr, t3.arrayExpression([expr]), t3.arrayExpression([]))
+  );
+}
+function buildSafeSpreadArgument(expr) {
+  return t3.isConditionalExpression(expr) || t3.isLogicalExpression(expr) ? t3.parenthesizedExpression(expr) : expr;
+}
 function getStaticMemberPropertyName(expr, path) {
   if (!expr.computed && t3.isIdentifier(expr.property)) {
     return expr.property.name;
@@ -1562,6 +1685,15 @@ function getStaticMemberPropertyName(expr, path) {
   }
   return null;
 }
+function getCallStyleArrayLikeExpression(expr, path) {
+  const localReturnExpr = getLocalFunctionReturnExpression(expr, path);
+  if (localReturnExpr) return localReturnExpr;
+  const firstArg = expr.arguments[0];
+  if (firstArg && !t3.isSpreadElement(firstArg) && (t3.isArrowFunctionExpression(firstArg) || t3.isFunctionExpression(firstArg))) {
+    return getFunctionLikeReturnExpression(firstArg);
+  }
+  return null;
+}
 function getLocalFunctionReturnExpression(expr, path) {
   if (!t3.isIdentifier(expr.callee)) return null;
   const binding = path.scope.getBinding(expr.callee.name);
@@ -1589,7 +1721,7 @@ function getFunctionLikeReturnExpression(fn) {
 
 // src/plugin/transform.ts
 var traverse2 = _traverse2.default ?? _traverse2;
-var generate = _generate.default ?? _generate;
+var generate2 = _generate2.default ?? _generate2;
 function transformTruss(code, filename, mapping) {
   if (!code.includes("Css")) return null;
   const ast = parse(code, {
@@ -1626,8 +1758,12 @@ function transformTruss(code, filename, mapping) {
   const stylexNamespaceName = existingStylexNamespace ?? reservePreferredName(usedTopLevelNames, "stylex");
   const createVarName = reservePreferredName(usedTopLevelNames, "css", "css_");
   const maybeIncHelperName = needsMaybeInc ? reservePreferredName(usedTopLevelNames, "__maybeInc") : null;
-  const mergePropsHelperName = reservePreferredName(usedTopLevelNames, "__mergeProps");
+  const existingMergePropsHelperName = findNamedImportBinding(ast, "@homebound/truss/runtime", "mergeProps");
+  const mergePropsHelperName = existingMergePropsHelperName ?? reservePreferredName(usedTopLevelNames, "mergeProps");
   const needsMergePropsHelper = { current: false };
+  const existingAsStyleArrayHelperName = findNamedImportBinding(ast, "@homebound/truss/runtime", "asStyleArray");
+  const asStyleArrayHelperName = existingAsStyleArrayHelperName ?? reservePreferredName(usedTopLevelNames, "asStyleArray");
+  const needsAsStyleArrayHelper = { current: false };
   const runtimeLookupNames = /* @__PURE__ */ new Map();
   for (const [lookupKey] of runtimeLookups) {
     runtimeLookupNames.set(lookupKey, reservePreferredName(usedTopLevelNames, `__${lookupKey}`));
@@ -1641,21 +1777,31 @@ function transformTruss(code, filename, mapping) {
     maybeIncHelperName,
     mergePropsHelperName,
     needsMergePropsHelper,
+    asStyleArrayHelperName,
+    needsAsStyleArrayHelper,
+    skippedCssPropMessages: errorMessages,
     runtimeLookupNames
   });
   removeCssImport(ast, cssBindingName);
   if (!findStylexNamespaceImport(ast)) {
     insertStylexNamespaceImport(ast, stylexNamespaceName);
   }
+  if (needsMergePropsHelper.current || needsAsStyleArrayHelper.current) {
+    const runtimeImports = [];
+    if (needsMergePropsHelper.current) {
+      runtimeImports.push({ importedName: "mergeProps", localName: mergePropsHelperName });
+    }
+    if (needsAsStyleArrayHelper.current) {
+      runtimeImports.push({ importedName: "asStyleArray", localName: asStyleArrayHelperName });
+    }
+    upsertNamedImports(ast, "@homebound/truss/runtime", runtimeImports);
+  }
   const markerVarNames = collectReferencedMarkerNames(createEntries);
   const hoistedMarkerDecls = hoistMarkerDeclarations(ast, markerVarNames);
   const declarationsToInsert = [];
   if (maybeIncHelperName) {
     declarationsToInsert.push(buildMaybeIncDeclaration(maybeIncHelperName, mapping.increment));
   }
-  if (needsMergePropsHelper.current) {
-    declarationsToInsert.push(buildMergePropsDeclaration(mergePropsHelperName, stylexNamespaceName));
-  }
   declarationsToInsert.push(...hoistedMarkerDecls);
   if (createProperties.length > 0) {
     declarationsToInsert.push(buildCreateDeclaration(createVarName, stylexNamespaceName, createProperties));
@@ -1676,10 +1822,12 @@ function transformTruss(code, filename, mapping) {
     declarationsToInsert.push(consoleError);
   }
   if (declarationsToInsert.length > 0) {
-    const insertIndex = findLastImportIndex(ast) + 1;
-    ast.program.body.splice(insertIndex, 0, ...declarationsToInsert);
+    const insertIndex = ast.program.body.findIndex(function(node) {
+      return !t4.isImportDeclaration(node);
+    });
+    ast.program.body.splice(insertIndex === -1 ? ast.program.body.length : insertIndex, 0, ...declarationsToInsert);
   }
-  const output = generate(ast, {
+  const output = generate2(ast, {
     sourceFileName: filename,
     retainLines: false
   });
@@ -1935,9 +2083,9 @@ ${body}
 
 // src/plugin/rewrite-css-ts-imports.ts
 import { parse as parse3 } from "@babel/parser";
-import _generate2 from "@babel/generator";
+import _generate3 from "@babel/generator";
 import * as t7 from "@babel/types";
-var generate2 = _generate2.default ?? _generate2;
+var generate3 = _generate3.default ?? _generate3;
 function rewriteCssTsImports(code, filename) {
   if (!code.includes(".css.ts")) {
     return { code, changed: false };
@@ -1975,7 +2123,7 @@ function rewriteCssTsImports(code, filename) {
     const insertIndex = findLastImportIndex(ast) + 1;
     ast.program.body.splice(insertIndex, 0, ...sideEffectImports);
   }
-  const output = generate2(ast, {
+  const output = generate3(ast, {
     sourceFileName: filename,
     retainLines: false
   });