vaderjs 1.1.1 → 1.1.2

package/website/node_modules/sucrase/dist/esm/transformers/CJSImportTransformer.js

@@ -0,0 +1,916 @@
+
+
+
+import {IdentifierRole, isDeclaration, isObjectShorthandDeclaration} from "../parser/tokenizer";
+import {ContextualKeyword} from "../parser/tokenizer/keywords";
+import {TokenType as tt} from "../parser/tokenizer/types";
+
+import elideImportEquals from "../util/elideImportEquals";
+import getDeclarationInfo, {
+
+  EMPTY_DECLARATION_INFO,
+} from "../util/getDeclarationInfo";
+import getImportExportSpecifierInfo from "../util/getImportExportSpecifierInfo";
+import isExportFrom from "../util/isExportFrom";
+import {removeMaybeImportAttributes} from "../util/removeMaybeImportAttributes";
+import shouldElideDefaultExport from "../util/shouldElideDefaultExport";
+
+
+import Transformer from "./Transformer";
+
+/**
+ * Class for editing import statements when we are transforming to commonjs.
+ */
+export default class CJSImportTransformer extends Transformer {
+   __init() {this.hadExport = false}
+   __init2() {this.hadNamedExport = false}
+   __init3() {this.hadDefaultExport = false}
+  
+
+  constructor(
+     rootTransformer,
+     tokens,
+     importProcessor,
+     nameManager,
+     helperManager,
+     reactHotLoaderTransformer,
+     enableLegacyBabel5ModuleInterop,
+     enableLegacyTypeScriptModuleInterop,
+     isTypeScriptTransformEnabled,
+     isFlowTransformEnabled,
+     preserveDynamicImport,
+     keepUnusedImports,
+  ) {
+    super();this.rootTransformer = rootTransformer;this.tokens = tokens;this.importProcessor = importProcessor;this.nameManager = nameManager;this.helperManager = helperManager;this.reactHotLoaderTransformer = reactHotLoaderTransformer;this.enableLegacyBabel5ModuleInterop = enableLegacyBabel5ModuleInterop;this.enableLegacyTypeScriptModuleInterop = enableLegacyTypeScriptModuleInterop;this.isTypeScriptTransformEnabled = isTypeScriptTransformEnabled;this.isFlowTransformEnabled = isFlowTransformEnabled;this.preserveDynamicImport = preserveDynamicImport;this.keepUnusedImports = keepUnusedImports;CJSImportTransformer.prototype.__init.call(this);CJSImportTransformer.prototype.__init2.call(this);CJSImportTransformer.prototype.__init3.call(this);;
+    this.declarationInfo = isTypeScriptTransformEnabled
+      ? getDeclarationInfo(tokens)
+      : EMPTY_DECLARATION_INFO;
+  }
+
+  getPrefixCode() {
+    let prefix = "";
+    if (this.hadExport) {
+      prefix += 'Object.defineProperty(exports, "__esModule", {value: true});';
+    }
+    return prefix;
+  }
+
+  getSuffixCode() {
+    if (this.enableLegacyBabel5ModuleInterop && this.hadDefaultExport && !this.hadNamedExport) {
+      return "\nmodule.exports = exports.default;\n";
+    }
+    return "";
+  }
+
+  process() {
+    // TypeScript `import foo = require('foo');` should always just be translated to plain require.
+    if (this.tokens.matches3(tt._import, tt.name, tt.eq)) {
+      return this.processImportEquals();
+    }
+    if (this.tokens.matches1(tt._import)) {
+      this.processImport();
+      return true;
+    }
+    if (this.tokens.matches2(tt._export, tt.eq)) {
+      this.tokens.replaceToken("module.exports");
+      return true;
+    }
+    if (this.tokens.matches1(tt._export) && !this.tokens.currentToken().isType) {
+      this.hadExport = true;
+      return this.processExport();
+    }
+    if (this.tokens.matches2(tt.name, tt.postIncDec)) {
+      // Fall through to normal identifier matching if this doesn't apply.
+      if (this.processPostIncDec()) {
+        return true;
+      }
+    }
+    if (this.tokens.matches1(tt.name) || this.tokens.matches1(tt.jsxName)) {
+      return this.processIdentifier();
+    }
+    if (this.tokens.matches1(tt.eq)) {
+      return this.processAssignment();
+    }
+    if (this.tokens.matches1(tt.assign)) {
+      return this.processComplexAssignment();
+    }
+    if (this.tokens.matches1(tt.preIncDec)) {
+      return this.processPreIncDec();
+    }
+    return false;
+  }
+
+   processImportEquals() {
+    const importName = this.tokens.identifierNameAtIndex(this.tokens.currentIndex() + 1);
+    if (this.importProcessor.shouldAutomaticallyElideImportedName(importName)) {
+      // If this name is only used as a type, elide the whole import.
+      elideImportEquals(this.tokens);
+    } else {
+      // Otherwise, switch `import` to `const`.
+      this.tokens.replaceToken("const");
+    }
+    return true;
+  }
+
+  /**
+   * Transform this:
+   * import foo, {bar} from 'baz';
+   * into
+   * var _baz = require('baz'); var _baz2 = _interopRequireDefault(_baz);
+   *
+   * The import code was already generated in the import preprocessing step, so
+   * we just need to look it up.
+   */
+   processImport() {
+    if (this.tokens.matches2(tt._import, tt.parenL)) {
+      if (this.preserveDynamicImport) {
+        // Bail out, only making progress for this one token.
+        this.tokens.copyToken();
+        return;
+      }
+      const requireWrapper = this.enableLegacyTypeScriptModuleInterop
+        ? ""
+        : `${this.helperManager.getHelperName("interopRequireWildcard")}(`;
+      this.tokens.replaceToken(`Promise.resolve().then(() => ${requireWrapper}require`);
+      const contextId = this.tokens.currentToken().contextId;
+      if (contextId == null) {
+        throw new Error("Expected context ID on dynamic import invocation.");
+      }
+      this.tokens.copyToken();
+      while (!this.tokens.matchesContextIdAndLabel(tt.parenR, contextId)) {
+        this.rootTransformer.processToken();
+      }
+      this.tokens.replaceToken(requireWrapper ? ")))" : "))");
+      return;
+    }
+
+    const shouldElideImport = this.removeImportAndDetectIfShouldElide();
+    if (shouldElideImport) {
+      this.tokens.removeToken();
+    } else {
+      const path = this.tokens.stringValue();
+      this.tokens.replaceTokenTrimmingLeftWhitespace(this.importProcessor.claimImportCode(path));
+      this.tokens.appendCode(this.importProcessor.claimImportCode(path));
+    }
+    removeMaybeImportAttributes(this.tokens);
+    if (this.tokens.matches1(tt.semi)) {
+      this.tokens.removeToken();
+    }
+  }
+
+  /**
+   * Erase this import (since any CJS output would be completely different), and
+   * return true if this import is should be elided due to being a type-only
+   * import. Such imports will not be emitted at all to avoid side effects.
+   *
+   * Import elision only happens with the TypeScript or Flow transforms enabled.
+   *
+   * TODO: This function has some awkward overlap with
+   *  CJSImportProcessor.pruneTypeOnlyImports , and the two should be unified.
+   *  That function handles TypeScript implicit import name elision, and removes
+   *  an import if all typical imported names (without `type`) are removed due
+   *  to being type-only imports. This function handles Flow import removal and
+   *  properly distinguishes `import 'foo'` from `import {} from 'foo'` for TS
+   *  purposes.
+   *
+   * The position should end at the import string.
+   */
+   removeImportAndDetectIfShouldElide() {
+    this.tokens.removeInitialToken();
+    if (
+      this.tokens.matchesContextual(ContextualKeyword._type) &&
+      !this.tokens.matches1AtIndex(this.tokens.currentIndex() + 1, tt.comma) &&
+      !this.tokens.matchesContextualAtIndex(this.tokens.currentIndex() + 1, ContextualKeyword._from)
+    ) {
+      // This is an "import type" statement, so exit early.
+      this.removeRemainingImport();
+      return true;
+    }
+
+    if (this.tokens.matches1(tt.name) || this.tokens.matches1(tt.star)) {
+      // We have a default import or namespace import, so there must be some
+      // non-type import.
+      this.removeRemainingImport();
+      return false;
+    }
+
+    if (this.tokens.matches1(tt.string)) {
+      // This is a bare import, so we should proceed with the import.
+      return false;
+    }
+
+    let foundNonTypeImport = false;
+    let foundAnyNamedImport = false;
+    while (!this.tokens.matches1(tt.string)) {
+      // Check if any named imports are of the form "foo" or "foo as bar", with
+      // no leading "type".
+      if (
+        (!foundNonTypeImport && this.tokens.matches1(tt.braceL)) ||
+        this.tokens.matches1(tt.comma)
+      ) {
+        this.tokens.removeToken();
+        if (!this.tokens.matches1(tt.braceR)) {
+          foundAnyNamedImport = true;
+        }
+        if (
+          this.tokens.matches2(tt.name, tt.comma) ||
+          this.tokens.matches2(tt.name, tt.braceR) ||
+          this.tokens.matches4(tt.name, tt.name, tt.name, tt.comma) ||
+          this.tokens.matches4(tt.name, tt.name, tt.name, tt.braceR)
+        ) {
+          foundNonTypeImport = true;
+        }
+      }
+      this.tokens.removeToken();
+    }
+    if (this.keepUnusedImports) {
+      return false;
+    }
+    if (this.isTypeScriptTransformEnabled) {
+      return !foundNonTypeImport;
+    } else if (this.isFlowTransformEnabled) {
+      // In Flow, unlike TS, `import {} from 'foo';` preserves the import.
+      return foundAnyNamedImport && !foundNonTypeImport;
+    } else {
+      return false;
+    }
+  }
+
+   removeRemainingImport() {
+    while (!this.tokens.matches1(tt.string)) {
+      this.tokens.removeToken();
+    }
+  }
+
+   processIdentifier() {
+    const token = this.tokens.currentToken();
+    if (token.shadowsGlobal) {
+      return false;
+    }
+
+    if (token.identifierRole === IdentifierRole.ObjectShorthand) {
+      return this.processObjectShorthand();
+    }
+
+    if (token.identifierRole !== IdentifierRole.Access) {
+      return false;
+    }
+    const replacement = this.importProcessor.getIdentifierReplacement(
+      this.tokens.identifierNameForToken(token),
+    );
+    if (!replacement) {
+      return false;
+    }
+    // Tolerate any number of closing parens while looking for an opening paren
+    // that indicates a function call.
+    let possibleOpenParenIndex = this.tokens.currentIndex() + 1;
+    while (
+      possibleOpenParenIndex < this.tokens.tokens.length &&
+      this.tokens.tokens[possibleOpenParenIndex].type === tt.parenR
+    ) {
+      possibleOpenParenIndex++;
+    }
+    // Avoid treating imported functions as methods of their `exports` object
+    // by using `(0, f)` when the identifier is in a paren expression. Else
+    // use `Function.prototype.call` when the identifier is a guaranteed
+    // function call. When using `call`, pass undefined as the context.
+    if (this.tokens.tokens[possibleOpenParenIndex].type === tt.parenL) {
+      if (
+        this.tokens.tokenAtRelativeIndex(1).type === tt.parenL &&
+        this.tokens.tokenAtRelativeIndex(-1).type !== tt._new
+      ) {
+        this.tokens.replaceToken(`${replacement}.call(void 0, `);
+        // Remove the old paren.
+        this.tokens.removeToken();
+        // Balance out the new paren.
+        this.rootTransformer.processBalancedCode();
+        this.tokens.copyExpectedToken(tt.parenR);
+      } else {
+        // See here: http://2ality.com/2015/12/references.html
+        this.tokens.replaceToken(`(0, ${replacement})`);
+      }
+    } else {
+      this.tokens.replaceToken(replacement);
+    }
+    return true;
+  }
+
+  processObjectShorthand() {
+    const identifier = this.tokens.identifierName();
+    const replacement = this.importProcessor.getIdentifierReplacement(identifier);
+    if (!replacement) {
+      return false;
+    }
+    this.tokens.replaceToken(`${identifier}: ${replacement}`);
+    return true;
+  }
+
+  processExport() {
+    if (
+      this.tokens.matches2(tt._export, tt._enum) ||
+      this.tokens.matches3(tt._export, tt._const, tt._enum)
+    ) {
+      this.hadNamedExport = true;
+      // Let the TypeScript transform handle it.
+      return false;
+    }
+    if (this.tokens.matches2(tt._export, tt._default)) {
+      if (this.tokens.matches3(tt._export, tt._default, tt._enum)) {
+        this.hadDefaultExport = true;
+        // Flow export default enums need some special handling, so handle them
+        // in that tranform rather than this one.
+        return false;
+      }
+      this.processExportDefault();
+      return true;
+    } else if (this.tokens.matches2(tt._export, tt.braceL)) {
+      this.processExportBindings();
+      return true;
+    } else if (
+      this.tokens.matches2(tt._export, tt.name) &&
+      this.tokens.matchesContextualAtIndex(this.tokens.currentIndex() + 1, ContextualKeyword._type)
+    ) {
+      // export type {a};
+      // export type {a as b};
+      // export type {a} from './b';
+      // export type * from './b';
+      // export type * as ns from './b';
+      this.tokens.removeInitialToken();
+      this.tokens.removeToken();
+      if (this.tokens.matches1(tt.braceL)) {
+        while (!this.tokens.matches1(tt.braceR)) {
+          this.tokens.removeToken();
+        }
+        this.tokens.removeToken();
+      } else {
+        // *
+        this.tokens.removeToken();
+        if (this.tokens.matches1(tt._as)) {
+          // as
+          this.tokens.removeToken();
+          // ns
+          this.tokens.removeToken();
+        }
+      }
+      // Remove type re-export `... } from './T'`
+      if (
+        this.tokens.matchesContextual(ContextualKeyword._from) &&
+        this.tokens.matches1AtIndex(this.tokens.currentIndex() + 1, tt.string)
+      ) {
+        this.tokens.removeToken();
+        this.tokens.removeToken();
+        removeMaybeImportAttributes(this.tokens);
+      }
+      return true;
+    }
+    this.hadNamedExport = true;
+    if (
+      this.tokens.matches2(tt._export, tt._var) ||
+      this.tokens.matches2(tt._export, tt._let) ||
+      this.tokens.matches2(tt._export, tt._const)
+    ) {
+      this.processExportVar();
+      return true;
+    } else if (
+      this.tokens.matches2(tt._export, tt._function) ||
+      // export async function
+      this.tokens.matches3(tt._export, tt.name, tt._function)
+    ) {
+      this.processExportFunction();
+      return true;
+    } else if (
+      this.tokens.matches2(tt._export, tt._class) ||
+      this.tokens.matches3(tt._export, tt._abstract, tt._class) ||
+      this.tokens.matches2(tt._export, tt.at)
+    ) {
+      this.processExportClass();
+      return true;
+    } else if (this.tokens.matches2(tt._export, tt.star)) {
+      this.processExportStar();
+      return true;
+    } else {
+      throw new Error("Unrecognized export syntax.");
+    }
+  }
+
+   processAssignment() {
+    const index = this.tokens.currentIndex();
+    const identifierToken = this.tokens.tokens[index - 1];
+    // If the LHS is a type identifier, this must be a declaration like `let a: b = c;`,
+    // with `b` as the identifier, so nothing needs to be done in that case.
+    if (identifierToken.isType || identifierToken.type !== tt.name) {
+      return false;
+    }
+    if (identifierToken.shadowsGlobal) {
+      return false;
+    }
+    if (index >= 2 && this.tokens.matches1AtIndex(index - 2, tt.dot)) {
+      return false;
+    }
+    if (index >= 2 && [tt._var, tt._let, tt._const].includes(this.tokens.tokens[index - 2].type)) {
+      // Declarations don't need an extra assignment. This doesn't avoid the
+      // assignment for comma-separated declarations, but it's still correct
+      // since the assignment is just redundant.
+      return false;
+    }
+    const assignmentSnippet = this.importProcessor.resolveExportBinding(
+      this.tokens.identifierNameForToken(identifierToken),
+    );
+    if (!assignmentSnippet) {
+      return false;
+    }
+    this.tokens.copyToken();
+    this.tokens.appendCode(` ${assignmentSnippet} =`);
+    return true;
+  }
+
+  /**
+   * Process something like `a += 3`, where `a` might be an exported value.
+   */
+   processComplexAssignment() {
+    const index = this.tokens.currentIndex();
+    const identifierToken = this.tokens.tokens[index - 1];
+    if (identifierToken.type !== tt.name) {
+      return false;
+    }
+    if (identifierToken.shadowsGlobal) {
+      return false;
+    }
+    if (index >= 2 && this.tokens.matches1AtIndex(index - 2, tt.dot)) {
+      return false;
+    }
+    const assignmentSnippet = this.importProcessor.resolveExportBinding(
+      this.tokens.identifierNameForToken(identifierToken),
+    );
+    if (!assignmentSnippet) {
+      return false;
+    }
+    this.tokens.appendCode(` = ${assignmentSnippet}`);
+    this.tokens.copyToken();
+    return true;
+  }
+
+  /**
+   * Process something like `++a`, where `a` might be an exported value.
+   */
+   processPreIncDec() {
+    const index = this.tokens.currentIndex();
+    const identifierToken = this.tokens.tokens[index + 1];
+    if (identifierToken.type !== tt.name) {
+      return false;
+    }
+    if (identifierToken.shadowsGlobal) {
+      return false;
+    }
+    // Ignore things like ++a.b and ++a[b] and ++a().b.
+    if (
+      index + 2 < this.tokens.tokens.length &&
+      (this.tokens.matches1AtIndex(index + 2, tt.dot) ||
+        this.tokens.matches1AtIndex(index + 2, tt.bracketL) ||
+        this.tokens.matches1AtIndex(index + 2, tt.parenL))
+    ) {
+      return false;
+    }
+    const identifierName = this.tokens.identifierNameForToken(identifierToken);
+    const assignmentSnippet = this.importProcessor.resolveExportBinding(identifierName);
+    if (!assignmentSnippet) {
+      return false;
+    }
+    this.tokens.appendCode(`${assignmentSnippet} = `);
+    this.tokens.copyToken();
+    return true;
+  }
+
+  /**
+   * Process something like `a++`, where `a` might be an exported value.
+   * This starts at the `a`, not at the `++`.
+   */
+   processPostIncDec() {
+    const index = this.tokens.currentIndex();
+    const identifierToken = this.tokens.tokens[index];
+    const operatorToken = this.tokens.tokens[index + 1];
+    if (identifierToken.type !== tt.name) {
+      return false;
+    }
+    if (identifierToken.shadowsGlobal) {
+      return false;
+    }
+    if (index >= 1 && this.tokens.matches1AtIndex(index - 1, tt.dot)) {
+      return false;
+    }
+    const identifierName = this.tokens.identifierNameForToken(identifierToken);
+    const assignmentSnippet = this.importProcessor.resolveExportBinding(identifierName);
+    if (!assignmentSnippet) {
+      return false;
+    }
+    const operatorCode = this.tokens.rawCodeForToken(operatorToken);
+    // We might also replace the identifier with something like exports.x, so
+    // do that replacement here as well.
+    const base = this.importProcessor.getIdentifierReplacement(identifierName) || identifierName;
+    if (operatorCode === "++") {
+      this.tokens.replaceToken(`(${base} = ${assignmentSnippet} = ${base} + 1, ${base} - 1)`);
+    } else if (operatorCode === "--") {
+      this.tokens.replaceToken(`(${base} = ${assignmentSnippet} = ${base} - 1, ${base} + 1)`);
+    } else {
+      throw new Error(`Unexpected operator: ${operatorCode}`);
+    }
+    this.tokens.removeToken();
+    return true;
+  }
+
+   processExportDefault() {
+    let exportedRuntimeValue = true;
+    if (
+      this.tokens.matches4(tt._export, tt._default, tt._function, tt.name) ||
+      // export default async function
+      (this.tokens.matches5(tt._export, tt._default, tt.name, tt._function, tt.name) &&
+        this.tokens.matchesContextualAtIndex(
+          this.tokens.currentIndex() + 2,
+          ContextualKeyword._async,
+        ))
+    ) {
+      this.tokens.removeInitialToken();
+      this.tokens.removeToken();
+      // Named function export case: change it to a top-level function
+      // declaration followed by exports statement.
+      const name = this.processNamedFunction();
+      this.tokens.appendCode(` exports.default = ${name};`);
+    } else if (
+      this.tokens.matches4(tt._export, tt._default, tt._class, tt.name) ||
+      this.tokens.matches5(tt._export, tt._default, tt._abstract, tt._class, tt.name) ||
+      this.tokens.matches3(tt._export, tt._default, tt.at)
+    ) {
+      this.tokens.removeInitialToken();
+      this.tokens.removeToken();
+      this.copyDecorators();
+      if (this.tokens.matches1(tt._abstract)) {
+        this.tokens.removeToken();
+      }
+      const name = this.rootTransformer.processNamedClass();
+      this.tokens.appendCode(` exports.default = ${name};`);
+      // After this point, this is a plain "export default E" statement.
+    } else if (
+      shouldElideDefaultExport(
+        this.isTypeScriptTransformEnabled,
+        this.keepUnusedImports,
+        this.tokens,
+        this.declarationInfo,
+      )
+    ) {
+      // If the exported value is just an identifier and should be elided by TypeScript
+      // rules, then remove it entirely. It will always have the form `export default e`,
+      // where `e` is an identifier.
+      exportedRuntimeValue = false;
+      this.tokens.removeInitialToken();
+      this.tokens.removeToken();
+      this.tokens.removeToken();
+    } else if (this.reactHotLoaderTransformer) {
+      // We need to assign E to a variable. Change "export default E" to
+      // "let _default; exports.default = _default = E"
+      const defaultVarName = this.nameManager.claimFreeName("_default");
+      this.tokens.replaceToken(`let ${defaultVarName}; exports.`);
+      this.tokens.copyToken();
+      this.tokens.appendCode(` = ${defaultVarName} =`);
+      this.reactHotLoaderTransformer.setExtractedDefaultExportName(defaultVarName);
+    } else {
+      // Change "export default E" to "exports.default = E"
+      this.tokens.replaceToken("exports.");
+      this.tokens.copyToken();
+      this.tokens.appendCode(" =");
+    }
+    if (exportedRuntimeValue) {
+      this.hadDefaultExport = true;
+    }
+  }
+
+   copyDecorators() {
+    while (this.tokens.matches1(tt.at)) {
+      this.tokens.copyToken();
+      if (this.tokens.matches1(tt.parenL)) {
+        this.tokens.copyExpectedToken(tt.parenL);
+        this.rootTransformer.processBalancedCode();
+        this.tokens.copyExpectedToken(tt.parenR);
+      } else {
+        this.tokens.copyExpectedToken(tt.name);
+        while (this.tokens.matches1(tt.dot)) {
+          this.tokens.copyExpectedToken(tt.dot);
+          this.tokens.copyExpectedToken(tt.name);
+        }
+        if (this.tokens.matches1(tt.parenL)) {
+          this.tokens.copyExpectedToken(tt.parenL);
+          this.rootTransformer.processBalancedCode();
+          this.tokens.copyExpectedToken(tt.parenR);
+        }
+      }
+    }
+  }
+
+  /**
+   * Transform a declaration like `export var`, `export let`, or `export const`.
+   */
+   processExportVar() {
+    if (this.isSimpleExportVar()) {
+      this.processSimpleExportVar();
+    } else {
+      this.processComplexExportVar();
+    }
+  }
+
+  /**
+   * Determine if the export is of the form:
+   * export var/let/const [varName] = [expr];
+   * In other words, determine if function name inference might apply.
+   */
+   isSimpleExportVar() {
+    let tokenIndex = this.tokens.currentIndex();
+    // export
+    tokenIndex++;
+    // var/let/const
+    tokenIndex++;
+    if (!this.tokens.matches1AtIndex(tokenIndex, tt.name)) {
+      return false;
+    }
+    tokenIndex++;
+    while (tokenIndex < this.tokens.tokens.length && this.tokens.tokens[tokenIndex].isType) {
+      tokenIndex++;
+    }
+    if (!this.tokens.matches1AtIndex(tokenIndex, tt.eq)) {
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * Transform an `export var` declaration initializing a single variable.
+   *
+   * For example, this:
+   * export const f = () => {};
+   * becomes this:
+   * const f = () => {}; exports.f = f;
+   *
+   * The variable is unused (e.g. exports.f has the true value of the export).
+   * We need to produce an assignment of this form so that the function will
+   * have an inferred name of "f", which wouldn't happen in the more general
+   * case below.
+   */
+   processSimpleExportVar() {
+    // export
+    this.tokens.removeInitialToken();
+    // var/let/const
+    this.tokens.copyToken();
+    const varName = this.tokens.identifierName();
+    // x: number  ->  x
+    while (!this.tokens.matches1(tt.eq)) {
+      this.rootTransformer.processToken();
+    }
+    const endIndex = this.tokens.currentToken().rhsEndIndex;
+    if (endIndex == null) {
+      throw new Error("Expected = token with an end index.");
+    }
+    while (this.tokens.currentIndex() < endIndex) {
+      this.rootTransformer.processToken();
+    }
+    this.tokens.appendCode(`; exports.${varName} = ${varName}`);
+  }
+
+  /**
+   * Transform normal declaration exports, including handling destructuring.
+   * For example, this:
+   * export const {x: [a = 2, b], c} = d;
+   * becomes this:
+   * ({x: [exports.a = 2, exports.b], c: exports.c} = d;)
+   */
+   processComplexExportVar() {
+    this.tokens.removeInitialToken();
+    this.tokens.removeToken();
+    const needsParens = this.tokens.matches1(tt.braceL);
+    if (needsParens) {
+      this.tokens.appendCode("(");
+    }
+
+    let depth = 0;
+    while (true) {
+      if (
+        this.tokens.matches1(tt.braceL) ||
+        this.tokens.matches1(tt.dollarBraceL) ||
+        this.tokens.matches1(tt.bracketL)
+      ) {
+        depth++;
+        this.tokens.copyToken();
+      } else if (this.tokens.matches1(tt.braceR) || this.tokens.matches1(tt.bracketR)) {
+        depth--;
+        this.tokens.copyToken();
+      } else if (
+        depth === 0 &&
+        !this.tokens.matches1(tt.name) &&
+        !this.tokens.currentToken().isType
+      ) {
+        break;
+      } else if (this.tokens.matches1(tt.eq)) {
+        // Default values might have assignments in the RHS that we want to ignore, so skip past
+        // them.
+        const endIndex = this.tokens.currentToken().rhsEndIndex;
+        if (endIndex == null) {
+          throw new Error("Expected = token with an end index.");
+        }
+        while (this.tokens.currentIndex() < endIndex) {
+          this.rootTransformer.processToken();
+        }
+      } else {
+        const token = this.tokens.currentToken();
+        if (isDeclaration(token)) {
+          const name = this.tokens.identifierName();
+          let replacement = this.importProcessor.getIdentifierReplacement(name);
+          if (replacement === null) {
+            throw new Error(`Expected a replacement for ${name} in \`export var\` syntax.`);
+          }
+          if (isObjectShorthandDeclaration(token)) {
+            replacement = `${name}: ${replacement}`;
+          }
+          this.tokens.replaceToken(replacement);
+        } else {
+          this.rootTransformer.processToken();
+        }
+      }
+    }
+
+    if (needsParens) {
+      // Seek to the end of the RHS.
+      const endIndex = this.tokens.currentToken().rhsEndIndex;
+      if (endIndex == null) {
+        throw new Error("Expected = token with an end index.");
+      }
+      while (this.tokens.currentIndex() < endIndex) {
+        this.rootTransformer.processToken();
+      }
+      this.tokens.appendCode(")");
+    }
+  }
+
+  /**
+   * Transform this:
+   * export function foo() {}
+   * into this:
+   * function foo() {} exports.foo = foo;
+   */
+   processExportFunction() {
+    this.tokens.replaceToken("");
+    const name = this.processNamedFunction();
+    this.tokens.appendCode(` exports.${name} = ${name};`);
+  }
+
+  /**
+   * Skip past a function with a name and return that name.
+   */
+   processNamedFunction() {
+    if (this.tokens.matches1(tt._function)) {
+      this.tokens.copyToken();
+    } else if (this.tokens.matches2(tt.name, tt._function)) {
+      if (!this.tokens.matchesContextual(ContextualKeyword._async)) {
+        throw new Error("Expected async keyword in function export.");
+      }
+      this.tokens.copyToken();
+      this.tokens.copyToken();
+    }
+    if (this.tokens.matches1(tt.star)) {
+      this.tokens.copyToken();
+    }
+    if (!this.tokens.matches1(tt.name)) {
+      throw new Error("Expected identifier for exported function name.");
+    }
+    const name = this.tokens.identifierName();
+    this.tokens.copyToken();
+    if (this.tokens.currentToken().isType) {
+      this.tokens.removeInitialToken();
+      while (this.tokens.currentToken().isType) {
+        this.tokens.removeToken();
+      }
+    }
+    this.tokens.copyExpectedToken(tt.parenL);
+    this.rootTransformer.processBalancedCode();
+    this.tokens.copyExpectedToken(tt.parenR);
+    this.rootTransformer.processPossibleTypeRange();
+    this.tokens.copyExpectedToken(tt.braceL);
+    this.rootTransformer.processBalancedCode();
+    this.tokens.copyExpectedToken(tt.braceR);
+    return name;
+  }
+
+  /**
+   * Transform this:
+   * export class A {}
+   * into this:
+   * class A {} exports.A = A;
+   */
+   processExportClass() {
+    this.tokens.removeInitialToken();
+    this.copyDecorators();
+    if (this.tokens.matches1(tt._abstract)) {
+      this.tokens.removeToken();
+    }
+    const name = this.rootTransformer.processNamedClass();
+    this.tokens.appendCode(` exports.${name} = ${name};`);
+  }
+
+  /**
+   * Transform this:
+   * export {a, b as c};
+   * into this:
+   * exports.a = a; exports.c = b;
+   *
+   * OR
+   *
+   * Transform this:
+   * export {a, b as c} from './foo';
+   * into the pre-generated Object.defineProperty code from the ImportProcessor.
+   *
+   * For the first case, if the TypeScript transform is enabled, we need to skip
+   * exports that are only defined as types.
+   */
+   processExportBindings() {
+    this.tokens.removeInitialToken();
+    this.tokens.removeToken();
+
+    const isReExport = isExportFrom(this.tokens);
+
+    const exportStatements = [];
+    while (true) {
+      if (this.tokens.matches1(tt.braceR)) {
+        this.tokens.removeToken();
+        break;
+      }
+
+      const specifierInfo = getImportExportSpecifierInfo(this.tokens);
+
+      while (this.tokens.currentIndex() < specifierInfo.endIndex) {
+        this.tokens.removeToken();
+      }
+
+      const shouldRemoveExport =
+        specifierInfo.isType ||
+        (!isReExport && this.shouldElideExportedIdentifier(specifierInfo.leftName));
+      if (!shouldRemoveExport) {
+        const exportedName = specifierInfo.rightName;
+        if (exportedName === "default") {
+          this.hadDefaultExport = true;
+        } else {
+          this.hadNamedExport = true;
+        }
+        const localName = specifierInfo.leftName;
+        const newLocalName = this.importProcessor.getIdentifierReplacement(localName);
+        exportStatements.push(`exports.${exportedName} = ${newLocalName || localName};`);
+      }
+
+      if (this.tokens.matches1(tt.braceR)) {
+        this.tokens.removeToken();
+        break;
+      }
+      if (this.tokens.matches2(tt.comma, tt.braceR)) {
+        this.tokens.removeToken();
+        this.tokens.removeToken();
+        break;
+      } else if (this.tokens.matches1(tt.comma)) {
+        this.tokens.removeToken();
+      } else {
+        throw new Error(`Unexpected token: ${JSON.stringify(this.tokens.currentToken())}`);
+      }
+    }
+
+    if (this.tokens.matchesContextual(ContextualKeyword._from)) {
+      // This is an export...from, so throw away the normal named export code
+      // and use the Object.defineProperty code from ImportProcessor.
+      this.tokens.removeToken();
+      const path = this.tokens.stringValue();
+      this.tokens.replaceTokenTrimmingLeftWhitespace(this.importProcessor.claimImportCode(path));
+      removeMaybeImportAttributes(this.tokens);
+    } else {
+      // This is a normal named export, so use that.
+      this.tokens.appendCode(exportStatements.join(" "));
+    }
+
+    if (this.tokens.matches1(tt.semi)) {
+      this.tokens.removeToken();
+    }
+  }
+
+   processExportStar() {
+    this.tokens.removeInitialToken();
+    while (!this.tokens.matches1(tt.string)) {
+      this.tokens.removeToken();
+    }
+    const path = this.tokens.stringValue();
+    this.tokens.replaceTokenTrimmingLeftWhitespace(this.importProcessor.claimImportCode(path));
+    removeMaybeImportAttributes(this.tokens);
+    if (this.tokens.matches1(tt.semi)) {
+      this.tokens.removeToken();
+    }
+  }
+
+   shouldElideExportedIdentifier(name) {
+    return (
+      this.isTypeScriptTransformEnabled &&
+      !this.keepUnusedImports &&
+      !this.declarationInfo.valueDeclarations.has(name)
+    );
+  }
+}