@griffel/transform 3.0.5 → 3.0.6

package/src/transformSync.test.mts

@@ -1,429 +0,0 @@
-import * as fs from 'node:fs';
-import NativeModule from 'node:module';
-import * as path from 'node:path';
-import { format } from 'prettier';
-import { describe, it, expect, vi } from 'vitest';
-
-import { ASSET_TAG_OPEN, ASSET_TAG_CLOSE } from './constants.mjs';
-import type { TransformResolver } from './evaluation/module.mjs';
-import { transformSync, type TransformOptions } from './transformSync.mjs';
-
-const EXTRA_EXTENSIONS = ['.ts', '.tsx', '.jsx', '.cjs'];
-
-const nodeResolve: TransformResolver = (id, opts) => {
-  const extensions = (NativeModule as unknown as { _extensions: Record<string, () => void> })._extensions;
-  const added: string[] = [];
-
-  try {
-    for (const ext of EXTRA_EXTENSIONS) {
-      if (!(ext in extensions)) {
-        extensions[ext] = () => {};
-        added.push(ext);
-      }
-    }
-
-    return {
-      path: (NativeModule as unknown as { _resolveFilename: (id: string, options: unknown) => string })._resolveFilename(id, opts),
-      builtin: false,
-    };
-  } finally {
-    for (const ext of added) {
-      delete extensions[ext];
-    }
-  }
-};
-
-type TestCase = {
-  title: string;
-  fixture: string;
-
-  error?: RegExp;
-  outputFixture?: string;
-
-  only?: boolean;
-  transformOptions?: Omit<TransformOptions, 'filename' | 'resolveModule'>;
-
-  setup?: () => (() => void) | void;
-};
-
-const prettierConfig = JSON.parse(
-  fs.readFileSync(path.resolve(__dirname, '../../../.prettierrc'), { encoding: 'utf-8' }),
-);
-const fixturesDir = path.join(__dirname, '..', '__fixtures__');
-
-/**
- * Asset paths in `<griffel-asset>` tags contain machine-specific absolute paths which also
- * cause class name hashes to differ. This normalizes both outputs by replacing absolute
- * paths with relative ones and hashes with ordered placeholders.
- *
- * Only applied when the meta output contains asset tags; other fixtures pass through unchanged.
- */
-function normalizeAssetOutputs(
-  code: string,
-  meta: string,
-  fixtureDir: string,
-): { code: string; meta: string } {
-  if (meta.indexOf(ASSET_TAG_OPEN) === -1) {
-    return { code, meta };
-  }
-
-  // 1. Replace absolute paths inside asset tags with fixture-relative paths
-  let normalizedMeta = '';
-  let searchFrom = 0;
-
-  while (searchFrom < meta.length) {
-    const openIdx = meta.indexOf(ASSET_TAG_OPEN, searchFrom);
-
-    if (openIdx === -1) {
-      normalizedMeta += meta.slice(searchFrom);
-      break;
-    }
-
-    normalizedMeta += meta.slice(searchFrom, openIdx + ASSET_TAG_OPEN.length);
-
-    const contentStart = openIdx + ASSET_TAG_OPEN.length;
-    const closeIdx = meta.indexOf(ASSET_TAG_CLOSE, contentStart);
-
-    if (closeIdx === -1) {
-      normalizedMeta += meta.slice(contentStart);
-      break;
-    }
-
-    normalizedMeta += path.relative(fixtureDir, meta.slice(contentStart, closeIdx));
-    searchFrom = closeIdx;
-  }
-
-  // 2. Collect unique class-name hashes from meta (e.g. ".fwvq0l6{" or ".r1abc23:")
-  const hashRegex = /\.([fr][a-z0-9]{4,})(?=[{:])/g;
-  const hashes: string[] = [];
-  let match;
-
-  // eslint-disable-next-line no-cond-assign
-  while ((match = hashRegex.exec(normalizedMeta)) !== null) {
-    if (!hashes.includes(match[1])) {
-      hashes.push(match[1]);
-    }
-  }
-
-  // 3. Replace hashes with deterministic ordered placeholders in both outputs
-  let normalizedCode = code;
-
-  for (let i = 0; i < hashes.length; i++) {
-    const placeholder = `${hashes[i][0]}___${i}`;
-
-    normalizedMeta = normalizedMeta.split(hashes[i]).join(placeholder);
-    normalizedCode = normalizedCode.split(hashes[i]).join(placeholder);
-  }
-
-  return { code: normalizedCode, meta: normalizedMeta };
-}
-
-const TESTS: TestCase[] = [
-  // 🎩 Tip: use "only: true" to run a single test
-  // https://github.com/babel-utils/babel-plugin-tester#only
-  //
-
-  // Fixtures
-  //
-  //
-  {
-    title: 'at rules',
-    fixture: path.resolve(fixturesDir, 'at-rules', 'code.ts'),
-    outputFixture: path.resolve(fixturesDir, 'at-rules', 'output.ts'),
-  },
-  {
-    title: 'multiple declarations',
-    fixture: path.resolve(fixturesDir, 'multiple-declarations', 'code.ts'),
-    outputFixture: path.resolve(fixturesDir, 'multiple-declarations', 'output.ts'),
-  },
-  {
-    title: 'call of non existing module',
-    fixture: path.resolve(fixturesDir, 'non-existing-module-call', 'code.ts'),
-    outputFixture: path.resolve(fixturesDir, 'non-existing-module-call', 'output.ts'),
-  },
-  {
-    title: 'syntax: animationName',
-    fixture: path.resolve(fixturesDir, 'keyframes', 'code.ts'),
-    outputFixture: path.resolve(fixturesDir, 'keyframes', 'output.ts'),
-  },
-  {
-    title: 'syntax: CSS shorthands',
-    fixture: path.resolve(fixturesDir, 'object-shorthands', 'code.ts'),
-    outputFixture: path.resolve(fixturesDir, 'object-shorthands', 'output.ts'),
-  },
-  {
-    title: 'syntax: reset (null values)',
-    fixture: path.resolve(fixturesDir, 'object-reset', 'code.ts'),
-    outputFixture: path.resolve(fixturesDir, 'object-reset', 'output.ts'),
-  },
-
-  // Assets
-  //
-  //
-  {
-    title: 'assets: import handling',
-    fixture: path.resolve(fixturesDir, 'assets', 'code.ts'),
-    outputFixture: path.resolve(fixturesDir, 'assets', 'output.ts'),
-  },
-  {
-    title: 'assets: multiple url()',
-    fixture: path.resolve(fixturesDir, 'assets-multiple-declarations', 'code.ts'),
-    outputFixture: path.resolve(fixturesDir, 'assets-multiple-declarations', 'output.ts'),
-  },
-  {
-    title: 'assets: url() without imports',
-    fixture: path.resolve(fixturesDir, 'assets-urls', 'code.ts'),
-    outputFixture: path.resolve(fixturesDir, 'assets-urls', 'output.ts'),
-  },
-
-  // Evaluation
-  //
-  //
-  {
-    title: 'evaluation: mixins via functions',
-    fixture: path.resolve(fixturesDir, 'function-mixin', 'code.ts'),
-    outputFixture: path.resolve(fixturesDir, 'function-mixin', 'output.ts'),
-  },
-  {
-    title: 'evaluation: object',
-    fixture: path.resolve(fixturesDir, 'object', 'code.ts'),
-    outputFixture: path.resolve(fixturesDir, 'object', 'output.ts'),
-  },
-  {
-    title: 'evaluation: object with computed keys',
-    fixture: path.resolve(fixturesDir, 'object-computed-keys', 'code.ts'),
-    outputFixture: path.resolve(fixturesDir, 'object-computed-keys', 'output.ts'),
-  },
-  {
-    title: 'evaluation: object with imported keys',
-    fixture: path.resolve(fixturesDir, 'object-imported-keys', 'code.ts'),
-    outputFixture: path.resolve(fixturesDir, 'object-imported-keys', 'output.ts'),
-  },
-  {
-    title: 'evaluation: object with mixins',
-    fixture: path.resolve(fixturesDir, 'object-mixins', 'code.ts'),
-    outputFixture: path.resolve(fixturesDir, 'object-mixins', 'output.ts'),
-  },
-  {
-    title: 'evaluation: nested objects',
-    fixture: path.resolve(fixturesDir, 'object-nesting', 'code.ts'),
-    outputFixture: path.resolve(fixturesDir, 'object-nesting', 'output.ts'),
-  },
-  {
-    title: 'evaluation: objects with sequence expression',
-    fixture: path.resolve(fixturesDir, 'object-sequence-expr', 'code.ts'),
-    outputFixture: path.resolve(fixturesDir, 'object-sequence-expr', 'output.ts'),
-  },
-  {
-    title: 'evaluation: objects with variables',
-    fixture: path.resolve(fixturesDir, 'object-variables', 'code.ts'),
-    outputFixture: path.resolve(fixturesDir, 'object-variables', 'output.ts'),
-  },
-  {
-    title: 'evaluation: rules with metadata',
-    fixture: path.resolve(fixturesDir, 'rules-with-metadata', 'code.ts'),
-    outputFixture: path.resolve(fixturesDir, 'rules-with-metadata', 'output.ts'),
-  },
-  {
-    title: 'evaluation: shared mixins',
-    fixture: path.resolve(fixturesDir, 'shared-mixins', 'code.ts'),
-    outputFixture: path.resolve(fixturesDir, 'shared-mixins', 'output.ts'),
-  },
-  {
-    title: 'evaluation: tokens scenario',
-    fixture: path.resolve(fixturesDir, 'tokens', 'code.ts'),
-    outputFixture: path.resolve(fixturesDir, 'tokens', 'output.ts'),
-  },
-  // Configs
-  //
-  //
-  {
-    title: 'config: classNameHashSalt',
-    fixture: path.resolve(fixturesDir, 'config-classname-hash-salt', 'code.ts'),
-    outputFixture: path.resolve(fixturesDir, 'config-classname-hash-salt', 'output.ts'),
-    transformOptions: {
-      classNameHashSalt: 'prefix',
-    },
-  },
-  {
-    title: 'config: evaluationRules',
-    fixture: path.resolve(fixturesDir, 'config-evaluation-rules', 'code.ts'),
-    outputFixture: path.resolve(fixturesDir, 'config-evaluation-rules', 'output.ts'),
-    transformOptions: {
-      evaluationRules: [{ action: require(path.resolve(fixturesDir, 'config-evaluation-rules', 'sampleEvaluator.cjs')).default }],
-    },
-  },
-
-  // Reset styles
-  //
-  //
-  {
-    title: 'reset: default',
-    fixture: path.resolve(fixturesDir, 'reset-styles', 'code.ts'),
-    outputFixture: path.resolve(fixturesDir, 'reset-styles', 'output.ts'),
-  },
-  {
-    title: 'reset: assets',
-    fixture: path.resolve(fixturesDir, 'assets-reset-styles', 'code.ts'),
-    outputFixture: path.resolve(fixturesDir, 'assets-reset-styles', 'output.ts'),
-  },
-  {
-    title: 'reset: at rules',
-    fixture: path.resolve(fixturesDir, 'reset-styles-at-rules', 'code.ts'),
-    outputFixture: path.resolve(fixturesDir, 'reset-styles-at-rules', 'output.ts'),
-  },
-
-  // Static styles
-  //
-  //
-  {
-    title: 'static: object',
-    fixture: path.resolve(fixturesDir, 'static-styles', 'code.ts'),
-    outputFixture: path.resolve(fixturesDir, 'static-styles', 'output.ts'),
-  },
-  {
-    title: 'static: string',
-    fixture: path.resolve(fixturesDir, 'static-styles-string', 'code.ts'),
-    outputFixture: path.resolve(fixturesDir, 'static-styles-string', 'output.ts'),
-  },
-  {
-    title: 'static: array',
-    fixture: path.resolve(fixturesDir, 'static-styles-array', 'code.ts'),
-    outputFixture: path.resolve(fixturesDir, 'static-styles-array', 'output.ts'),
-  },
-
-  // Imports
-  //
-
-  {
-    title: 'imports: alias usage',
-    fixture: path.resolve(fixturesDir, 'import-alias', 'code.ts'),
-    outputFixture: path.resolve(fixturesDir, 'import-alias', 'output.ts'),
-  },
-  {
-    title: 'imports: custom module',
-    fixture: path.resolve(fixturesDir, 'import-custom-module', 'code.ts'),
-    outputFixture: path.resolve(fixturesDir, 'import-custom-module', 'output.ts'),
-    transformOptions: {
-      importsToTransform: ['custom-package'],
-    },
-  },
-
-  {
-    title: 'errors: throws on CJS',
-    fixture: path.resolve(fixturesDir, 'error-cjs', 'fixture.js'),
-    error: /is not an ES module/,
-  },
-
-  // Exports
-  //
-
-  {
-    title: 'exports: handles default export',
-    fixture: path.resolve(fixturesDir, 'export-default', 'code.ts'),
-    outputFixture: path.resolve(fixturesDir, 'export-default', 'output.ts'),
-  },
-
-  // Errors
-  //
-  //
-
-  {
-    title: 'errors: unsupported shorthand CSS properties',
-    fixture: path.resolve(fixturesDir, 'unsupported-css-properties', 'fixture.ts'),
-    outputFixture: path.resolve(fixturesDir, 'unsupported-css-properties', 'output.ts'),
-    setup() {
-      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {
-        // Suppress console errors during test
-      });
-
-      return function teardown() {
-        consoleSpy.mockRestore();
-      };
-    },
-  },
-  {
-    title: 'errors: throws on invalid argument count',
-    fixture: path.resolve(fixturesDir, 'error-argument-count', 'fixture.js'),
-    error: /function accepts only a single param/,
-  },
-  {
-    title: 'errors: throws on undefined',
-    fixture: path.resolve(fixturesDir, 'error-on-undefined', 'fixture.ts'),
-    error: /Cannot read properties of undefined/,
-  },
-];
-
-describe('transformSync', () => {
-  it('astEvaluationPlugins: fluentTokensPlugin is enabled by default', () => {
-    const sourceCode = `
-import { makeStyles } from '@griffel/react';
-
-const tokens = { colorBrandBackground: 'var(--colorBrandBackground)' };
-
-export const useStyles = makeStyles({
-  root: {
-    color: tokens.colorBrandBackground,
-    margin: \`\${tokens.spacingVerticalS} 0\`,
-    display: 'flex',
-  },
-});
-`;
-
-    const result = transformSync(sourceCode, {
-      filename: 'test-plugins.ts',
-      resolveModule: nodeResolve,
-    });
-
-    expect(result.usedProcessing).toBe(true);
-    // fluentTokensPlugin is on by default — tokens are evaluated statically, no VM needed
-    expect(result.usedVMForEvaluation).toBe(false);
-    expect(result.code).toContain('__css');
-  });
-
-  for (const testCase of TESTS) {
-    const testFn = testCase.only ? it.only : it;
-
-    testFn(testCase.title, async () => {
-      const sourceCode = fs.readFileSync(testCase.fixture, { encoding: 'utf-8' });
-      const teardown = testCase.setup?.();
-
-      const transformOptions = testCase.transformOptions || {};
-
-      if (testCase.error) {
-        expect(() =>
-          transformSync(sourceCode, {
-            filename: testCase.fixture,
-            resolveModule: nodeResolve,
-            ...transformOptions,
-          }),
-        ).toThrow(testCase.error);
-        return;
-      }
-
-      const { code, cssRulesByBucket, usedProcessing, usedVMForEvaluation } = transformSync(sourceCode, {
-        filename: testCase.fixture,
-        resolveModule: nodeResolve,
-        ...transformOptions,
-      });
-      const outputCode = await format(code, { ...prettierConfig, parser: 'typescript' });
-      const outputMeta = await format(
-        JSON.stringify({ usedProcessing, usedVMForEvaluation, cssRulesByBucket }, null, 2),
-        {
-          ...prettierConfig,
-          parser: 'json',
-        },
-      );
-
-      const fixtureDir = path.dirname(testCase.fixture);
-      const normalized = normalizeAssetOutputs(outputCode, outputMeta, fixtureDir);
-
-      await expect(normalized.code).toMatchFileSnapshot(testCase.outputFixture!);
-      await expect(normalized.meta).toMatchFileSnapshot(testCase.outputFixture!.replace(/\.ts$/, '.meta.json'));
-
-      if (typeof teardown === 'function') {
-        teardown?.();
-      }
-    });
-  }
-});

package/src/types.mts

@@ -1,13 +0,0 @@
-import type { Node } from 'oxc-parser';
-
-export interface StyleCall {
-  declaratorId: string;
-  functionKind: 'makeStyles' | 'makeResetStyles' | 'makeStaticStyles';
-  argumentStart: number;
-  argumentEnd: number;
-  argumentCode: string;
-  argumentNode: Node;
-  callStart: number;
-  callEnd: number;
-  importId: string;
-}

package/src/utils/convertESMtoCJS.mts

@@ -1,226 +0,0 @@
-import { parseSync } from 'oxc-parser';
-import type { Node } from 'oxc-parser';
-import MagicString from 'magic-string';
-
-// Helper to access AST node properties without violating noPropertyAccessFromIndexSignature
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const prop = (node: Node, key: string): any => (node as unknown as Record<string, unknown>)[key];
-
-/**
- * Extracts all declared binding names from a pattern node (Identifier, ObjectPattern, ArrayPattern, AssignmentPattern).
- */
-function extractDeclaredNames(node: Node): string[] {
-  switch (node.type) {
-    case 'Identifier':
-      return [prop(node, 'name') as string];
-    case 'ObjectPattern':
-      return (prop(node, 'properties') as Node[]).flatMap(p => {
-        if (p.type === 'RestElement') {
-          return extractDeclaredNames(prop(p, 'argument') as Node);
-        }
-        return extractDeclaredNames(prop(p, 'value') as Node);
-      });
-    case 'ArrayPattern':
-      return (prop(node, 'elements') as (Node | null)[]).filter(Boolean).flatMap(el => extractDeclaredNames(el!));
-    case 'AssignmentPattern':
-      return extractDeclaredNames(prop(node, 'left') as Node);
-    default:
-      return [];
-  }
-}
-
-/**
- * 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 function convertESMtoCJS(code: string, filename: string): string {
-  const parseResult = parseSync(filename, code, { sourceType: 'module' });
-
-  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: string[] = [];
-
-  for (const node of program.body) {
-    switch (node.type) {
-      case 'ImportDeclaration': {
-        const source = prop(prop(node, 'source'), 'value') as string;
-        const specifiers = prop(node, 'specifiers') as Node[];
-
-        if (specifiers.length === 0) {
-          ms.overwrite(node.start, node.end, `require(${JSON.stringify(source)});`);
-        } else {
-          let defaultName: string | null = null;
-          let namespaceName: string | null = null;
-          const namedImports: string[] = [];
-
-          for (const spec of specifiers) {
-            if (spec.type === 'ImportDefaultSpecifier') {
-              defaultName = prop(prop(spec, 'local'), 'name') as string;
-            } else if (spec.type === 'ImportNamespaceSpecifier') {
-              namespaceName = prop(prop(spec, 'local'), 'name') as string;
-            } else if (spec.type === 'ImportSpecifier') {
-              const importedNode = prop(spec, 'imported') as Node;
-              const imported =
-                importedNode.type === 'Identifier'
-                  ? (prop(importedNode, 'name') as string)
-                  : (prop(importedNode, 'value') as string);
-              const local = prop(prop(spec, 'local'), 'name') as string;
-              if (imported === local) {
-                namedImports.push(imported);
-              } else {
-                namedImports.push(`${imported}: ${local}`);
-              }
-            }
-          }
-
-          const parts: string[] = [];
-
-          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') as Node | null;
-
-        if (decl) {
-          ms.overwrite(node.start, decl.start, '');
-
-          if (decl.type === 'VariableDeclaration') {
-            const names = (prop(decl, 'declarations') as Node[]).flatMap(d =>
-              extractDeclaredNames(prop(d, 'id') as Node),
-            );
-            deferredExports.push(...names);
-          } else if (decl.type === 'FunctionDeclaration' || decl.type === 'ClassDeclaration') {
-            const id = prop(decl, 'id') as Node | null;
-            if (id) {
-              deferredExports.push(prop(id, 'name') as string);
-            }
-          }
-        } else if (prop(node, 'source')) {
-          const source = prop(prop(node, 'source'), 'value') as string;
-          const parts: string[] = [];
-          for (const spec of prop(node, 'specifiers') as Node[]) {
-            const localNode = prop(spec, 'local') as Node;
-            const exportedNode = prop(spec, 'exported') as Node;
-            const local =
-              localNode.type === 'Identifier'
-                ? (prop(localNode, 'name') as string)
-                : (prop(localNode, 'value') as string);
-            const exported =
-              exportedNode.type === 'Identifier'
-                ? (prop(exportedNode, 'name') as string)
-                : (prop(exportedNode, 'value') as string);
-            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: string[] = [];
-          for (const spec of prop(node, 'specifiers') as Node[]) {
-            const localNode = prop(spec, 'local') as Node;
-            const exportedNode = prop(spec, 'exported') as Node;
-            const local =
-              localNode.type === 'Identifier'
-                ? (prop(localNode, 'name') as string)
-                : (prop(localNode, 'value') as string);
-            const exported =
-              exportedNode.type === 'Identifier'
-                ? (prop(exportedNode, 'name') as string)
-                : (prop(exportedNode, 'value') as string);
-            parts.push(`exports[${JSON.stringify(exported)}] = ${local};`);
-          }
-          ms.overwrite(node.start, node.end, parts.join('\n'));
-        }
-        break;
-      }
-
-      case 'ExportDefaultDeclaration': {
-        const decl = prop(node, 'declaration') as Node;
-        if (decl.type === 'FunctionDeclaration' || decl.type === 'ClassDeclaration') {
-          const id = prop(decl, 'id') as Node | null;
-          if (id) {
-            ms.overwrite(node.start, decl.start, '');
-            ms.appendLeft(node.end, `\nexports.default = ${prop(id, 'name') as string};`);
-          } 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') as string;
-        const exportedNode = prop(node, 'exported') as Node | null;
-        if (exportedNode) {
-          const name =
-            exportedNode.type === 'Identifier'
-              ? (prop(exportedNode, 'name') as string)
-              : (prop(exportedNode, 'value') as string);
-          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;
-      }
-    }
-  }
-
-  // Append deferred exports at end-of-file so that IIFEs (e.g. TS compiled enums)
-  // can populate variables before they are captured by `exports.X = X`.
-  // ESM uses live bindings; deferring to end-of-file approximates that for CJS.
-  if (deferredExports.length > 0) {
-    ms.append('\n' + deferredExports.map(name => `exports.${name} = ${name};`).join('\n'));
-  }
-
-  // Mark the module as ESM-converted for interop
-  ms.prepend('Object.defineProperty(exports, "__esModule", { value: true });\n');
-
-  return ms.toString();
-}