babel_v7.x.x.js

/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * @flow
 * @format
 */

'use strict';

type _BabelSourceMap = $ReadOnly<{
  file?: string,
  mappings: string,
  names: Array<string>,
  sourceRoot?: string,
  sources: Array<string>,
  sourcesContent?: Array<?string>,
  version: number,
}>;

type _BabelSourceMapSegment = {
  generated: {column: number, line: number, ...},
  name?: ?string,
  original?: {column: number, line: number, ...},
  source?: ?string,
  ...
};

export type BabelSourceLocation = $ReadOnly<{
  start: $ReadOnly<{line: number, column: number}>,
  end: $ReadOnly<{line: number, column: number}>,
}>;

declare module '@babel/parser' {
  // See https://github.com/babel/babel/blob/master/packages/babel-parser/typings/babel-parser.d.ts
  declare export type ParserPlugin =
    | 'asyncGenerators'
    | 'bigInt'
    | 'classPrivateMethods'
    | 'classPrivateProperties'
    | 'classProperties'
    | 'decorators'
    | 'decorators-legacy'
    | 'doExpressions'
    | 'dynamicImport'
    | 'estree'
    | 'exportDefaultFrom'
    | 'exportNamespaceFrom' // deprecated
    | 'flow'
    | 'flowComments'
    | 'functionBind'
    | 'functionSent'
    | 'importMeta'
    | 'jsx'
    | 'logicalAssignment'
    | 'moduleAttributes'
    | 'nullishCoalescingOperator'
    | 'numericSeparator'
    | 'objectRestSpread'
    | 'optionalCatchBinding'
    | 'optionalChaining'
    | 'partialApplication'
    | 'pipelineOperator'
    | 'placeholders'
    | 'privateIn'
    | 'throwExpressions'
    | 'topLevelAwait'
    | 'typescript'
    | 'v8intrinsic'
    | ParserPluginWithOptions;

  declare export type ParserPluginWithOptions =
    | ['decorators', DecoratorsPluginOptions]
    | ['pipelineOperator', PipelineOperatorPluginOptions]
    | ['flow', FlowPluginOptions];

  declare type DecoratorsPluginOptions = {
    decoratorsBeforeExport?: boolean,
  };

  declare type PipelineOperatorPluginOptions = {
    proposal: 'minimal' | 'smart',
  };

  declare type FlowPluginOptions = {
    all?: boolean,
    enums?: boolean,
  };

  declare export type ParserOptions = {
    /**
     * By default, import and export declarations can only appear at a program's top level.
     * Setting this option to true allows them anywhere where a statement is allowed.
     * @default false
     */
    allowImportExportEverywhere?: boolean,

    /**
     * By default, await use is only allowed inside of an async function or, when the topLevelAwait plugin is enabled, in the top-level scope of modules.
     * Set this to true to also accept it in the top-level scope of scripts.
     * @default false
     */
    allowAwaitOutsideFunction?: boolean,

    /**
     * By default, a return statement at the top level raises an error. Set this to true to accept such code.
     * @default false
     */
    allowReturnOutsideFunction?: boolean,

    /**
     * By default, super use is not allowed outside of class and object methods. Set this to true to accept such code.
     * @default false
     */
    allowSuperOutsideMethod?: boolean,

    /**
     * By default, exporting an identifier that was not declared in the current module scope will raise an error.
     * While this behavior is required by the ECMAScript modules specification,
     * Babel's parser cannot anticipate transforms later in the plugin pipeline that might insert the appropriate declarations,
     * so it is sometimes important to set this option to true to prevent the parser from prematurely complaining about undeclared exports that will be added later.
     * @default false
     */
    allowUndeclaredExports?: boolean,

    /**
     * By default, the parser sets extra.parenthesized on the expression nodes.
     * When this option is set to true, ParenthesizedExpression AST nodes are created instead.
     * @default false
     */
    createParenthesizedExpressions?: boolean,

    /**
     * By default, Babel always throws an error when it finds some invalid code.
     * When this option is set to true, it will store the parsing error and try to continue parsing the invalid input file.
     * The resulting AST will have an errors property representing an array of all the parsing errors.
     * Note that even when this option is enabled, @babel/parser could throw for unrecoverable errors.
     * @default false
     */
    errorRecovery?: boolean,

    /**
     * Array containing the plugins that you want to enable.
     */
    plugins?: Array<ParserPlugin>,

    /**
     * Indicate the mode the code should be parsed in. Can be one of "script", "module", or "unambiguous".
     * Defaults to "script". "unambiguous" will make @babel/parser attempt to guess, based on the presence of ES6 import or export statements.
     * Files with ES6 imports and exports are considered "module" and are otherwise "script".
     * @default 'script'
     */
    sourceType?: 'script' | 'module' | 'unambiguous',

    /**
     * Correlate output AST nodes with their source filename.
     * Useful when generating code and source maps from the ASTs of multiple input files.
     */
    sourceFilename?: string,

    /**
     * By default, the first line of code parsed is treated as line 1.
     * You can provide a line number to alternatively start with. Useful for integration with other source tools.
     * @default 1
     */
    startLine?: number,

    /**
     * By default, ECMAScript code is parsed as strict only if a "use strict"; directive is present or if the parsed file is an ECMAScript module.
     * Set this option to true to always parse files in strict mode.
     * @default false
     */
    strictMode?: boolean,

    /**
     * Adds a range property to each node: [node.start, node.end]
     * @default false
     */
    ranges?: boolean,

    /**
     * Adds all parsed tokens to a tokens property on the File node
     * default false
     */
    tokens?: boolean,
  };

  /**
   * Parse the provided code as an entire ECMAScript program.
   */
  declare export function parse(
    input: string,
    options?: ParserOptions,
  ): BabelNodeFile;

  /**
   * Parse the provided code as a single expression.
   */
  declare export function parseExpression(
    input: string,
    options?: ParserOptions,
  ): BabelNodeExpression;

  declare type TokenOptions = {
    keyword?: string,
    beforeExpr?: boolean,
    startsExpr?: boolean,
    rightAssociative?: boolean,
    isLoop?: boolean,
    isAssign?: boolean,
    prefix?: boolean,
    postfix?: boolean,
    binop?: ?number,
  };

  declare class TokenType {
    label: string;
    keyword: ?string;
    beforeExpr: boolean;
    startsExpr: boolean;
    rightAssociative: boolean;
    isLoop: boolean;
    isAssign: boolean;
    prefix: boolean;
    postfix: boolean;
    binop: ?number;
    updateContext: ?(prevType: TokenType) => void;

    constructor(label: string, conf?: TokenOptions): TokenType;
  }

  declare export var tokTypes: {[name: string]: TokenType};
}

declare module '@babel/core' {
  import type {Visitor, Scope, Hub, NodePath} from '@babel/traverse';
  import type {ParserOptions} from '@babel/parser';
  import typeof {tokTypes as TokTypes} from '@babel/parser';
  import type {Options as GeneratorOptions} from '@babel/generator';
  import typeof Template from '@babel/template';
  import typeof Traverse from '@babel/traverse';
  import typeof * as Types from '@babel/types';

  declare export var version: string;
  declare export var tokTypes: TokTypes;

  declare type ImportSpecifier =
    | {
        kind: 'named',
        imported: string,
        local: string,
      }
    | {
        kind: 'namespace',
        local: string,
      };

  declare type ExportSpecifier =
    | {
        kind: 'local',
        name: string,
        exported: string,
      }
    | {
        kind: 'external',
        local: string,
        exported: string,
        source: string | null,
      }
    | {
        kind: 'external-namespace',
        exported: string,
        source: string | null,
      }
    | {
        kind: 'external-all',
        source: string | null,
      };

  declare export type BabelFileModulesMetadata = {
    imports: Array<{
      source: string,
      imported: Array<string>,
      specifiers: Array<ImportSpecifier>,
    }>,
    exports: {
      exported: Array<BabelNode>,
      specifiers: Array<ExportSpecifier>,
    },
  };

  declare export type BabelFileMetadata = {
    usedHelpers?: Array<string>,
    marked?: Array<{
      type: string,
      message: string,
      loc: BabelNodeSourceLocation,
    }>,
    modules?: BabelFileModulesMetadata,
    ...
  };

  declare class Store {
    constructor(): Store;
    setDynamic(key: string, fn: () => mixed): void;
    set(key: string, val: mixed): void;
    get(key: string): mixed;
  }

  declare export class File extends Store {
    static helpers: Array<string>;

    opts: BabelCoreOptions;
    pluginPasses: Array<Array<{...}>>;
    parserOpts: ParserOptions;
    dynamicImportTypes: {...};
    dynamicImportIds: {...};
    dynamicImports: Array<{...}>;
    declarations: {...};
    usedHelpers: {...};
    code: string;
    shebang: string;
    ast: BabelNode | {};
    scope: Scope;
    hub: Hub;
    path: NodePath<> | null;
    metadata: BabelFileMetadata;

    constructor(
      options: BabelCoreOptions,
      input: $ReadOnly<{ast: BabelNode, code: string, inputMap: any}>,
    ): File;

    getMetadata(): void;

    getModuleName(): ?string;

    resolveModuleSource(source: string): string;

    addImport(
      source: string,
      imported: string,
      name?: string,
    ): BabelNodeIdentifier;

    addHelper(name: string): BabelNodeIdentifier;

    addTemplateObject(
      helperName: string,
      strings: Array<{...}>,
      raw: BabelNodeArrayExpression,
    ): BabelNodeIdentifier;

    buildCodeFrameError<TError: Error>(
      node: BabelNode,
      msg: string,
      Class<TError>,
    ): TError;

    mergeSourceMap(map: _BabelSourceMap): _BabelSourceMap;

    parse(code: string): BabelNode;

    addAst(ast: BabelNode): void;

    transform(): TransformResult<>;

    wrap(code: string, callback: () => mixed): TransformResult<>;

    addCode(code: string): void;

    parseCode(): void;

    parseInputSourceMap(code: string): string;

    parseShebang(): void;

    makeResult<T>(TransformResult<T>): TransformResult<T>;

