Socket
Socket
Sign inDemoInstall

@babel/core

Package Overview
Dependencies
15
Maintainers
4
Versions
187
Alerts
File Explorer

Advanced tools

npm Scripts
License

Install Socket

Detect and block malicious and high-risk dependencies

Install

Comparing version 7.21.4-esm to 7.21.4-esm.1

2

lib/config/cache-contexts.js

@@ -1,3 +0,3 @@

0 && 0;
//# sourceMappingURL=cache-contexts.js.map

49

lib/config/caching.js

@@ -1,22 +0,6 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.assertSimpleType = assertSimpleType;
exports.makeStrongCache = makeStrongCache;
exports.makeStrongCacheSync = makeStrongCacheSync;
exports.makeWeakCache = makeWeakCache;
exports.makeWeakCacheSync = makeWeakCacheSync;
function _gensync() {
const data = require("gensync");
_gensync = function () {
return data;
};
return data;
}
var _async = require("../gensync-utils/async");
var _util = require("./util");
import gensync from "gensync";
import { maybeAsync, isAsync, onFirstPause, waitFor, isThenable } from "../gensync-utils/async.js";
import { isIterableIterator } from "./util.js";
const synchronize = gen => {
return _gensync()(gen).sync;
return gensync(gen).sync;
};

@@ -26,12 +10,12 @@ function* genTrue() {

}
function makeWeakCache(handler) {
export function makeWeakCache(handler) {
return makeCachedFunction(WeakMap, handler);
}
function makeWeakCacheSync(handler) {
export function makeWeakCacheSync(handler) {
return synchronize(makeWeakCache(handler));
}
function makeStrongCache(handler) {
export function makeStrongCache(handler) {
return makeCachedFunction(Map, handler);
}
function makeStrongCacheSync(handler) {
export function makeStrongCacheSync(handler) {
return synchronize(makeStrongCache(handler));

@@ -44,3 +28,3 @@ }

return function* cachedFunction(arg, data) {
const asyncContext = yield* (0, _async.isAsync)();
const asyncContext = yield* isAsync();
const callCache = asyncContext ? callCacheAsync : callCacheSync;

@@ -53,4 +37,4 @@ const cached = yield* getCachedValueOrWait(asyncContext, callCache, futureCache, arg, data);

let value;
if ((0, _util.isIterableIterator)(handlerResult)) {
value = yield* (0, _async.onFirstPause)(handlerResult, () => {
if (isIterableIterator(handlerResult)) {
value = yield* onFirstPause(handlerResult, () => {
finishLock = setupAsyncLocks(cache, futureCache, arg);

@@ -95,3 +79,3 @@ });

if (cached.valid) {
const value = yield* (0, _async.waitFor)(cached.value.promise);
const value = yield* waitFor(cached.value.promise);
return {

@@ -196,4 +180,4 @@ valid: true,

const key = handler(this._data);
const fn = (0, _async.maybeAsync)(handler, `You appear to be using an async cache handler, but Babel has been called synchronously`);
if ((0, _async.isThenable)(key)) {
const fn = maybeAsync(handler, `You appear to be using an async cache handler, but Babel has been called synchronously`);
if (isThenable(key)) {
return key.then(key => {

@@ -241,4 +225,4 @@ this._pairs.push([key, fn]);

}
function assertSimpleType(value) {
if ((0, _async.isThenable)(value)) {
export function assertSimpleType(value) {
if (isThenable(value)) {
throw new Error(`You appear to be using an async cache handler, ` + `which your current version of Babel does not support. ` + `We may add support for this in the future, ` + `but if you're on the most recent version of @babel/core and still ` + `seeing this error, then you'll need to synchronously handle your caching logic.`);

@@ -265,4 +249,3 @@ }

}
0 && 0;
//# sourceMappingURL=caching.js.map

116

lib/config/config-chain.js

@@ -1,33 +0,13 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.buildPresetChain = buildPresetChain;
exports.buildPresetChainWalker = void 0;
exports.buildRootChain = buildRootChain;
function _path() {
const data = require("path");
_path = function () {
return data;
};
return data;
}
function _debug() {
const data = require("debug");
_debug = function () {
return data;
};
return data;
}
var _options = require("./validation/options");
var _patternToRegex = require("./pattern-to-regex");
var _printer = require("./printer");
var _rewriteStackTrace = require("../errors/rewrite-stack-trace");
var _configError = require("../errors/config-error");
var _files = require("./files");
var _caching = require("./caching");
var _configDescriptors = require("./config-descriptors");
const debug = _debug()("babel:config:config-chain");
function* buildPresetChain(arg, context) {
import path from "path";
import buildDebug from "debug";
import { validate } from "./validation/options.js";
import pathPatternToRegex from "./pattern-to-regex.js";
import { ConfigPrinter, ChainFormatter } from "./printer.js";
import { endHiddenCallStack } from "../errors/rewrite-stack-trace.js";
import ConfigError from "../errors/config-error.js";
const debug = buildDebug("babel:config:config-chain");
import { findPackageData, findRelativeConfig, findRootConfig, loadConfig } from "./files/index.js";
import { makeWeakCacheSync, makeStrongCacheSync } from "./caching.js";
import { createCachedDescriptors, createUncachedDescriptors } from "./config-descriptors.js";
export function* buildPresetChain(arg, context) {
const chain = yield* buildPresetChainWalker(arg, context);

@@ -42,3 +22,3 @@ if (!chain) return null;

}
const buildPresetChainWalker = makeChainWalker({
export const buildPresetChainWalker = makeChainWalker({
root: preset => loadPresetDescriptors(preset),

@@ -50,10 +30,9 @@ env: (preset, envName) => loadPresetEnvDescriptors(preset)(envName),

});
exports.buildPresetChainWalker = buildPresetChainWalker;
const loadPresetDescriptors = (0, _caching.makeWeakCacheSync)(preset => buildRootDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors));
const loadPresetEnvDescriptors = (0, _caching.makeWeakCacheSync)(preset => (0, _caching.makeStrongCacheSync)(envName => buildEnvDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, envName)));
const loadPresetOverridesDescriptors = (0, _caching.makeWeakCacheSync)(preset => (0, _caching.makeStrongCacheSync)(index => buildOverrideDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, index)));
const loadPresetOverridesEnvDescriptors = (0, _caching.makeWeakCacheSync)(preset => (0, _caching.makeStrongCacheSync)(index => (0, _caching.makeStrongCacheSync)(envName => buildOverrideEnvDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, index, envName))));
function* buildRootChain(opts, context) {
const loadPresetDescriptors = makeWeakCacheSync(preset => buildRootDescriptors(preset, preset.alias, createUncachedDescriptors));
const loadPresetEnvDescriptors = makeWeakCacheSync(preset => makeStrongCacheSync(envName => buildEnvDescriptors(preset, preset.alias, createUncachedDescriptors, envName)));
const loadPresetOverridesDescriptors = makeWeakCacheSync(preset => makeStrongCacheSync(index => buildOverrideDescriptors(preset, preset.alias, createUncachedDescriptors, index)));
const loadPresetOverridesEnvDescriptors = makeWeakCacheSync(preset => makeStrongCacheSync(index => makeStrongCacheSync(envName => buildOverrideEnvDescriptors(preset, preset.alias, createUncachedDescriptors, index, envName))));
export function* buildRootChain(opts, context) {
let configReport, babelRcReport;
const programmaticLogger = new _printer.ConfigPrinter();
const programmaticLogger = new ConfigPrinter();
const programmaticChain = yield* loadProgrammaticChain({

@@ -67,5 +46,5 @@ options: opts,

if (typeof opts.configFile === "string") {
configFile = yield* (0, _files.loadConfig)(opts.configFile, context.cwd, context.envName, context.caller);
configFile = yield* loadConfig(opts.configFile, context.cwd, context.envName, context.caller);
} else if (opts.configFile !== false) {
configFile = yield* (0, _files.findRootConfig)(context.root, context.envName, context.caller);
configFile = yield* findRootConfig(context.root, context.envName, context.caller);
}

@@ -78,3 +57,3 @@ let {

const configFileChain = emptyChain();
const configFileLogger = new _printer.ConfigPrinter();
const configFileLogger = new ConfigPrinter();
if (configFile) {

@@ -98,3 +77,3 @@ const validatedFile = validateConfigFile(configFile);

if ((babelrc === true || babelrc === undefined) && typeof context.filename === "string") {
const pkgData = yield* (0, _files.findPackageData)(context.filename);
const pkgData = yield* findPackageData(context.filename);
if (pkgData && babelrcLoadEnabled(context, pkgData, babelrcRoots, babelrcRootsDirectory)) {

@@ -104,3 +83,3 @@ ({

config: babelrcFile
} = yield* (0, _files.findRelativeConfig)(pkgData, context.envName, context.caller));
} = yield* findRelativeConfig(pkgData, context.envName, context.caller));
if (ignoreFile) {

@@ -114,3 +93,3 @@ fileChain.files.add(ignoreFile.filepath);

const validatedFile = validateBabelrcFile(babelrcFile);
const babelrcLogger = new _printer.ConfigPrinter();
const babelrcLogger = new ConfigPrinter();
const result = yield* loadFileChain(validatedFile, context, undefined, babelrcLogger);

@@ -155,3 +134,3 @@ if (!result) {

babelrcPatterns = babelrcPatterns.map(pat => {
return typeof pat === "string" ? _path().resolve(babelrcRootsDirectory, pat) : pat;
return typeof pat === "string" ? path.resolve(babelrcRootsDirectory, pat) : pat;
});

@@ -163,3 +142,3 @@ if (babelrcPatterns.length === 1 && babelrcPatterns[0] === absoluteRoot) {

if (typeof pat === "string") {
pat = (0, _patternToRegex.default)(pat, babelrcRootsDirectory);
pat = pathPatternToRegex(pat, babelrcRootsDirectory);
}

@@ -171,22 +150,22 @@ return pkgData.directories.some(directory => {

}
const validateConfigFile = (0, _caching.makeWeakCacheSync)(file => ({
const validateConfigFile = makeWeakCacheSync(file => ({
filepath: file.filepath,
dirname: file.dirname,
options: (0, _options.validate)("configfile", file.options, file.filepath)
options: validate("configfile", file.options, file.filepath)
}));
const validateBabelrcFile = (0, _caching.makeWeakCacheSync)(file => ({
const validateBabelrcFile = makeWeakCacheSync(file => ({
filepath: file.filepath,
dirname: file.dirname,
options: (0, _options.validate)("babelrcfile", file.options, file.filepath)
options: validate("babelrcfile", file.options, file.filepath)
}));
const validateExtendFile = (0, _caching.makeWeakCacheSync)(file => ({
const validateExtendFile = makeWeakCacheSync(file => ({
filepath: file.filepath,
dirname: file.dirname,
options: (0, _options.validate)("extendsfile", file.options, file.filepath)
options: validate("extendsfile", file.options, file.filepath)
}));
const loadProgrammaticChain = makeChainWalker({
root: input => buildRootDescriptors(input, "base", _configDescriptors.createCachedDescriptors),
env: (input, envName) => buildEnvDescriptors(input, "base", _configDescriptors.createCachedDescriptors, envName),
overrides: (input, index) => buildOverrideDescriptors(input, "base", _configDescriptors.createCachedDescriptors, index),
overridesEnv: (input, index, envName) => buildOverrideEnvDescriptors(input, "base", _configDescriptors.createCachedDescriptors, index, envName),
root: input => buildRootDescriptors(input, "base", createCachedDescriptors),
env: (input, envName) => buildEnvDescriptors(input, "base", createCachedDescriptors, envName),
overrides: (input, index) => buildOverrideDescriptors(input, "base", createCachedDescriptors, index),
overridesEnv: (input, index, envName) => buildOverrideEnvDescriptors(input, "base", createCachedDescriptors, index, envName),
createLogger: (input, context, baseLogger) => buildProgrammaticLogger(input, context, baseLogger)

@@ -208,6 +187,6 @@ });

}
const loadFileDescriptors = (0, _caching.makeWeakCacheSync)(file => buildRootDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors));
const loadFileEnvDescriptors = (0, _caching.makeWeakCacheSync)(file => (0, _caching.makeStrongCacheSync)(envName => buildEnvDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, envName)));
const loadFileOverridesDescriptors = (0, _caching.makeWeakCacheSync)(file => (0, _caching.makeStrongCacheSync)(index => buildOverrideDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, index)));
const loadFileOverridesEnvDescriptors = (0, _caching.makeWeakCacheSync)(file => (0, _caching.makeStrongCacheSync)(index => (0, _caching.makeStrongCacheSync)(envName => buildOverrideEnvDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, index, envName))));
const loadFileDescriptors = makeWeakCacheSync(file => buildRootDescriptors(file, file.filepath, createUncachedDescriptors));
const loadFileEnvDescriptors = makeWeakCacheSync(file => makeStrongCacheSync(envName => buildEnvDescriptors(file, file.filepath, createUncachedDescriptors, envName)));
const loadFileOverridesDescriptors = makeWeakCacheSync(file => makeStrongCacheSync(index => buildOverrideDescriptors(file, file.filepath, createUncachedDescriptors, index)));
const loadFileOverridesEnvDescriptors = makeWeakCacheSync(file => makeStrongCacheSync(index => makeStrongCacheSync(envName => buildOverrideEnvDescriptors(file, file.filepath, createUncachedDescriptors, index, envName))));
function buildFileLogger(filepath, context, baseLogger) {

@@ -217,3 +196,3 @@ if (!baseLogger) {

}
return baseLogger.configure(context.showConfig, _printer.ChainFormatter.Config, {
return baseLogger.configure(context.showConfig, ChainFormatter.Config, {
filepath

@@ -233,3 +212,3 @@ });

}
return baseLogger.configure(context.showConfig, _printer.ChainFormatter.Programmatic, {
return baseLogger.configure(context.showConfig, ChainFormatter.Programmatic, {
callerName: (_context$caller = context.caller) == null ? void 0 : _context$caller.name

@@ -336,3 +315,3 @@ });

if (opts.extends === undefined) return true;
const file = yield* (0, _files.loadConfig)(opts.extends, dirname, context.envName, context.caller);
const file = yield* loadConfig(opts.extends, dirname, context.envName, context.caller);
if (files.has(file)) {

@@ -467,3 +446,3 @@ throw new Error(`Configuration cycle detected loading ${file.filepath}.\n` + `File already loaded following the config chain:\n` + Array.from(files, file => ` - ${file.filepath}`).join("\n"));

if (typeof pattern === "function") {
return !!(0, _rewriteStackTrace.endHiddenCallStack)(pattern)(pathToTest, {
return !!endHiddenCallStack(pattern)(pathToTest, {
dirname,

@@ -475,11 +454,10 @@ envName: context.envName,

if (typeof pathToTest !== "string") {
throw new _configError.default(`Configuration contains string/RegExp pattern, but no filename was passed to Babel`, configName);
throw new ConfigError(`Configuration contains string/RegExp pattern, but no filename was passed to Babel`, configName);
}
if (typeof pattern === "string") {
pattern = (0, _patternToRegex.default)(pattern, dirname);
pattern = pathPatternToRegex(pattern, dirname);
}
return pattern.test(pathToTest);
}
0 && 0;
//# sourceMappingURL=config-chain.js.map

53

lib/config/config-descriptors.js

@@ -1,21 +0,7 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.createCachedDescriptors = createCachedDescriptors;
exports.createDescriptor = createDescriptor;
exports.createUncachedDescriptors = createUncachedDescriptors;
function _gensync() {
const data = require("gensync");
_gensync = function () {
return data;
};
return data;
}
var _functional = require("../gensync-utils/functional");
var _files = require("./files");
var _item = require("./item");
var _caching = require("./caching");
var _resolveTargets = require("./resolve-targets");
import gensync from "gensync";
import { once } from "../gensync-utils/functional.js";
import { loadPlugin, loadPreset } from "./files/index.js";
import { getItemDescriptor } from "./item.js";
import { makeWeakCacheSync, makeStrongCacheSync, makeStrongCache } from "./caching.js";
import { resolveBrowserslistConfigFile } from "./resolve-targets.js";
function isEqualDescriptor(a, b) {

@@ -29,7 +15,7 @@ return a.name === b.name && a.value === b.value && a.options === b.options && a.dirname === b.dirname && a.alias === b.alias && a.ownPass === b.ownPass && (a.file && a.file.request) === (b.file && b.file.request) && (a.file && a.file.resolved) === (b.file && b.file.resolved);

if (typeof options.browserslistConfigFile === "string") {
options.browserslistConfigFile = (0, _resolveTargets.resolveBrowserslistConfigFile)(options.browserslistConfigFile, dirname);
options.browserslistConfigFile = resolveBrowserslistConfigFile(options.browserslistConfigFile, dirname);
}
return options;
}
function createCachedDescriptors(dirname, options, alias) {
export function createCachedDescriptors(dirname, options, alias) {
const {

@@ -46,13 +32,13 @@ plugins,

}
function createUncachedDescriptors(dirname, options, alias) {
export function createUncachedDescriptors(dirname, options, alias) {
return {
options: optionsWithResolvedBrowserslistConfigFile(options, dirname),
plugins: (0, _functional.once)(() => createPluginDescriptors(options.plugins || [], dirname, alias)),
presets: (0, _functional.once)(() => createPresetDescriptors(options.presets || [], dirname, alias, !!options.passPerPreset))
plugins: once(() => createPluginDescriptors(options.plugins || [], dirname, alias)),
presets: once(() => createPresetDescriptors(options.presets || [], dirname, alias, !!options.passPerPreset))
};
}
const PRESET_DESCRIPTOR_CACHE = new WeakMap();
const createCachedPresetDescriptors = (0, _caching.makeWeakCacheSync)((items, cache) => {
const createCachedPresetDescriptors = makeWeakCacheSync((items, cache) => {
const dirname = cache.using(dir => dir);
return (0, _caching.makeStrongCacheSync)(alias => (0, _caching.makeStrongCache)(function* (passPerPreset) {
return makeStrongCacheSync(alias => makeStrongCache(function* (passPerPreset) {
const descriptors = yield* createPresetDescriptors(items, dirname, alias, passPerPreset);

@@ -63,5 +49,5 @@ return descriptors.map(desc => loadCachedDescriptor(PRESET_DESCRIPTOR_CACHE, desc));

const PLUGIN_DESCRIPTOR_CACHE = new WeakMap();
const createCachedPluginDescriptors = (0, _caching.makeWeakCacheSync)((items, cache) => {
const createCachedPluginDescriptors = makeWeakCacheSync((items, cache) => {
const dirname = cache.using(dir => dir);
return (0, _caching.makeStrongCache)(function* (alias) {
return makeStrongCache(function* (alias) {
const descriptors = yield* createPluginDescriptors(items, dirname, alias);

@@ -104,3 +90,3 @@ return descriptors.map(desc => loadCachedDescriptor(PLUGIN_DESCRIPTOR_CACHE, desc));

function* createDescriptors(type, items, dirname, alias, ownPass) {
const descriptors = yield* _gensync().all(items.map((item, index) => createDescriptor(item, dirname, {
const descriptors = yield* gensync.all(items.map((item, index) => createDescriptor(item, dirname, {
type,

@@ -113,3 +99,3 @@ alias: `${alias}$${index}`,

}
function* createDescriptor(pair, dirname, {
export function* createDescriptor(pair, dirname, {
type,

@@ -119,3 +105,3 @@ alias,

}) {
const desc = (0, _item.getItemDescriptor)(pair);
const desc = getItemDescriptor(pair);
if (desc) {

@@ -140,3 +126,3 @@ return desc;

}
const resolver = type === "plugin" ? _files.loadPlugin : _files.loadPreset;
const resolver = type === "plugin" ? loadPlugin : loadPreset;
const request = value;

@@ -194,4 +180,3 @@ ({

}
0 && 0;
//# sourceMappingURL=config-descriptors.js.map

149

lib/config/files/configuration.js

@@ -1,63 +0,23 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.ROOT_CONFIG_FILENAMES = void 0;
exports.findConfigUpwards = findConfigUpwards;
exports.findRelativeConfig = findRelativeConfig;
exports.findRootConfig = findRootConfig;
exports.loadConfig = loadConfig;
exports.resolveShowConfigPath = resolveShowConfigPath;
function _debug() {
const data = require("debug");
_debug = function () {
return data;
};
return data;
}
function _fs() {
const data = require("fs");
_fs = function () {
return data;
};
return data;
}
function _path() {
const data = require("path");
_path = function () {
return data;
};
return data;
}
function _json() {
const data = require("json5");
_json = function () {
return data;
};
return data;
}
function _gensync() {
const data = require("gensync");
_gensync = function () {
return data;
};
return data;
}
var _caching = require("../caching");
var _configApi = require("../helpers/config-api");
var _utils = require("./utils");
var _moduleTypes = require("./module-types");
var _patternToRegex = require("../pattern-to-regex");
var _configError = require("../../errors/config-error");
var fs = require("../../gensync-utils/fs");
var _rewriteStackTrace = require("../../errors/rewrite-stack-trace");
const debug = _debug()("babel:config:loading:files:configuration");
const ROOT_CONFIG_FILENAMES = ["babel.config.js", "babel.config.cjs", "babel.config.mjs", "babel.config.json", "babel.config.cts"];
exports.ROOT_CONFIG_FILENAMES = ROOT_CONFIG_FILENAMES;
import buildDebug from "debug";
import nodeFs from "fs";
import path from "path";
import json5 from "json5";
import gensync from "gensync";
import { makeStrongCache, makeWeakCacheSync } from "../caching.js";
import { makeConfigAPI } from "../helpers/config-api.js";
import { makeStaticFileCache } from "./utils.js";
import loadCodeDefault from "./module-types.js";
import pathPatternToRegex from "../pattern-to-regex.js";
import ConfigError from "../../errors/config-error.js";
import * as fs from "../../gensync-utils/fs.js";
import { createRequire } from "module";
import { endHiddenCallStack } from "../../errors/rewrite-stack-trace.js";
const require = createRequire(import.meta.url);
const debug = buildDebug("babel:config:loading:files:configuration");
export const ROOT_CONFIG_FILENAMES = ["babel.config.js", "babel.config.cjs", "babel.config.mjs", "babel.config.json", "babel.config.cts"];
const RELATIVE_CONFIG_FILENAMES = [".babelrc", ".babelrc.js", ".babelrc.cjs", ".babelrc.mjs", ".babelrc.json", ".babelrc.cts"];
const BABELIGNORE_FILENAME = ".babelignore";
const LOADING_CONFIGS = new Set();
const readConfigCode = (0, _caching.makeStrongCache)(function* readConfigCode(filepath, cache) {
if (!_fs().existsSync(filepath)) {
const readConfigCode = makeStrongCache(function* readConfigCode(filepath, cache) {
if (!nodeFs.existsSync(filepath)) {
cache.never();

@@ -71,3 +31,3 @@ return null;

filepath,
dirname: _path().dirname(filepath),
dirname: path.dirname(filepath),
options: {}

@@ -79,3 +39,3 @@ };

LOADING_CONFIGS.add(filepath);
options = yield* (0, _moduleTypes.default)(filepath, "You appear to be using a native ECMAScript module configuration " + "file, which is only supported when running Babel asynchronously.");
options = yield* loadCodeDefault(filepath, "You appear to be using a native ECMAScript module configuration " + "file, which is only supported when running Babel asynchronously.");
} finally {

@@ -87,10 +47,10 @@ LOADING_CONFIGS.delete(filepath);

yield* [];
options = (0, _rewriteStackTrace.endHiddenCallStack)(options)((0, _configApi.makeConfigAPI)(cache));
options = endHiddenCallStack(options)(makeConfigAPI(cache));
assertCache = true;
}
if (!options || typeof options !== "object" || Array.isArray(options)) {
throw new _configError.default(`Configuration should be an exported JavaScript object.`, filepath);
throw new ConfigError(`Configuration should be an exported JavaScript object.`, filepath);
}
if (typeof options.then === "function") {
throw new _configError.default(`You appear to be using an async configuration, ` + `which your current version of Babel does not support. ` + `We may add support for this in the future, ` + `but if you're on the most recent version of @babel/core and still ` + `seeing this error, then you'll need to synchronously return your config.`, filepath);
throw new ConfigError(`You appear to be using an async configuration, ` + `which your current version of Babel does not support. ` + `We may add support for this in the future, ` + `but if you're on the most recent version of @babel/core and still ` + `seeing this error, then you'll need to synchronously return your config.`, filepath);
}

@@ -100,11 +60,11 @@ if (assertCache && !cache.configured()) throwConfigError(filepath);

filepath,
dirname: _path().dirname(filepath),
dirname: path.dirname(filepath),
options
};
});
const packageToBabelConfig = (0, _caching.makeWeakCacheSync)(file => {
const packageToBabelConfig = makeWeakCacheSync(file => {
const babel = file.options["babel"];
if (typeof babel === "undefined") return null;
if (typeof babel !== "object" || Array.isArray(babel) || babel === null) {
throw new _configError.default(`.babel property must be an object`, file.filepath);
throw new ConfigError(`.babel property must be an object`, file.filepath);
}

@@ -117,15 +77,15 @@ return {

});
const readConfigJSON5 = (0, _utils.makeStaticFileCache)((filepath, content) => {
const readConfigJSON5 = makeStaticFileCache((filepath, content) => {
let options;
try {
options = _json().parse(content);
options = json5.parse(content);
} catch (err) {
throw new _configError.default(`Error while parsing config - ${err.message}`, filepath);
throw new ConfigError(`Error while parsing config - ${err.message}`, filepath);
}
if (!options) throw new _configError.default(`No config detected`, filepath);
if (!options) throw new ConfigError(`No config detected`, filepath);
if (typeof options !== "object") {
throw new _configError.default(`Config returned typeof ${typeof options}`, filepath);
throw new ConfigError(`Config returned typeof ${typeof options}`, filepath);
}
if (Array.isArray(options)) {
throw new _configError.default(`Expected config object but found array`, filepath);
throw new ConfigError(`Expected config object but found array`, filepath);
}

@@ -135,12 +95,12 @@ delete options["$schema"];

filepath,
dirname: _path().dirname(filepath),
dirname: path.dirname(filepath),
options
};
});
const readIgnoreConfig = (0, _utils.makeStaticFileCache)((filepath, content) => {
const ignoreDir = _path().dirname(filepath);
const readIgnoreConfig = makeStaticFileCache((filepath, content) => {
const ignoreDir = path.dirname(filepath);
const ignorePatterns = content.split("\n").map(line => line.replace(/#(.*?)$/, "").trim()).filter(line => !!line);
for (const pattern of ignorePatterns) {
if (pattern[0] === "!") {
throw new _configError.default(`Negation of file paths is not supported.`, filepath);
throw new ConfigError(`Negation of file paths is not supported.`, filepath);
}

@@ -150,15 +110,15 @@ }

filepath,
dirname: _path().dirname(filepath),
ignore: ignorePatterns.map(pattern => (0, _patternToRegex.default)(pattern, ignoreDir))
dirname: path.dirname(filepath),
ignore: ignorePatterns.map(pattern => pathPatternToRegex(pattern, ignoreDir))
};
});
function findConfigUpwards(rootDir) {
export function findConfigUpwards(rootDir) {
let dirname = rootDir;
for (;;) {
for (const filename of ROOT_CONFIG_FILENAMES) {
if (_fs().existsSync(_path().join(dirname, filename))) {
if (nodeFs.existsSync(path.join(dirname, filename))) {
return dirname;
}
}
const nextDir = _path().dirname(dirname);
const nextDir = path.dirname(dirname);
if (dirname === nextDir) break;

@@ -169,6 +129,6 @@ dirname = nextDir;

}
function* findRelativeConfig(packageData, envName, caller) {
export function* findRelativeConfig(packageData, envName, caller) {
let config = null;
let ignore = null;
const dirname = _path().dirname(packageData.filepath);
const dirname = path.dirname(packageData.filepath);
for (const loc of packageData.directories) {

@@ -180,3 +140,3 @@ if (!config) {

if (!ignore) {
const ignoreLoc = _path().join(loc, BABELIGNORE_FILENAME);
const ignoreLoc = path.join(loc, BABELIGNORE_FILENAME);
ignore = yield* readIgnoreConfig(ignoreLoc);

@@ -193,10 +153,10 @@ if (ignore) {

}
function findRootConfig(dirname, envName, caller) {
export function findRootConfig(dirname, envName, caller) {
return loadOneConfig(ROOT_CONFIG_FILENAMES, dirname, envName, caller);
}
function* loadOneConfig(names, dirname, envName, caller, previousConfig = null) {
const configs = yield* _gensync().all(names.map(filename => readConfig(_path().join(dirname, filename), envName, caller)));
const configs = yield* gensync.all(names.map(filename => readConfig(path.join(dirname, filename), envName, caller)));
const config = configs.reduce((previousConfig, config) => {
if (config && previousConfig) {
throw new _configError.default(`Multiple configuration files found. Please remove one:\n` + ` - ${_path().basename(previousConfig.filepath)}\n` + ` - ${config.filepath}\n` + `from ${dirname}`);
throw new ConfigError(`Multiple configuration files found. Please remove one:\n` + ` - ${path.basename(previousConfig.filepath)}\n` + ` - ${config.filepath}\n` + `from ${dirname}`);
}

@@ -210,3 +170,3 @@ return config || previousConfig;

}
function* loadConfig(name, dirname, envName, caller) {
export function* loadConfig(name, dirname, envName, caller) {
const filepath = (((v, w) => (v = v.split("."), w = w.split("."), +v[0] > +w[0] || v[0] == w[0] && +v[1] >= +w[1]))(process.versions.node, "8.9") ? require.resolve : (r, {

@@ -225,3 +185,3 @@ paths: [b]

if (!conf) {
throw new _configError.default(`Config file contains no configuration data`, filepath);
throw new ConfigError(`Config file contains no configuration data`, filepath);
}

@@ -232,3 +192,3 @@ debug("Loaded config %o from %o.", name, dirname);

function readConfig(filepath, envName, caller) {
const ext = _path().extname(filepath);
const ext = path.extname(filepath);
switch (ext) {

@@ -247,6 +207,6 @@ case ".js":

}
function* resolveShowConfigPath(dirname) {
export function* resolveShowConfigPath(dirname) {
const targetPath = process.env.BABEL_SHOW_CONFIG_FOR;
if (targetPath != null) {
const absolutePath = _path().resolve(dirname, targetPath);
const absolutePath = path.resolve(dirname, targetPath);
const stats = yield* fs.stat(absolutePath);

@@ -261,3 +221,3 @@ if (!stats.isFile()) {

function throwConfigError(filepath) {
throw new _configError.default(`\
throw new ConfigError(`\
Caching was left unconfigured. Babel's plugins, presets, and .babelrc.js files can be configured

@@ -297,4 +257,3 @@ for various types of caching, using the first param of their handler functions:

}
0 && 0;
//# sourceMappingURL=configuration.js.map

15

lib/config/files/import-meta-resolve.js

@@ -1,10 +0,6 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = resolve;
var _importMetaResolve = require("../../vendor/import-meta-resolve");
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
import { createRequire } from "module";
import { resolve as polyfill } from "../../vendor/import-meta-resolve.js";
const require = createRequire(import.meta.url);
let import_;

@@ -14,4 +10,4 @@ try {

} catch (_unused) {}
const importMetaResolveP = import_ && process.execArgv.includes("--experimental-import-meta-resolve") ? import_("data:text/javascript,export default import.meta.resolve").then(m => m.default || _importMetaResolve.resolve, () => _importMetaResolve.resolve) : Promise.resolve(_importMetaResolve.resolve);
function resolve(_x, _x2) {
const importMetaResolveP = import_ && process.execArgv.includes("--experimental-import-meta-resolve") ? import_("data:text/javascript,export default import.meta.resolve").then(m => m.default || polyfill, () => polyfill) : Promise.resolve(polyfill);
export default function resolve(_x, _x2) {
return _resolve.apply(this, arguments);

@@ -25,4 +21,3 @@ }

}
0 && 0;
//# sourceMappingURL=import-meta-resolve.js.map

40

lib/config/files/index-browser.js

@@ -1,21 +0,5 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.ROOT_CONFIG_FILENAMES = void 0;
exports.findConfigUpwards = findConfigUpwards;
exports.findPackageData = findPackageData;
exports.findRelativeConfig = findRelativeConfig;
exports.findRootConfig = findRootConfig;
exports.loadConfig = loadConfig;
exports.loadPlugin = loadPlugin;
exports.loadPreset = loadPreset;
exports.resolvePlugin = resolvePlugin;
exports.resolvePreset = resolvePreset;
exports.resolveShowConfigPath = resolveShowConfigPath;
function findConfigUpwards(rootDir) {
export function findConfigUpwards(rootDir) {
return null;
}
function* findPackageData(filepath) {
export function* findPackageData(filepath) {
return {

@@ -28,3 +12,3 @@ filepath,

}
function* findRelativeConfig(pkgData, envName, caller) {
export function* findRelativeConfig(pkgData, envName, caller) {
return {

@@ -35,27 +19,25 @@ config: null,

}
function* findRootConfig(dirname, envName, caller) {
export function* findRootConfig(dirname, envName, caller) {
return null;
}
function* loadConfig(name, dirname, envName, caller) {
export function* loadConfig(name, dirname, envName, caller) {
throw new Error(`Cannot load ${name} relative to ${dirname} in a browser`);
}
function* resolveShowConfigPath(dirname) {
export function* resolveShowConfigPath(dirname) {
return null;
}
const ROOT_CONFIG_FILENAMES = [];
exports.ROOT_CONFIG_FILENAMES = ROOT_CONFIG_FILENAMES;
function resolvePlugin(name, dirname) {
export const ROOT_CONFIG_FILENAMES = [];
export function resolvePlugin(name, dirname) {
return null;
}
function resolvePreset(name, dirname) {
export function resolvePreset(name, dirname) {
return null;
}
function loadPlugin(name, dirname) {
export function loadPlugin(name, dirname) {
throw new Error(`Cannot load plugin ${name} relative to ${dirname} in a browser`);
}
function loadPreset(name, dirname) {
export function loadPreset(name, dirname) {
throw new Error(`Cannot load preset ${name} relative to ${dirname} in a browser`);
}
0 && 0;
//# sourceMappingURL=index-browser.js.map

82

lib/config/files/index.js

@@ -1,78 +0,10 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "ROOT_CONFIG_FILENAMES", {
enumerable: true,
get: function () {
return _configuration.ROOT_CONFIG_FILENAMES;
}
});
Object.defineProperty(exports, "findConfigUpwards", {
enumerable: true,
get: function () {
return _configuration.findConfigUpwards;
}
});
Object.defineProperty(exports, "findPackageData", {
enumerable: true,
get: function () {
return _package.findPackageData;
}
});
Object.defineProperty(exports, "findRelativeConfig", {
enumerable: true,
get: function () {
return _configuration.findRelativeConfig;
}
});
Object.defineProperty(exports, "findRootConfig", {
enumerable: true,
get: function () {
return _configuration.findRootConfig;
}
});
Object.defineProperty(exports, "loadConfig", {
enumerable: true,
get: function () {
return _configuration.loadConfig;
}
});
Object.defineProperty(exports, "loadPlugin", {
enumerable: true,
get: function () {
return plugins.loadPlugin;
}
});
Object.defineProperty(exports, "loadPreset", {
enumerable: true,
get: function () {
return plugins.loadPreset;
}
});
exports.resolvePreset = exports.resolvePlugin = void 0;
Object.defineProperty(exports, "resolveShowConfigPath", {
enumerable: true,
get: function () {
return _configuration.resolveShowConfigPath;
}
});
var _package = require("./package");
var _configuration = require("./configuration");
var plugins = require("./plugins");
function _gensync() {
const data = require("gensync");
_gensync = function () {
return data;
};
return data;
}
({});
const resolvePlugin = _gensync()(plugins.resolvePlugin).sync;
exports.resolvePlugin = resolvePlugin;
const resolvePreset = _gensync()(plugins.resolvePreset).sync;
exports.resolvePreset = resolvePreset;
0 && 0;
export { findPackageData } from "./package.js";
export { findConfigUpwards, findRelativeConfig, findRootConfig, loadConfig, resolveShowConfigPath, ROOT_CONFIG_FILENAMES } from "./configuration.js";
export { loadPlugin, loadPreset } from "./plugins.js";
import gensync from "gensync";
import * as plugins from "./plugins.js";
export const resolvePlugin = gensync(plugins.resolvePlugin).sync;
export const resolvePreset = gensync(plugins.resolvePreset).sync;
//# sourceMappingURL=index.js.map

71

lib/config/files/module-types.js

@@ -1,35 +0,12 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = loadCodeDefault;
exports.supportsESM = void 0;
var _async = require("../../gensync-utils/async");
function _path() {
const data = require("path");
_path = function () {
return data;
};
return data;
}
function _url() {
const data = require("url");
_url = function () {
return data;
};
return data;
}
function _semver() {
const data = require("semver");
_semver = function () {
return data;
};
return data;
}
var _rewriteStackTrace = require("../../errors/rewrite-stack-trace");
var _configError = require("../../errors/config-error");
var _transformFile = require("../../transform-file");
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
import { isAsync, waitFor } from "../../gensync-utils/async.js";
import path from "path";
import { pathToFileURL } from "url";
import { createRequire } from "module";
import semver from "semver";
import { endHiddenCallStack } from "../../errors/rewrite-stack-trace.js";
import ConfigError from "../../errors/config-error.js";
import { transformFileSync } from "../../transform-file.js";
const require = createRequire(import.meta.url);
let import_;

@@ -39,6 +16,5 @@ try {

} catch (_unused) {}
const supportsESM = _semver().satisfies(process.versions.node, "^12.17 || >=13.2");
exports.supportsESM = supportsESM;
function* loadCodeDefault(filepath, asyncError, fallbackToTranspiledModule = false) {
switch (_path().extname(filepath)) {
export const supportsESM = semver.satisfies(process.versions.node, "^12.17 || >=13.2");
export default function* loadCodeDefault(filepath, asyncError, fallbackToTranspiledModule = false) {
switch (path.extname(filepath)) {
case ".cjs":

@@ -57,6 +33,6 @@ return loadCjsDefault(filepath, fallbackToTranspiledModule);

}
if (yield* (0, _async.isAsync)()) {
return yield* (0, _async.waitFor)(loadMjsDefault(filepath));
if (yield* isAsync()) {
return yield* waitFor(loadMjsDefault(filepath));
}
throw new _configError.default(asyncError, filepath);
throw new ConfigError(asyncError, filepath);
}

@@ -73,3 +49,3 @@ function loadCtsDefault(filepath) {

sourceMaps: "inline",
sourceFileName: _path().basename(filepath),
sourceFileName: path.basename(filepath),
presets: [[getTSPreset(filepath), Object.assign({

@@ -85,3 +61,3 @@ onlyRemoveTypeImports: true,

try {
return m._compile((0, _transformFile.transformFileSync)(filename, Object.assign({}, opts, {
return m._compile(transformFileSync(filename, Object.assign({}, opts, {
filename

@@ -92,3 +68,3 @@ })).code, filename);

const packageJson = require("@babel/preset-typescript/package.json");
if (_semver().lte(packageJson.version, "7.21.4")) {
if (semver.lte(packageJson.version, "7.21.4")) {
console.error("`.cts` configuration file failed to load, please try to update `@babel/preset-typescript`.");

@@ -105,3 +81,3 @@ }

try {
const module = (0, _rewriteStackTrace.endHiddenCallStack)(require)(filepath);
const module = endHiddenCallStack(require)(filepath);
return module != null && module.__esModule ? module.default : module;

@@ -116,3 +92,3 @@ } finally {

function loadCjsDefault(filepath, fallbackToTranspiledModule) {
const module = (0, _rewriteStackTrace.endHiddenCallStack)(require)(filepath);
const module = endHiddenCallStack(require)(filepath);
return module != null && module.__esModule ? module.default || (fallbackToTranspiledModule ? module : undefined) : module;

@@ -126,5 +102,5 @@ }

if (!import_) {
throw new _configError.default("Internal error: Native ECMAScript modules aren't supported by this platform.\n", filepath);
throw new ConfigError("Internal error: Native ECMAScript modules aren't supported by this platform.\n", filepath);
}
const module = yield (0, _rewriteStackTrace.endHiddenCallStack)(import_)((0, _url().pathToFileURL)(filepath));
const module = yield endHiddenCallStack(import_)(pathToFileURL(filepath));
return module.default;

@@ -150,7 +126,6 @@ });

}
throw new _configError.default(message, filepath);
throw new ConfigError(message, filepath);
}
}
0 && 0;
//# sourceMappingURL=module-types.js.map

39

lib/config/files/package.js

@@ -1,18 +0,6 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.findPackageData = findPackageData;
function _path() {
const data = require("path");
_path = function () {
return data;
};
return data;
}
var _utils = require("./utils");
var _configError = require("../../errors/config-error");
import path from "path";
import { makeStaticFileCache } from "./utils.js";
import ConfigError from "../../errors/config-error.js";
const PACKAGE_FILENAME = "package.json";
const readConfigPackage = (0, _utils.makeStaticFileCache)((filepath, content) => {
const readConfigPackage = makeStaticFileCache((filepath, content) => {
let options;

@@ -22,26 +10,26 @@ try {

} catch (err) {
throw new _configError.default(`Error while parsing JSON - ${err.message}`, filepath);
throw new ConfigError(`Error while parsing JSON - ${err.message}`, filepath);
}
if (!options) throw new Error(`${filepath}: No config detected`);
if (typeof options !== "object") {
throw new _configError.default(`Config returned typeof ${typeof options}`, filepath);
throw new ConfigError(`Config returned typeof ${typeof options}`, filepath);
}
if (Array.isArray(options)) {
throw new _configError.default(`Expected config object but found array`, filepath);
throw new ConfigError(`Expected config object but found array`, filepath);
}
return {
filepath,
dirname: _path().dirname(filepath),
dirname: path.dirname(filepath),
options
};
});
function* findPackageData(filepath) {
export function* findPackageData(filepath) {
let pkg = null;
const directories = [];
let isPackage = true;
let dirname = _path().dirname(filepath);
while (!pkg && _path().basename(dirname) !== "node_modules") {
let dirname = path.dirname(filepath);
while (!pkg && path.basename(dirname) !== "node_modules") {
directories.push(dirname);
pkg = yield* readConfigPackage(_path().join(dirname, PACKAGE_FILENAME));
const nextLoc = _path().dirname(dirname);
pkg = yield* readConfigPackage(path.join(dirname, PACKAGE_FILENAME));
const nextLoc = path.dirname(dirname);
if (dirname === nextLoc) {

@@ -60,4 +48,3 @@ isPackage = false;

}
0 && 0;
//# sourceMappingURL=package.js.map

76

lib/config/files/plugins.js

@@ -1,44 +0,13 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.loadPlugin = loadPlugin;
exports.loadPreset = loadPreset;
exports.resolvePlugin = resolvePlugin;
exports.resolvePreset = resolvePreset;
function _debug() {
const data = require("debug");
_debug = function () {
return data;
};
return data;
}
function _path() {
const data = require("path");
_path = function () {
return data;
};
return data;
}
function _gensync() {
const data = require("gensync");
_gensync = function () {
return data;
};
return data;
}
var _async = require("../../gensync-utils/async");
var _moduleTypes = require("./module-types");
function _url() {
const data = require("url");
_url = function () {
return data;
};
return data;
}
var _importMetaResolve = require("./import-meta-resolve");
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
const debug = _debug()("babel:config:loading:files:plugins");
import buildDebug from "debug";
import path from "path";
import gensync from "gensync";
import { isAsync } from "../../gensync-utils/async.js";
import loadCodeDefault, { supportsESM } from "./module-types.js";
import { fileURLToPath, pathToFileURL } from "url";
import importMetaResolve from "./import-meta-resolve.js";
import { createRequire } from "module";
const require = createRequire(import.meta.url);
const debug = buildDebug("babel:config:loading:files:plugins");
const EXACT_RE = /^module:/;

@@ -52,9 +21,9 @@ const BABEL_PLUGIN_PREFIX_RE = /^(?!@|module:|[^/]+\/|babel-plugin-)/;

const OTHER_ORG_DEFAULT_RE = /^(@(?!babel$)[^/]+)$/;
function* resolvePlugin(name, dirname) {
export function* resolvePlugin(name, dirname) {
return yield* resolveStandardizedName("plugin", name, dirname);
}
function* resolvePreset(name, dirname) {
export function* resolvePreset(name, dirname) {
return yield* resolveStandardizedName("preset", name, dirname);
}
function* loadPlugin(name, dirname) {
export function* loadPlugin(name, dirname) {
const filepath = yield* resolvePlugin(name, dirname);

@@ -68,3 +37,3 @@ const value = yield* requireModule("plugin", filepath);

}
function* loadPreset(name, dirname) {
export function* loadPreset(name, dirname) {
const filepath = yield* resolvePreset(name, dirname);

@@ -79,3 +48,3 @@ const value = yield* requireModule("preset", filepath);

function standardizeName(type, name) {
if (_path().isAbsolute(name)) return name;
if (path.isAbsolute(name)) return name;
const isPreset = type === "preset";

@@ -137,3 +106,3 @@ return name.replace(isPreset ? BABEL_PRESET_PREFIX_RE : BABEL_PLUGIN_PREFIX_RE, `babel-${type}-`).replace(isPreset ? BABEL_PRESET_ORG_RE : BABEL_PLUGIN_ORG_RE, `$1${type}-`).replace(isPreset ? OTHER_PRESET_ORG_RE : OTHER_PLUGIN_ORG_RE, `$1babel-${type}-`).replace(OTHER_ORG_DEFAULT_RE, `$1/babel-${type}`).replace(EXACT_RE, "");

error: null,
value: yield (0, _importMetaResolve.default)(id, options)
value: yield importMetaResolve(id, options)
};

@@ -164,3 +133,3 @@ } catch (error) {

_resolveStandardizedNameForImport = _asyncToGenerator(function* (type, name, dirname) {
const parentUrl = (0, _url().pathToFileURL)(_path().join(dirname, "./babel-virtual-resolve-base.js")).href;
const parentUrl = pathToFileURL(path.join(dirname, "./babel-virtual-resolve-base.js")).href;
const it = resolveAlternativesHelper(type, name);

@@ -171,7 +140,7 @@ let res = it.next();

}
return (0, _url().fileURLToPath)(res.value);
return fileURLToPath(res.value);
});
return _resolveStandardizedNameForImport.apply(this, arguments);
}
const resolveStandardizedName = _gensync()({
const resolveStandardizedName = gensync({
sync(type, name, dirname = process.cwd()) {

@@ -182,3 +151,3 @@ return resolveStandardizedNameForRequire(type, name, dirname);

return _asyncToGenerator(function* () {
if (!_moduleTypes.supportsESM) {
if (!supportsESM) {
return resolveStandardizedNameForRequire(type, name, dirname);

@@ -205,3 +174,3 @@ }

{
if (!(yield* (0, _async.isAsync)()) && LOADING_MODULES.has(name)) {
if (!(yield* isAsync()) && LOADING_MODULES.has(name)) {
throw new Error(`Reentrant ${type} detected trying to load "${name}". This module is not ignored ` + "and is trying to load itself while compiling itself, leading to a dependency cycle. " + 'We recommend adding it to your "ignore" list in your babelrc, or to a .babelignore.');

@@ -214,3 +183,3 @@ }

}
return yield* (0, _moduleTypes.default)(name, `You appear to be using a native ECMAScript module ${type}, ` + "which is only supported when running Babel asynchronously.", true);
return yield* loadCodeDefault(name, `You appear to be using a native ECMAScript module ${type}, ` + "which is only supported when running Babel asynchronously.", true);
} catch (err) {

@@ -225,4 +194,3 @@ err.message = `[BABEL]: ${err.message} (While processing: ${name})`;

}
0 && 0;
//# sourceMappingURL=plugins.js.map

2

lib/config/files/types.js

@@ -1,3 +0,3 @@

0 && 0;
//# sourceMappingURL=types.js.map

27

lib/config/files/utils.js

@@ -1,18 +0,6 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.makeStaticFileCache = makeStaticFileCache;
var _caching = require("../caching");
var fs = require("../../gensync-utils/fs");
function _fs2() {
const data = require("fs");
_fs2 = function () {
return data;
};
return data;
}
function makeStaticFileCache(fn) {
return (0, _caching.makeStrongCache)(function* (filepath, cache) {
import { makeStrongCache } from "../caching.js";
import * as fs from "../../gensync-utils/fs.js";
import nodeFs from "fs";
export function makeStaticFileCache(fn) {
return makeStrongCache(function* (filepath, cache) {
const cached = cache.invalidate(() => fileMtime(filepath));

@@ -26,5 +14,5 @@ if (cached === null) {

function fileMtime(filepath) {
if (!_fs2().existsSync(filepath)) return null;
if (!nodeFs.existsSync(filepath)) return null;
try {
return +_fs2().statSync(filepath).mtime;
return +nodeFs.statSync(filepath).mtime;
} catch (e) {

@@ -35,4 +23,3 @@ if (e.code !== "ENOENT" && e.code !== "ENOTDIR") throw e;

}
0 && 0;
//# sourceMappingURL=utils.js.map

102

lib/config/full.js

@@ -1,37 +0,19 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
function _gensync() {
const data = require("gensync");
_gensync = function () {
return data;
};
return data;
}
var _async = require("../gensync-utils/async");
var _util = require("./util");
var context = require("../index");
var _plugin = require("./plugin");
var _item = require("./item");
var _configChain = require("./config-chain");
var _deepArray = require("./helpers/deep-array");
function _traverse() {
const data = require("@babel/traverse");
_traverse = function () {
return data;
};
return data;
}
var _caching = require("./caching");
var _options = require("./validation/options");
var _plugins = require("./validation/plugins");
var _configApi = require("./helpers/config-api");
var _partial = require("./partial");
var _configError = require("../errors/config-error");
var _default = _gensync()(function* loadFullConfig(inputOpts) {
import gensync from "gensync";
import { forwardAsync, maybeAsync, isThenable } from "../gensync-utils/async.js";
import { mergeOptions } from "./util.js";
import * as context from "../index.js";
import Plugin from "./plugin.js";
import { getItemDescriptor } from "./item.js";
import { buildPresetChain } from "./config-chain.js";
import { finalize as freezeDeepArray } from "./helpers/deep-array.js";
import traverse from "@babel/traverse";
import { makeWeakCache, makeWeakCacheSync } from "./caching.js";
import { validate, checkNoUnwrappedItemOptionPairs } from "./validation/options.js";
import { validatePluginObject } from "./validation/plugins.js";
import { makePluginAPI, makePresetAPI } from "./helpers/config-api.js";
import loadPrivatePartialConfig from "./partial.js";
import ConfigError from "../errors/config-error.js";
export default gensync(function* loadFullConfig(inputOpts) {
var _opts$assumptions;
const result = yield* (0, _partial.default)(inputOpts);
const result = yield* loadPrivatePartialConfig(inputOpts);
if (!result) {

@@ -60,3 +42,3 @@ return null;

const toDescriptor = item => {
const desc = (0, _item.getItemDescriptor)(item);
const desc = getItemDescriptor(item);
if (!desc) {

@@ -81,3 +63,3 @@ throw new Error("Assertion failure - must be config item");

if (e.code === "BABEL_UNKNOWN_OPTION") {
(0, _options.checkNoUnwrappedItemOptionPairs)(rawPresets, i, "preset", e);
checkNoUnwrappedItemOptionPairs(rawPresets, i, "preset", e);
}

@@ -111,3 +93,3 @@ throw e;

preset.options.forEach(opts => {
(0, _util.mergeOptions)(optionDefaults, opts);
mergeOptions(optionDefaults, opts);
});

@@ -119,3 +101,3 @@ }

const opts = optionDefaults;
(0, _util.mergeOptions)(opts, options);
mergeOptions(opts, options);
const pluginContext = Object.assign({}, presetContext, {

@@ -136,3 +118,3 @@ assumptions: (_opts$assumptions = opts.assumptions) != null ? _opts$assumptions : {}

if (e.code === "BABEL_UNKNOWN_PLUGIN_PROPERTY") {
(0, _options.checkNoUnwrappedItemOptionPairs)(descs, i, "plugin", e);
checkNoUnwrappedItemOptionPairs(descs, i, "plugin", e);
}

@@ -155,6 +137,5 @@ throw e;

passes: passes,
externalDependencies: (0, _deepArray.finalize)(externalDependencies)
externalDependencies: freezeDeepArray(externalDependencies)
};
});
exports.default = _default;
function enhanceError(context, fn) {

@@ -173,3 +154,3 @@ return function* (arg1, arg2) {

}
const makeDescriptorLoader = apiFactory => (0, _caching.makeWeakCache)(function* ({
const makeDescriptorLoader = apiFactory => makeWeakCache(function* ({
value,

@@ -185,3 +166,3 @@ options,

if (typeof value === "function") {
const factory = (0, _async.maybeAsync)(value, `You appear to be using an async plugin/preset, but Babel has been called synchronously`);
const factory = maybeAsync(value, `You appear to be using an async plugin/preset, but Babel has been called synchronously`);
const api = Object.assign({}, context, apiFactory(cache, externalDependencies));

@@ -200,3 +181,3 @@ try {

}
if ((0, _async.isThenable)(item)) {
if (isThenable(item)) {
yield* [];

@@ -220,8 +201,8 @@ throw new Error(`You appear to be using a promise as a plugin, ` + `which your current version of Babel does not support. ` + `If you're using a published plugin, ` + `you may need to upgrade your @babel/core version. ` + `As an alternative, you can prefix the promise with "await". ` + `(While processing: ${JSON.stringify(alias)})`);

alias,
externalDependencies: (0, _deepArray.finalize)(externalDependencies)
externalDependencies: freezeDeepArray(externalDependencies)
};
});
const pluginDescriptorLoader = makeDescriptorLoader(_configApi.makePluginAPI);
const presetDescriptorLoader = makeDescriptorLoader(_configApi.makePresetAPI);
const instantiatePlugin = (0, _caching.makeWeakCache)(function* ({
const pluginDescriptorLoader = makeDescriptorLoader(makePluginAPI);
const presetDescriptorLoader = makeDescriptorLoader(makePresetAPI);
const instantiatePlugin = makeWeakCache(function* ({
value,

@@ -233,6 +214,6 @@ options,

}, cache) {
const pluginObj = (0, _plugins.validatePluginObject)(value);
const pluginObj = validatePluginObject(value);
const plugin = Object.assign({}, pluginObj);
if (plugin.visitor) {
plugin.visitor = _traverse().default.explode(Object.assign({}, plugin.visitor));
plugin.visitor = traverse.explode(Object.assign({}, plugin.visitor));
}

@@ -247,3 +228,3 @@ if (plugin.inherits) {

};
const inherits = yield* (0, _async.forwardAsync)(loadPluginDescriptor, run => {
const inherits = yield* forwardAsync(loadPluginDescriptor, run => {
return cache.invalidate(data => run(inheritsDescriptor, data));

@@ -254,3 +235,3 @@ });

plugin.manipulateOptions = chain(inherits.manipulateOptions, plugin.manipulateOptions);
plugin.visitor = _traverse().default.visitors.merge([inherits.visitor || {}, plugin.visitor || {}]);
plugin.visitor = traverse.visitors.merge([inherits.visitor || {}, plugin.visitor || {}]);
if (inherits.externalDependencies.length > 0) {

@@ -260,10 +241,10 @@ if (externalDependencies.length === 0) {

} else {
externalDependencies = (0, _deepArray.finalize)([externalDependencies, inherits.externalDependencies]);
externalDependencies = freezeDeepArray([externalDependencies, inherits.externalDependencies]);
}
}
}
return new _plugin.default(plugin, options, alias, externalDependencies);
return new Plugin(plugin, options, alias, externalDependencies);
});
function* loadPluginDescriptor(descriptor, context) {
if (descriptor.value instanceof _plugin.default) {
if (descriptor.value instanceof Plugin) {
if (descriptor.options) {

@@ -280,3 +261,3 @@ throw new Error("Passed options to an existing Plugin instance will not work.");

const formattedPresetName = descriptor.name ? `"${descriptor.name}"` : "/* your preset */";
throw new _configError.default([`Preset ${formattedPresetName} requires a filename to be set when babel is called directly,`, `\`\`\``, `babel.transformSync(code, { filename: 'file.ts', presets: [${formattedPresetName}] });`, `\`\`\``, `See https://babeljs.io/docs/en/options#filename for more information.`].join("\n"));
throw new ConfigError([`Preset ${formattedPresetName} requires a filename to be set when babel is called directly,`, `\`\`\``, `babel.transformSync(code, { filename: 'file.ts', presets: [${formattedPresetName}] });`, `\`\`\``, `See https://babeljs.io/docs/en/options#filename for more information.`].join("\n"));
}

@@ -295,3 +276,3 @@ };

};
const instantiatePreset = (0, _caching.makeWeakCacheSync)(({
const instantiatePreset = makeWeakCacheSync(({
value,

@@ -303,3 +284,3 @@ dirname,

return {
options: (0, _options.validate)("preset", value),
options: validate("preset", value),
alias,

@@ -314,3 +295,3 @@ dirname,

return {
chain: yield* (0, _configChain.buildPresetChain)(preset, context),
chain: yield* buildPresetChain(preset, context),
externalDependencies: preset.externalDependencies

@@ -328,4 +309,3 @@ };

}
0 && 0;
//# sourceMappingURL=full.js.map

41

lib/config/helpers/config-api.js

@@ -1,23 +0,9 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.makeConfigAPI = makeConfigAPI;
exports.makePluginAPI = makePluginAPI;
exports.makePresetAPI = makePresetAPI;
function _semver() {
const data = require("semver");
_semver = function () {
return data;
};
return data;
}
var _ = require("../../");
var _caching = require("../caching");
function makeConfigAPI(cache) {
import semver from "semver";
import { version as coreVersion } from "../..//index.js";
import { assertSimpleType } from "../caching.js";
export function makeConfigAPI(cache) {
const env = value => cache.using(data => {
if (typeof value === "undefined") return data.envName;
if (typeof value === "function") {
return (0, _caching.assertSimpleType)(value(data.envName));
return assertSimpleType(value(data.envName));
}

@@ -31,5 +17,5 @@ return (Array.isArray(value) ? value : [value]).some(entry => {

});
const caller = cb => cache.using(data => (0, _caching.assertSimpleType)(cb(data.caller)));
const caller = cb => cache.using(data => assertSimpleType(cb(data.caller)));
return {
version: _.version,
version: coreVersion,
cache: cache.simple(),

@@ -42,3 +28,3 @@ env,

}
function makePresetAPI(cache, externalDependencies) {
export function makePresetAPI(cache, externalDependencies) {
const targets = () => JSON.parse(cache.using(data => JSON.stringify(data.targets)));

@@ -53,3 +39,3 @@ const addExternalDependency = ref => {

}
function makePluginAPI(cache, externalDependencies) {
export function makePluginAPI(cache, externalDependencies) {
const assumption = name => cache.using(data => data.assumptions[name]);

@@ -70,3 +56,5 @@ return Object.assign({}, makePresetAPI(cache, externalDependencies), {

}
if (_semver().satisfies(_.version.replace("-esm", ""), range)) return;
if (semver.satisfies(coreVersion.replace(/-esm(?:\.\d+)?/, ""), range)) {
return;
}
const limit = Error.stackTraceLimit;

@@ -76,3 +64,3 @@ if (typeof limit === "number" && limit < 25) {

}
const err = new Error(`Requires Babel "${range}", but was loaded with "${_.version}". ` + `If you are sure you have a compatible version of @babel/core, ` + `it is likely that something in your build process is loading the ` + `wrong version. Inspect the stack trace of this error to look for ` + `the first entry that doesn't mention "@babel/core" or "babel-core" ` + `to see what is calling Babel.`);
const err = new Error(`Requires Babel "${range}", but was loaded with "${coreVersion}". ` + `If you are sure you have a compatible version of @babel/core, ` + `it is likely that something in your build process is loading the ` + `wrong version. Inspect the stack trace of this error to look for ` + `the first entry that doesn't mention "@babel/core" or "babel-core" ` + `to see what is calling Babel.`);
if (typeof limit === "number") {

@@ -83,8 +71,7 @@ Error.stackTraceLimit = limit;

code: "BABEL_VERSION_UNSUPPORTED",
version: _.version,
version: coreVersion,
range
});
}
0 && 0;
//# sourceMappingURL=config-api.js.map

12

lib/config/helpers/deep-array.js

@@ -1,12 +0,5 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.finalize = finalize;
exports.flattenToSet = flattenToSet;
function finalize(deepArr) {
export function finalize(deepArr) {
return Object.freeze(deepArr);
}
function flattenToSet(arr) {
export function flattenToSet(arr) {
const result = new Set();

@@ -21,4 +14,3 @@ const stack = [arr];

}
0 && 0;
//# sourceMappingURL=deep-array.js.map

9

lib/config/helpers/environment.js

@@ -1,12 +0,5 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.getEnv = getEnv;
function getEnv(defaultValue = "development") {
export function getEnv(defaultValue = "development") {
return process.env.BABEL_ENV || process.env.NODE_ENV || defaultValue;
}
0 && 0;
//# sourceMappingURL=environment.js.map

62

lib/config/index.js

@@ -1,31 +0,12 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.createConfigItem = createConfigItem;
exports.createConfigItemSync = exports.createConfigItemAsync = void 0;
Object.defineProperty(exports, "default", {
enumerable: true,
get: function () {
return _full.default;
}
});
exports.loadPartialConfigSync = exports.loadPartialConfigAsync = exports.loadPartialConfig = exports.loadOptionsSync = exports.loadOptionsAsync = exports.loadOptions = void 0;
function _gensync() {
const data = require("gensync");
_gensync = function () {
return data;
};
return data;
}
var _full = require("./full");
var _partial = require("./partial");
var _item = require("./item");
const loadOptionsRunner = _gensync()(function* (opts) {
import gensync from "gensync";
import loadFullConfig from "./full.js";
import { loadPartialConfig as loadPartialConfigRunner } from "./partial.js";
export { loadFullConfig as default };
import { createConfigItem as createConfigItemImpl } from "./item.js";
const loadOptionsRunner = gensync(function* (opts) {
var _config$options;
const config = yield* (0, _full.default)(opts);
const config = yield* loadFullConfig(opts);
return (_config$options = config == null ? void 0 : config.options) != null ? _config$options : null;
});
const createConfigItemRunner = _gensync()(_item.createConfigItem);
const createConfigItemRunner = gensync(createConfigItemImpl);
const maybeErrback = runner => (argOrCallback, maybeCallback) => {

@@ -46,19 +27,11 @@ let arg;

};
const loadPartialConfig = maybeErrback(_partial.loadPartialConfig);
exports.loadPartialConfig = loadPartialConfig;
const loadPartialConfigSync = _partial.loadPartialConfig.sync;
exports.loadPartialConfigSync = loadPartialConfigSync;
const loadPartialConfigAsync = _partial.loadPartialConfig.async;
exports.loadPartialConfigAsync = loadPartialConfigAsync;
const loadOptions = maybeErrback(loadOptionsRunner);
exports.loadOptions = loadOptions;
const loadOptionsSync = loadOptionsRunner.sync;
exports.loadOptionsSync = loadOptionsSync;
const loadOptionsAsync = loadOptionsRunner.async;
exports.loadOptionsAsync = loadOptionsAsync;
const createConfigItemSync = createConfigItemRunner.sync;
exports.createConfigItemSync = createConfigItemSync;
const createConfigItemAsync = createConfigItemRunner.async;
exports.createConfigItemAsync = createConfigItemAsync;
function createConfigItem(target, options, callback) {
export const loadPartialConfig = maybeErrback(loadPartialConfigRunner);
export const loadPartialConfigSync = loadPartialConfigRunner.sync;
export const loadPartialConfigAsync = loadPartialConfigRunner.async;
export const loadOptions = maybeErrback(loadOptionsRunner);
export const loadOptionsSync = loadOptionsRunner.sync;
export const loadOptionsAsync = loadOptionsRunner.async;
export const createConfigItemSync = createConfigItemRunner.sync;
export const createConfigItemAsync = createConfigItemRunner.async;
export function createConfigItem(target, options, callback) {
if (callback !== undefined) {

@@ -72,4 +45,3 @@ createConfigItemRunner.errback(target, options, callback);

}
0 && 0;
//# sourceMappingURL=index.js.map

27

lib/config/item.js

@@ -1,25 +0,11 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.createConfigItem = createConfigItem;
exports.createItemFromDescriptor = createItemFromDescriptor;
exports.getItemDescriptor = getItemDescriptor;
function _path() {
const data = require("path");
_path = function () {
return data;
};
return data;
}
var _configDescriptors = require("./config-descriptors");
function createItemFromDescriptor(desc) {
import path from "path";
import { createDescriptor } from "./config-descriptors.js";
export function createItemFromDescriptor(desc) {
return new ConfigItem(desc);
}
function* createConfigItem(value, {
export function* createConfigItem(value, {
dirname = ".",
type
} = {}) {
const descriptor = yield* (0, _configDescriptors.createDescriptor)(value, _path().resolve(dirname), {
const descriptor = yield* createDescriptor(value, path.resolve(dirname), {
type,

@@ -31,3 +17,3 @@ alias: "programmatic item"

const CONFIG_ITEM_BRAND = Symbol.for("@babel/core@7 - ConfigItem");
function getItemDescriptor(item) {
export function getItemDescriptor(item) {
if (item != null && item[CONFIG_ITEM_BRAND]) {

@@ -66,4 +52,3 @@ return item._descriptor;

Object.freeze(ConfigItem.prototype);
0 && 0;
//# sourceMappingURL=item.js.map

75

lib/config/partial.js

@@ -1,32 +0,13 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = loadPrivatePartialConfig;
exports.loadPartialConfig = void 0;
function _path() {
const data = require("path");
_path = function () {
return data;
};
return data;
}
function _gensync() {
const data = require("gensync");
_gensync = function () {
return data;
};
return data;
}
var _plugin = require("./plugin");
var _util = require("./util");
var _item = require("./item");
var _configChain = require("./config-chain");
var _environment = require("./helpers/environment");
var _options = require("./validation/options");
var _files = require("./files");
var _resolveTargets = require("./resolve-targets");
const _excluded = ["showIgnoredFiles"];
function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
import path from "path";
import gensync from "gensync";
import Plugin from "./plugin.js";
import { mergeOptions } from "./util.js";
import { createItemFromDescriptor } from "./item.js";
import { buildRootChain } from "./config-chain.js";
import { getEnv } from "./helpers/environment.js";
import { validate } from "./validation/options.js";
import { findConfigUpwards, resolveShowConfigPath, ROOT_CONFIG_FILENAMES } from "./files/index.js";
import { resolveTargets } from "./resolve-targets.js";
function resolveRootMode(rootDir, rootMode) {

@@ -38,3 +19,3 @@ switch (rootMode) {

{
const upwardRootDir = (0, _files.findConfigUpwards)(rootDir);
const upwardRootDir = findConfigUpwards(rootDir);
return upwardRootDir === null ? rootDir : upwardRootDir;

@@ -44,5 +25,5 @@ }

{
const upwardRootDir = (0, _files.findConfigUpwards)(rootDir);
const upwardRootDir = findConfigUpwards(rootDir);
if (upwardRootDir !== null) return upwardRootDir;
throw Object.assign(new Error(`Babel was run with rootMode:"upward" but a root could not ` + `be found when searching upward from "${rootDir}".\n` + `One of the following config files must be in the directory tree: ` + `"${_files.ROOT_CONFIG_FILENAMES.join(", ")}".`), {
throw Object.assign(new Error(`Babel was run with rootMode:"upward" but a root could not ` + `be found when searching upward from "${rootDir}".\n` + `One of the following config files must be in the directory tree: ` + `"${ROOT_CONFIG_FILENAMES.join(", ")}".`), {
code: "BABEL_ROOT_NOT_FOUND",

@@ -56,9 +37,9 @@ dirname: rootDir

}
function* loadPrivatePartialConfig(inputOpts) {
export default function* loadPrivatePartialConfig(inputOpts) {
if (inputOpts != null && (typeof inputOpts !== "object" || Array.isArray(inputOpts))) {
throw new Error("Babel options must be an object, null, or undefined");
}
const args = inputOpts ? (0, _options.validate)("arguments", inputOpts) : {};
const args = inputOpts ? validate("arguments", inputOpts) : {};
const {
envName = (0, _environment.getEnv)(),
envName = getEnv(),
cwd = ".",

@@ -70,6 +51,6 @@ root: rootDir = ".",

} = args;
const absoluteCwd = _path().resolve(cwd);
const absoluteRootDir = resolveRootMode(_path().resolve(absoluteCwd, rootDir), rootMode);
const filename = typeof args.filename === "string" ? _path().resolve(cwd, args.filename) : undefined;
const showConfigPath = yield* (0, _files.resolveShowConfigPath)(absoluteCwd);
const absoluteCwd = path.resolve(cwd);
const absoluteRootDir = resolveRootMode(path.resolve(absoluteCwd, rootDir), rootMode);
const filename = typeof args.filename === "string" ? path.resolve(cwd, args.filename) : undefined;
const showConfigPath = yield* resolveShowConfigPath(absoluteCwd);
const context = {

@@ -83,3 +64,3 @@ filename,

};
const configChain = yield* (0, _configChain.buildRootChain)(args, context);
const configChain = yield* buildRootChain(args, context);
if (!configChain) return null;

@@ -90,6 +71,6 @@ const merged = {

configChain.options.forEach(opts => {
(0, _util.mergeOptions)(merged, opts);
mergeOptions(merged, opts);
});
const options = Object.assign({}, merged, {
targets: (0, _resolveTargets.resolveTargets)(merged, absoluteRootDir),
targets: resolveTargets(merged, absoluteRootDir),
cloneInputAst,

@@ -105,4 +86,4 @@ babelrc: false,

filename: typeof context.filename === "string" ? context.filename : undefined,
plugins: configChain.plugins.map(descriptor => (0, _item.createItemFromDescriptor)(descriptor)),
presets: configChain.presets.map(descriptor => (0, _item.createItemFromDescriptor)(descriptor))
plugins: configChain.plugins.map(descriptor => createItemFromDescriptor(descriptor)),
presets: configChain.presets.map(descriptor => createItemFromDescriptor(descriptor))
});

@@ -119,3 +100,3 @@ return {

}
const loadPartialConfig = _gensync()(function* (opts) {
export const loadPartialConfig = gensync(function* (opts) {
let showIgnoredFiles = false;

@@ -144,3 +125,3 @@ if (typeof opts === "object" && opts !== null && !Array.isArray(opts)) {

(options.plugins || []).forEach(item => {
if (item.value instanceof _plugin.default) {
if (item.value instanceof Plugin) {
throw new Error("Passing cached plugin instances is not supported in " + "babel.loadPartialConfig()");

@@ -151,3 +132,2 @@ }

});
exports.loadPartialConfig = loadPartialConfig;
class PartialConfig {

@@ -174,4 +154,3 @@ constructor(options, babelrc, ignore, config, fileHandling, files) {

Object.freeze(PartialConfig.prototype);
0 && 0;
//# sourceMappingURL=partial.js.map

21

lib/config/pattern-to-regex.js

@@ -1,15 +0,3 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = pathToPattern;
function _path() {
const data = require("path");
_path = function () {
return data;
};
return data;
}
const sep = `\\${_path().sep}`;
import path from "path";
const sep = `\\${path.sep}`;
const endSep = `(?:${sep}|$)`;

@@ -24,4 +12,4 @@ const substitution = `[^${sep}]+`;

}
function pathToPattern(pattern, dirname) {
const parts = _path().resolve(dirname, pattern).split(_path().sep);
export default function pathToPattern(pattern, dirname) {
const parts = path.resolve(dirname, pattern).split(path.sep);
return new RegExp(["^", ...parts.map((part, i) => {

@@ -37,4 +25,3 @@ const last = i === parts.length - 1;

}
0 && 0;
//# sourceMappingURL=pattern-to-regex.js.map

14

lib/config/plugin.js

@@ -1,10 +0,4 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
var _deepArray = require("./helpers/deep-array");
class Plugin {
constructor(plugin, options, key, externalDependencies = (0, _deepArray.finalize)([])) {
import { finalize } from "./helpers/deep-array.js";
export default class Plugin {
constructor(plugin, options, key, externalDependencies = finalize([])) {
this.key = void 0;

@@ -30,5 +24,3 @@ this.manipulateOptions = void 0;

}
exports.default = Plugin;
0 && 0;
//# sourceMappingURL=plugin.js.map

23

lib/config/printer.js

@@ -1,19 +0,6 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.ConfigPrinter = exports.ChainFormatter = void 0;
function _gensync() {
const data = require("gensync");
_gensync = function () {
return data;
};
return data;
}
const ChainFormatter = {
import gensync from "gensync";
export const ChainFormatter = {
Programmatic: 0,
Config: 1
};
exports.ChainFormatter = ChainFormatter;
const Formatter = {

@@ -78,3 +65,3 @@ title(type, callerName, filepath) {

}
class ConfigPrinter {
export class ConfigPrinter {
constructor() {

@@ -108,9 +95,7 @@ this._stack = [];

if (this._stack.length === 0) return "";
const configs = yield* _gensync().all(this._stack.map(s => ConfigPrinter.format(s)));
const configs = yield* gensync.all(this._stack.map(s => ConfigPrinter.format(s)));
return configs.join("\n\n");
}
}
exports.ConfigPrinter = ConfigPrinter;
0 && 0;
//# sourceMappingURL=printer.js.map

22

lib/config/resolve-targets-browser.js

@@ -1,19 +0,6 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.resolveBrowserslistConfigFile = resolveBrowserslistConfigFile;
exports.resolveTargets = resolveTargets;
function _helperCompilationTargets() {
const data = require("@babel/helper-compilation-targets");
_helperCompilationTargets = function () {
return data;
};
return data;
}
function resolveBrowserslistConfigFile(browserslistConfigFile, configFilePath) {
import getTargets from "@babel/helper-compilation-targets";
export function resolveBrowserslistConfigFile(browserslistConfigFile, configFilePath) {
return undefined;
}
function resolveTargets(options, root) {
export function resolveTargets(options, root) {
const optTargets = options.targets;

@@ -34,3 +21,3 @@ let targets;

}
return (0, _helperCompilationTargets().default)(targets, {
return getTargets(targets, {
ignoreBrowserslistConfig: true,

@@ -40,4 +27,3 @@ browserslistEnv: options.browserslistEnv

}
0 && 0;
//# sourceMappingURL=resolve-targets-browser.js.map

32

lib/config/resolve-targets.js

@@ -1,27 +0,8 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.resolveBrowserslistConfigFile = resolveBrowserslistConfigFile;
exports.resolveTargets = resolveTargets;
function _path() {
const data = require("path");
_path = function () {
return data;
};
return data;
}
function _helperCompilationTargets() {
const data = require("@babel/helper-compilation-targets");
_helperCompilationTargets = function () {
return data;
};
return data;
}
({});
function resolveBrowserslistConfigFile(browserslistConfigFile, configFileDir) {
return _path().resolve(configFileDir, browserslistConfigFile);
import path from "path";
import getTargets from "@babel/helper-compilation-targets";
export function resolveBrowserslistConfigFile(browserslistConfigFile, configFileDir) {
return path.resolve(configFileDir, browserslistConfigFile);
}
function resolveTargets(options, root) {
export function resolveTargets(options, root) {
const optTargets = options.targets;

@@ -52,3 +33,3 @@ let targets;

}
return (0, _helperCompilationTargets().default)(targets, {
return getTargets(targets, {
ignoreBrowserslistConfig,

@@ -60,4 +41,3 @@ configFile,

}
0 && 0;
//# sourceMappingURL=resolve-targets.js.map

12

lib/config/util.js

@@ -1,9 +0,2 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.isIterableIterator = isIterableIterator;
exports.mergeOptions = mergeOptions;
function mergeOptions(target, source) {
export function mergeOptions(target, source) {
for (const k of Object.keys(source)) {

@@ -26,7 +19,6 @@ if ((k === "parserOpts" || k === "generatorOpts" || k === "assumptions") && source[k]) {

}
function isIterableIterator(value) {
export function isIterableIterator(value) {
return !!value && typeof value.next === "function" && typeof value[Symbol.iterator] === "function";
}
0 && 0;
//# sourceMappingURL=util.js.map

86

lib/config/validation/option-assertions.js

@@ -1,35 +0,4 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.access = access;
exports.assertArray = assertArray;
exports.assertAssumptions = assertAssumptions;
exports.assertBabelrcSearch = assertBabelrcSearch;
exports.assertBoolean = assertBoolean;
exports.assertCallerMetadata = assertCallerMetadata;
exports.assertCompact = assertCompact;
exports.assertConfigApplicableTest = assertConfigApplicableTest;
exports.assertConfigFileSearch = assertConfigFileSearch;
exports.assertFunction = assertFunction;
exports.assertIgnoreList = assertIgnoreList;
exports.assertInputSourceMap = assertInputSourceMap;
exports.assertObject = assertObject;
exports.assertPluginList = assertPluginList;
exports.assertRootMode = assertRootMode;
exports.assertSourceMaps = assertSourceMaps;
exports.assertSourceType = assertSourceType;
exports.assertString = assertString;
exports.assertTargets = assertTargets;
exports.msg = msg;
function _helperCompilationTargets() {
const data = require("@babel/helper-compilation-targets");
_helperCompilationTargets = function () {
return data;
};
return data;
}
var _options = require("./options");
function msg(loc) {
import { isBrowsersQueryValid, TargetNames } from "@babel/helper-compilation-targets";
import { assumptionsNames } from "./options.js";
export function msg(loc) {
switch (loc.type) {

@@ -50,3 +19,3 @@ case "root":

}
function access(loc, name) {
export function access(loc, name) {
return {

@@ -58,3 +27,3 @@ type: "access",

}
function assertRootMode(loc, value) {
export function assertRootMode(loc, value) {
if (value !== undefined && value !== "root" && value !== "upward" && value !== "upward-optional") {

@@ -65,3 +34,3 @@ throw new Error(`${msg(loc)} must be a "root", "upward", "upward-optional" or undefined`);

}
function assertSourceMaps(loc, value) {
export function assertSourceMaps(loc, value) {
if (value !== undefined && typeof value !== "boolean" && value !== "inline" && value !== "both") {

@@ -72,3 +41,3 @@ throw new Error(`${msg(loc)} must be a boolean, "inline", "both", or undefined`);

}
function assertCompact(loc, value) {
export function assertCompact(loc, value) {
if (value !== undefined && typeof value !== "boolean" && value !== "auto") {

@@ -79,3 +48,3 @@ throw new Error(`${msg(loc)} must be a boolean, "auto", or undefined`);

}
function assertSourceType(loc, value) {
export function assertSourceType(loc, value) {
if (value !== undefined && value !== "module" && value !== "script" && value !== "unambiguous") {

@@ -86,3 +55,3 @@ throw new Error(`${msg(loc)} must be "module", "script", "unambiguous", or undefined`);

}
function assertCallerMetadata(loc, value) {
export function assertCallerMetadata(loc, value) {
const obj = assertObject(loc, value);

@@ -103,3 +72,3 @@ if (obj) {

}
function assertInputSourceMap(loc, value) {
export function assertInputSourceMap(loc, value) {
if (value !== undefined && typeof value !== "boolean" && (typeof value !== "object" || !value)) {

@@ -110,3 +79,3 @@ throw new Error(`${msg(loc)} must be a boolean, object, or undefined`);

}
function assertString(loc, value) {
export function assertString(loc, value) {
if (value !== undefined && typeof value !== "string") {

@@ -117,3 +86,3 @@ throw new Error(`${msg(loc)} must be a string, or undefined`);

}
function assertFunction(loc, value) {
export function assertFunction(loc, value) {
if (value !== undefined && typeof value !== "function") {

@@ -124,3 +93,3 @@ throw new Error(`${msg(loc)} must be a function, or undefined`);

}
function assertBoolean(loc, value) {
export function assertBoolean(loc, value) {
if (value !== undefined && typeof value !== "boolean") {

@@ -131,3 +100,3 @@ throw new Error(`${msg(loc)} must be a boolean, or undefined`);

}
function assertObject(loc, value) {
export function assertObject(loc, value) {
if (value !== undefined && (typeof value !== "object" || Array.isArray(value) || !value)) {

@@ -138,3 +107,3 @@ throw new Error(`${msg(loc)} must be an object, or undefined`);

}
function assertArray(loc, value) {
export function assertArray(loc, value) {
if (value != null && !Array.isArray(value)) {

@@ -145,3 +114,3 @@ throw new Error(`${msg(loc)} must be an array, or undefined`);

}
function assertIgnoreList(loc, value) {
export function assertIgnoreList(loc, value) {
const arr = assertArray(loc, value);

@@ -159,3 +128,3 @@ if (arr) {

}
function assertConfigApplicableTest(loc, value) {
export function assertConfigApplicableTest(loc, value) {
if (value === undefined) {

@@ -178,3 +147,3 @@ return value;

}
function assertConfigFileSearch(loc, value) {
export function assertConfigFileSearch(loc, value) {
if (value !== undefined && typeof value !== "boolean" && typeof value !== "string") {

@@ -185,3 +154,3 @@ throw new Error(`${msg(loc)} must be a undefined, a boolean, a string, ` + `got ${JSON.stringify(value)}`);

}
function assertBabelrcSearch(loc, value) {
export function assertBabelrcSearch(loc, value) {
if (value === undefined || typeof value === "boolean") {

@@ -201,3 +170,3 @@ return value;

}
function assertPluginList(loc, value) {
export function assertPluginList(loc, value) {
const arr = assertArray(loc, value);

@@ -241,4 +210,4 @@ if (arr) {

}
function assertTargets(loc, value) {
if ((0, _helperCompilationTargets().isBrowsersQueryValid)(value)) return value;
export function assertTargets(loc, value) {
if (isBrowsersQueryValid(value)) return value;
if (typeof value !== "object" || !value || Array.isArray(value)) {

@@ -254,4 +223,4 @@ throw new Error(`${msg(loc)} must be a string, an array of strings or an object`);

const subLoc = access(loc, key);
if (key === "esmodules") assertBoolean(subLoc, val);else if (key === "browsers") assertBrowsersList(subLoc, val);else if (!Object.hasOwnProperty.call(_helperCompilationTargets().TargetNames, key)) {
const validTargets = Object.keys(_helperCompilationTargets().TargetNames).join(", ");
if (key === "esmodules") assertBoolean(subLoc, val);else if (key === "browsers") assertBrowsersList(subLoc, val);else if (!Object.hasOwnProperty.call(TargetNames, key)) {
const validTargets = Object.keys(TargetNames).join(", ");
throw new Error(`${msg(subLoc)} is not a valid target. Supported targets are ${validTargets}`);

@@ -263,3 +232,3 @@ } else assertBrowserVersion(subLoc, val);

function assertBrowsersList(loc, value) {
if (value !== undefined && !(0, _helperCompilationTargets().isBrowsersQueryValid)(value)) {
if (value !== undefined && !isBrowsersQueryValid(value)) {
throw new Error(`${msg(loc)} must be undefined, a string or an array of strings`);

@@ -273,3 +242,3 @@ }

}
function assertAssumptions(loc, value) {
export function assertAssumptions(loc, value) {
if (value === undefined) return;

@@ -286,3 +255,3 @@ if (typeof value !== "object" || value === null) {

const subLoc = access(loc, name);
if (!_options.assumptionsNames.has(name)) {
if (!assumptionsNames.has(name)) {
throw new Error(`${msg(subLoc)} is not a supported assumption.`);

@@ -299,4 +268,3 @@ }

}
0 && 0;
//# sourceMappingURL=option-assertions.js.map

152

lib/config/validation/options.js

@@ -1,80 +0,71 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.assumptionsNames = void 0;
exports.checkNoUnwrappedItemOptionPairs = checkNoUnwrappedItemOptionPairs;
exports.validate = validate;
var _removed = require("./removed");
var _optionAssertions = require("./option-assertions");
var _configError = require("../../errors/config-error");
import removed from "./removed.js";
import { msg, access, assertString, assertBoolean, assertObject, assertArray, assertCallerMetadata, assertInputSourceMap, assertIgnoreList, assertPluginList, assertConfigApplicableTest, assertConfigFileSearch, assertBabelrcSearch, assertFunction, assertRootMode, assertSourceMaps, assertCompact, assertSourceType, assertTargets, assertAssumptions } from "./option-assertions.js";
import ConfigError from "../../errors/config-error.js";
const ROOT_VALIDATORS = {
cwd: _optionAssertions.assertString,
root: _optionAssertions.assertString,
rootMode: _optionAssertions.assertRootMode,
configFile: _optionAssertions.assertConfigFileSearch,
caller: _optionAssertions.assertCallerMetadata,
filename: _optionAssertions.assertString,
filenameRelative: _optionAssertions.assertString,
code: _optionAssertions.assertBoolean,
ast: _optionAssertions.assertBoolean,
cloneInputAst: _optionAssertions.assertBoolean,
envName: _optionAssertions.assertString
cwd: assertString,
root: assertString,
rootMode: assertRootMode,
configFile: assertConfigFileSearch,
caller: assertCallerMetadata,
filename: assertString,
filenameRelative: assertString,
code: assertBoolean,
ast: assertBoolean,
cloneInputAst: assertBoolean,
envName: assertString
};
const BABELRC_VALIDATORS = {
babelrc: _optionAssertions.assertBoolean,
babelrcRoots: _optionAssertions.assertBabelrcSearch
babelrc: assertBoolean,
babelrcRoots: assertBabelrcSearch
};
const NONPRESET_VALIDATORS = {
extends: _optionAssertions.assertString,
ignore: _optionAssertions.assertIgnoreList,
only: _optionAssertions.assertIgnoreList,
targets: _optionAssertions.assertTargets,
browserslistConfigFile: _optionAssertions.assertConfigFileSearch,
browserslistEnv: _optionAssertions.assertString
extends: assertString,
ignore: assertIgnoreList,
only: assertIgnoreList,
targets: assertTargets,
browserslistConfigFile: assertConfigFileSearch,
browserslistEnv: assertString
};
const COMMON_VALIDATORS = {
inputSourceMap: _optionAssertions.assertInputSourceMap,
presets: _optionAssertions.assertPluginList,
plugins: _optionAssertions.assertPluginList,
passPerPreset: _optionAssertions.assertBoolean,
assumptions: _optionAssertions.assertAssumptions,
inputSourceMap: assertInputSourceMap,
presets: assertPluginList,
plugins: assertPluginList,
passPerPreset: assertBoolean,
assumptions: assertAssumptions,
env: assertEnvSet,
overrides: assertOverridesList,
test: _optionAssertions.assertConfigApplicableTest,
include: _optionAssertions.assertConfigApplicableTest,
exclude: _optionAssertions.assertConfigApplicableTest,
retainLines: _optionAssertions.assertBoolean,
comments: _optionAssertions.assertBoolean,
shouldPrintComment: _optionAssertions.assertFunction,
compact: _optionAssertions.assertCompact,
minified: _optionAssertions.assertBoolean,
auxiliaryCommentBefore: _optionAssertions.assertString,
auxiliaryCommentAfter: _optionAssertions.assertString,
sourceType: _optionAssertions.assertSourceType,
wrapPluginVisitorMethod: _optionAssertions.assertFunction,
highlightCode: _optionAssertions.assertBoolean,
sourceMaps: _optionAssertions.assertSourceMaps,
sourceMap: _optionAssertions.assertSourceMaps,
sourceFileName: _optionAssertions.assertString,
sourceRoot: _optionAssertions.assertString,
parserOpts: _optionAssertions.assertObject,
generatorOpts: _optionAssertions.assertObject
test: assertConfigApplicableTest,
include: assertConfigApplicableTest,
exclude: assertConfigApplicableTest,
retainLines: assertBoolean,
comments: assertBoolean,
shouldPrintComment: assertFunction,
compact: assertCompact,
minified: assertBoolean,
auxiliaryCommentBefore: assertString,
auxiliaryCommentAfter: assertString,
sourceType: assertSourceType,
wrapPluginVisitorMethod: assertFunction,
highlightCode: assertBoolean,
sourceMaps: assertSourceMaps,
sourceMap: assertSourceMaps,
sourceFileName: assertString,
sourceRoot: assertString,
parserOpts: assertObject,
generatorOpts: assertObject
};
{
Object.assign(COMMON_VALIDATORS, {
getModuleId: _optionAssertions.assertFunction,
moduleRoot: _optionAssertions.assertString,
moduleIds: _optionAssertions.assertBoolean,
moduleId: _optionAssertions.assertString
getModuleId: assertFunction,
moduleRoot: assertString,
moduleIds: assertBoolean,
moduleId: assertString
});
}
const knownAssumptions = ["arrayLikeIsIterable", "constantReexports", "constantSuper", "enumerableModuleMeta", "ignoreFunctionLength", "ignoreToPrimitiveHint", "iterableIsArray", "mutableTemplateObject", "noClassCalls", "noDocumentAll", "noIncompleteNsImportDetection", "noNewArrows", "objectRestNoSymbols", "privateFieldsAsSymbols", "privateFieldsAsProperties", "pureGetters", "setClassMethods", "setComputedProperties", "setPublicClassFields", "setSpreadProperties", "skipForOfIteratorClosing", "superIsCallableConstructor"];
const assumptionsNames = new Set(knownAssumptions);
exports.assumptionsNames = assumptionsNames;
export const assumptionsNames = new Set(knownAssumptions);
function getSource(loc) {
return loc.type === "root" ? loc.source : getSource(loc.parent);
}
function validate(type, opts, filename) {
export function validate(type, opts, filename) {
try {

@@ -86,3 +77,3 @@ return validateNested({

} catch (error) {
const configError = new _configError.default(error.message, filename);
const configError = new ConfigError(error.message, filename);
if (error.code) configError.code = error.code;

@@ -102,12 +93,12 @@ throw configError;

if (type === "preset" && NONPRESET_VALIDATORS[key]) {
throw new Error(`${(0, _optionAssertions.msg)(optLoc)} is not allowed in preset options`);
throw new Error(`${msg(optLoc)} is not allowed in preset options`);
}
if (type !== "arguments" && ROOT_VALIDATORS[key]) {
throw new Error(`${(0, _optionAssertions.msg)(optLoc)} is only allowed in root programmatic options`);
throw new Error(`${msg(optLoc)} is only allowed in root programmatic options`);
}
if (type !== "arguments" && type !== "configfile" && BABELRC_VALIDATORS[key]) {
if (type === "babelrcfile" || type === "extendsfile") {
throw new Error(`${(0, _optionAssertions.msg)(optLoc)} is not allowed in .babelrc or "extends"ed files, only in root programmatic options, ` + `or babel.config.js/config file options`);
throw new Error(`${msg(optLoc)} is not allowed in .babelrc or "extends"ed files, only in root programmatic options, ` + `or babel.config.js/config file options`);
}
throw new Error(`${(0, _optionAssertions.msg)(optLoc)} is only allowed in root programmatic options, or babel.config.js/config file options`);
throw new Error(`${msg(optLoc)} is only allowed in root programmatic options, or babel.config.js/config file options`);
}

@@ -121,10 +112,10 @@ const validator = COMMON_VALIDATORS[key] || NONPRESET_VALIDATORS[key] || BABELRC_VALIDATORS[key] || ROOT_VALIDATORS[key] || throwUnknownError;

const key = loc.name;
if (_removed.default[key]) {
if (removed[key]) {
const {
message,
version = 5
} = _removed.default[key];
throw new Error(`Using removed Babel ${version} option: ${(0, _optionAssertions.msg)(loc)} - ${message}`);
} = removed[key];
throw new Error(`Using removed Babel ${version} option: ${msg(loc)} - ${message}`);
} else {
const unknownOptErr = new Error(`Unknown option: ${(0, _optionAssertions.msg)(loc)}. Check out https://babeljs.io/docs/en/babel-core/#options for more information about options.`);
const unknownOptErr = new Error(`Unknown option: ${msg(loc)}. Check out https://babeljs.io/docs/en/babel-core/#options for more information about options.`);
unknownOptErr.code = "BABEL_UNKNOWN_OPTION";

@@ -144,9 +135,9 @@ throw unknownOptErr;

if (loc.parent.type === "env") {
throw new Error(`${(0, _optionAssertions.msg)(loc)} is not allowed inside of another .env block`);
throw new Error(`${msg(loc)} is not allowed inside of another .env block`);
}
const parent = loc.parent;
const obj = (0, _optionAssertions.assertObject)(loc, value);
const obj = assertObject(loc, value);
if (obj) {
for (const envName of Object.keys(obj)) {
const env = (0, _optionAssertions.assertObject)((0, _optionAssertions.access)(loc, envName), obj[envName]);
const env = assertObject(access(loc, envName), obj[envName]);
if (!env) continue;

@@ -165,14 +156,14 @@ const envLoc = {

if (loc.parent.type === "env") {
throw new Error(`${(0, _optionAssertions.msg)(loc)} is not allowed inside an .env block`);
throw new Error(`${msg(loc)} is not allowed inside an .env block`);
}
if (loc.parent.type === "overrides") {
throw new Error(`${(0, _optionAssertions.msg)(loc)} is not allowed inside an .overrides block`);
throw new Error(`${msg(loc)} is not allowed inside an .overrides block`);
}
const parent = loc.parent;
const arr = (0, _optionAssertions.assertArray)(loc, value);
const arr = assertArray(loc, value);
if (arr) {
for (const [index, item] of arr.entries()) {
const objLoc = (0, _optionAssertions.access)(loc, index);
const env = (0, _optionAssertions.assertObject)(objLoc, item);
if (!env) throw new Error(`${(0, _optionAssertions.msg)(objLoc)} must be an object`);
const objLoc = access(loc, index);
const env = assertObject(objLoc, item);
if (!env) throw new Error(`${msg(objLoc)} must be an object`);
const overridesLoc = {

@@ -188,3 +179,3 @@ type: "overrides",

}
function checkNoUnwrappedItemOptionPairs(items, index, type, e) {
export function checkNoUnwrappedItemOptionPairs(items, index, type, e) {
if (index === 0) return;

@@ -197,4 +188,3 @@ const lastItem = items[index - 1];

}
0 && 0;
//# sourceMappingURL=options.js.map

29

lib/config/validation/plugins.js

@@ -1,24 +0,18 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.validatePluginObject = validatePluginObject;
var _optionAssertions = require("./option-assertions");
import { assertString, assertFunction, assertObject, msg } from "./option-assertions.js";
const VALIDATORS = {
name: _optionAssertions.assertString,
manipulateOptions: _optionAssertions.assertFunction,
pre: _optionAssertions.assertFunction,
post: _optionAssertions.assertFunction,
inherits: _optionAssertions.assertFunction,
name: assertString,
manipulateOptions: assertFunction,
pre: assertFunction,
post: assertFunction,
inherits: assertFunction,
visitor: assertVisitorMap,
parserOverride: _optionAssertions.assertFunction,
generatorOverride: _optionAssertions.assertFunction
parserOverride: assertFunction,
generatorOverride: assertFunction
};
function assertVisitorMap(loc, value) {
const obj = (0, _optionAssertions.assertObject)(loc, value);
const obj = assertObject(loc, value);
if (obj) {
Object.keys(obj).forEach(prop => assertVisitorHandler(prop, obj[prop]));
if (obj.enter || obj.exit) {
throw new Error(`${(0, _optionAssertions.msg)(loc)} cannot contain catch-all "enter" or "exit" handlers. Please target individual nodes.`);
throw new Error(`${msg(loc)} cannot contain catch-all "enter" or "exit" handlers. Please target individual nodes.`);
}

@@ -40,3 +34,3 @@ }

}
function validatePluginObject(obj) {
export function validatePluginObject(obj) {
const rootPath = {

@@ -63,4 +57,3 @@ type: "root",

}
0 && 0;
//# sourceMappingURL=plugins.js.map

10

lib/config/validation/removed.js

@@ -1,8 +0,2 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
var _default = {
export default {
auxiliaryComment: {

@@ -66,5 +60,3 @@ message: "Use `auxiliaryCommentBefore` or `auxiliaryCommentAfter`"

};
exports.default = _default;
0 && 0;
//# sourceMappingURL=removed.js.map

16

lib/errors/config-error.js

@@ -1,18 +0,10 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
var _rewriteStackTrace = require("./rewrite-stack-trace");
class ConfigError extends Error {
import { injectVirtualStackFrame, expectedError } from "./rewrite-stack-trace.js";
export default class ConfigError extends Error {
constructor(message, filename) {
super(message);
(0, _rewriteStackTrace.expectedError)(this);
if (filename) (0, _rewriteStackTrace.injectVirtualStackFrame)(this, filename);
expectedError(this);
if (filename) injectVirtualStackFrame(this, filename);
}
}
exports.default = ConfigError;
0 && 0;
//# sourceMappingURL=config-error.js.map

18

lib/errors/rewrite-stack-trace.js

@@ -1,10 +0,1 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.beginHiddenCallStack = beginHiddenCallStack;
exports.endHiddenCallStack = endHiddenCallStack;
exports.expectedError = expectedError;
exports.injectVirtualStackFrame = injectVirtualStackFrame;
const ErrorToString = Function.call.bind(Error.prototype.toString);

@@ -30,3 +21,3 @@ const SUPPORTED = !!Error.captureStackTrace;

}
function injectVirtualStackFrame(error, filename) {
export function injectVirtualStackFrame(error, filename) {
if (!SUPPORTED) return;

@@ -38,3 +29,3 @@ let frames = virtualFrames.get(error);

}
function expectedError(error) {
export function expectedError(error) {
if (!SUPPORTED) return;

@@ -44,3 +35,3 @@ expectedErrors.add(error);

}
function beginHiddenCallStack(fn) {
export function beginHiddenCallStack(fn) {
if (!SUPPORTED) return fn;

@@ -54,3 +45,3 @@ return Object.defineProperty(function (...args) {

}
function endHiddenCallStack(fn) {
export function endHiddenCallStack(fn) {
if (!SUPPORTED) return fn;

@@ -99,4 +90,3 @@ return Object.defineProperty(function (...args) {

}
0 && 0;
//# sourceMappingURL=rewrite-stack-trace.js.map

42

lib/gensync-utils/async.js

@@ -1,30 +0,13 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.forwardAsync = forwardAsync;
exports.isAsync = void 0;
exports.isThenable = isThenable;
exports.maybeAsync = maybeAsync;
exports.waitFor = exports.onFirstPause = void 0;
function _gensync() {
const data = require("gensync");
_gensync = function () {
return data;
};
return data;
}
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
const runGenerator = _gensync()(function* (item) {
import gensync from "gensync";
const runGenerator = gensync(function* (item) {
return yield* item;
});
const isAsync = _gensync()({
export const isAsync = gensync({
sync: () => false,
errback: cb => cb(null, true)
});
exports.isAsync = isAsync;
function maybeAsync(fn, message) {
return _gensync()({
export function maybeAsync(fn, message) {
return gensync({
sync(...args) {

@@ -40,3 +23,3 @@ const result = fn.apply(this, args);

}
const withKind = _gensync()({
const withKind = gensync({
sync: cb => cb("sync"),

@@ -52,4 +35,4 @@ async: function () {

});
function forwardAsync(action, cb) {
const g = _gensync()(action);
export function forwardAsync(action, cb) {
const g = gensync(action);
return withKind(kind => {

@@ -60,3 +43,3 @@ const adapted = g[kind];

}
const onFirstPause = _gensync()({
export const onFirstPause = gensync({
name: "onFirstPause",

@@ -78,4 +61,3 @@ arity: 2,

});
exports.onFirstPause = onFirstPause;
const waitFor = _gensync()({
export const waitFor = gensync({
sync: x => x,

@@ -91,8 +73,6 @@ async: function () {

});
exports.waitFor = waitFor;
function isThenable(val) {
export function isThenable(val) {
return !!val && (typeof val === "object" || typeof val === "function") && !!val.then && typeof val.then === "function";
}
0 && 0;
//# sourceMappingURL=async.js.map

37

lib/gensync-utils/fs.js

@@ -1,33 +0,12 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
import fs from "fs";
import gensync from "gensync";
export const readFile = gensync({
sync: fs.readFileSync,
errback: fs.readFile
});
exports.stat = exports.readFile = void 0;
function _fs() {
const data = require("fs");
_fs = function () {
return data;
};
return data;
}
function _gensync() {
const data = require("gensync");
_gensync = function () {
return data;
};
return data;
}
const readFile = _gensync()({
sync: _fs().readFileSync,
errback: _fs().readFile
export const stat = gensync({
sync: fs.statSync,
errback: fs.stat
});
exports.readFile = readFile;
const stat = _gensync()({
sync: _fs().statSync,
errback: _fs().stat
});
exports.stat = stat;
0 && 0;
//# sourceMappingURL=fs.js.map

15

lib/gensync-utils/functional.js

@@ -1,9 +0,3 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.once = once;
var _async = require("./async");
function once(fn) {
import { isAsync, waitFor } from "./async.js";
export function once(fn) {
let result;

@@ -13,4 +7,4 @@ let resultP;

if (result) return result;
if (!(yield* (0, _async.isAsync)())) return result = yield* fn();
if (resultP) return yield* (0, _async.waitFor)(resultP);
if (!(yield* isAsync())) return result = yield* fn();
if (resultP) return yield* waitFor(resultP);
let resolve, reject;

@@ -32,4 +26,3 @@ resultP = new Promise((res, rej) => {

}
0 && 0;
//# sourceMappingURL=functional.js.map

266

lib/index.js

@@ -1,244 +0,36 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.DEFAULT_EXTENSIONS = void 0;
Object.defineProperty(exports, "File", {
enumerable: true,
get: function () {
return _file.default;
export const version = "7.21.4-esm.1";
export { default as File } from "./transformation/file/file.js";
export { default as buildExternalHelpers } from "./tools/build-external-helpers.js";
export { resolvePlugin, resolvePreset } from "./config/files/index.js";
export { getEnv } from "./config/helpers/environment.js";
import * as _types from "@babel/types";
export { _types as types };
export { tokTypes } from "@babel/parser";
export { default as traverse } from "@babel/traverse";
export { default as template } from "@babel/template";
export { createConfigItem, createConfigItemSync, createConfigItemAsync } from "./config/index.js";
export { loadPartialConfig, loadPartialConfigSync, loadPartialConfigAsync, loadOptions, loadOptionsSync, loadOptionsAsync } from "./config/index.js";
export { transform, transformSync, transformAsync } from "./transform.js";
export { transformFile, transformFileSync, transformFileAsync } from "./transform-file.js";
export { transformFromAst, transformFromAstSync, transformFromAstAsync } from "./transform-ast.js";
export { parse, parseSync, parseAsync } from "./parse.js";
export const DEFAULT_EXTENSIONS = Object.freeze([".js", ".jsx", ".es6", ".es", ".mjs", ".cjs"]);
import { loadOptionsSync } from "./config/index.js";
export class OptionManager {
init(opts) {
return loadOptionsSync(opts);
}
});
exports.OptionManager = void 0;
exports.Plugin = Plugin;
Object.defineProperty(exports, "buildExternalHelpers", {
enumerable: true,
get: function () {
return _buildExternalHelpers.default;
}
});
Object.defineProperty(exports, "createConfigItem", {
enumerable: true,
get: function () {
return _config.createConfigItem;
}
});
Object.defineProperty(exports, "createConfigItemAsync", {
enumerable: true,
get: function () {
return _config.createConfigItemAsync;
}
});
Object.defineProperty(exports, "createConfigItemSync", {
enumerable: true,
get: function () {
return _config.createConfigItemSync;
}
});
Object.defineProperty(exports, "getEnv", {
enumerable: true,
get: function () {
return _environment.getEnv;
}
});
Object.defineProperty(exports, "loadOptions", {
enumerable: true,
get: function () {
return _config.loadOptions;
}
});
Object.defineProperty(exports, "loadOptionsAsync", {
enumerable: true,
get: function () {
return _config.loadOptionsAsync;
}
});
Object.defineProperty(exports, "loadOptionsSync", {
enumerable: true,
get: function () {
return _config.loadOptionsSync;
}
});
Object.defineProperty(exports, "loadPartialConfig", {
enumerable: true,
get: function () {
return _config.loadPartialConfig;
}
});
Object.defineProperty(exports, "loadPartialConfigAsync", {
enumerable: true,
get: function () {
return _config.loadPartialConfigAsync;
}
});
Object.defineProperty(exports, "loadPartialConfigSync", {
enumerable: true,
get: function () {
return _config.loadPartialConfigSync;
}
});
Object.defineProperty(exports, "parse", {
enumerable: true,
get: function () {
return _parse.parse;
}
});
Object.defineProperty(exports, "parseAsync", {
enumerable: true,
get: function () {
return _parse.parseAsync;
}
});
Object.defineProperty(exports, "parseSync", {
enumerable: true,
get: function () {
return _parse.parseSync;
}
});
Object.defineProperty(exports, "resolvePlugin", {
enumerable: true,
get: function () {
return _files.resolvePlugin;
}
});
Object.defineProperty(exports, "resolvePreset", {
enumerable: true,
get: function () {
return _files.resolvePreset;
}
});
Object.defineProperty((0, exports), "template", {
enumerable: true,
get: function () {
return _template().default;
}
});
Object.defineProperty((0, exports), "tokTypes", {
enumerable: true,
get: function () {
return _parser().tokTypes;
}
});
Object.defineProperty(exports, "transform", {
enumerable: true,
get: function () {
return _transform.transform;
}
});
Object.defineProperty(exports, "transformAsync", {
enumerable: true,
get: function () {
return _transform.transformAsync;
}
});
Object.defineProperty(exports, "transformFile", {
enumerable: true,
get: function () {
return _transformFile.transformFile;
}
});
Object.defineProperty(exports, "transformFileAsync", {
enumerable: true,
get: function () {
return _transformFile.transformFileAsync;
}
});
Object.defineProperty(exports, "transformFileSync", {
enumerable: true,
get: function () {
return _transformFile.transformFileSync;
}
});
Object.defineProperty(exports, "transformFromAst", {
enumerable: true,
get: function () {
return _transformAst.transformFromAst;
}
});
Object.defineProperty(exports, "transformFromAstAsync", {
enumerable: true,
get: function () {
return _transformAst.transformFromAstAsync;
}
});
Object.defineProperty(exports, "transformFromAstSync", {
enumerable: true,
get: function () {
return _transformAst.transformFromAstSync;
}
});
Object.defineProperty(exports, "transformSync", {
enumerable: true,
get: function () {
return _transform.transformSync;
}
});
Object.defineProperty((0, exports), "traverse", {
enumerable: true,
get: function () {
return _traverse().default;
}
});
exports.version = exports.types = void 0;
var _file = require("./transformation/file/file");
var _buildExternalHelpers = require("./tools/build-external-helpers");
var _files = require("./config/files");
var _environment = require("./config/helpers/environment");
function _types() {
const data = require("@babel/types");
_types = function () {
return data;
};
return data;
}
Object.defineProperty((0, exports), "types", {
enumerable: true,
get: function () {
return _types();
}
});
function _parser() {
const data = require("@babel/parser");
_parser = function () {
return data;
};
return data;
export function Plugin(alias) {
throw new Error(`The (${alias}) Babel 5 plugin is being run with an unsupported Babel version.`);
}
function _traverse() {
const data = require("@babel/traverse");
_traverse = function () {
return data;
};
return data;
}
function _template() {
const data = require("@babel/template");
_template = function () {
return data;
};
return data;
}
var _config = require("./config");
var _transform = require("./transform");
var _transformFile = require("./transform-file");
var _transformAst = require("./transform-ast");
var _parse = require("./parse");
var thisFile = require("./index");
const version = "7.21.4-esm";
exports.version = version;
const DEFAULT_EXTENSIONS = Object.freeze([".js", ".jsx", ".es6", ".es", ".mjs", ".cjs"]);
exports.DEFAULT_EXTENSIONS = DEFAULT_EXTENSIONS;
class OptionManager {
init(opts) {
return (0, _config.loadOptionsSync)(opts);
import Module from "module";
import * as thisFile from "./index.js";
{
{
const cjsProxy = Module.createRequire(import.meta.url)("../cjs-proxy.cjs");
cjsProxy["__ initialize @babel/core cjs proxy __"] = thisFile;
}
}
exports.OptionManager = OptionManager;
function Plugin(alias) {
throw new Error(`The (${alias}) Babel 5 plugin is being run with an unsupported Babel version.`);
}
;
0 && (exports.types = exports.traverse = exports.tokTypes = exports.template = 0);
//# sourceMappingURL=index.js.map

46

lib/parse.js

@@ -1,28 +0,14 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.parse = void 0;
exports.parseAsync = parseAsync;
exports.parseSync = parseSync;
function _gensync() {
const data = require("gensync");
_gensync = function () {
return data;
};
return data;
}
var _config = require("./config");
var _parser = require("./parser");
var _normalizeOpts = require("./transformation/normalize-opts");
var _rewriteStackTrace = require("./errors/rewrite-stack-trace");
const parseRunner = _gensync()(function* parse(code, opts) {
const config = yield* (0, _config.default)(opts);
import gensync from "gensync";
import loadConfig from "./config/index.js";
import parser from "./parser/index.js";
import normalizeOptions from "./transformation/normalize-opts.js";
import { beginHiddenCallStack } from "./errors/rewrite-stack-trace.js";
const parseRunner = gensync(function* parse(code, opts) {
const config = yield* loadConfig(opts);
if (config === null) {
return null;
}
return yield* (0, _parser.default)(config.passes, (0, _normalizeOpts.default)(config), code);
return yield* parser(config.passes, normalizeOptions(config), code);
});
const parse = function parse(code, opts, callback) {
export const parse = function parse(code, opts, callback) {
if (typeof opts === "function") {

@@ -34,16 +20,14 @@ callback = opts;

{
return (0, _rewriteStackTrace.beginHiddenCallStack)(parseRunner.sync)(code, opts);
return beginHiddenCallStack(parseRunner.sync)(code, opts);
}
}
(0, _rewriteStackTrace.beginHiddenCallStack)(parseRunner.errback)(code, opts, callback);
beginHiddenCallStack(parseRunner.errback)(code, opts, callback);
};
exports.parse = parse;
function parseSync(...args) {
return (0, _rewriteStackTrace.beginHiddenCallStack)(parseRunner.sync)(...args);
export function parseSync(...args) {
return beginHiddenCallStack(parseRunner.sync)(...args);
}
function parseAsync(...args) {
return (0, _rewriteStackTrace.beginHiddenCallStack)(parseRunner.async)(...args);
export function parseAsync(...args) {
return beginHiddenCallStack(parseRunner.async)(...args);
}
0 && 0;
//# sourceMappingURL=parse.js.map

35

lib/parser/index.js

@@ -1,23 +0,5 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = parser;
function _parser() {
const data = require("@babel/parser");
_parser = function () {
return data;
};
return data;
}
function _codeFrame() {
const data = require("@babel/code-frame");
_codeFrame = function () {
return data;
};
return data;
}
var _missingPluginHelper = require("./util/missing-plugin-helper");
function* parser(pluginPasses, {
import { parse } from "@babel/parser";
import { codeFrameColumns } from "@babel/code-frame";
import generateMissingPluginMessage from "./util/missing-plugin-helper.js";
export default function* parser(pluginPasses, {
parserOpts,

@@ -35,3 +17,3 @@ highlightCode = true,

if (parserOverride) {
const ast = parserOverride(code, parserOpts, _parser().parse);
const ast = parserOverride(code, parserOpts, parse);
if (ast !== undefined) results.push(ast);

@@ -42,3 +24,3 @@ }

if (results.length === 0) {
return (0, _parser().parse)(code, parserOpts);
return parse(code, parserOpts);
} else if (results.length === 1) {

@@ -61,3 +43,3 @@ yield* [];

if (loc) {
const codeFrame = (0, _codeFrame().codeFrameColumns)(code, {
const codeFrame = codeFrameColumns(code, {
start: {

@@ -71,3 +53,3 @@ line: loc.line,

if (missingPlugin) {
err.message = `${filename}: ` + (0, _missingPluginHelper.default)(missingPlugin[0], loc, codeFrame);
err.message = `${filename}: ` + generateMissingPluginMessage(missingPlugin[0], loc, codeFrame);
} else {

@@ -81,4 +63,3 @@ err.message = `${filename}: ${err.message}\n\n` + codeFrame;

}
0 && 0;
//# sourceMappingURL=index.js.map

9

lib/parser/util/missing-plugin-helper.js

@@ -1,7 +0,1 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = generateMissingPluginMessage;
const pluginNameMap = {

@@ -299,3 +293,3 @@ asyncDoExpressions: {

}) => `${name} (${url})`;
function generateMissingPluginMessage(missingPluginName, loc, codeFrame) {
export default function generateMissingPluginMessage(missingPluginName, loc, codeFrame) {
let helpMessage = `Support for the experimental syntax '${missingPluginName}' isn't currently enabled ` + `(${loc.line}:${loc.column + 1}):\n\n` + codeFrame;

@@ -322,4 +316,3 @@ const pluginInfo = pluginNameMap[missingPluginName];

}
0 && 0;
//# sourceMappingURL=missing-plugin-helper.js.map

55

lib/tools/build-external-helpers.js

@@ -1,36 +0,5 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = _default;
function helpers() {
const data = require("@babel/helpers");
helpers = function () {
return data;
};
return data;
}
function _generator() {
const data = require("@babel/generator");
_generator = function () {
return data;
};
return data;
}
function _template() {
const data = require("@babel/template");
_template = function () {
return data;
};
return data;
}
function _t() {
const data = require("@babel/types");
_t = function () {
return data;
};
return data;
}
var _file = require("../transformation/file/file");
import * as helpers from "@babel/helpers";
import generator from "@babel/generator";
import template from "@babel/template";
import * as _t from "@babel/types";
const {

@@ -56,4 +25,5 @@ arrayExpression,

variableDeclarator
} = _t();
const buildUmdWrapper = replacements => _template().default.statement`
} = _t;
import File from "../transformation/file/file.js";
const buildUmdWrapper = replacements => template.statement`
(function (root, factory) {

@@ -116,9 +86,9 @@ if (typeof define === "function" && define.amd) {

const refs = {};
helpers().list.forEach(function (name) {
helpers.list.forEach(function (name) {
if (allowlist && allowlist.indexOf(name) < 0) return;
const ref = refs[name] = getHelperReference(name);
helpers().ensure(name, _file.default);
helpers.ensure(name, File);
const {
nodes
} = helpers().get(name, getHelperReference, ref);
} = helpers.get(name, getHelperReference, ref);
body.push(...nodes);

@@ -128,3 +98,3 @@ });

}
function _default(allowlist, outputType = "global") {
export default function (allowlist, outputType = "global") {
let tree;

@@ -142,6 +112,5 @@ const build = {

}
return (0, _generator().default)(tree).code;
return generator(tree).code;
}
0 && 0;
//# sourceMappingURL=build-external-helpers.js.map

44

lib/transform-ast.js

@@ -1,26 +0,12 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.transformFromAst = void 0;
exports.transformFromAstAsync = transformFromAstAsync;
exports.transformFromAstSync = transformFromAstSync;
function _gensync() {
const data = require("gensync");
_gensync = function () {
return data;
};
return data;
}
var _config = require("./config");
var _transformation = require("./transformation");
var _rewriteStackTrace = require("./errors/rewrite-stack-trace");
const transformFromAstRunner = _gensync()(function* (ast, code, opts) {
const config = yield* (0, _config.default)(opts);
import gensync from "gensync";
import loadConfig from "./config/index.js";
import { run } from "./transformation/index.js";
import { beginHiddenCallStack } from "./errors/rewrite-stack-trace.js";
const transformFromAstRunner = gensync(function* (ast, code, opts) {
const config = yield* loadConfig(opts);
if (config === null) return null;
if (!ast) throw new Error("No AST given");
return yield* (0, _transformation.run)(config, code, ast);
return yield* run(config, code, ast);
});
const transformFromAst = function transformFromAst(ast, code, optsOrCallback, maybeCallback) {
export const transformFromAst = function transformFromAst(ast, code, optsOrCallback, maybeCallback) {
let opts;

@@ -37,16 +23,14 @@ let callback;

{
return (0, _rewriteStackTrace.beginHiddenCallStack)(transformFromAstRunner.sync)(ast, code, opts);
return beginHiddenCallStack(transformFromAstRunner.sync)(ast, code, opts);
}
}
(0, _rewriteStackTrace.beginHiddenCallStack)(transformFromAstRunner.errback)(ast, code, opts, callback);
beginHiddenCallStack(transformFromAstRunner.errback)(ast, code, opts, callback);
};
exports.transformFromAst = transformFromAst;
function transformFromAstSync(...args) {
return (0, _rewriteStackTrace.beginHiddenCallStack)(transformFromAstRunner.sync)(...args);
export function transformFromAstSync(...args) {
return beginHiddenCallStack(transformFromAstRunner.sync)(...args);
}
function transformFromAstAsync(...args) {
return (0, _rewriteStackTrace.beginHiddenCallStack)(transformFromAstRunner.async)(...args);
export function transformFromAstAsync(...args) {
return beginHiddenCallStack(transformFromAstRunner.async)(...args);
}
0 && 0;
//# sourceMappingURL=transform-ast.js.map

16

lib/transform-file-browser.js

@@ -1,10 +0,2 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.transformFile = void 0;
exports.transformFileAsync = transformFileAsync;
exports.transformFileSync = transformFileSync;
const transformFile = function transformFile(filename, opts, callback) {
export const transformFile = function transformFile(filename, opts, callback) {
if (typeof opts === "function") {

@@ -15,11 +7,9 @@ callback = opts;

};
exports.transformFile = transformFile;
function transformFileSync() {
export function transformFileSync() {
throw new Error("Transforming files is not supported in browsers");
}
function transformFileAsync() {
export function transformFileAsync() {
return Promise.reject(new Error("Transforming files is not supported in browsers"));
}
0 && 0;
//# sourceMappingURL=transform-file-browser.js.map

35

lib/transform-file.js

@@ -1,40 +0,25 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.transformFile = transformFile;
exports.transformFileAsync = transformFileAsync;
exports.transformFileSync = transformFileSync;
function _gensync() {
const data = require("gensync");
_gensync = function () {
return data;
};
return data;
}
var _config = require("./config");
var _transformation = require("./transformation");
var fs = require("./gensync-utils/fs");
import gensync from "gensync";
import loadConfig from "./config/index.js";
import { run } from "./transformation/index.js";
import * as fs from "./gensync-utils/fs.js";
({});
const transformFileRunner = _gensync()(function* (filename, opts) {
const transformFileRunner = gensync(function* (filename, opts) {
const options = Object.assign({}, opts, {
filename
});
const config = yield* (0, _config.default)(options);
const config = yield* loadConfig(options);
if (config === null) return null;
const code = yield* fs.readFile(filename, "utf8");
return yield* (0, _transformation.run)(config, code);
return yield* run(config, code);
});
function transformFile(...args) {
export function transformFile(...args) {
transformFileRunner.errback(...args);
}
function transformFileSync(...args) {
export function transformFileSync(...args) {
return transformFileRunner.sync(...args);
}
function transformFileAsync(...args) {
export function transformFileAsync(...args) {
return transformFileRunner.async(...args);
}
0 && 0;
//# sourceMappingURL=transform-file.js.map

44

lib/transform.js

@@ -1,25 +0,11 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.transform = void 0;
exports.transformAsync = transformAsync;
exports.transformSync = transformSync;
function _gensync() {
const data = require("gensync");
_gensync = function () {
return data;
};
return data;
}
var _config = require("./config");
var _transformation = require("./transformation");
var _rewriteStackTrace = require("./errors/rewrite-stack-trace");
const transformRunner = _gensync()(function* transform(code, opts) {
const config = yield* (0, _config.default)(opts);
import gensync from "gensync";
import loadConfig from "./config/index.js";
import { run } from "./transformation/index.js";
import { beginHiddenCallStack } from "./errors/rewrite-stack-trace.js";
const transformRunner = gensync(function* transform(code, opts) {
const config = yield* loadConfig(opts);
if (config === null) return null;
return yield* (0, _transformation.run)(config, code);
return yield* run(config, code);
});
const transform = function transform(code, optsOrCallback, maybeCallback) {
export const transform = function transform(code, optsOrCallback, maybeCallback) {
let opts;

@@ -36,16 +22,14 @@ let callback;

{
return (0, _rewriteStackTrace.beginHiddenCallStack)(transformRunner.sync)(code, opts);
return beginHiddenCallStack(transformRunner.sync)(code, opts);
}
}
(0, _rewriteStackTrace.beginHiddenCallStack)(transformRunner.errback)(code, opts, callback);
beginHiddenCallStack(transformRunner.errback)(code, opts, callback);
};
exports.transform = transform;
function transformSync(...args) {
return (0, _rewriteStackTrace.beginHiddenCallStack)(transformRunner.sync)(...args);
export function transformSync(...args) {
return beginHiddenCallStack(transformRunner.sync)(...args);
}
function transformAsync(...args) {
return (0, _rewriteStackTrace.beginHiddenCallStack)(transformRunner.async)(...args);
export function transformAsync(...args) {
return beginHiddenCallStack(transformRunner.async)(...args);
}
0 && 0;
//# sourceMappingURL=transform.js.map

23

lib/transformation/block-hoist-plugin.js

@@ -1,15 +0,3 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = loadBlockHoistPlugin;
function _traverse() {
const data = require("@babel/traverse");
_traverse = function () {
return data;
};
return data;
}
var _plugin = require("../config/plugin");
import traverse from "@babel/traverse";
import Plugin from "../config/plugin.js";
let LOADED_PLUGIN;

@@ -43,6 +31,6 @@ const blockHoistPlugin = {

};
function loadBlockHoistPlugin() {
export default function loadBlockHoistPlugin() {
if (!LOADED_PLUGIN) {
LOADED_PLUGIN = new _plugin.default(Object.assign({}, blockHoistPlugin, {
visitor: _traverse().default.explode(blockHoistPlugin.visitor)
LOADED_PLUGIN = new Plugin(Object.assign({}, blockHoistPlugin, {
visitor: traverse.explode(blockHoistPlugin.visitor)
}), {});

@@ -76,4 +64,3 @@ }

}
0 && 0;
//# sourceMappingURL=block-hoist-plugin.js.map

81

lib/transformation/file/file.js

@@ -1,53 +0,12 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
function helpers() {
const data = require("@babel/helpers");
helpers = function () {
return data;
};
return data;
}
function _traverse() {
const data = require("@babel/traverse");
_traverse = function () {
return data;
};
return data;
}
function _codeFrame() {
const data = require("@babel/code-frame");
_codeFrame = function () {
return data;
};
return data;
}
function _t() {
const data = require("@babel/types");
_t = function () {
return data;
};
return data;
}
function _helperModuleTransforms() {
const data = require("@babel/helper-module-transforms");
_helperModuleTransforms = function () {
return data;
};
return data;
}
function _semver() {
const data = require("semver");
_semver = function () {
return data;
};
return data;
}
import * as helpers from "@babel/helpers";
import { NodePath } from "@babel/traverse";
import { codeFrameColumns } from "@babel/code-frame";
import traverse from "@babel/traverse";
import * as _t from "@babel/types";
const {
cloneNode,
interpreterDirective
} = _t();
} = _t;
import { getModuleName } from "@babel/helper-module-transforms";
import semver from "semver";
const errorVisitor = {

@@ -62,3 +21,3 @@ enter(path, state) {

};
class File {
export default class File {
constructor(options, {

@@ -89,3 +48,3 @@ code,

this.inputMap = inputMap;
this.path = _traverse().NodePath.get({
this.path = NodePath.get({
hub: this.hub,

@@ -125,3 +84,3 @@ parentPath: null,

getModuleName() {
return (0, _helperModuleTransforms().getModuleName)(this.opts, this.opts);
return getModuleName(this.opts, this.opts);
}

@@ -134,3 +93,3 @@ addImport() {

try {
minVersion = helpers().minVersion(name);
minVersion = helpers.minVersion(name);
} catch (err) {

@@ -141,4 +100,4 @@ if (err.code !== "BABEL_HELPER_UNKNOWN") throw err;

if (typeof versionRange !== "string") return true;
if (_semver().valid(versionRange)) versionRange = `^${versionRange}`;
return !_semver().intersects(`<${minVersion}`, versionRange) && !_semver().intersects(`>=8.0.0`, versionRange);
if (semver.valid(versionRange)) versionRange = `^${versionRange}`;
return !semver.intersects(`<${minVersion}`, versionRange) && !semver.intersects(`>=8.0.0`, versionRange);
}

@@ -153,6 +112,6 @@ addHelper(name) {

}
helpers().ensure(name, File);
helpers.ensure(name, File);
const uid = this.declarations[name] = this.scope.generateUidIdentifier(name);
const dependencies = {};
for (const dep of helpers().getDependencies(name)) {
for (const dep of helpers.getDependencies(name)) {
dependencies[dep] = this.addHelper(dep);

@@ -163,3 +122,3 @@ }

globals
} = helpers().get(name, dep => dependencies[dep], uid, Object.keys(this.scope.getAllBindings()));
} = helpers.get(name, dep => dependencies[dep], uid, Object.keys(this.scope.getAllBindings()));
globals.forEach(name => {

@@ -189,3 +148,3 @@ if (this.path.scope.hasBinding(name, true)) {

};
(0, _traverse().default)(node, errorVisitor, this.scope, state);
traverse(node, errorVisitor, this.scope, state);
loc = state.loc;

@@ -200,3 +159,3 @@ let txt = "This is an error on an internal node. Probably an internal error.";

} = this.opts;
msg += "\n" + (0, _codeFrame().codeFrameColumns)(this.code, {
msg += "\n" + codeFrameColumns(this.code, {
start: {

@@ -217,5 +176,3 @@ line: loc.start.line,

}
exports.default = File;
0 && 0;
//# sourceMappingURL=file.js.map

35

lib/transformation/file/generate.js

@@ -1,23 +0,5 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = generateCode;
function _convertSourceMap() {
const data = require("convert-source-map");
_convertSourceMap = function () {
return data;
};
return data;
}
function _generator() {
const data = require("@babel/generator");
_generator = function () {
return data;
};
return data;
}
var _mergeMap = require("./merge-map");
function generateCode(pluginPasses, file) {
import convertSourceMap from "convert-source-map";
import generate from "@babel/generator";
import mergeSourceMap from "./merge-map.js";
export default function generateCode(pluginPasses, file) {
const {

@@ -40,3 +22,3 @@ opts,

if (generatorOverride) {
const result = generatorOverride(ast, generatorOpts, code, _generator().default);
const result = generatorOverride(ast, generatorOpts, code, generate);
if (result !== undefined) results.push(result);

@@ -48,3 +30,3 @@ }

if (results.length === 0) {
result = (0, _generator().default)(ast, generatorOpts, code);
result = generate(ast, generatorOpts, code);
} else if (results.length === 1) {

@@ -67,3 +49,3 @@ result = results[0];

if (inputMap) {
outputMap = (0, _mergeMap.default)(inputMap.toObject(), outputMap, generatorOpts.sourceFileName);
outputMap = mergeSourceMap(inputMap.toObject(), outputMap, generatorOpts.sourceFileName);
} else {

@@ -75,3 +57,3 @@ outputMap = result.map;

if (opts.sourceMaps === "inline" || opts.sourceMaps === "both") {
outputCode += "\n" + _convertSourceMap().fromObject(outputMap).toComment();
outputCode += "\n" + convertSourceMap.fromObject(outputMap).toComment();
}

@@ -86,4 +68,3 @@ if (opts.sourceMaps === "inline") {

}
0 && 0;
//# sourceMappingURL=generate.js.map

19

lib/transformation/file/merge-map.js

@@ -1,18 +0,6 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = mergeSourceMap;
function _remapping() {
const data = require("@ampproject/remapping");
_remapping = function () {
return data;
};
return data;
}
function mergeSourceMap(inputMap, map, sourceFileName) {
import remapping from "@ampproject/remapping";
export default function mergeSourceMap(inputMap, map, sourceFileName) {
const source = sourceFileName.replace(/\\/g, "/");
let found = false;
const result = _remapping()(rootless(map), (s, ctx) => {
const result = remapping(rootless(map), (s, ctx) => {
if (s === source && !found) {

@@ -35,4 +23,3 @@ found = true;

}
0 && 0;
//# sourceMappingURL=merge-map.js.map

43

lib/transformation/index.js

@@ -1,22 +0,10 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.run = run;
function _traverse() {
const data = require("@babel/traverse");
_traverse = function () {
return data;
};
return data;
}
var _pluginPass = require("./plugin-pass");
var _blockHoistPlugin = require("./block-hoist-plugin");
var _normalizeOpts = require("./normalize-opts");
var _normalizeFile = require("./normalize-file");
var _generate = require("./file/generate");
var _deepArray = require("../config/helpers/deep-array");
function* run(config, code, ast) {
const file = yield* (0, _normalizeFile.default)(config.passes, (0, _normalizeOpts.default)(config), code, ast);
import traverse from "@babel/traverse";
import PluginPass from "./plugin-pass.js";
import loadBlockHoistPlugin from "./block-hoist-plugin.js";
import normalizeOptions from "./normalize-opts.js";
import normalizeFile from "./normalize-file.js";
import generateCode from "./file/generate.js";
import { flattenToSet } from "../config/helpers/deep-array.js";
export function* run(config, code, ast) {
const file = yield* normalizeFile(config.passes, normalizeOptions(config), code, ast);
const opts = file.opts;

@@ -39,3 +27,3 @@ try {

outputMap
} = (0, _generate.default)(config.passes, file));
} = generateCode(config.passes, file));
}

@@ -57,3 +45,3 @@ } catch (e) {

sourceType: file.ast.program.sourceType,
externalDependencies: (0, _deepArray.flattenToSet)(config.externalDependencies)
externalDependencies: flattenToSet(config.externalDependencies)
};

@@ -66,4 +54,4 @@ }

const visitors = [];
for (const plugin of pluginPairs.concat([(0, _blockHoistPlugin.default)()])) {
const pass = new _pluginPass.default(file, plugin.key, plugin.options);
for (const plugin of pluginPairs.concat([loadBlockHoistPlugin()])) {
const pass = new PluginPass(file, plugin.key, plugin.options);
passPairs.push([plugin, pass]);

@@ -83,4 +71,4 @@ passes.push(pass);

}
const visitor = _traverse().default.visitors.merge(visitors, passes, file.opts.wrapPluginVisitorMethod);
(0, _traverse().default)(file.ast, visitor, file.scope);
const visitor = traverse.visitors.merge(visitors, passes, file.opts.wrapPluginVisitorMethod);
traverse(file.ast, visitor, file.scope);
for (const [plugin, pass] of passPairs) {

@@ -101,4 +89,3 @@ const fn = plugin.post;

}
0 && 0;
//# sourceMappingURL=index.js.map

73

lib/transformation/normalize-file.js

@@ -1,53 +0,17 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = normalizeFile;
function _fs() {
const data = require("fs");
_fs = function () {
return data;
};
return data;
}
function _path() {
const data = require("path");
_path = function () {
return data;
};
return data;
}
function _debug() {
const data = require("debug");
_debug = function () {
return data;
};
return data;
}
function _t() {
const data = require("@babel/types");
_t = function () {
return data;
};
return data;
}
function _convertSourceMap() {
const data = require("convert-source-map");
_convertSourceMap = function () {
return data;
};
return data;
}
var _file = require("./file/file");
var _parser = require("../parser");
var _cloneDeep = require("./util/clone-deep");
import fs from "fs";
import path from "path";
import buildDebug from "debug";
import * as _t from "@babel/types";
const {
file,
traverseFast
} = _t();
const debug = _debug()("babel:transform:file");
} = _t;
import convertSourceMap from "convert-source-map";
import File from "./file/file.js";
import parser from "../parser/index.js";
import cloneDeep from "./util/clone-deep.js";
const debug = buildDebug("babel:transform:file");
const INLINE_SOURCEMAP_REGEX = /^[@#]\s+sourceMappingURL=data:(?:application|text)\/json;(?:charset[:=]\S+?;)?base64,(?:.*)$/;
const EXTERNAL_SOURCEMAP_REGEX = /^[@#][ \t]+sourceMappingURL=([^\s'"`]+)[ \t]*$/;
function* normalizeFile(pluginPasses, options, code, ast) {
export default function* normalizeFile(pluginPasses, options, code, ast) {
code = `${code || ""}`;

@@ -61,6 +25,6 @@ if (ast) {

if (options.cloneInputAst) {
ast = (0, _cloneDeep.default)(ast);
ast = cloneDeep(ast);
}
} else {
ast = yield* (0, _parser.default)(pluginPasses, options, code);
ast = yield* parser(pluginPasses, options, code);
}

@@ -70,3 +34,3 @@ let inputMap = null;

if (typeof options.inputSourceMap === "object") {
inputMap = _convertSourceMap().fromObject(options.inputSourceMap);
inputMap = convertSourceMap.fromObject(options.inputSourceMap);
}

@@ -77,3 +41,3 @@ if (!inputMap) {

try {
inputMap = _convertSourceMap().fromComment(lastComment);
inputMap = convertSourceMap.fromComment(lastComment);
} catch (err) {

@@ -89,4 +53,4 @@ debug("discarding unknown inline input sourcemap", err);

const match = EXTERNAL_SOURCEMAP_REGEX.exec(lastComment);
const inputMapContent = _fs().readFileSync(_path().resolve(_path().dirname(options.filename), match[1]), "utf8");
inputMap = _convertSourceMap().fromJSON(inputMapContent);
const inputMapContent = fs.readFileSync(path.resolve(path.dirname(options.filename), match[1]), "utf8");
inputMap = convertSourceMap.fromJSON(inputMapContent);
} catch (err) {

@@ -100,3 +64,3 @@ debug("discarding unknown file input sourcemap", err);

}
return new _file.default(options, {
return new File(options, {
code,

@@ -130,4 +94,3 @@ ast: ast,

}
0 && 0;
//# sourceMappingURL=normalize-file.js.map

23

lib/transformation/normalize-opts.js

@@ -1,19 +0,7 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = normalizeOptions;
function _path() {
const data = require("path");
_path = function () {
return data;
};
return data;
}
function normalizeOptions(config) {
import path from "path";
export default function normalizeOptions(config) {
const {
filename,
cwd,
filenameRelative = typeof filename === "string" ? _path().relative(cwd, filename) : "unknown",
filenameRelative = typeof filename === "string" ? path.relative(cwd, filename) : "unknown",
sourceType = "module",

@@ -23,3 +11,3 @@ inputSourceMap,

sourceRoot = config.options.moduleRoot,
sourceFileName = _path().basename(filenameRelative),
sourceFileName = path.basename(filenameRelative),
comments = true,

@@ -31,3 +19,3 @@ compact = "auto"

parserOpts: Object.assign({
sourceType: _path().extname(filenameRelative) === ".mjs" ? "module" : sourceType,
sourceType: path.extname(filenameRelative) === ".mjs" ? "module" : sourceType,
sourceFileName: filename,

@@ -59,4 +47,3 @@ plugins: []

}
0 && 0;
//# sourceMappingURL=normalize-opts.js.map

10

lib/transformation/plugin-pass.js

@@ -1,8 +0,2 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
class PluginPass {
export default class PluginPass {
constructor(file, key, options) {

@@ -40,3 +34,2 @@ this._map = new Map();

}
exports.default = PluginPass;
{

@@ -47,4 +40,3 @@ PluginPass.prototype.getModuleName = function getModuleName() {

}
0 && 0;
//# sourceMappingURL=plugin-pass.js.map

9

lib/transformation/util/clone-deep.js

@@ -1,7 +0,1 @@

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = _default;
function deepClone(value, cache) {

@@ -30,8 +24,7 @@ if (value !== null) {

}
function _default(value) {
export default function (value) {
if (typeof value !== "object") return value;
return deepClone(value, new Map());
}
0 && 0;
//# sourceMappingURL=clone-deep.js.map

41

package.json
{
"name": "@babel/core",
"version": "7.21.4-esm",
"version": "7.21.4-esm.1",
"description": "Babel compiler core.",

@@ -50,11 +50,11 @@ "main": "./lib/index.js",

"@ampproject/remapping": "^2.2.0",
"@babel/code-frame": "^7.21.4-esm",
"@babel/generator": "^7.21.4-esm",
"@babel/helper-compilation-targets": "^7.21.4-esm",
"@babel/helper-module-transforms": "^7.21.4-esm",
"@babel/helpers": "^7.21.4-esm",
"@babel/parser": "^7.21.4-esm",
"@babel/template": "^7.21.4-esm",
"@babel/traverse": "^7.21.4-esm",
"@babel/types": "^7.21.4-esm",
"@babel/code-frame": "^7.21.4-esm.1",
"@babel/generator": "^7.21.4-esm.1",
"@babel/helper-compilation-targets": "^7.21.4-esm.1",
"@babel/helper-module-transforms": "^7.21.4-esm.1",
"@babel/helpers": "^7.21.4-esm.1",
"@babel/parser": "^7.21.4-esm.1",
"@babel/template": "^7.21.4-esm.1",
"@babel/traverse": "^7.21.4-esm.1",
"@babel/types": "^7.21.4-esm.1",
"convert-source-map": "^1.7.0",

@@ -67,8 +67,8 @@ "debug": "^4.1.0",

"devDependencies": {
"@babel/helper-transform-fixture-test-runner": "^7.21.4-esm",
"@babel/plugin-syntax-flow": "^7.21.4-esm",
"@babel/plugin-transform-flow-strip-types": "^7.21.4-esm",
"@babel/plugin-transform-modules-commonjs": "^7.21.4-esm",
"@babel/preset-env": "^7.21.4-esm",
"@babel/preset-typescript": "^7.21.4-esm",
"@babel/helper-transform-fixture-test-runner": "^7.21.4-esm.1",
"@babel/plugin-syntax-flow": "^7.21.4-esm.1",
"@babel/plugin-transform-flow-strip-types": "^7.21.4-esm.1",
"@babel/plugin-transform-modules-commonjs": "^7.21.4-esm.1",
"@babel/preset-env": "^7.21.4-esm.1",
"@babel/preset-typescript": "^7.21.4-esm.1",
"@jridgewell/trace-mapping": "^0.3.17",

@@ -83,3 +83,10 @@ "@types/convert-source-map": "^1.5.1",

},
"type": "commonjs"
"type": "module",
"exports": {
".": {
"require": "./cjs-proxy.cjs",
"default": "./lib/index.js"
},
"./package.json": "./package.json"
}
}
lib/config/caching.js.map

Sorry, the diff of this file is not supported yet

lib/config/config-chain.js.map

Sorry, the diff of this file is not supported yet

lib/config/config-descriptors.js.map

Sorry, the diff of this file is not supported yet

lib/config/files/configuration.js.map

Sorry, the diff of this file is not supported yet

lib/config/files/import-meta-resolve.js.map

Sorry, the diff of this file is not supported yet

lib/config/files/import.cjs

Sorry, the diff of this file is not supported yet

lib/config/files/import.cjs.map

Sorry, the diff of this file is not supported yet

lib/config/files/index-browser.js.map

Sorry, the diff of this file is not supported yet

lib/config/files/index.js.map

Sorry, the diff of this file is not supported yet

lib/config/files/module-types.js.map

Sorry, the diff of this file is not supported yet

lib/config/files/package.js.map

Sorry, the diff of this file is not supported yet

lib/config/files/plugins.js.map

Sorry, the diff of this file is not supported yet

lib/config/files/utils.js.map

Sorry, the diff of this file is not supported yet

lib/config/full.js.map

Sorry, the diff of this file is not supported yet

lib/config/helpers/config-api.js.map

Sorry, the diff of this file is not supported yet

lib/config/helpers/deep-array.js.map

Sorry, the diff of this file is not supported yet

lib/config/helpers/environment.js.map

Sorry, the diff of this file is not supported yet

lib/config/index.js.map

Sorry, the diff of this file is not supported yet

lib/config/item.js.map

Sorry, the diff of this file is not supported yet

lib/config/partial.js.map

Sorry, the diff of this file is not supported yet

lib/config/pattern-to-regex.js.map

Sorry, the diff of this file is not supported yet

lib/config/plugin.js.map

Sorry, the diff of this file is not supported yet

lib/config/printer.js.map

Sorry, the diff of this file is not supported yet

lib/config/resolve-targets-browser.js.map

Sorry, the diff of this file is not supported yet

lib/config/resolve-targets.js.map

Sorry, the diff of this file is not supported yet

lib/config/util.js.map

Sorry, the diff of this file is not supported yet

lib/config/validation/option-assertions.js.map

Sorry, the diff of this file is not supported yet

lib/config/validation/options.js.map

Sorry, the diff of this file is not supported yet

lib/config/validation/plugins.js.map

Sorry, the diff of this file is not supported yet

lib/config/validation/removed.js.map

Sorry, the diff of this file is not supported yet

lib/errors/config-error.js.map

Sorry, the diff of this file is not supported yet

lib/errors/rewrite-stack-trace.js.map

Sorry, the diff of this file is not supported yet

lib/gensync-utils/async.js.map

Sorry, the diff of this file is not supported yet

lib/gensync-utils/fs.js.map

Sorry, the diff of this file is not supported yet

lib/gensync-utils/functional.js.map

Sorry, the diff of this file is not supported yet

lib/index.js.map

Sorry, the diff of this file is not supported yet

lib/parse.js.map

Sorry, the diff of this file is not supported yet

lib/parser/index.js.map

Sorry, the diff of this file is not supported yet

lib/parser/util/missing-plugin-helper.js.map

Sorry, the diff of this file is not supported yet

lib/tools/build-external-helpers.js.map

Sorry, the diff of this file is not supported yet

lib/transform-ast.js.map

Sorry, the diff of this file is not supported yet

lib/transform-file-browser.js.map

Sorry, the diff of this file is not supported yet

lib/transform-file.js.map

Sorry, the diff of this file is not supported yet

lib/transform.js.map

Sorry, the diff of this file is not supported yet

lib/transformation/block-hoist-plugin.js.map

Sorry, the diff of this file is not supported yet

lib/transformation/file/file.js.map

Sorry, the diff of this file is not supported yet

lib/transformation/file/generate.js.map

Sorry, the diff of this file is not supported yet

lib/transformation/file/merge-map.js.map

Sorry, the diff of this file is not supported yet

lib/transformation/index.js.map

Sorry, the diff of this file is not supported yet

lib/transformation/normalize-file.js.map

Sorry, the diff of this file is not supported yet

lib/transformation/normalize-opts.js.map

Sorry, the diff of this file is not supported yet

lib/transformation/plugin-pass.js.map

Sorry, the diff of this file is not supported yet

lib/transformation/util/clone-deep.js.map

Sorry, the diff of this file is not supported yet

lib/vendor/import-meta-resolve.js

Sorry, the diff of this file is too big to display

lib/vendor/import-meta-resolve.js.map

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap

About

Packages

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc