@griffel/transform 1.2.1 → 2.0.0

package/CHANGELOG.md

@@ -1,12 +1,25 @@
 # Change Log - @griffel/transform
 
-This log was last generated on Fri, 06 Mar 2026 15:54:55 GMT and should not be manually modified.
+This log was last generated on Wed, 11 Mar 2026 13:31:20 GMT and should not be manually modified.
 
 <!-- Start content -->
 
+## 2.0.0
+
+Wed, 11 Mar 2026 13:31:20 GMT
+
+### Major changes
+
+- BREAKING: Replace @linaria/shaker with @griffel/transform-shaker. Remove babelOptions from TransformOptions. Remove StrictOptions type. (olfedias@microsoft.com)
+
+### Patches
+
+- feat: add collectPerfIssues option to TransformOptions (olfedias@microsoft.com)
+- fix: fix VM result index mapping in batchEvaluator (olfedias@microsoft.com)
+
 ## 1.2.1
 
-Fri, 06 Mar 2026 15:54:55 GMT
+Fri, 06 Mar 2026 15:56:28 GMT
 
 ### Patches
 

package/evaluation/batchEvaluator.d.mts

@@ -1,12 +1,13 @@
 import { Program } from 'oxc-parser';
-import { StrictOptions, AstEvaluatorPlugin } from './types.mjs';
 import { StyleCall } from '../types.mjs';
+import { TransformResolver } from './module.mjs';
+import { AstEvaluatorPlugin, EvalRule } from './types.mjs';
 /**
  * Batch evaluates all style calls in a file for better performance.
  * Uses static evaluation first, then falls back to VM evaluation for complex expressions.
  * Optimizes VM evaluation by sharing module loading and parsing overhead.
  */
-export declare function batchEvaluator(sourceCode: string, filename: string, styleCalls: StyleCall[], babelOptions: NonNullable<StrictOptions['babelOptions']>, evaluationRules: NonNullable<StrictOptions['rules']>, programAst: Program, astEvaluationPlugins?: AstEvaluatorPlugin[]): {
+export declare function batchEvaluator(sourceCode: string, filename: string, styleCalls: StyleCall[], evaluationRules: EvalRule[], resolveFilename: TransformResolver, programAst: Program, astEvaluationPlugins?: AstEvaluatorPlugin[]): {
     usedVMForEvaluation: boolean;
     evaluationResults: unknown[];
 };

package/evaluation/module.d.mts

@@ -1,18 +1,25 @@
-import { StrictOptions } from './types.mjs';
+import { EvalRule } from './types.mjs';
+export type TransformResolver = (id: string, options: {
+    filename: string;
+    paths: readonly string[];
+}) => {
+    path: string;
+    builtin: boolean;
+};
 export declare class Module {
     readonly id: string;
     readonly filename: string;
     readonly paths: readonly string[];
-    options: StrictOptions;
+    rules: EvalRule[];
     imports: Map<string, string[]> | null;
     dependencies: string[] | null;
     transform: ((code: string, filename: string) => string) | null;
+    static readonly extensions: Set<string>;
     exports: unknown;
-    extensions: string[];
+    private readonly resolveFilename;
     private debug;
     private debuggerDepth;
-    constructor(filename: string, options: StrictOptions, debuggerDepth?: number);
-    resolve: (id: string) => string;
+    constructor(filename: string, rules: EvalRule[], resolveFilename: TransformResolver, debuggerDepth?: number);
     require: ((id: string) => unknown) & {
         ensure: () => void;
         cache: Record<string, Module>;
@@ -21,9 +28,5 @@ export declare class Module {
     evaluate(text: string, only?: string[] | null): void;
     static invalidate: () => void;
     static invalidateEvalCache: () => void;
-    static _resolveFilename: (id: string, options: {
-        filename: string;
-        paths: readonly string[];
-    }) => string;
     static _nodeModulePaths: (filename: string) => string[];
 }

package/evaluation/types.d.mts

@@ -1,19 +1,19 @@
 import { Node, Program } from 'oxc-parser';
-export type Evaluator = (filename: string, options: StrictOptions, text: string, only: string[] | null) => [string, Map<string, string[]> | null];
+export type EvaluatorResult = {
+    code: string;
+    imports: Map<string, string[]> | null;
+    moduleKind: 'esm' | 'cjs';
+};
 export type EvalRule = {
     test?: RegExp | ((path: string) => boolean);
-    action: Evaluator | 'ignore' | string;
-};
-export type StrictOptions = {
-    displayName: boolean;
-    evaluate: boolean;
-    babelOptions: {
-        plugins?: unknown[];
-        presets?: unknown[];
-        [key: string]: unknown;
-    };
-    rules: EvalRule[];
+    action: Evaluator | 'ignore';
 };
+export type Evaluator = (filename: string, text: string, only: string[] | null) => EvaluatorResult;
+export interface TransformPerfIssue {
+    type: 'cjs-module' | 'barrel-export-star';
+    /** The dependency file that caused the issue */
+    dependencyFilename: string;
+}
 export interface EvaluationResult {
     confident: boolean;
     value?: unknown;

package/evaluation/vmEvaluator.d.mts

@@ -1,2 +1,3 @@
-import { EvaluationResult, StrictOptions } from './types.mjs';
-export declare function vmEvaluator(sourceCode: string, filename: string, expressionCode: string, babelOptions: NonNullable<StrictOptions['babelOptions']>, evaluationRules: NonNullable<StrictOptions['rules']>): EvaluationResult;
+import { TransformResolver } from './module.mjs';
+import { EvalRule, EvaluationResult } from './types.mjs';
+export declare function vmEvaluator(sourceCode: string, filename: string, expressionCode: string, evaluationRules: EvalRule[], resolveFilename: TransformResolver): EvaluationResult;

package/index.d.mts

@@ -1,9 +1,9 @@
-export { default as shakerEvaluator } from '@linaria/shaker';
-export { Module } from './evaluation/module.mjs';
+export { default as shakerEvaluator } from '@griffel/transform-shaker';
+export { Module, type TransformResolver } from './evaluation/module.mjs';
 export * as EvalCache from './evaluation/evalCache.mjs';
 export { ASSET_TAG_OPEN, ASSET_TAG_CLOSE } from './constants.mjs';
-export type { Evaluator, EvalRule } from './evaluation/types.mjs';
+export type { Evaluator, EvaluatorResult, EvalRule } from './evaluation/types.mjs';
 export { transformSync, type TransformOptions, type TransformResult } from './transformSync.mjs';
 export { DEOPT, type Deopt } from './evaluation/astEvaluator.mjs';
-export type { AstEvaluatorPlugin, AstEvaluatorContext } from './evaluation/types.mjs';
+export type { AstEvaluatorPlugin, AstEvaluatorContext, TransformPerfIssue } from './evaluation/types.mjs';
 export { fluentTokensPlugin } from './evaluation/fluentTokensPlugin.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@griffel/transform",
-  "version": "1.2.1",
+  "version": "2.0.0",
   "description": "A package that performs build time transforms for Griffel",
   "license": "MIT",
   "repository": {
@@ -17,7 +17,7 @@
   },
   "dependencies": {
     "@griffel/core": "^1.20.1",
-    "@linaria/shaker": "^3.0.0-beta.22",
+    "@griffel/transform-shaker": "^1.0.0",
     "debug": "^4.3.0",
     "magic-string": "^0.30.19",
     "oxc-parser": "^0.116.0",

package/transform.js

@@ -1,17 +1,181 @@
-import _shaker from "@linaria/shaker";
-import { default as default2 } from "@linaria/shaker";
+import shakerEvaluator from "@griffel/transform-shaker";
+import { default as default2 } from "@griffel/transform-shaker";
 import fs from "node:fs";
 import NativeModule from "node:module";
-import path, { dirname, extname } from "node:path";
+import path from "node:path";
 import vm from "node:vm";
 import createDebug from "debug";
+import { parseSync } from "oxc-parser";
+import MagicString from "magic-string";
 import { createHash } from "node:crypto";
-import { rawTransferSupported, parseSync } from "oxc-parser";
 import { ScopeTracker, walk } from "oxc-walker";
-import MagicString from "magic-string";
 import { resolveStaticStyleRules, resolveResetStyleRules, resolveStyleRulesForSlots, normalizeCSSBucketEntry } from "@griffel/core";
 const ASSET_TAG_OPEN = "<griffel-asset>";
 const ASSET_TAG_CLOSE = "</griffel-asset>";
+const prop = (node, key) => node[key];
+function extractDeclaredNames(node) {
+  switch (node.type) {
+    case "Identifier":
+      return [prop(node, "name")];
+    case "ObjectPattern":
+      return prop(node, "properties").flatMap((p) => {
+        if (p.type === "RestElement") {
+          return extractDeclaredNames(prop(p, "argument"));
+        }
+        return extractDeclaredNames(prop(p, "value"));
+      });
+    case "ArrayPattern":
+      return prop(node, "elements").filter(Boolean).flatMap((el) => extractDeclaredNames(el));
+    case "AssignmentPattern":
+      return extractDeclaredNames(prop(node, "left"));
+    default:
+      return [];
+  }
+}
+function convertESMtoCJS(code, filename) {
+  const parseResult = parseSync(filename, code);
+  if (parseResult.errors.length > 0) {
+    throw new Error(
+      `convertESMtoCJS: failed to parse "${filename}": ${parseResult.errors.map((e) => e.message).join(", ")}`
+    );
+  }
+  const program = parseResult.program;
+  let hasESM = false;
+  for (const node of program.body) {
+    if (node.type === "ImportDeclaration" || node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration" || node.type === "ExportAllDeclaration") {
+      hasESM = true;
+      break;
+    }
+  }
+  if (!hasESM) {
+    return code;
+  }
+  const ms = new MagicString(code);
+  for (const node of program.body) {
+    switch (node.type) {
+      case "ImportDeclaration": {
+        const source = prop(prop(node, "source"), "value");
+        const specifiers = prop(node, "specifiers");
+        if (specifiers.length === 0) {
+          ms.overwrite(node.start, node.end, `require(${JSON.stringify(source)});`);
+        } else {
+          let defaultName = null;
+          let namespaceName = null;
+          const namedImports = [];
+          for (const spec of specifiers) {
+            if (spec.type === "ImportDefaultSpecifier") {
+              defaultName = prop(prop(spec, "local"), "name");
+            } else if (spec.type === "ImportNamespaceSpecifier") {
+              namespaceName = prop(prop(spec, "local"), "name");
+            } else if (spec.type === "ImportSpecifier") {
+              const importedNode = prop(spec, "imported");
+              const imported = importedNode.type === "Identifier" ? prop(importedNode, "name") : prop(importedNode, "value");
+              const local = prop(prop(spec, "local"), "name");
+              if (imported === local) {
+                namedImports.push(imported);
+              } else {
+                namedImports.push(`${imported}: ${local}`);
+              }
+            }
+          }
+          const parts = [];
+          if (namespaceName) {
+            parts.push(`const ${namespaceName} = require(${JSON.stringify(source)});`);
+          } else if (defaultName && namedImports.length > 0) {
+            const tempVar = `_require$${defaultName}`;
+            parts.push(`const ${tempVar} = require(${JSON.stringify(source)});`);
+            parts.push(`const ${defaultName} = ${tempVar}.__esModule ? ${tempVar}.default : ${tempVar};`);
+            parts.push(`const { ${namedImports.join(", ")} } = ${tempVar};`);
+          } else if (defaultName) {
+            const tempVar = `_require$${defaultName}`;
+            parts.push(`const ${tempVar} = require(${JSON.stringify(source)});`);
+            parts.push(`const ${defaultName} = ${tempVar}.__esModule ? ${tempVar}.default : ${tempVar};`);
+          } else if (namedImports.length > 0) {
+            parts.push(`const { ${namedImports.join(", ")} } = require(${JSON.stringify(source)});`);
+          }
+          ms.overwrite(node.start, node.end, parts.join("\n"));
+        }
+        break;
+      }
+      case "ExportNamedDeclaration": {
+        const decl = prop(node, "declaration");
+        if (decl) {
+          ms.overwrite(node.start, decl.start, "");
+          if (decl.type === "VariableDeclaration") {
+            const names = prop(decl, "declarations").flatMap(
+              (d) => extractDeclaredNames(prop(d, "id"))
+            );
+            const exportsCode = names.map((name) => `exports.${name} = ${name};`).join(" ");
+            ms.appendLeft(node.end, "\n" + exportsCode);
+          } else if (decl.type === "FunctionDeclaration" || decl.type === "ClassDeclaration") {
+            const id = prop(decl, "id");
+            if (id) {
+              const name = prop(id, "name");
+              ms.appendLeft(node.end, `
+exports.${name} = ${name};`);
+            }
+          }
+        } else if (prop(node, "source")) {
+          const source = prop(prop(node, "source"), "value");
+          const parts = [];
+          for (const spec of prop(node, "specifiers")) {
+            const localNode = prop(spec, "local");
+            const exportedNode = prop(spec, "exported");
+            const local = localNode.type === "Identifier" ? prop(localNode, "name") : prop(localNode, "value");
+            const exported = exportedNode.type === "Identifier" ? prop(exportedNode, "name") : prop(exportedNode, "value");
+            parts.push(
+              `exports[${JSON.stringify(exported)}] = require(${JSON.stringify(source)})[${JSON.stringify(local)}];`
+            );
+          }
+          ms.overwrite(node.start, node.end, parts.join("\n"));
+        } else {
+          const parts = [];
+          for (const spec of prop(node, "specifiers")) {
+            const localNode = prop(spec, "local");
+            const exportedNode = prop(spec, "exported");
+            const local = localNode.type === "Identifier" ? prop(localNode, "name") : prop(localNode, "value");
+            const exported = exportedNode.type === "Identifier" ? prop(exportedNode, "name") : prop(exportedNode, "value");
+            parts.push(`exports[${JSON.stringify(exported)}] = ${local};`);
+          }
+          ms.overwrite(node.start, node.end, parts.join("\n"));
+        }
+        break;
+      }
+      case "ExportDefaultDeclaration": {
+        const decl = prop(node, "declaration");
+        if (decl.type === "FunctionDeclaration" || decl.type === "ClassDeclaration") {
+          const id = prop(decl, "id");
+          if (id) {
+            ms.overwrite(node.start, decl.start, "");
+            ms.appendLeft(node.end, `
+exports.default = ${prop(id, "name")};`);
+          } else {
+            ms.overwrite(node.start, decl.start, "exports.default = ");
+          }
+        } else {
+          ms.overwrite(node.start, decl.start, "exports.default = ");
+          if (code[node.end - 1] !== ";") {
+            ms.appendLeft(node.end, ";");
+          }
+        }
+        break;
+      }
+      case "ExportAllDeclaration": {
+        const source = prop(prop(node, "source"), "value");
+        const exportedNode = prop(node, "exported");
+        if (exportedNode) {
+          const name = exportedNode.type === "Identifier" ? prop(exportedNode, "name") : prop(exportedNode, "value");
+          ms.overwrite(node.start, node.end, `exports[${JSON.stringify(name)}] = require(${JSON.stringify(source)});`);
+        } else {
+          ms.overwrite(node.start, node.end, `Object.assign(exports, require(${JSON.stringify(source)}));`);
+        }
+        break;
+      }
+    }
+  }
+  ms.prepend('Object.defineProperty(exports, "__esModule", { value: true });\n');
+  return ms.toString();
+}
 const debug$1 = createDebug("griffel:eval-cache");
 const fileHashes = /* @__PURE__ */ new Map();
 const evalCache = /* @__PURE__ */ new Map();
@@ -126,41 +290,6 @@ const mockProcess = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineP
   uvCounters
 }, Symbol.toStringTag, { value: "Module" }));
 const debug = createDebug("griffel:module");
-const builtins = {
-  assert: true,
-  buffer: true,
-  child_process: false,
-  cluster: false,
-  console: true,
-  constants: true,
-  crypto: true,
-  dgram: false,
-  dns: false,
-  domain: true,
-  events: true,
-  fs: false,
-  http: true,
-  https: true,
-  module: false,
-  net: false,
-  os: true,
-  path: true,
-  punycode: true,
-  process: true,
-  querystring: true,
-  readline: false,
-  repl: false,
-  stream: true,
-  string_decoder: true,
-  sys: true,
-  timers: true,
-  tls: false,
-  tty: true,
-  url: true,
-  util: true,
-  vm: true,
-  zlib: true
-};
 let cache = {};
 const NOOP = () => {
 };
@@ -171,18 +300,20 @@ const createCustomDebug = (depth) => (namespaces, arg1, ...args) => {
 class Module {
   id;
   filename;
-  options;
+  rules;
   imports = null;
   dependencies = null;
   transform = null;
+  static extensions = /* @__PURE__ */ new Set([".json", ".js", ".jsx", ".ts", ".tsx", ".cjs", ".mjs", ".mts", ".cts"]);
   exports = {};
-  extensions;
+  resolveFilename;
   debug;
   debuggerDepth;
-  constructor(filename, options, debuggerDepth = 0) {
+  constructor(filename, rules, resolveFilename, debuggerDepth = 0) {
     this.id = filename;
     this.filename = filename;
-    this.options = options;
+    this.rules = rules;
+    this.resolveFilename = resolveFilename;
     this.debuggerDepth = debuggerDepth;
     this.debug = createCustomDebug(debuggerDepth);
     Object.defineProperties(this, {
@@ -204,38 +335,16 @@ class Module {
       }
     });
     this.exports = {};
-    this.extensions = [".json", ".js", ".jsx", ".ts", ".tsx", ".cjs"];
     this.debug("prepare", filename);
   }
-  resolve = (id) => {
-    const extensions = NativeModule._extensions;
-    const added = [];
-    try {
-      this.extensions.forEach((ext) => {
-        if (ext in extensions) {
-          return;
-        }
-        extensions[ext] = NOOP;
-        added.push(ext);
-      });
-      return Module._resolveFilename(id, this);
-    } finally {
-      added.forEach((ext) => delete extensions[ext]);
-    }
-  };
   require = Object.assign(
     (id) => {
       this.debug("require", id);
-      if (id in builtins) {
-        if (builtins[id]) {
-          return require(id);
-        }
-        return null;
-      }
-      const filename = this.resolve(id);
-      if (filename === id && !path.isAbsolute(id)) {
+      const resolved = this.resolveFilename(id, this);
+      if (resolved.builtin) {
         throw new Error(`Unable to import "${id}". Importing Node builtins is not supported in the sandbox.`);
       }
+      const filename = resolved.path;
       this.dependencies?.push(id);
       let cacheKey = filename;
       let only = [];
@@ -249,12 +358,13 @@ class Module {
       let m = cache[cacheKey];
       if (!m) {
         this.debug("cached:not-exist", id);
-        m = new Module(filename, this.options, this.debuggerDepth + 1);
+        m = new Module(filename, this.rules, this.resolveFilename, this.debuggerDepth + 1);
         m.transform = this.transform;
         cache[cacheKey] = m;
-        if (this.extensions.includes(path.extname(filename))) {
+        const ext = path.extname(filename).toLowerCase();
+        if (Module.extensions.has(ext)) {
           const code = fs.readFileSync(filename, "utf-8");
-          if (/\.json$/.test(filename)) {
+          if (ext === ".json") {
             m.exports = JSON.parse(code);
           } else {
             m.evaluate(code, only.includes("*") ? ["*"] : only);
@@ -270,16 +380,16 @@ class Module {
     {
       ensure: NOOP,
       cache,
-      resolve: this.resolve
+      resolve: (id) => this.resolveFilename(id, this).path
     }
   );
   evaluate(text, only = null) {
     const { filename } = this;
     let action = "ignore";
-    for (let i = this.options.rules.length - 1; i >= 0; i--) {
-      const { test } = this.options.rules[i];
-      if (!test || (typeof test === "function" ? test(filename) : test instanceof RegExp && test.test(filename))) {
-        action = this.options.rules[i].action;
+    for (let i = this.rules.length - 1; i >= 0; i--) {
+      const { test } = this.rules[i];
+      if (!test || (typeof test === "function" ? test(filename) : test.test(filename))) {
+        action = this.rules[i].action;
         break;
       }
     }
@@ -293,13 +403,13 @@ class Module {
       this.debug("ignore", `${filename}`);
       code = text;
     } else {
-      const evaluator = typeof action === "function" ? action : require(require.resolve(action, {
-        paths: [dirname(this.filename)]
-      })).default;
-      let imports;
-      this.debug("prepare-evaluation", this.filename, "using", evaluator.name);
-      [code, imports] = evaluator(this.filename, this.options, text, only);
-      this.imports = imports;
+      this.debug("prepare-evaluation", this.filename, "using", action.name);
+      const result = action(this.filename, text, only);
+      code = result.code;
+      this.imports = result.imports;
+      if (result.moduleKind === "esm") {
+        code = convertESMtoCJS(code, this.filename);
+      }
       this.debug("evaluate", `${this.filename} (only ${(only || []).join(", ")}):
 ${code}`);
     }
@@ -315,6 +425,7 @@ ${code}`);
         setImmediate: NOOP,
         setInterval: NOOP,
         setTimeout: NOOP,
+        fetch: NOOP,
         global,
         process: mockProcess,
         module: this,
@@ -332,13 +443,6 @@ ${code}`);
   static invalidateEvalCache = () => {
     clear();
   };
-  // Alias to resolve the module using node's resolve algorithm
-  // This static property can be overridden by the webpack loader
-  // This allows us to use webpack's module resolution algorithm
-  static _resolveFilename = (id, options) => NativeModule._resolveFilename(
-    id,
-    options
-  );
   static _nodeModulePaths = (filename) => NativeModule._nodeModulePaths(filename);
 }
 const DEOPT = /* @__PURE__ */ Symbol("deopt");
@@ -369,17 +473,17 @@ function astEvaluator(node, programAst, plugins = []) {
   }
   function evaluateObjectExpression(node2) {
     const obj = {};
-    for (const prop of node2.properties) {
-      if (prop.type !== "Property" || prop.kind !== "init") {
+    for (const prop2 of node2.properties) {
+      if (prop2.type !== "Property" || prop2.kind !== "init") {
         return DEOPT;
       }
       let key;
-      if (prop.computed) {
+      if (prop2.computed) {
         return DEOPT;
-      } else if (prop.key.type === "Identifier") {
-        key = prop.key.name;
-      } else if (prop.key.type === "Literal") {
-        const keyLiteral = prop.key;
+      } else if (prop2.key.type === "Identifier") {
+        key = prop2.key.name;
+      } else if (prop2.key.type === "Literal") {
+        const keyLiteral = prop2.key;
         if (typeof keyLiteral.value === "string" || typeof keyLiteral.value === "number") {
           key = String(keyLiteral.value);
         } else {
@@ -388,7 +492,7 @@ function astEvaluator(node, programAst, plugins = []) {
       } else {
         return DEOPT;
       }
-      const value = evaluateNode(prop.value);
+      const value = evaluateNode(prop2.value);
       if (value === DEOPT) {
         return DEOPT;
       }
@@ -411,34 +515,20 @@ function astEvaluator(node, programAst, plugins = []) {
 function isError(e) {
   return Object.prototype.toString.call(e) === "[object Error]";
 }
-function vmEvaluator(sourceCode, filename, expressionCode, babelOptions, evaluationRules) {
+function vmEvaluator(sourceCode, filename, expressionCode, evaluationRules, resolveFilename) {
   const codeForEvaluation = `
 ${sourceCode}
 
-const __mkPreval = (() => {
+export const __mkPreval = (() => {
   try {
     return ([${expressionCode}]);
   } catch (e) {
     return e;
   }
 })();
-
-if (typeof module !== 'undefined' && module.exports) {
-  module.exports = { __mkPreval };
-}
 `;
   try {
-    const options = {
-      displayName: false,
-      evaluate: true,
-      rules: evaluationRules,
-      babelOptions: {
-        ...babelOptions,
-        configFile: false,
-        babelrc: false
-      }
-    };
-    const mod = new Module(filename, options);
+    const mod = new Module(filename, evaluationRules, resolveFilename);
     mod.evaluate(codeForEvaluation, ["__mkPreval"]);
     const result = mod.exports.__mkPreval;
     if (isError(result)) {
@@ -449,10 +539,10 @@ if (typeof module !== 'undefined' && module.exports) {
     return { confident: false, error: err };
   }
 }
-function batchEvaluator(sourceCode, filename, styleCalls, babelOptions, evaluationRules, programAst, astEvaluationPlugins = []) {
+function batchEvaluator(sourceCode, filename, styleCalls, evaluationRules, resolveFilename, programAst, astEvaluationPlugins = []) {
   const evaluationResults = new Array(styleCalls.length);
-  const argumentsCode = new Array(styleCalls.length).fill(null);
-  let vmEvaluationNeeded = false;
+  const vmIndices = [];
+  let expressionCode = "";
   for (let i = 0; i < styleCalls.length; i++) {
     const styleCall = styleCalls[i];
     const staticResult = astEvaluator(styleCall.argumentNode, programAst, astEvaluationPlugins);
@@ -460,16 +550,19 @@ function batchEvaluator(sourceCode, filename, styleCalls, babelOptions, evaluati
       evaluationResults[i] = staticResult.value;
       continue;
     }
-    vmEvaluationNeeded = true;
-    argumentsCode[i] = styleCall.argumentCode;
+    if (expressionCode.length > 0) {
+      expressionCode += ",";
+    }
+    expressionCode += styleCall.argumentCode;
+    vmIndices.push(i);
   }
-  if (!vmEvaluationNeeded) {
+  if (vmIndices.length === 0) {
     return {
       usedVMForEvaluation: false,
       evaluationResults
     };
   }
-  const vmResult = vmEvaluator(sourceCode, filename, argumentsCode.join(","), babelOptions, evaluationRules);
+  const vmResult = vmEvaluator(sourceCode, filename, expressionCode, evaluationRules, resolveFilename);
   if (!vmResult.confident) {
     if (vmResult.error) {
       throw vmResult.error;
@@ -478,45 +571,14 @@ function batchEvaluator(sourceCode, filename, styleCalls, babelOptions, evaluati
     }
   }
   const vmValues = vmResult.value;
-  for (let i = 0; i < vmValues.length; i++) {
-    if (vmValues[i] === null) {
-      continue;
-    }
-    evaluationResults[i] = vmValues[i];
+  for (let i = 0; i < vmIndices.length; i++) {
+    evaluationResults[vmIndices[i]] = vmValues[i];
   }
   return {
     usedVMForEvaluation: true,
     evaluationResults
   };
 }
-const CJS_EXTENSIONS = /* @__PURE__ */ new Set([".cjs", ".cts", ".json"]);
-const ESM_EXTENSIONS = /* @__PURE__ */ new Set([".mjs", ".mts"]);
-const useRawTransfer = rawTransferSupported();
-const NODE_MODULES_RE = /[/\\]node_modules[/\\]/;
-function createHybridEvaluator(shakerEvaluator2) {
-  return (filename, options, text, only) => {
-    if (!NODE_MODULES_RE.test(filename)) {
-      return shakerEvaluator2(filename, options, text, only);
-    }
-    const ext = extname(filename);
-    if (CJS_EXTENSIONS.has(ext)) {
-      return [text, null];
-    }
-    if (ESM_EXTENSIONS.has(ext)) {
-      return shakerEvaluator2(filename, options, text, only);
-    }
-    const parseResult = parseSync(filename, text, {
-      sourceType: "unambiguous",
-      ...useRawTransfer && { experimentalLazy: true }
-    });
-    const isESM = parseResult.module.hasModuleSyntax;
-    parseResult.dispose?.();
-    if (!isESM) {
-      return [text, null];
-    }
-    return shakerEvaluator2(filename, options, text, only);
-  };
-}
 function evaluateTemplateLiteralWithTokens(node) {
   let result = "";
   for (let i = 0; i < node.quasis.length; i++) {
@@ -568,7 +630,18 @@ function dedupeCSSRules(cssRulesByBucket) {
     })
   );
 }
-const shakerEvaluator = _shaker.default || _shaker;
+const EXPORT_STAR_RE = /export\s+\*\s+from\s/;
+function wrapWithPerfIssues(evaluator, perfIssues) {
+  return (filename, text, only) => {
+    const result = evaluator(filename, text, only);
+    if (result.moduleKind === "cjs") {
+      perfIssues.push({ type: "cjs-module", dependencyFilename: filename });
+    } else if (EXPORT_STAR_RE.test(result.code)) {
+      perfIssues.push({ type: "barrel-export-star", dependencyFilename: filename });
+    }
+    return result;
+  };
+}
 const RUNTIME_IDENTIFIERS = /* @__PURE__ */ new Map([
   ["makeStyles", "__css"],
   ["makeResetStyles", "__resetCSS"],
@@ -634,13 +707,14 @@ function concatCSSRulesByBucket(bucketA = {}, bucketB) {
   return bucketA;
 }
 function transformSync(sourceCode, options) {
+  const perfIssues = options.collectPerfIssues ? [] : void 0;
   const {
-    babelOptions = {},
     filename,
+    resolveModule,
     classNameHashSalt = "",
     generateMetadata = false,
     modules = ["@griffel/core", "@griffel/react", "@fluentui/react-components"],
-    evaluationRules = [{ action: createHybridEvaluator(shakerEvaluator) }],
+    evaluationRules = [{ action: perfIssues ? wrapWithPerfIssues(shakerEvaluator, perfIssues) : shakerEvaluator }],
     astEvaluationPlugins = [fluentTokensPlugin]
   } = options;
   if (!filename) {
@@ -740,8 +814,8 @@ function transformSync(sourceCode, options) {
     sourceCode,
     filename,
     styleCalls,
-    babelOptions,
     evaluationRules,
+    resolveModule,
     programAst,
     astEvaluationPlugins
   );
@@ -804,7 +878,8 @@ function transformSync(sourceCode, options) {
     code: magicString.toString(),
     cssRulesByBucket,
     usedProcessing: true,
-    usedVMForEvaluation
+    usedVMForEvaluation,
+    perfIssues
   };
 }
 export {

package/transformSync.d.mts

@@ -1,7 +1,10 @@
-import { StrictOptions, AstEvaluatorPlugin } from './evaluation/types.mjs';
+import { TransformResolver } from './evaluation/module.mjs';
+import { EvalRule, TransformPerfIssue, AstEvaluatorPlugin } from './evaluation/types.mjs';
 import { CSSRulesByBucket } from '@griffel/core';
 export type TransformOptions = {
     filename: string;
+    /** Custom module resolver used to resolve imports inside evaluated modules. */
+    resolveModule: TransformResolver;
     classNameHashSalt?: string;
     /**
      * Returns the evaluated CSS rules in the file result metadata
@@ -10,21 +13,22 @@ export type TransformOptions = {
     generateMetadata?: boolean;
     /** Defines set of modules and imports handled by a transformPlugin. */
     modules?: string[];
-    /**
-     * If you need to specify custom Babel configuration, you can pass them here. These options will be used by the
-     * transformPlugin when parsing and evaluating modules.
-     */
-    babelOptions?: Pick<StrictOptions['babelOptions'], 'plugins' | 'presets'>;
     /** The set of rules that defines how the matched files will be transformed during the evaluation. */
-    evaluationRules?: StrictOptions['rules'];
+    evaluationRules?: EvalRule[];
     /** Plugins for extending AST evaluation with custom node handling. */
     astEvaluationPlugins?: AstEvaluatorPlugin[];
+    /**
+     * Collects performance issues (CJS modules, barrel re-exports) during evaluation.
+     * @default false
+     */
+    collectPerfIssues?: boolean;
 };
 export type TransformResult = {
     code: string;
     cssRulesByBucket?: CSSRulesByBucket;
     usedProcessing: boolean;
     usedVMForEvaluation: boolean;
+    perfIssues?: TransformPerfIssue[];
 };
 /**
  * Transforms passed source code with oxc-parser and oxc-walker instead of Babel.

package/utils/convertESMtoCJS.d.mts

@@ -0,0 +1,6 @@
+/**
+ * Converts ESM import/export syntax to CJS require/exports equivalents.
+ * This is needed because the VM evaluator wraps code in `(function(exports) { ... })(exports)`
+ * which cannot contain ESM syntax.
+ */
+export declare function convertESMtoCJS(code: string, filename: string): string;

package/evaluation/hybridEvaluator.d.mts

@@ -1,2 +0,0 @@
-import { Evaluator } from './types.mjs';
-export declare function createHybridEvaluator(shakerEvaluator: Evaluator): Evaluator;