    generate(): TransformResult<>;
  }

  declare export type MatchPattern =
    | string
    | RegExp
    | ((
        filename: string | void,
        context: {caller: {name: string} | void},
        envName: string,
        dirname: string,
      ) => boolean);

  declare export type PluginObj<TVisitorState = void> = {
    name?: string,
    inherits?: mixed,
    maniuplateOptions?: (
      opts: BabelCoreOptions,
      parserOpts: ParserOptions,
    ) => void,
    // this is a PluginPass
    pre?: (file: File) => void,
    visitor: Visitor<TVisitorState>,
    // this is a PluginPass
    post?: (file: File) => void,
  };

  // Represents a plugin or presets at a given location in a config object.
  // At this point these have been resolved to a specific object or function,
  // but have not yet been executed to call functions with options.
  declare export type UnloadedDescriptor = {
    name: string | void,
    value: PluginObj<mixed> | (() => PluginObj<mixed>),
    options: EntryOptions,
    dirname: string,
    alias: string,
    ownPass?: boolean,
    file?: {
      request: string,
      resolved: string,
    } | void,
  };

  declare export class ConfigItem {
    +value: PluginObj<mixed> | (() => PluginObj<mixed>);
    +options: EntryOptions;
    +dirname: string;
    +name: string | void;
    +file: {
      +request: string,
      +resolved: string,
    } | void;

    constructor(descriptor: UnloadedDescriptor): ConfigItem;
  }

  declare export type EntryTarget = string | {...} | Function;
  declare export type EntryOptions = {...} | false | void;
  declare export type PluginEntry =
    | EntryTarget
    | ConfigItem
    | [EntryTarget]
    | [EntryTarget, EntryOptions]
    | [EntryTarget, EntryOptions, string | void];

  declare export type Plugins = Array<PluginEntry>;
  declare export type PresetEntry = PluginEntry;
  declare export type Presets = Array<PresetEntry>;

