@griffel/transform 3.0.0 → 3.0.1

package/transform.js

@@ -1,933 +0,0 @@
-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 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 { ScopeTracker, walk } from "oxc-walker";
-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);
-  const deferredExports = [];
-  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"))
-            );
-            deferredExports.push(...names);
-          } else if (decl.type === "FunctionDeclaration" || decl.type === "ClassDeclaration") {
-            const id = prop(decl, "id");
-            if (id) {
-              deferredExports.push(prop(id, "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;
-      }
-    }
-  }
-  if (deferredExports.length > 0) {
-    ms.append("\n" + deferredExports.map((name) => `exports.${name} = ${name};`).join("\n"));
-  }
-  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();
-const fileKeys = /* @__PURE__ */ new Map();
-const hash = (text) => createHash("sha1").update(text).digest("base64");
-let lastText = "";
-let lastHash = hash(lastText);
-const memoizedHash = (text) => {
-  if (lastText !== text) {
-    lastHash = hash(text);
-    lastText = text;
-  }
-  return lastHash;
-};
-const toKey = (filename, exports$1) => exports$1.length > 0 ? `${filename}:${exports$1.join(",")}` : filename;
-const clear = () => {
-  fileHashes.clear();
-  evalCache.clear();
-  fileKeys.clear();
-};
-const clearForFile = (filename) => {
-  const keys = fileKeys.get(filename) ?? [];
-  if (keys.length === 0) {
-    return;
-  }
-  debug$1("clear-for-file", filename);
-  keys.forEach((key) => {
-    fileHashes.delete(key);
-    evalCache.delete(key);
-  });
-  fileKeys.set(filename, []);
-};
-const has = ([filename, ...exports$1], text) => {
-  const key = toKey(filename, exports$1);
-  const textHash = memoizedHash(text);
-  debug$1("has", `${key} ${textHash}`);
-  return fileHashes.get(key) === textHash;
-};
-const get = ([filename, ...exports$1], text) => {
-  const key = toKey(filename, exports$1);
-  const textHash = memoizedHash(text);
-  debug$1("get", `${key} ${textHash}`);
-  if (fileHashes.get(key) !== textHash) {
-    return void 0;
-  }
-  return evalCache.get(key);
-};
-const set = ([filename, ...exports$1], text, value) => {
-  const key = toKey(filename, exports$1);
-  const textHash = memoizedHash(text);
-  debug$1("set", `${key} ${textHash}`);
-  fileHashes.set(key, textHash);
-  evalCache.set(key, value);
-  if (!fileKeys.has(filename)) {
-    fileKeys.set(filename, []);
-  }
-  fileKeys.get(filename).push(key);
-};
-const evalCache$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  clear,
-  clearForFile,
-  get,
-  has,
-  set
-}, Symbol.toStringTag, { value: "Module" }));
-const nextTick = (fn) => setTimeout(fn, 0);
-const platform = "browser";
-const arch = "browser";
-const execPath = "browser";
-const title = "browser";
-const pid = 1;
-const browser = true;
-const argv = [];
-const binding = function binding2() {
-  throw new Error("No such module. (Possibly not yet loaded)");
-};
-const cwd = () => "/";
-const noop = () => {
-};
-const exit = noop;
-const kill = noop;
-const chdir = noop;
-const umask = noop;
-const dlopen = noop;
-const uptime = noop;
-const memoryUsage = noop;
-const uvCounters = noop;
-const features = {};
-const env = process.env;
-const mockProcess = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  arch,
-  argv,
-  binding,
-  browser,
-  chdir,
-  cwd,
-  dlopen,
-  env,
-  execPath,
-  exit,
-  features,
-  kill,
-  memoryUsage,
-  nextTick,
-  pid,
-  platform,
-  title,
-  umask,
-  uptime,
-  uvCounters
-}, Symbol.toStringTag, { value: "Module" }));
-const debug = createDebug("griffel:module");
-let cache = {};
-const NOOP = () => {
-};
-function isError$1(e) {
-  return e != null && typeof e === "object" && "message" in e && "stack" in e;
-}
-const createCustomDebug = (depth) => (namespaces, arg1, ...args) => {
-  const modulePrefix = depth === 0 ? "module" : `sub-module-${depth}`;
-  debug(`${modulePrefix}:${namespaces}`, arg1, ...args);
-};
-class Module {
-  id;
-  filename;
-  rules;
-  imports = null;
-  dependencies = null;
-  transform = null;
-  static extensions = /* @__PURE__ */ new Set([".json", ".js", ".jsx", ".ts", ".tsx", ".cjs", ".mjs", ".mts", ".cts"]);
-  exports = {};
-  resolveFilename;
-  debug;
-  debuggerDepth;
-  constructor(filename, rules, resolveFilename, debuggerDepth = 0) {
-    this.id = filename;
-    this.filename = filename;
-    this.rules = rules;
-    this.resolveFilename = resolveFilename;
-    this.debuggerDepth = debuggerDepth;
-    this.debug = createCustomDebug(debuggerDepth);
-    Object.defineProperties(this, {
-      id: {
-        value: filename,
-        writable: false
-      },
-      filename: {
-        value: filename,
-        writable: false
-      },
-      paths: {
-        value: Object.freeze(
-          NativeModule._nodeModulePaths(
-            path.dirname(filename)
-          )
-        ),
-        writable: false
-      }
-    });
-    this.exports = {};
-    this.debug("prepare", filename);
-  }
-  require = Object.assign(
-    (id) => {
-      this.debug("require", 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 = [];
-      if (this.imports?.has(id)) {
-        only = this.imports.get(id).sort();
-        if (only.length === 0) {
-          only = ["default"];
-        }
-        cacheKey += `:${only.join(",")}`;
-      }
-      let m = cache[cacheKey];
-      if (!m) {
-        this.debug("cached:not-exist", id);
-        m = new Module(filename, this.rules, this.resolveFilename, this.debuggerDepth + 1);
-        m.transform = this.transform;
-        cache[cacheKey] = m;
-        const ext = path.extname(filename).toLowerCase();
-        if (Module.extensions.has(ext)) {
-          const code = fs.readFileSync(filename, "utf-8");
-          if (ext === ".json") {
-            m.exports = JSON.parse(code);
-          } else {
-            m.evaluate(code, only.includes("*") ? ["*"] : only);
-          }
-        } else {
-          m.exports = ASSET_TAG_OPEN + filename + ASSET_TAG_CLOSE;
-        }
-      } else {
-        this.debug("cached:exist", id);
-      }
-      return m.exports;
-    },
-    {
-      ensure: NOOP,
-      cache,
-      resolve: (id) => this.resolveFilename(id, this).path
-    }
-  );
-  evaluate(text, only = null, useEvalCache = true) {
-    const { filename } = this;
-    let action = "ignore";
-    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;
-      }
-    }
-    const cacheKey = [this.filename, ...only ?? []];
-    if (useEvalCache && has(cacheKey, text)) {
-      this.exports = get(cacheKey, text);
-      return;
-    }
-    let code;
-    if (action === "ignore") {
-      this.debug("ignore", `${filename}`);
-      code = text;
-    } else {
-      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}`);
-    }
-    const script = new vm.Script(`(function (exports) { ${code}
-})(exports);`, {
-      filename: this.filename
-    });
-    try {
-      script.runInContext(
-        vm.createContext({
-          clearImmediate: NOOP,
-          clearInterval: NOOP,
-          clearTimeout: NOOP,
-          setImmediate: NOOP,
-          setInterval: NOOP,
-          setTimeout: NOOP,
-          fetch: NOOP,
-          global,
-          process: mockProcess,
-          module: this,
-          exports: this.exports,
-          require: this.require,
-          __filename: this.filename,
-          __dirname: path.dirname(this.filename)
-        })
-      );
-    } catch (vmError) {
-      const message = isError$1(vmError) ? vmError.message : String(vmError);
-      const hostError = new Error(message);
-      if (isError$1(vmError)) {
-        hostError.stack = vmError.stack;
-      }
-      throw hostError;
-    }
-    if (useEvalCache) {
-      set(cacheKey, text, this.exports);
-    }
-  }
-  static invalidate = () => {
-    cache = {};
-  };
-  static invalidateEvalCache = () => {
-    clear();
-  };
-  static _nodeModulePaths = (filename) => NativeModule._nodeModulePaths(filename);
-}
-const DEOPT = /* @__PURE__ */ Symbol("deopt");
-function astEvaluator(node, programAst, plugins = []) {
-  const context = {
-    programAst,
-    evaluateNode
-  };
-  function evaluateNode(node2) {
-    switch (node2.type) {
-      case "Literal":
-        return node2.value;
-      case "ObjectExpression":
-        return evaluateObjectExpression(node2);
-      case "TemplateLiteral":
-        if (node2.expressions.length === 0) {
-          return node2.quasis[0].value.cooked;
-        }
-        break;
-    }
-    for (const plugin of plugins) {
-      const result2 = plugin.evaluateNode(node2, context);
-      if (result2 !== DEOPT) {
-        return result2;
-      }
-    }
-    return DEOPT;
-  }
-  function evaluateObjectExpression(node2) {
-    const obj = {};
-    for (const prop2 of node2.properties) {
-      if (prop2.type !== "Property" || prop2.kind !== "init") {
-        return DEOPT;
-      }
-      let key;
-      if (prop2.computed) {
-        return DEOPT;
-      } 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 {
-          return DEOPT;
-        }
-      } else {
-        return DEOPT;
-      }
-      const value = evaluateNode(prop2.value);
-      if (value === DEOPT) {
-        return DEOPT;
-      }
-      obj[key] = value;
-    }
-    return obj;
-  }
-  const result = evaluateNode(node);
-  if (result === DEOPT) {
-    return {
-      confident: false,
-      value: void 0
-    };
-  }
-  return {
-    confident: true,
-    value: result
-  };
-}
-function isError(e) {
-  return Object.prototype.toString.call(e) === "[object Error]";
-}
-function vmEvaluator(sourceCode, filename, expressionCode, evaluationRules, resolveFilename) {
-  const codeForEvaluation = `
-${sourceCode}
-
-export const __mkPreval = (() => {
-  try {
-    return ([${expressionCode}]);
-  } catch (e) {
-    return e;
-  }
-})();
-`;
-  try {
-    const mod = new Module(filename, evaluationRules, resolveFilename);
-    mod.evaluate(
-      codeForEvaluation,
-      ["__mkPreval"],
-      /* useEvalCache */
-      false
-    );
-    const result = mod.exports.__mkPreval;
-    if (isError(result)) {
-      return { confident: false, error: result };
-    }
-    return { confident: true, value: result };
-  } catch (err) {
-    return { confident: false, error: err };
-  }
-}
-function batchEvaluator(sourceCode, filename, styleCalls, evaluationRules, resolveFilename, programAst, astEvaluationPlugins = []) {
-  const evaluationResults = new Array(styleCalls.length);
-  const vmIndices = [];
-  let expressionCode = "";
-  for (let i = 0; i < styleCalls.length; i++) {
-    const styleCall = styleCalls[i];
-    const staticResult = astEvaluator(styleCall.argumentNode, programAst, astEvaluationPlugins);
-    if (staticResult.confident) {
-      evaluationResults[i] = staticResult.value;
-      continue;
-    }
-    if (expressionCode.length > 0) {
-      expressionCode += ",";
-    }
-    expressionCode += styleCall.argumentCode;
-    vmIndices.push(i);
-  }
-  if (vmIndices.length === 0) {
-    return {
-      usedVMForEvaluation: false,
-      evaluationResults
-    };
-  }
-  const vmResult = vmEvaluator(sourceCode, filename, expressionCode, evaluationRules, resolveFilename);
-  if (!vmResult.confident) {
-    if (vmResult.error) {
-      throw vmResult.error;
-    } else {
-      throw new Error("Evaluation of a code fragment failed, this is a bug, please report it");
-    }
-  }
-  const vmValues = vmResult.value;
-  for (let i = 0; i < vmIndices.length; i++) {
-    evaluationResults[vmIndices[i]] = vmValues[i];
-  }
-  return {
-    usedVMForEvaluation: true,
-    evaluationResults
-  };
-}
-const Z_INDEX_DEFAULTS = {
-  zIndexBackground: 0,
-  zIndexContent: 1,
-  zIndexOverlay: 1e3,
-  zIndexPopup: 2e3,
-  zIndexMessages: 3e3,
-  zIndexFloating: 4e3,
-  zIndexPriority: 5e3,
-  zIndexDebug: 6e3
-};
-function evaluateTemplateLiteralWithTokens(node) {
-  let result = "";
-  for (let i = 0; i < node.quasis.length; i++) {
-    result += node.quasis[i].value.cooked;
-    if (i < node.expressions.length) {
-      const expression = node.expressions[i];
-      if (expression.type === "MemberExpression" && expression.object.type === "Identifier" && expression.object.name === "tokens" && expression.property.type === "Identifier" && !expression.computed) {
-        const name = expression.property.name;
-        const fallback = Z_INDEX_DEFAULTS[name];
-        result += fallback !== void 0 ? `var(--${name}, ${fallback})` : `var(--${name})`;
-      } else {
-        return DEOPT;
-      }
-    }
-  }
-  return result;
-}
-function evaluateTokensMemberExpression(node) {
-  if (node.object.type === "Identifier" && node.object.name === "tokens" && node.property.type === "Identifier" && !node.computed) {
-    const name = node.property.name;
-    const fallback = Z_INDEX_DEFAULTS[name];
-    return fallback !== void 0 ? `var(--${name}, ${fallback})` : `var(--${name})`;
-  } else {
-    return DEOPT;
-  }
-}
-const fluentTokensPlugin = {
-  name: "fluentTokensPlugin",
-  evaluateNode(node) {
-    switch (node.type) {
-      case "TemplateLiteral":
-        return evaluateTemplateLiteralWithTokens(node);
-      case "MemberExpression":
-        return evaluateTokensMemberExpression(node);
-      default:
-        return DEOPT;
-    }
-  }
-};
-function dedupeCSSRules(cssRulesByBucket) {
-  return Object.fromEntries(
-    Object.entries(cssRulesByBucket).map(([styleBucketName, cssBucketEntries]) => {
-      if (styleBucketName === "m") {
-        const seen = /* @__PURE__ */ new Map();
-        for (const entry of cssBucketEntries) {
-          if (!seen.has(entry[0])) {
-            seen.set(entry[0], entry);
-          }
-        }
-        return [styleBucketName, Array.from(seen.values())];
-      }
-      return [styleBucketName, Array.from(new Set(cssBucketEntries))];
-    })
-  );
-}
-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"],
-  ["makeStaticStyles", "__staticCSS"]
-]);
-function buildCSSResetEntriesMetadata(cssResetEntries, cssRules, declaratorId) {
-  const cssRulesByBucket = Array.isArray(cssRules) ? { d: cssRules } : cssRules;
-  cssResetEntries[declaratorId] ??= [];
-  cssResetEntries[declaratorId] = Object.values(cssRulesByBucket).flatMap((bucketEntries) => {
-    return bucketEntries.map((bucketEntry) => {
-      if (Array.isArray(bucketEntry)) {
-        throw new Error(
-          `CSS rules in buckets for "makeResetStyles()" should not contain arrays, got: ${JSON.stringify(
-            bucketEntry
-          )})}`
-        );
-      }
-      return bucketEntry;
-    });
-  });
-}
-function buildCSSEntriesMetadata(cssEntries, classnamesMapping, cssRulesByBucket, declaratorId) {
-  const classesBySlot = Object.fromEntries(
-    Object.entries(classnamesMapping).map(([slot, cssClassesMap]) => {
-      const uniqueClasses = /* @__PURE__ */ new Set();
-      Object.values(cssClassesMap).forEach((cssClasses) => {
-        if (typeof cssClasses === "string") {
-          uniqueClasses.add(cssClasses);
-        } else if (Array.isArray(cssClasses)) {
-          cssClasses.forEach((cssClass) => uniqueClasses.add(cssClass));
-        }
-      });
-      return [slot, Array.from(uniqueClasses)];
-    })
-  );
-  const cssRules = Object.values(cssRulesByBucket).flatMap((cssRulesByBucket2) => {
-    return cssRulesByBucket2.map((bucketEntry) => {
-      const [cssRule] = normalizeCSSBucketEntry(bucketEntry);
-      return cssRule;
-    });
-  });
-  cssEntries[declaratorId] = Object.fromEntries(
-    Object.entries(classesBySlot).map(([slot, cssClasses]) => {
-      return [
-        slot,
-        cssClasses.map((cssClass) => {
-          return cssRules.find((rule) => rule.includes(cssClass));
-        })
-      ];
-    })
-  );
-}
-function concatCSSRulesByBucket(bucketA = {}, bucketB) {
-  for (const cssBucketName in bucketB) {
-    const bucketName = cssBucketName;
-    const bucketBEntries = bucketB[bucketName] ?? [];
-    if (bucketA[bucketName]) {
-      bucketA[bucketName].push(...bucketBEntries);
-    } else {
-      bucketA[bucketName] = bucketBEntries;
-    }
-  }
-  return bucketA;
-}
-function transformSync(sourceCode, options) {
-  const perfIssues = options.collectPerfIssues ? [] : void 0;
-  const {
-    filename,
-    resolveModule,
-    classNameHashSalt = "",
-    generateMetadata = false,
-    importsToTransform = ["@griffel/core", "@griffel/react", "@fluentui/react-components"],
-    functionsToTransform = ["makeStyles", "makeResetStyles", "makeStaticStyles"],
-    evaluationRules = [{ action: perfIssues ? wrapWithPerfIssues(shakerEvaluator, perfIssues) : shakerEvaluator }],
-    astEvaluationPlugins = [fluentTokensPlugin]
-  } = options;
-  const importsToTransformSet = new Set(importsToTransform);
-  const functionsToTransformSet = new Set(functionsToTransform);
-  if (!filename) {
-    throw new Error('Transform error: "filename" option is required');
-  }
-  const parseResult = parseSync(filename, sourceCode);
-  if (parseResult.errors.length > 0) {
-    throw new Error(`Failed to parse "${filename}": ${parseResult.errors.map((e) => e.message).join(", ")}`);
-  }
-  if (parseResult.program.body.length > 0 && !parseResult.module.hasModuleSyntax) {
-    throw new Error(
-      `Transform error: "${filename}" is not an ES module. @griffel/transform only supports ES modules (files using import/export syntax).`
-    );
-  }
-  const magicString = new MagicString(sourceCode);
-  const programAst = parseResult.program;
-  const hasGriffelImports = parseResult.module.staticImports.some(
-    (si) => importsToTransformSet.has(si.moduleRequest.value) && si.entries.some((e) => e.importName.kind === "Name" && functionsToTransformSet.has(e.importName.name))
-  );
-  if (!hasGriffelImports) {
-    return { code: sourceCode, usedProcessing: false, usedVMForEvaluation: false };
-  }
-  const styleCalls = [];
-  const cssEntries = {};
-  const cssResetEntries = {};
-  let cssRulesByBucket = {};
-  const scopeTracker = new ScopeTracker();
-  const matchedSpecifiers = /* @__PURE__ */ new Map();
-  walk(programAst, {
-    scopeTracker,
-    enter(node, parent) {
-      if (node.type === "CallExpression" && node.callee.type === "Identifier") {
-        const declaration = scopeTracker.getDeclaration(node.callee.name);
-        if (declaration?.type !== "Import" || declaration.node.type !== "ImportSpecifier") {
-          return;
-        }
-        const importSource = declaration.importNode.source.value;
-        if (!importsToTransformSet.has(importSource)) {
-          return;
-        }
-        const imported = declaration.node.imported;
-        if (imported.type !== "Identifier") {
-          return;
-        }
-        const importedName = imported.name;
-        if (!functionsToTransformSet.has(importedName)) {
-          return;
-        }
-        const functionKind = importedName;
-        if (node.arguments.length !== 1) {
-          throw new Error(
-            `${functionKind}() function accepts only a single param, got ${node.arguments.length} in ${filename}`
-          );
-        }
-        matchedSpecifiers.set(declaration.node.start, {
-          start: declaration.node.start,
-          end: declaration.node.end,
-          functionKind
-        });
-        let declaratorId = "unknownHook";
-        let current = parent;
-        while (current) {
-          if (!current) {
-            break;
-          }
-          if (current.type === "VariableDeclarator" && current.id.type === "Identifier") {
-            declaratorId = current.id.name;
-            break;
-          }
-          if ("parent" in current) {
-            current = current.parent;
-            continue;
-          }
-          break;
-        }
-        const argument = node.arguments[0];
-        styleCalls.push({
-          declaratorId,
-          functionKind,
-          argumentStart: argument.start,
-          argumentEnd: argument.end,
-          argumentCode: sourceCode.slice(argument.start, argument.end),
-          argumentNode: argument,
-          callStart: node.start,
-          callEnd: node.end,
-          importId: node.callee.name
-        });
-      }
-    }
-  });
-  if (styleCalls.length === 0) {
-    return {
-      code: sourceCode,
-      usedProcessing: false,
-      usedVMForEvaluation: false
-    };
-  }
-  const { evaluationResults, usedVMForEvaluation } = batchEvaluator(
-    sourceCode,
-    filename,
-    styleCalls,
-    evaluationRules,
-    resolveModule,
-    programAst,
-    astEvaluationPlugins
-  );
-  for (let i = styleCalls.length - 1; i >= 0; i--) {
-    const styleCall = styleCalls[i];
-    const evaluationResult = evaluationResults[i];
-    switch (styleCall.functionKind) {
-      case "makeStyles":
-        {
-          const stylesBySlots = evaluationResult;
-          const [classnamesMapping, resolvedCSSRules] = resolveStyleRulesForSlots(stylesBySlots, classNameHashSalt);
-          const uniqueCSSRules = dedupeCSSRules(cssRulesByBucket);
-          if (generateMetadata) {
-            buildCSSEntriesMetadata(cssEntries, classnamesMapping, uniqueCSSRules, styleCall.declaratorId);
-          }
-          magicString.overwrite(styleCall.argumentStart, styleCall.argumentEnd, `${JSON.stringify(classnamesMapping)}`);
-          cssRulesByBucket = concatCSSRulesByBucket(cssRulesByBucket, resolvedCSSRules);
-        }
-        break;
-      case "makeResetStyles":
-        {
-          const styles = evaluationResult;
-          const [ltrClassName, rtlClassName, cssRules] = resolveResetStyleRules(styles, classNameHashSalt);
-          if (generateMetadata) {
-            buildCSSResetEntriesMetadata(cssResetEntries, cssRules, styleCall.declaratorId);
-          }
-          magicString.overwrite(
-            styleCall.argumentStart,
-            styleCall.argumentEnd,
-            `${JSON.stringify(ltrClassName)}, ${JSON.stringify(rtlClassName)}`
-          );
-          cssRulesByBucket = concatCSSRulesByBucket(
-            cssRulesByBucket,
-            Array.isArray(cssRules) ? { r: cssRules } : cssRules
-          );
-        }
-        break;
-      case "makeStaticStyles":
-        {
-          const styles = evaluationResult;
-          const stylesSet = Array.isArray(styles) ? styles : [styles];
-          const cssRules = resolveStaticStyleRules(stylesSet);
-          magicString.overwrite(styleCall.argumentStart, styleCall.argumentEnd, JSON.stringify({ d: cssRules }));
-          cssRulesByBucket = concatCSSRulesByBucket(cssRulesByBucket, { d: cssRules });
-        }
-        break;
-    }
-  }
-  for (const specifier of matchedSpecifiers.values()) {
-    magicString.overwrite(specifier.start, specifier.end, RUNTIME_IDENTIFIERS.get(specifier.functionKind));
-  }
-  for (const styleCall of styleCalls) {
-    magicString.overwrite(
-      styleCall.callStart,
-      styleCall.callStart + styleCall.importId.length,
-      RUNTIME_IDENTIFIERS.get(styleCall.functionKind)
-    );
-  }
-  return {
-    code: magicString.toString(),
-    cssRulesByBucket,
-    usedProcessing: true,
-    usedVMForEvaluation,
-    perfIssues
-  };
-}
-export {
-  ASSET_TAG_CLOSE,
-  ASSET_TAG_OPEN,
-  DEOPT,
-  evalCache$1 as EvalCache,
-  Module,
-  fluentTokensPlugin,
-  default2 as shakerEvaluator,
-  transformSync
-};