  // See https://babeljs.io/docs/en/next/options#code-generator-options
  declare export type BabelCoreOptions = {|
    // Primary options

    /**
     * The working directory that all paths in the programmatic options will be resolved relative to.
     * default process.cwd()
     */
    cwd?: string,

    caller?: {
      name: string,
      supportsStaticESM?: boolean,
      supportsDynamicImport?: boolean,
      supportsTopLevelAwait?: boolean,
      supportsExportNamespaceFrom?: boolean,
      ...
    },

    /**
     * The filename associated with the code currently being compiled, if there is one.
     * The filename is optional, but not all of Babel's functionality is available when the filename is unknown, because a subset of options rely on the filename for their functionality.
     *
     * The three primary cases users could run into are:
     * - The filename is exposed to plugins. Some plugins may require the presence of the filename.
     * - Options like "test", "exclude", and "ignore" require the filename for string/RegExp matching.
     * - .babelrc.json files are loaded relative to the file being compiled. If this option is omitted, Babel will behave as if babelrc: false has been set.
     */
    filename?: string,

    /**
     * Used as the default value for Babel's sourceFileName option, and used as part of generation of filenames for the AMD / UMD / SystemJS module transforms.
     * @default path.relative(opts.cwd, opts.filename) (if opts.filename was passed)
     */
    filenameRelative?: string,

    /**
     * Babel's default return value includes code and map properties with the resulting generated code.
     * In some contexts where multiple calls to Babel are being made,
     * it can be helpful to disable code generation and instead use ast: true to get the AST directly in order to avoid doing unnecessary work.
     * @default true
     */
    code?: boolean,

    /**
     * Babel's default is to generate a string and a sourcemap, but in some contexts it can be useful to get the AST itself.
     * The primary use case for this would be a chain of multiple transform passes.
     * @default false
     */
    ast?: boolean,

    /**
     * By default babel.transformFromAst will clone the input AST to avoid mutations.
     * Specifying cloneInputAst: false can improve parsing performance if the input AST is not used elsewhere.
     */
    cloneInputAst?: boolean,

    // Config Loading options

    /**
     * The initial path that will be processed based on the "rootMode" to determine the conceptual root folder for the current Babel project.
     * This is used in two primary cases:
     *
     * - The base directory when checking for the default "configFile" value
     * - The default value for "babelrcRoots".
     * @default opts.cwd
     */
    root?: string,

    /**
     * This option, combined with the "root" value, defines how Babel chooses its project root.
     * The different modes define different ways that Babel can process the "root" value to get the final project root.
     * - "root" - Passes the "root" value through as unchanged.
     * - "upward" - Walks upward from the "root" directory, looking for a directory containing a babel.config.json file,
     *              and throws an error if a babel.config.json is not found.
     * - "upward-optional" - Walk upward from the "root" directory, looking for a directory containing a babel.config.json file,
     *            and falls back to "root" if a babel.config.json is not found.
     *
     * "root" is the default mode because it avoids the risk that Babel will accidentally load a babel.config.json
     * that is entirely outside of the current project folder. If you use "upward-optional",
     * be aware that it will walk up the directory structure all the way to the filesystem root,
     * and it is always possible that someone will have a forgotten babel.config.json in their home directory,
     * which could cause unexpected errors in your builds.
     *
     * Users with monorepo project structures that run builds/tests on a per-package basis may well want to use "upward"
     * since monorepos often have a babel.config.json in the project root.
     * Running Babel in a monorepo subdirectory without "upward",
     * will cause Babel to skip loading any babel.config.json files in the project root,
     * which can lead to unexpected errors and compilation failure.
     * @default "root"
     */
    rootMode?: 'root' | 'upward' | 'upward-optional',

    /**
     * The current active environment used during configuration loading.
     * This value is used as the key when resolving "env" configs, and is also available inside configuration functions,
     * plugins, and presets, via the api.env() function.
     * @default process.env.BABEL_ENV || process.env.NODE_ENV || "development"
     */
    envName?: string,

    /**
     * Defaults to searching for a default babel.config.json file, but can be passed the path of any JS or JSON5 config file.
     *
     * NOTE: This option does not affect loading of .babelrc.json files, so while it may be tempting to do configFile: "./foo/.babelrc.json",
     * it is not recommended. If the given .babelrc.json is loaded via the standard file-relative logic,
     * you'll end up loading the same config file twice, merging it with itself.
     * If you are linking a specific config file, it is recommended to stick with a naming scheme that is independent of the "babelrc" name.
     *
     * @default path.resolve(opts.root, "babel.config.json"), if exists, false otherwise
     */
    configFile?: string | boolean,

    /**
     * true will enable searching for configuration files relative to the "filename" provided to Babel.
     * A babelrc value passed in the programmatic options will override one set within a configuration file.
     *
     * Note: .babelrc.json files are only loaded if the current "filename" is inside of a package that matches one of the "babelrcRoots" packages.
     *
     * @default true as long as the filename option has been specified
     */
    babelrc?: boolean,

    /**
     * By default, Babel will only search for .babelrc.json files within the "root" package
     * because otherwise Babel cannot know if a given .babelrc.json is meant to be loaded,
     * or if it's "plugins" and "presets" have even been installed, since the file being compiled could be inside node_modules,
     * or have been symlinked into the project.
     *
     * This option allows users to provide a list of other packages that should be considered "root" packages
     * when considering whether to load .babelrc.json files.
     *
     * @default opts.root
     */
    babelrcRoots?: boolean | MatchPattern | Array<MatchPattern>,

    // Plugin and Preset options

    /**
     * An array of plugins to activate when processing this file.
     * For more information on how individual entries interact, especially when used across multiple nested "env" and "overrides" configs,
     * see merging.
     *
     * Note: The option also allows Plugin instances from Babel itself, but using these directly is not recommended.
     * If you need to create a persistent representation of a plugin or preset, you should use babel.createConfigItem().
     *
     * @default []
     */
    plugins?: Plugins,

    /**
     * An array of presets to activate when processing this file.
     * For more information on how individual entries interact,
     * especially when used across multiple nested "env" and "overrides" configs, see merging.
     *
     * Note: The format of presets is identical to plugins,
     * except for the fact that name normalization expects "preset-" instead of "plugin-", and presets cannot be instances of Plugin.
     *
     * @default []
     */
    presets?: Presets,

    /**
     * Instructs Babel to run each of the presets in the presets array as an independent pass.
     * This option tends to introduce a lot of confusion around the exact ordering of plugins,
     * but can be useful if you absolutely need to run a set of operations as independent compilation passes.
     *
     * Note: This option may be removed in future Babel versions as we add better support for defining ordering between plugins.
     *
     * @default false
     * @deprecated
     */
    passPerPreset?: boolean,

    // Output targets

    /**
     * Describes the environments you support/target for your project.
     * When no targets are specified: Babel will assume you are targeting the oldest browsers possible. For example, @babel/preset-env will transform all ES2015-ES2020 code to be ES5 compatible.
     */
    targets?:
      | string
      | Array<string>
      | {[env: string]: string}
      | {
          esmodules?: boolean,
          node?: string | 'current' | true,
          safari?: string | 'tp',
          browsers?: string | Array<string>,
        },

    /**
     * Toggles whether or not browserslist config sources are used,
     * which includes searching for any browserslist files or referencing the browserslist key inside package.json.
     * This is useful for projects that use a browserslist config for files that won't be compiled with Babel.
     *
     * If a string is specified, it must represent the path of a browserslist configuration file.
     * Relative paths are resolved relative to the configuration file which specifies this option,
     * or to cwd when it's passed as part of the programmatic options.
     */
    browserslistConfigFile?: boolean | string,

    /**
     * The Browserslist environment to use.
     *
     * @see https://github.com/browserslist/browserslist#configuring-for-different-environments
     */
    browserslistEnv?: string | void,

    // Config Merging options

    /**
     * Configs may "extend" other configuration files.
     * Config fields in the current config will be merged on top of the extended file's configuration.
     */
    extends?: string,

    /**
     * Placement: May not be nested inside of another env block.
     *
     * Allows for entire nested configuration options that will only be enabled if the envKey matches the envName option.
     *
     * Note: env[envKey] options will be merged on top of the options specified in the root object.
     */
    env?: {[envKey: string]: BabelCoreOptions},

    /**
     * Placement: May not be nested inside of another overrides object, or within an env block.
     *
     * Allows users to provide an array of options that will be merged into the current configuration one at a time.
     * This feature is best used alongside the "test"/"include"/"exclude" options to provide conditions for which an override should apply.
     * For example:
     *
     * ```
     * overrides: [{
     *  test: "./vendor/large.min.js",
     *  compact: true,
     * }],
     * ```
     *
     * could be used to enable the compact option for one specific file that is known to be large and minified,
     * and tell Babel not to bother trying to print the file nicely.
     */
    overrides?: Array<BabelCoreOptions>,

    /**
     * If all patterns fail to match, the current configuration object is considered inactive and is ignored during config processing.
     * This option is most useful when used within an overrides option object, but it's allowed anywhere.
     *
     * Note: These toggles do not affect the programmatic and config-loading options in earlier sections,
     * since they are taken into account long before the configuration that is prepared for merging.
     */
    test?: MatchPattern | Array<MatchPattern>,

    /**
     * This option is a synonym for "test".
     */
    include?: MatchPattern | Array<MatchPattern>,

    /**
     * If any of patterns match, the current configuration object is considered inactive and is ignored during config processing.
     * This option is most useful when used within an overrides option object, but it's allowed anywhere.
     *
     * Note: These toggles do not affect the programmatic and config-loading options in earlier sections,
     * since they are taken into account long before the configuration that is prepared for merging.
     */
    exclude?: MatchPattern | Array<MatchPattern>,

    /**
     * If any of the patterns match, Babel will immediately stop all processing of the current build.
     * For example, a user may want to do something like: `ignore: ['./lib']` to explicitly disable Babel compilation of files inside the lib directory.
     *
     * Note: This option disables all Babel processing of a file. While that has its uses,
     * it is also worth considering the "exclude" option as a less aggressive alternative.
     */
    ignore?: MatchPattern | Array<MatchPattern>,

    /**
     * If all of the patterns fail to match, Babel will immediately stop all processing of the current build.
     * For example, a user may want to do something like `only: ['./src']` to explicitly enable Babel compilation of files inside the src directory while disabling everything else.
     *
     * Note: This option disables all Babel processing of a file. While that has its uses,
     * it is also worth considering the "test"/"include" options as a less aggressive alternative.
     */
    only?: MatchPattern | Array<MatchPattern>,

    extensions?: Array<string>,

    // Source Map options

    /**
     * true will attempt to load an input sourcemap from the file itself, if it contains a //# sourceMappingURL=... comment.
     * If no map is found, or the map fails to load and parse, it will be silently discarded.
     *
     * If an object is provided, it will be treated as the source map object itself.
     *
     * @default true
     */
    inputSourceMap?: boolean | _BabelSourceMap,

    /**
     * - true to generate a sourcemap for the code and include it in the result object.
     * - "inline" to generate a sourcemap and append it as a data URL to the end of the code, but not include it in the result object.
     * - "both" is the same as inline, but will include the map in the result object.
     *
     * @babel/cli overloads some of these to also affect how maps are written to disk:
     * - true will write the map to a .map file on disk
     * - "inline" will write the file directly, so it will have a data: containing the map
     * - "both" will write the file with a data: URL and also a .map.
     *
     * Note: These options are bit weird, so it may make the most sense to just use true and handle the rest in your own code, depending on your use case.
     *
     * @default true
     */
    sourceMaps?: boolean | 'inline' | 'both',

    /**
     * This is an synonym for sourceMaps. Using sourceMaps is recommended.
     */
    sourceMap?: boolean,

    /**
     * The name to use for the file inside the source map object.
     * @default path.basename(opts.filenameRelative) when available, or "unknown"
     */
    sourceFileName?: string,

    /**
     * The sourceRoot fields to set in the generated source map, if one is desired.
     */
    sourceRoot?: string,

    // Misc options

    /**
     * - "script" - Parse the file using the ECMAScript Script grammar. No import/export statements allowed, and files are not in strict mode.
     * - "module" - Parse the file using the ECMAScript Module grammar. Files are automatically strict, and import/export statements are allowed.
     * - "unambiguous" - Consider the file a "module" if import/export statements are present, or else consider it a "script".
     *
     * unambiguous can be quite useful in contexts where the type is unknown,
     * but it can lead to false matches because it's perfectly valid to have a module file that does not use import/export statements.
     *
     * This option is important because the type of the current file affects both parsing of input files,
     * and certain transforms that may wish to add import/require usage to the current file.
     *
     * For instance, @babel/plugin-transform-runtime relies on the type of the current document to decide whether to insert an import declaration,
     * or a require() call. @babel/preset-env also does the same for its "useBuiltIns" option.
     * Since Babel defaults to treating files are ES modules, generally these plugins/presets will insert import statements.
     * Setting the correct sourceType can be important because having the wrong type
     * can lead to cases where Babel would insert import statements into files that are meant to be CommonJS files.
     * This can be particularly important in projects where compilation of node_modules dependencies is being performed,
     * because inserting an import statements can cause Webpack and other tooling to see a file as an ES module,
     * breaking what would otherwise be a functional CommonJS file.
     *
     * Note: This option will not affect parsing of .mjs files, as they are currently hard-coded to always parse as "module" files.
     *
     * @default 'module'
     */
    sourceType?: 'script' | 'module' | 'unambiguous',

    /**
     * Highlight tokens in code snippets in Babel's error messages to make them easier to read.
     *
     * @default true
     */
    highlightCode?: boolean,

    /**
     * Set assumptions that Babel can make in order to produce smaller output
     * @see https://babel.dev/assumptions
     */
    assumptions?: {[assumption: string]: boolean},

    /**
     * Allows users to add a wrapper on each visitor in order to inspect the visitor process as Babel executes the plugins.
     *
     * - key is a simple opaque string that represents the plugin being executed.
     * - nodeType is the type of AST node currently being visited.
     * - fn is the visitor function itself.
     *
     * Users can return a replacement function that should call the original function after performing whatever logging
     * and analysis they wish to do.
     */
    wrapPluginVisitorMethod?: (
      key: string,
      nodeType: BabelNode['type'],
      fn: Function,
    ) => Function,

    /**
     * An opaque object containing options to pass through to the parser being used.
     */
    parserOpts?: ParserOptions,

    /**
     * An opaque object containing options to pass through to the code generator being used.
     */
    generatorOpts?: GeneratorOptions,

    // Code Generator options

    /**
     * Optional string to add as a block comment at the start of the output file
     */
    auxiliaryCommentBefore?: string,

    /**
     * Optional string to add as a block comment at the end of the output file
     */
    auxiliaryCommentAfter?: string,

    /**
     * Function that takes a comment (as a string) and returns true if the comment should be included in the output.
     * By default, comments are included if opts.comments is true or if opts.minified is false and the comment contains @preserve or @license
     */
    shouldPrintComment?: (comment: string) => boolean,

    /**
     * Attempt to use the same line numbers in the output code as in the source code (helps preserve stack traces)
     * @default false
     */
    retainLines?: boolean,

    /**
     * Should comments be included in output
     * @default true
     */
    comments?: boolean,

    /**
     * Set to true to avoid adding whitespace for formatting
     * @default opts.minified
     */
    compact?: boolean | 'auto',

    /**
     * Should the output be minified
     * @default false
     */
    minified?: boolean,

    // AMD / UMD / SystemJS module options

    /**
     * Enables module ID generation.
     *
     * @default !!opts.moduleId
     */
    moduleIds?: boolean,

    /**
     * A hard-coded ID to use for the module. Cannot be used alongside getModuleId.
     */
    moduleId?: string,

    /**
     * Given the babel-generated module name, return the name to use. Returning a falsy value will use the original name.
     */
    getModuleId?: (name: string) => string,

    /**
     * A root path to include on generated module names.
     */
    moduleRoot?: string,
  |};

  declare export type TransformResult<T = BabelFileMetadata> = {|
    metadata: T,
    options: BabelCoreOptions,
    code: string,
    map: _BabelSourceMap | null,
    ast: BabelNodeFile | null,
    ignored?: boolean,
  |};

  declare type TransformCallback<TMetadata> =
    | ((Error, null) => mixed)
    | ((null, TransformResult<TMetadata> | null) => mixed);

  /**
   * Transforms the passed in code. Calling a callback with an object with the generated code, source map, and AST.
   */
  declare export function transform<TMetadata = BabelFileMetadata>(
    code: string,
    options: ?BabelCoreOptions,
    callback: TransformCallback<TMetadata>,
  ): void;

  /***
   * Transforms the passed in code. Returning an object with the generated code, source map, and AST.
   */
  declare export function transformSync<TMetadata = BabelFileMetadata>(
    code: string,
    options?: BabelCoreOptions,
  ): TransformResult<TMetadata>;

  /**
   * Transforms the passed in code. Returning an promise for an object with the generated code, source map, and AST.
   */
  declare export function transformAsync<TMetadata = BabelFileMetadata>(
    code: string,
    options?: BabelCoreOptions,
  ): Promise<TransformResult<TMetadata>>;

  /**
   * Asynchronously transforms the entire contents of a file.
   */
  declare export function transformFile<TMetadata = BabelFileMetadata>(
    filename: string,
    options?: BabelCoreOptions,
    callback: TransformCallback<TMetadata>,
  ): void;

  /**
   * Synchronous version of babel.transformFile. Returns the transformed contents of the filename.
   */
  declare export function transformFileSync<TMetadata = BabelFileMetadata>(
    filename: string,
    options?: BabelCoreOptions,
  ): TransformResult<TMetadata>;

  /**
   * Promise version of babel.transformFile. Returns a promise for the transformed contents of the filename.
   */
  declare export function transformFileAsync<TMetadata = BabelFileMetadata>(
    filename: string,
    options?: BabelCoreOptions,
  ): Promise<TransformResult<TMetadata>>;

  /**
   * Given an AST, transform it.
   */
  declare export function transformFromAst<TMetadata = BabelFileMetadata>(
    ast: BabelNodeFile | BabelNodeProgram,
    code?: string,
    options?: BabelCoreOptions,
    callback: TransformCallback<TMetadata>,
  ): void;

  /**
   * Given an AST, transform it.
   */
  declare export function transformFromAstSync<TMetadata = BabelFileMetadata>(
    ast: BabelNodeFile | BabelNodeProgram,
    code?: string,
    options?: BabelCoreOptions,
  ): TransformResult<TMetadata>;

  /**
   * Given an AST, transform it.
   */
  declare export function transformFromAstAsync<TMetadata = BabelFileMetadata>(
    ast: BabelNodeFile | BabelNodeProgram,
    code?: string,
    options?: BabelCoreOptions,
  ): Promise<TransformResult<TMetadata>>;

  /**
   * Given some code, parse it using Babel's standard behavior. Referenced presets and plugins will be loaded such that optional syntax plugins are automatically enabled.
   */
  declare export function parse(
    code: string,
    options?: BabelCoreOptions,
    callback: ((error: Error) => void) | ((void, BabelNodeFile) => void),
  ): void;

  declare export function parseSync(
    code: string,
    options?: BabelCoreOptions,
  ): BabelNodeFile;

  declare export function parseAsync(
    code: string,
    options?: BabelCoreOptions,
  ): Promise<BabelNodeFile>;

  declare export var template: Template;
  declare export var traverse: Traverse;
  declare export var types: Types;
  declare export var DEFAULT_EXTENSIONS: $ReadOnlyArray<string>;

  declare export function buildExternalHelpers(
    whitelist?: Array<string>,
    outputType?: 'global' | 'module' | 'umd' | 'var',
  ): string;

  declare export function getEnv(defaultValue?: string): string;

  declare export function resolvePlugin(
    name: string,
    dirname: string,
  ): string | null;

  declare export function resolvePreset(
    name: string,
    dirname: string,
  ): string | null;

  declare export function createConfigItem(
    value:
      | EntryTarget
      | [EntryTarget, EntryOptions]
      | [EntryTarget, EntryOptions, string | void],
    options: ?{
      dirname?: string,
      type?: 'preset' | 'plugin',
    },
  ): ConfigItem;

  declare export type ResolvedConfig = {
    options: BabelCoreOptions,
    passes: Array<Array<PluginObj<mixed> | (() => PluginObj<mixed>)>>,
  };

  declare export function loadOptions(
    options?: mixed,
    callback:
      | ((error: Error, null) => mixed)
      | ((null, config: ResolvedConfig | null) => mixed),
  ): void;
  declare export function loadOptionsSync(
    options?: mixed,
  ): ResolvedConfig | null;
  declare export function loadOptionsAsync(
    options?: mixed,
  ): Promise<ResolvedConfig | null>;

  // For now
  declare type ValidatedOptions = BabelCoreOptions;

  declare class PartialConfig {
    +options: $ReadOnly<ValidatedOptions>;
    +babelrc: string | void;
    +babelignore: string | void;
    +config: string | void;

    constructor(options: ValidatedOptions): PartialConfig;

    hasFilesystemConfig(): boolean;
  }

  declare export function loadPartialConfig(
    options?: mixed,
    callback:
      | ((error: Error, null) => mixed)
      | ((null, config: PartialConfig | null) => mixed),
  ): void;
  declare export function loadPartialConfigSync(
    options?: mixed,
  ): PartialConfig | null;
  declare export function loadPartialConfigAsync(
    options?: mixed,
  ): Promise<PartialConfig | null>;
}

declare module '@babel/generator' {
  declare export type BabelSourceMapSegment = _BabelSourceMapSegment;

  declare export type GeneratorResult = {
    code: string,
    map: ?_BabelSourceMap,
    rawMappings: ?Array<BabelSourceMapSegment>,
  };

  declare export class CodeGenerator {
    constructor(ast: BabelNode, opts: {...}, code: string): CodeGenerator;

    generate(): GeneratorResult;
  }

  declare export type Options = {
    /**
     * Optional string to add as a block comment at the start of the output file
     */
    auxiliaryCommentBefore?: string,

    /**
     * Optional string to add as a block comment at the end of the output file
     */
    auxiliaryCommentAfter?: string,

    /**
     * Function that takes a comment (as a string) and returns true if the comment should be included in the output.
     * By default, comments are included if opts.comments is true or if opts.minified is false and the comment contains @preserve or @license
     */
    shouldPrintComment?: (comment: string) => boolean,

    /**
     * Attempt to use the same line numbers in the output code as in the source code (helps preserve stack traces)
     * @default false
     */
    retainLines?: boolean,

    /**
     * Retain parens around function expressions (could be used to change engine parsing behavior)
     * @default false
     */
    retainFunctionParens?: boolean,

    /**
     * Should comments be included in output
     * @default true
     */
    comments?: boolean,

    /**
     * Set to true to avoid adding whitespace for formatting
     * @default opts.minified
     */
    compact?: boolean | 'auto',

    /**
     * Should the output be minified
     * @default false
     */
    minified?: boolean,

    /**
     * Set to true to reduce whitespace (but not as much as opts.compact)
     * @default false
     */
    concise?: boolean,

    /**
     * Used in warning messages
     */
    filename?: string,

    /**
     * Set to true to run jsesc with "json": true to print "\u00A9" vs. "©";
     * @default false
     */
    jsonCompatibleStrings?: boolean,

    /**
     * Use jsesc to process literals. jsesc is applied to numbers only if jsescOption.numbers is present.
     * You can customize jsesc by passing options to it.
     */
    jsecsOption?: {...},

    decoratorsBeforeExport?: boolean,
    recordAndTupleSyntaxType?: mixed,

    /**
     * Enable generating source maps
     * @default false
     */
    sourceMaps?: boolean,

    /**
     * A root for all relative URLs in the source map
     */
    sourceRoot?: string,

    /**
     * The filename for the source code (i.e. the code in the code argument). This will only be used if code is a string.
     */
    sourceFileName?: string,
    /**
     * The filename of the generated code that the source map will be associated with
     */
    sourceMapTarget?: string,
  };

  declare export default (
    ast: BabelNode,
    options?: Options,
    code?: string | {[string]: string, ...},
  ) => GeneratorResult;

  declare export default (
    ast: BabelNode,
    options?: Options,
    code?: string | {|[filename: string]: string|},
  ) => GeneratorResult;
}

declare module '@babel/register' {
  import type {BabelCoreOptions} from '@babel/core';

  declare module.exports: (options?: BabelCoreOptions) => void;
}

declare module '@babel/template' {
  import type {Node, Statement, Expression, Program} from '@babel/types';

  declare export type PublicOpts = {
    /**
     * A set of placeholder names to automatically accept, ignoring the given
     * pattern entirely.
     *
     * This option can be used when using %%foo%% style placeholders.
     */
    placeholderWhitelist?: ?Set<string>,

    /**
     * A pattern to search for when looking for Identifier and StringLiteral
     * nodes that can be replaced.
     *
     * 'false' will disable placeholder searching entirely, leaving only the
     * 'placeholderWhitelist' value to find replacements.
     *
     * Defaults to /^[_$A-Z0-9]+$/.
     *
     * This option can be used when using %%foo%% style placeholders.
     */
    placeholderPattern?: ?(RegExp | false),

    /**
     * 'true' to pass through comments from the template into the resulting AST,
     * or 'false' to automatically discard comments. Defaults to 'false'.
     */
    preserveComments?: ?boolean,

    /**
     * 'true' to use %%foo%% style placeholders, 'false' to use legacy placeholders
     * described by placeholderPattern or placeholderWhitelist.
     * When it is not set, it behaves as 'true' if there are syntactic placeholders,
     * otherwise as 'false'.
     */
    syntacticPlaceholders?: ?boolean,
  };

  declare export type PublicReplacements =
    | {[string]: ?BabelNode}
    | Array<?BabelNode>;

  declare export type TemplateBuilder<T> = {
    // Build a new builder, merging the given options with the previous ones.
    (opts: PublicOpts): TemplateBuilder<T>,

    // Building from a string produces an AST builder function by default.
    (tpl: string, opts: ?PublicOpts): (?PublicReplacements) => T,

    // Building from a template literal produces an AST builder function by default.
    (tpl: Array<string>, ...args: Array<mixed>): (?PublicReplacements) => T,

    // Allow users to explicitly create templates that produce ASTs, skipping
    // the need for an intermediate function.
    ast: {
      (tpl: string, opts: ?PublicOpts): T,
      (tpl: Array<string>, ...args: Array<mixed>): T,
    },
  };

  declare export type smart = TemplateBuilder<Statement | Array<Statement>>;
  declare export type expression = TemplateBuilder<Expression>;
  declare export type statement = TemplateBuilder<Statement>;
  declare export type statements = TemplateBuilder<Array<Statement>>;
  declare export type program = TemplateBuilder<Program>;

  declare export type DefaultTemplateBuilder = {
    smart: smart,
    statement: statement,
    statements: statements,
    expression: expression,
    program: program,

    // The call signatures are missing if I spread the `TemplateBuilder` type for whatever reason
    // Copy paste the definition in here solves the problem.

    // Build a new builder, merging the given options with the previous ones.
    (opts: PublicOpts): TemplateBuilder<Statement | Array<Statement>>,

    // Building from a string produces an AST builder function by default.
    (
      tpl: string,
      opts: ?PublicOpts,
    ): (?PublicReplacements) => Statement | Array<Statement>,

    // Building from a template literal produces an AST builder function by default.
    (
      tpl: Array<string>,
      ...args: Array<mixed>
    ): (?PublicReplacements) => Statement | Array<Statement>,

    // Allow users to explicitly create templates that produce ASTs, skipping
    // the need for an intermediate function.
    ast: {
      (tpl: string, opts: ?PublicOpts): Statement | Array<Statement>,
      (tpl: Array<string>, ...args: Array<mixed>): Statement | Array<Statement>,
    },
  };

  declare export default DefaultTemplateBuilder;
}