s2/minifyfromhtml
1
0
Fork 0
mirror of https://github.com/S2-/minifyfromhtml.git synced 2025-08-02 20:00:05 +02:00
Code Issues Releases Wiki Activity

update node modules

Browse Source
This commit is contained in:
s2
2019-03-29 15:56:41 +01:00
parent f114871153
commit 89c32fb4e6
8347 changed files with 390123 additions and 159877 deletions
Download Patch File Download Diff File Expand all files Collapse all files

130
node_modules/@babel/core/lib/config/caching.js generated vendored
View File

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
});
exports.makeStrongCache = makeStrongCache;
exports.makeWeakCache = makeWeakCache;
exports.assertSimpleType = assertSimpleType;
function makeStrongCache(handler) {
return makeCachedFunction(new Map(), handler);
@@ -16,47 +17,35 @@ function makeWeakCache(handler) {
function makeCachedFunction(callCache, handler) {
return function cachedFunction(arg, data) {
var cachedValue = callCache.get(arg);
let cachedValue = callCache.get(arg);
if (cachedValue) {
for (var _iterator = cachedValue, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
var _ref2;
if (_isArray) {
if (_i >= _iterator.length) break;
_ref2 = _iterator[_i++];
} else {
_i = _iterator.next();
if (_i.done) break;
_ref2 = _i.value;
}
var _ref3 = _ref2;
var _value = _ref3.value,
_valid = _ref3.valid;
if (_valid(data)) return _value;
for (const _ref of cachedValue) {
const {
value,
valid
} = _ref;
if (valid(data)) return value;
}
}
var cache = new CacheConfigurator(data);
var value = handler(arg, cache);
const cache = new CacheConfigurator(data);
const value = handler(arg, cache);
if (!cache.configured()) cache.forever();
cache.deactivate();
switch (cache.mode()) {
case "forever":
cachedValue = [{
value: value,
valid: function valid() {
return true;
}
value,
valid: () => true
}];
callCache.set(arg, cachedValue);
break;
case "invalidate":
cachedValue = [{
value: value,
value,
valid: cache.validator()
}];
callCache.set(arg, cachedValue);
@@ -65,12 +54,12 @@ function makeCachedFunction(callCache, handler) {
case "valid":
if (cachedValue) {
cachedValue.push({
value: value,
value,
valid: cache.validator()
});
} else {
cachedValue = [{
value: value,
value,
valid: cache.validator()
}];
callCache.set(arg, cachedValue);
@@ -82,8 +71,8 @@ function makeCachedFunction(callCache, handler) {
};
}
var CacheConfigurator = function () {
function CacheConfigurator(data) {
class CacheConfigurator {
constructor(data) {
this._active = true;
this._never = false;
this._forever = false;
@@ -93,20 +82,18 @@ var CacheConfigurator = function () {
this._data = data;
}
var _proto = CacheConfigurator.prototype;
_proto.simple = function simple() {
simple() {
return makeSimpleConfigurator(this);
};
}
_proto.mode = function mode() {
mode() {
if (this._never) return "never";
if (this._forever) return "forever";
if (this._invalidate) return "invalidate";
return "valid";
};
}
_proto.forever = function forever() {
forever() {
if (!this._active) {
throw new Error("Cannot change caching after evaluation has completed.");
}
@@ -117,9 +104,9 @@ var CacheConfigurator = function () {
this._forever = true;
this._configured = true;
};
}
_proto.never = function never() {
never() {
if (!this._active) {
throw new Error("Cannot change caching after evaluation has completed.");
}
@@ -130,9 +117,9 @@ var CacheConfigurator = function () {
this._never = true;
this._configured = true;
};
}
_proto.using = function using(handler) {
using(handler) {
if (!this._active) {
throw new Error("Cannot change caching after evaluation has completed.");
}
@@ -142,14 +129,14 @@ var CacheConfigurator = function () {
}
this._configured = true;
var key = handler(this._data);
const key = handler(this._data);
this._pairs.push([key, handler]);
return key;
};
}
_proto.invalidate = function invalidate(handler) {
invalidate(handler) {
if (!this._active) {
throw new Error("Cannot change caching after evaluation has completed.");
}
@@ -160,34 +147,27 @@ var CacheConfigurator = function () {
this._invalidate = true;
this._configured = true;
var key = handler(this._data);
const key = handler(this._data);
this._pairs.push([key, handler]);
return key;
};
}
_proto.validator = function validator() {
var pairs = this._pairs;
return function (data) {
return pairs.every(function (_ref4) {
var key = _ref4[0],
fn = _ref4[1];
return key === fn(data);
});
};
};
validator() {
const pairs = this._pairs;
return data => pairs.every(([key, fn]) => key === fn(data));
}
_proto.deactivate = function deactivate() {
deactivate() {
this._active = false;
};
}
_proto.configured = function configured() {
configured() {
return this._configured;
};
}
return CacheConfigurator;
}();
}
function makeSimpleConfigurator(cache) {
function cacheFn(val) {
@@ -196,28 +176,24 @@ function makeSimpleConfigurator(cache) {
return;
}
return cache.using(val);
return cache.using(() => assertSimpleType(val()));
}
cacheFn.forever = function () {
return cache.forever();
};
cacheFn.forever = () => cache.forever();
cacheFn.never = function () {
return cache.never();
};
cacheFn.never = () => cache.never();
cacheFn.using = function (cb) {
return cache.using(function () {
return cb();
});
};
cacheFn.using = cb => cache.using(() => assertSimpleType(cb()));
cacheFn.invalidate = function (cb) {
return cache.invalidate(function () {
return cb();
});
};
cacheFn.invalidate = cb => cache.invalidate(() => assertSimpleType(cb()));
return cacheFn;
}
function assertSimpleType(value) {
if (value != null && typeof value !== "string" && typeof value !== "boolean" && typeof value !== "number") {
throw new Error("Cache keys must be either string, boolean, number, null, or undefined.");
}
return value;
}

549
node_modules/@babel/core/lib/config/config-chain.js generated vendored
View File

@@ -3,23 +3,14 @@
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.buildPresetChain = buildPresetChain;
exports.buildRootChain = buildRootChain;
exports.buildPresetChain = void 0;
exports.buildPresetChainWalker = void 0;
function _path() {
var data = _interopRequireDefault(require("path"));
const data = _interopRequireDefault(require("path"));
_path = function _path() {
return data;
};
return data;
}
function _micromatch() {
var data = _interopRequireDefault(require("micromatch"));
_micromatch = function _micromatch() {
_path = function () {
return data;
};
@@ -27,9 +18,9 @@ function _micromatch() {
}
function _debug() {
var data = _interopRequireDefault(require("debug"));
const data = _interopRequireDefault(require("debug"));
_debug = function _debug() {
_debug = function () {
return data;
};
@@ -38,6 +29,8 @@ function _debug() {
var _options = require("./validation/options");
var _patternToRegex = _interopRequireDefault(require("./pattern-to-regex"));
var _files = require("./files");
var _caching = require("./caching");
@@ -46,255 +39,223 @@ var _configDescriptors = require("./config-descriptors");
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
var debug = (0, _debug().default)("babel:config:config-chain");
var buildPresetChain = makeChainWalker({
init: function init(arg) {
return arg;
},
root: function root(preset) {
return loadPresetDescriptors(preset);
},
env: function env(preset, envName) {
return loadPresetEnvDescriptors(preset)(envName);
},
overrides: function overrides(preset, index) {
return loadPresetOverridesDescriptors(preset)(index);
},
overridesEnv: function overridesEnv(preset, index, envName) {
return loadPresetOverridesEnvDescriptors(preset)(index)(envName);
}
});
exports.buildPresetChain = buildPresetChain;
var loadPresetDescriptors = (0, _caching.makeWeakCache)(function (preset) {
return buildRootDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors);
});
var loadPresetEnvDescriptors = (0, _caching.makeWeakCache)(function (preset) {
return (0, _caching.makeStrongCache)(function (envName) {
return buildEnvDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, envName);
});
});
var loadPresetOverridesDescriptors = (0, _caching.makeWeakCache)(function (preset) {
return (0, _caching.makeStrongCache)(function (index) {
return buildOverrideDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, index);
});
});
var loadPresetOverridesEnvDescriptors = (0, _caching.makeWeakCache)(function (preset) {
return (0, _caching.makeStrongCache)(function (index) {
return (0, _caching.makeStrongCache)(function (envName) {
return buildOverrideEnvDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, index, envName);
});
});
const debug = (0, _debug().default)("babel:config:config-chain");
function buildPresetChain(arg, context) {
const chain = buildPresetChainWalker(arg, context);
if (!chain) return null;
return {
plugins: dedupDescriptors(chain.plugins),
presets: dedupDescriptors(chain.presets),
options: chain.options.map(o => normalizeOptions(o))
};
}
const buildPresetChainWalker = makeChainWalker({
init: arg => arg,
root: preset => loadPresetDescriptors(preset),
env: (preset, envName) => loadPresetEnvDescriptors(preset)(envName),
overrides: (preset, index) => loadPresetOverridesDescriptors(preset)(index),
overridesEnv: (preset, index, envName) => loadPresetOverridesEnvDescriptors(preset)(index)(envName)
});
exports.buildPresetChainWalker = buildPresetChainWalker;
const loadPresetDescriptors = (0, _caching.makeWeakCache)(preset => buildRootDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors));
const loadPresetEnvDescriptors = (0, _caching.makeWeakCache)(preset => (0, _caching.makeStrongCache)(envName => buildEnvDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, envName)));
const loadPresetOverridesDescriptors = (0, _caching.makeWeakCache)(preset => (0, _caching.makeStrongCache)(index => buildOverrideDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, index)));
const loadPresetOverridesEnvDescriptors = (0, _caching.makeWeakCache)(preset => (0, _caching.makeStrongCache)(index => (0, _caching.makeStrongCache)(envName => buildOverrideEnvDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, index, envName))));
function buildRootChain(opts, context) {
var programmaticChain = loadProgrammaticChain({
const programmaticChain = loadProgrammaticChain({
options: opts,
dirname: context.cwd
}, context);
if (!programmaticChain) return null;
var _opts$root = opts.root,
rootDir = _opts$root === void 0 ? "." : _opts$root,
_opts$babelrc = opts.babelrc,
babelrc = _opts$babelrc === void 0 ? true : _opts$babelrc,
babelrcRoots = opts.babelrcRoots,
_opts$configFile = opts.configFile,
configFileName = _opts$configFile === void 0 ? true : _opts$configFile;
let configFile;
var absoluteRoot = _path().default.resolve(context.cwd, rootDir);
var configFile;
if (typeof configFileName === "string") {
configFile = (0, _files.loadConfig)(configFileName, context.cwd, context.envName);
} else if (configFileName === true) {
configFile = (0, _files.findRootConfig)(absoluteRoot, context.envName);
if (typeof opts.configFile === "string") {
configFile = (0, _files.loadConfig)(opts.configFile, context.cwd, context.envName, context.caller);
} else if (opts.configFile !== false) {
configFile = (0, _files.findRootConfig)(context.root, context.envName, context.caller);
}
var configFileChain = emptyChain();
let {
babelrc,
babelrcRoots
} = opts;
let babelrcRootsDirectory = context.cwd;
const configFileChain = emptyChain();
if (configFile) {
var result = loadFileChain(configFile, context);
const validatedFile = validateConfigFile(configFile);
const result = loadFileChain(validatedFile, context);
if (!result) return null;
if (babelrc === undefined) {
babelrc = validatedFile.options.babelrc;
}
if (babelrcRoots === undefined) {
babelrcRootsDirectory = validatedFile.dirname;
babelrcRoots = validatedFile.options.babelrcRoots;
}
mergeChain(configFileChain, result);
}
var pkgData = typeof context.filename === "string" ? (0, _files.findPackageData)(context.filename) : null;
var ignoreFile, babelrcFile;
var fileChain = emptyChain();
const pkgData = typeof context.filename === "string" ? (0, _files.findPackageData)(context.filename) : null;
let ignoreFile, babelrcFile;
const fileChain = emptyChain();
if (babelrc && pkgData && babelrcLoadEnabled(context, pkgData, babelrcRoots, absoluteRoot)) {
var _findRelativeConfig = (0, _files.findRelativeConfig)(pkgData, context.envName);
ignoreFile = _findRelativeConfig.ignore;
babelrcFile = _findRelativeConfig.config;
if ((babelrc === true || babelrc === undefined) && pkgData && babelrcLoadEnabled(context, pkgData, babelrcRoots, babelrcRootsDirectory)) {
({
ignore: ignoreFile,
config: babelrcFile
} = (0, _files.findRelativeConfig)(pkgData, context.envName, context.caller));
if (ignoreFile && shouldIgnore(context, ignoreFile.ignore, null, ignoreFile.dirname)) {
return null;
}
if (babelrcFile) {
var _result = loadFileChain(babelrcFile, context);
if (!_result) return null;
mergeChain(fileChain, _result);
const result = loadFileChain(validateBabelrcFile(babelrcFile), context);
if (!result) return null;
mergeChain(fileChain, result);
}
}
var chain = mergeChain(mergeChain(mergeChain(emptyChain(), configFileChain), fileChain), programmaticChain);
const chain = mergeChain(mergeChain(mergeChain(emptyChain(), configFileChain), fileChain), programmaticChain);
return {
plugins: dedupDescriptors(chain.plugins),
presets: dedupDescriptors(chain.presets),
options: chain.options.map(function (o) {
return normalizeOptions(o);
}),
options: chain.options.map(o => normalizeOptions(o)),
ignore: ignoreFile || undefined,
babelrc: babelrcFile || undefined,
config: configFile || undefined
};
}
function babelrcLoadEnabled(context, pkgData, babelrcRoots, absoluteRoot) {
function babelrcLoadEnabled(context, pkgData, babelrcRoots, babelrcRootsDirectory) {
if (typeof babelrcRoots === "boolean") return babelrcRoots;
const absoluteRoot = context.root;
if (babelrcRoots === undefined) {
return pkgData.directories.indexOf(absoluteRoot) !== -1;
}
var babelrcPatterns = babelrcRoots;
let babelrcPatterns = babelrcRoots;
if (!Array.isArray(babelrcPatterns)) babelrcPatterns = [babelrcPatterns];
babelrcPatterns = babelrcPatterns.map(function (pat) {
return _path().default.resolve(context.cwd, pat);
babelrcPatterns = babelrcPatterns.map(pat => {
return typeof pat === "string" ? _path().default.resolve(babelrcRootsDirectory, pat) : pat;
});
if (babelrcPatterns.length === 1 && babelrcPatterns[0] === absoluteRoot) {
return pkgData.directories.indexOf(absoluteRoot) !== -1;
}
return (0, _micromatch().default)(pkgData.directories, babelrcPatterns).length > 0;
}
return babelrcPatterns.some(pat => {
if (typeof pat === "string") {
pat = (0, _patternToRegex.default)(pat, babelrcRootsDirectory);
}
var loadProgrammaticChain = makeChainWalker({
init: function init(arg) {
return arg;
},
root: function root(input) {
return buildRootDescriptors(input, "base", _configDescriptors.createCachedDescriptors);
},
env: function env(input, envName) {
return buildEnvDescriptors(input, "base", _configDescriptors.createCachedDescriptors, envName);
},
overrides: function overrides(input, index) {
return buildOverrideDescriptors(input, "base", _configDescriptors.createCachedDescriptors, index);
},
overridesEnv: function overridesEnv(input, index, envName) {
return buildOverrideEnvDescriptors(input, "base", _configDescriptors.createCachedDescriptors, index, envName);
}
});
var loadFileChain = makeChainWalker({
init: function init(input) {
return validateFile(input);
},
root: function root(file) {
return loadFileDescriptors(file);
},
env: function env(file, envName) {
return loadFileEnvDescriptors(file)(envName);
},
overrides: function overrides(file, index) {
return loadFileOverridesDescriptors(file)(index);
},
overridesEnv: function overridesEnv(file, index, envName) {
return loadFileOverridesEnvDescriptors(file)(index)(envName);
}
});
var validateFile = (0, _caching.makeWeakCache)(function (file) {
return {
filepath: file.filepath,
dirname: file.dirname,
options: (0, _options.validate)("file", file.options)
};
});
var loadFileDescriptors = (0, _caching.makeWeakCache)(function (file) {
return buildRootDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors);
});
var loadFileEnvDescriptors = (0, _caching.makeWeakCache)(function (file) {
return (0, _caching.makeStrongCache)(function (envName) {
return buildEnvDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, envName);
});
});
var loadFileOverridesDescriptors = (0, _caching.makeWeakCache)(function (file) {
return (0, _caching.makeStrongCache)(function (index) {
return buildOverrideDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, index);
});
});
var loadFileOverridesEnvDescriptors = (0, _caching.makeWeakCache)(function (file) {
return (0, _caching.makeStrongCache)(function (index) {
return (0, _caching.makeStrongCache)(function (envName) {
return buildOverrideEnvDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, index, envName);
return pkgData.directories.some(directory => {
return matchPattern(pat, babelrcRootsDirectory, directory, context);
});
});
});
}
function buildRootDescriptors(_ref, alias, descriptors) {
var dirname = _ref.dirname,
options = _ref.options;
const validateConfigFile = (0, _caching.makeWeakCache)(file => ({
filepath: file.filepath,
dirname: file.dirname,
options: (0, _options.validate)("configfile", file.options)
}));
const validateBabelrcFile = (0, _caching.makeWeakCache)(file => ({
filepath: file.filepath,
dirname: file.dirname,
options: (0, _options.validate)("babelrcfile", file.options)
}));
const validateExtendFile = (0, _caching.makeWeakCache)(file => ({
filepath: file.filepath,
dirname: file.dirname,
options: (0, _options.validate)("extendsfile", file.options)
}));
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)
});
const loadFileChain = makeChainWalker({
root: file => loadFileDescriptors(file),
env: (file, envName) => loadFileEnvDescriptors(file)(envName),
overrides: (file, index) => loadFileOverridesDescriptors(file)(index),
overridesEnv: (file, index, envName) => loadFileOverridesEnvDescriptors(file)(index)(envName)
});
const loadFileDescriptors = (0, _caching.makeWeakCache)(file => buildRootDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors));
const loadFileEnvDescriptors = (0, _caching.makeWeakCache)(file => (0, _caching.makeStrongCache)(envName => buildEnvDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, envName)));
const loadFileOverridesDescriptors = (0, _caching.makeWeakCache)(file => (0, _caching.makeStrongCache)(index => buildOverrideDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, index)));
const loadFileOverridesEnvDescriptors = (0, _caching.makeWeakCache)(file => (0, _caching.makeStrongCache)(index => (0, _caching.makeStrongCache)(envName => buildOverrideEnvDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, index, envName))));
function buildRootDescriptors({
dirname,
options
}, alias, descriptors) {
return descriptors(dirname, options, alias);
}
function buildEnvDescriptors(_ref2, alias, descriptors, envName) {
var dirname = _ref2.dirname,
options = _ref2.options;
var opts = options.env && options.env[envName];
return opts ? descriptors(dirname, opts, alias + ".env[\"" + envName + "\"]") : null;
function buildEnvDescriptors({
dirname,
options
}, alias, descriptors, envName) {
const opts = options.env && options.env[envName];
return opts ? descriptors(dirname, opts, `${alias}.env["${envName}"]`) : null;
}
function buildOverrideDescriptors(_ref3, alias, descriptors, index) {
var dirname = _ref3.dirname,
options = _ref3.options;
var opts = options.overrides && options.overrides[index];
function buildOverrideDescriptors({
dirname,
options
}, alias, descriptors, index) {
const opts = options.overrides && options.overrides[index];
if (!opts) throw new Error("Assertion failure - missing override");
return descriptors(dirname, opts, alias + ".overrides[" + index + "]");
return descriptors(dirname, opts, `${alias}.overrides[${index}]`);
}
function buildOverrideEnvDescriptors(_ref4, alias, descriptors, index, envName) {
var dirname = _ref4.dirname,
options = _ref4.options;
var override = options.overrides && options.overrides[index];
function buildOverrideEnvDescriptors({
dirname,
options
}, alias, descriptors, index, envName) {
const override = options.overrides && options.overrides[index];
if (!override) throw new Error("Assertion failure - missing override");
var opts = override.env && override.env[envName];
return opts ? descriptors(dirname, opts, alias + ".overrides[" + index + "].env[\"" + envName + "\"]") : null;
const opts = override.env && override.env[envName];
return opts ? descriptors(dirname, opts, `${alias}.overrides[${index}].env["${envName}"]`) : null;
}
function makeChainWalker(_ref5) {
var init = _ref5.init,
root = _ref5.root,
env = _ref5.env,
overrides = _ref5.overrides,
overridesEnv = _ref5.overridesEnv;
return function (arg, context, files) {
if (files === void 0) {
files = new Set();
}
var input = init(arg);
var dirname = input.dirname;
var flattenedConfigs = [];
var rootOpts = root(input);
function makeChainWalker({
root,
env,
overrides,
overridesEnv
}) {
return (input, context, files = new Set()) => {
const {
dirname
} = input;
const flattenedConfigs = [];
const rootOpts = root(input);
if (configIsApplicable(rootOpts, dirname, context)) {
flattenedConfigs.push(rootOpts);
var envOpts = env(input, context.envName);
const envOpts = env(input, context.envName);
if (envOpts && configIsApplicable(envOpts, dirname, context)) {
flattenedConfigs.push(envOpts);
}
(rootOpts.options.overrides || []).forEach(function (_, index) {
var overrideOps = overrides(input, index);
(rootOpts.options.overrides || []).forEach((_, index) => {
const overrideOps = overrides(input, index);
if (configIsApplicable(overrideOps, dirname, context)) {
flattenedConfigs.push(overrideOps);
var overrideEnvOpts = overridesEnv(input, index, context.envName);
const overrideEnvOpts = overridesEnv(input, index, context.envName);
if (overrideEnvOpts && configIsApplicable(overrideEnvOpts, dirname, context)) {
flattenedConfigs.push(overrideEnvOpts);
@@ -303,20 +264,18 @@ function makeChainWalker(_ref5) {
});
}
if (flattenedConfigs.some(function (_ref6) {
var _ref6$options = _ref6.options,
ignore = _ref6$options.ignore,
only = _ref6$options.only;
return shouldIgnore(context, ignore, only, dirname);
})) {
if (flattenedConfigs.some(({
options: {
ignore,
only
}
}) => shouldIgnore(context, ignore, only, dirname))) {
return null;
}
var chain = emptyChain();
for (var _i = 0; _i < flattenedConfigs.length; _i++) {
var op = flattenedConfigs[_i];
const chain = emptyChain();
for (const op of flattenedConfigs) {
if (!mergeExtendsChain(chain, op.options, dirname, context, files)) {
return null;
}
@@ -330,16 +289,14 @@ function makeChainWalker(_ref5) {
function mergeExtendsChain(chain, opts, dirname, context, files) {
if (opts.extends === undefined) return true;
var file = (0, _files.loadConfig)(opts.extends, dirname, context.envName);
const file = (0, _files.loadConfig)(opts.extends, dirname, context.envName, context.caller);
if (files.has(file)) {
throw new Error("Configuration cycle detected loading " + file.filepath + ".\n" + "File already loaded following the config chain:\n" + Array.from(files, function (file) {
return " - " + file.filepath;
}).join("\n"));
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"));
}
files.add(file);
var fileChain = loadFileChain(file, context, files);
const fileChain = loadFileChain(validateExtendFile(file), context, files);
files.delete(file);
if (!fileChain) return false;
mergeChain(chain, fileChain);
@@ -347,29 +304,20 @@ function mergeExtendsChain(chain, opts, dirname, context, files) {
}
function mergeChain(target, source) {
var _target$options, _target$plugins, _target$presets;
(_target$options = target.options).push.apply(_target$options, source.options);
(_target$plugins = target.plugins).push.apply(_target$plugins, source.plugins);
(_target$presets = target.presets).push.apply(_target$presets, source.presets);
target.options.push(...source.options);
target.plugins.push(...source.plugins);
target.presets.push(...source.presets);
return target;
}
function mergeChainOpts(target, _ref7) {
var _target$plugins2, _target$presets2;
var options = _ref7.options,
plugins = _ref7.plugins,
presets = _ref7.presets;
function mergeChainOpts(target, {
options,
plugins,
presets
}) {
target.options.push(options);
(_target$plugins2 = target.plugins).push.apply(_target$plugins2, plugins());
(_target$presets2 = target.presets).push.apply(_target$presets2, presets());
target.plugins.push(...plugins());
target.presets.push(...presets());
return target;
}
@@ -382,16 +330,20 @@ function emptyChain() {
}
function normalizeOptions(opts) {
var options = Object.assign({}, opts);
const options = Object.assign({}, opts);
delete options.extends;
delete options.env;
delete options.overrides;
delete options.plugins;
delete options.presets;
delete options.passPerPreset;
delete options.ignore;
delete options.only;
delete options.test;
delete options.include;
delete options.exclude;
if (options.sourceMap) {
if (options.hasOwnProperty("sourceMap")) {
options.sourceMaps = options.sourceMap;
delete options.sourceMap;
}
@@ -400,44 +352,27 @@ function normalizeOptions(opts) {
}
function dedupDescriptors(items) {
var map = new Map();
var descriptors = [];
for (var _iterator = items, _isArray = Array.isArray(_iterator), _i2 = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
var _ref8;
if (_isArray) {
if (_i2 >= _iterator.length) break;
_ref8 = _iterator[_i2++];
} else {
_i2 = _iterator.next();
if (_i2.done) break;
_ref8 = _i2.value;
}
var item = _ref8;
const map = new Map();
const descriptors = [];
for (const item of items) {
if (typeof item.value === "function") {
var fnKey = item.value;
var nameMap = map.get(fnKey);
const fnKey = item.value;
let nameMap = map.get(fnKey);
if (!nameMap) {
nameMap = new Map();
map.set(fnKey, nameMap);
}
var desc = nameMap.get(item.name);
let desc = nameMap.get(item.name);
if (!desc) {
desc = {
value: null
value: item
};
descriptors.push(desc);
if (!item.ownPass) nameMap.set(item.name, desc);
}
if (item.options === false) {
desc.value = null;
} else {
desc.value = item;
}
@@ -448,111 +383,57 @@ function dedupDescriptors(items) {
}
}
return descriptors.reduce(function (acc, desc) {
if (desc.value) acc.push(desc.value);
return descriptors.reduce((acc, desc) => {
acc.push(desc.value);
return acc;
}, []);
}
function configIsApplicable(_ref9, dirname, context) {
var options = _ref9.options;
function configIsApplicable({
options
}, dirname, context) {
return (options.test === undefined || configFieldIsApplicable(context, options.test, dirname)) && (options.include === undefined || configFieldIsApplicable(context, options.include, dirname)) && (options.exclude === undefined || !configFieldIsApplicable(context, options.exclude, dirname));
}
function configFieldIsApplicable(context, test, dirname) {
if (context.filename === null) {
throw new Error("Configuration contains explicit test/include/exclude checks, but no filename was passed to Babel");
}
var ctx = context;
var patterns = Array.isArray(test) ? test : [test];
return matchesPatterns(ctx, patterns, dirname, false);
const patterns = Array.isArray(test) ? test : [test];
return matchesPatterns(context, patterns, dirname);
}
function shouldIgnore(context, ignore, only, dirname) {
if (ignore) {
if (context.filename === null) {
throw new Error("Configuration contains ignore checks, but no filename was passed to Babel");
}
var ctx = context;
if (matchesPatterns(ctx, ignore, dirname)) {
debug("Ignored %o because it matched one of %O from %o", context.filename, ignore, dirname);
return true;
}
if (ignore && matchesPatterns(context, ignore, dirname)) {
debug("Ignored %o because it matched one of %O from %o", context.filename, ignore, dirname);
return true;
}
if (only) {
if (context.filename === null) {
throw new Error("Configuration contains ignore checks, but no filename was passed to Babel");
}
var _ctx = context;
if (!matchesPatterns(_ctx, only, dirname)) {
debug("Ignored %o because it failed to match one of %O from %o", context.filename, only, dirname);
return true;
}
if (only && !matchesPatterns(context, only, dirname)) {
debug("Ignored %o because it failed to match one of %O from %o", context.filename, only, dirname);
return true;
}
return false;
}
function matchesPatterns(context, patterns, dirname, allowNegation) {
if (allowNegation === void 0) {
allowNegation = true;
}
function matchesPatterns(context, patterns, dirname) {
return patterns.some(pattern => matchPattern(pattern, dirname, context.filename, context));
}
var res = [];
var strings = [];
var fns = [];
patterns.forEach(function (pattern) {
if (typeof pattern === "string") strings.push(pattern);else if (typeof pattern === "function") fns.push(pattern);else res.push(pattern);
});
var filename = context.filename;
if (res.some(function (re) {
return re.test(context.filename);
})) return true;
if (fns.some(function (fn) {
return fn(filename);
})) return true;
if (strings.length > 0) {
var possibleDirs = getPossibleDirs(context);
var absolutePatterns = strings.map(function (pattern) {
var negate = pattern[0] === "!";
if (negate && !allowNegation) {
throw new Error("Negation of file paths is not supported.");
}
if (negate) pattern = pattern.slice(1);
return (negate ? "!" : "") + _path().default.resolve(dirname, pattern);
function matchPattern(pattern, dirname, pathToTest, context) {
if (typeof pattern === "function") {
return !!pattern(pathToTest, {
dirname,
envName: context.envName,
caller: context.caller
});
if ((0, _micromatch().default)(possibleDirs, absolutePatterns, {
nocase: true,
nonegate: !allowNegation
}).length > 0) {
return true;
}
}
return false;
}
var getPossibleDirs = (0, _caching.makeWeakCache)(function (context) {
var current = context.filename;
if (current === null) return [];
var possibleDirs = [current];
while (true) {
var previous = current;
current = _path().default.dirname(current);
if (previous === current) break;
possibleDirs.push(current);
if (typeof pathToTest !== "string") {
throw new Error(`Configuration contains string/RegExp pattern, but no filename was passed to Babel`);
}
return possibleDirs;
});
if (typeof pattern === "string") {
pattern = (0, _patternToRegex.default)(pattern, dirname);
}
return pattern.test(pathToTest);
}

213
node_modules/@babel/core/lib/config/config-descriptors.js generated vendored
View File

@@ -13,85 +13,89 @@ var _item = require("./item");
var _caching = require("./caching");
function isEqualDescriptor(a, b) {
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);
}
function createCachedDescriptors(dirname, options, alias) {
var plugins = options.plugins,
presets = options.presets,
passPerPreset = options.passPerPreset;
const {
plugins,
presets,
passPerPreset
} = options;
return {
options: options,
plugins: plugins ? function () {
return createCachedPluginDescriptors(plugins, dirname)(alias);
} : function () {
return [];
},
presets: presets ? function () {
return createCachedPresetDescriptors(presets, dirname)(alias)(!!passPerPreset);
} : function () {
return [];
}
options,
plugins: plugins ? () => createCachedPluginDescriptors(plugins, dirname)(alias) : () => [],
presets: presets ? () => createCachedPresetDescriptors(presets, dirname)(alias)(!!passPerPreset) : () => []
};
}
function createUncachedDescriptors(dirname, options, alias) {
var plugins;
var presets;
let plugins;
let presets;
return {
options: options,
plugins: function (_plugins) {
function plugins() {
return _plugins.apply(this, arguments);
}
plugins.toString = function () {
return _plugins.toString();
};
return plugins;
}(function () {
options,
plugins: () => {
if (!plugins) {
plugins = createPluginDescriptors(options.plugins || [], dirname, alias);
}
return plugins;
}),
presets: function (_presets) {
function presets() {
return _presets.apply(this, arguments);
}
presets.toString = function () {
return _presets.toString();
};
return presets;
}(function () {
},
presets: () => {
if (!presets) {
presets = createPresetDescriptors(options.presets || [], dirname, alias, !!options.passPerPreset);
}
return presets;
})
}
};
}
var createCachedPresetDescriptors = (0, _caching.makeWeakCache)(function (items, cache) {
var dirname = cache.using(function (dir) {
return dir;
});
return (0, _caching.makeStrongCache)(function (alias) {
return (0, _caching.makeStrongCache)(function (passPerPreset) {
return createPresetDescriptors(items, dirname, alias, passPerPreset);
});
});
const PRESET_DESCRIPTOR_CACHE = new WeakMap();
const createCachedPresetDescriptors = (0, _caching.makeWeakCache)((items, cache) => {
const dirname = cache.using(dir => dir);
return (0, _caching.makeStrongCache)(alias => (0, _caching.makeStrongCache)(passPerPreset => createPresetDescriptors(items, dirname, alias, passPerPreset).map(desc => loadCachedDescriptor(PRESET_DESCRIPTOR_CACHE, desc))));
});
var createCachedPluginDescriptors = (0, _caching.makeWeakCache)(function (items, cache) {
var dirname = cache.using(function (dir) {
return dir;
});
return (0, _caching.makeStrongCache)(function (alias) {
return createPluginDescriptors(items, dirname, alias);
});
const PLUGIN_DESCRIPTOR_CACHE = new WeakMap();
const createCachedPluginDescriptors = (0, _caching.makeWeakCache)((items, cache) => {
const dirname = cache.using(dir => dir);
return (0, _caching.makeStrongCache)(alias => createPluginDescriptors(items, dirname, alias).map(desc => loadCachedDescriptor(PLUGIN_DESCRIPTOR_CACHE, desc)));
});
const DEFAULT_OPTIONS = {};
function loadCachedDescriptor(cache, desc) {
const {
value,
options = DEFAULT_OPTIONS
} = desc;
if (options === false) return desc;
let cacheByOptions = cache.get(value);
if (!cacheByOptions) {
cacheByOptions = new WeakMap();
cache.set(value, cacheByOptions);
}
let possibilities = cacheByOptions.get(options);
if (!possibilities) {
possibilities = [];
cacheByOptions.set(options, possibilities);
}
if (possibilities.indexOf(desc) === -1) {
const matches = possibilities.filter(possibility => isEqualDescriptor(possibility, desc));
if (matches.length > 0) {
return matches[0];
}
possibilities.push(desc);
}
return desc;
}
function createPresetDescriptors(items, dirname, alias, passPerPreset) {
return createDescriptors("preset", items, dirname, alias, passPerPreset);
@@ -102,67 +106,60 @@ function createPluginDescriptors(items, dirname, alias) {
}
function createDescriptors(type, items, dirname, alias, ownPass) {
var descriptors = items.map(function (item, index) {
return createDescriptor(item, dirname, {
type: type,
alias: alias + "$" + index,
ownPass: !!ownPass
});
});
const descriptors = items.map((item, index) => createDescriptor(item, dirname, {
type,
alias: `${alias}$${index}`,
ownPass: !!ownPass
}));
assertNoDuplicates(descriptors);
return descriptors;
}
function createDescriptor(pair, dirname, _ref) {
var type = _ref.type,
alias = _ref.alias,
ownPass = _ref.ownPass;
var desc = (0, _item.getItemDescriptor)(pair);
function createDescriptor(pair, dirname, {
type,
alias,
ownPass
}) {
const desc = (0, _item.getItemDescriptor)(pair);
if (desc) {
return desc;
}
var name;
var options;
var value = pair;
let name;
let options;
let value = pair;
if (Array.isArray(value)) {
if (value.length === 3) {
var _value = value;
value = _value[0];
options = _value[1];
name = _value[2];
[value, options, name] = value;
} else {
var _value2 = value;
value = _value2[0];
options = _value2[1];
[value, options] = value;
}
}
var file = undefined;
var filepath = null;
let file = undefined;
let filepath = null;
if (typeof value === "string") {
if (typeof type !== "string") {
throw new Error("To resolve a string-based item, the type of item must be given");
}
var resolver = type === "plugin" ? _files.loadPlugin : _files.loadPreset;
var _request = value;
var _resolver = resolver(value, dirname);
filepath = _resolver.filepath;
value = _resolver.value;
const resolver = type === "plugin" ? _files.loadPlugin : _files.loadPreset;
const request = value;
({
filepath,
value
} = resolver(value, dirname));
file = {
request: _request,
request,
resolved: filepath
};
}
if (!value) {
throw new Error("Unexpected falsy value: " + String(value));
throw new Error(`Unexpected falsy value: ${String(value)}`);
}
if (typeof value === "object" && value.__esModule) {
@@ -174,42 +171,30 @@ function createDescriptor(pair, dirname, _ref) {
}
if (typeof value !== "object" && typeof value !== "function") {
throw new Error("Unsupported format: " + typeof value + ". Expected an object or a function.");
throw new Error(`Unsupported format: ${typeof value}. Expected an object or a function.`);
}
if (filepath !== null && typeof value === "object" && value) {
throw new Error("Plugin/Preset files are not allowed to export objects, only functions. In " + filepath);
throw new Error(`Plugin/Preset files are not allowed to export objects, only functions. In ${filepath}`);
}
return {
name: name,
name,
alias: filepath || alias,
value: value,
options: options,
dirname: dirname,
ownPass: ownPass,
file: file
value,
options,
dirname,
ownPass,
file
};
}
function assertNoDuplicates(items) {
var map = new Map();
const map = new Map();
for (var _iterator = items, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
var _ref2;
if (_isArray) {
if (_i >= _iterator.length) break;
_ref2 = _iterator[_i++];
} else {
_i = _iterator.next();
if (_i.done) break;
_ref2 = _i.value;
}
var item = _ref2;
for (const item of items) {
if (typeof item.value !== "function") continue;
var nameMap = map.get(item.value);
let nameMap = map.get(item.value);
if (!nameMap) {
nameMap = new Set();
@@ -217,7 +202,7 @@ function assertNoDuplicates(items) {
}
if (nameMap.has(item.name)) {
throw new Error(["Duplicate plugin/preset detected.", "If you'd like to use two separate instances of a plugin,", "they neen separate names, e.g.", "", " plugins: [", " ['some-plugin', {}],", " ['some-plugin', {}, 'some unique name'],", " ]"].join("\n"));
throw new Error([`Duplicate plugin/preset detected.`, `If you'd like to use two separate instances of a plugin,`, `they need separate names, e.g.`, ``, ` plugins: [`, ` ['some-plugin', {}],`, ` ['some-plugin', {}, 'some unique name'],`, ` ]`].join("\n"));
}
nameMap.add(item.name);

212
node_modules/@babel/core/lib/config/files/configuration.js generated vendored
View File

@@ -3,14 +3,15 @@
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.findConfigUpwards = findConfigUpwards;
exports.findRelativeConfig = findRelativeConfig;
exports.findRootConfig = findRootConfig;
exports.loadConfig = loadConfig;
function _debug() {
var data = _interopRequireDefault(require("debug"));
const data = _interopRequireDefault(require("debug"));
_debug = function _debug() {
_debug = function () {
return data;
};
@@ -18,9 +19,9 @@ function _debug() {
}
function _path() {
var data = _interopRequireDefault(require("path"));
const data = _interopRequireDefault(require("path"));
_path = function _path() {
_path = function () {
return data;
};
@@ -28,9 +29,9 @@ function _path() {
}
function _fs() {
var data = _interopRequireDefault(require("fs"));
const data = _interopRequireDefault(require("fs"));
_fs = function _fs() {
_fs = function () {
return data;
};
@@ -38,9 +39,9 @@ function _fs() {
}
function _json() {
var data = _interopRequireDefault(require("json5"));
const data = _interopRequireDefault(require("json5"));
_json = function _json() {
_json = function () {
return data;
};
@@ -48,9 +49,9 @@ function _json() {
}
function _resolve() {
var data = _interopRequireDefault(require("resolve"));
const data = _interopRequireDefault(require("resolve"));
_resolve = function _resolve() {
_resolve = function () {
return data;
};
@@ -63,49 +64,57 @@ var _configApi = _interopRequireDefault(require("../helpers/config-api"));
var _utils = require("./utils");
var _patternToRegex = _interopRequireDefault(require("../pattern-to-regex"));
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
var debug = (0, _debug().default)("babel:config:loading:files:configuration");
var BABEL_CONFIG_JS_FILENAME = "babel.config.js";
var BABELRC_FILENAME = ".babelrc";
var BABELRC_JS_FILENAME = ".babelrc.js";
var BABELIGNORE_FILENAME = ".babelignore";
const debug = (0, _debug().default)("babel:config:loading:files:configuration");
const BABEL_CONFIG_JS_FILENAME = "babel.config.js";
const BABELRC_FILENAME = ".babelrc";
const BABELRC_JS_FILENAME = ".babelrc.js";
const BABELIGNORE_FILENAME = ".babelignore";
function findRelativeConfig(packageData, envName) {
var config = null;
var ignore = null;
function findConfigUpwards(rootDir) {
let dirname = rootDir;
var dirname = _path().default.dirname(packageData.filepath);
var _loop = function _loop() {
if (_isArray) {
if (_i >= _iterator.length) return "break";
_ref = _iterator[_i++];
} else {
_i = _iterator.next();
if (_i.done) return "break";
_ref = _i.value;
while (true) {
if (_fs().default.existsSync(_path().default.join(dirname, BABEL_CONFIG_JS_FILENAME))) {
return dirname;
}
var loc = _ref;
const nextDir = _path().default.dirname(dirname);
if (dirname === nextDir) break;
dirname = nextDir;
}
return null;
}
function findRelativeConfig(packageData, envName, caller) {
let config = null;
let ignore = null;
const dirname = _path().default.dirname(packageData.filepath);
for (const loc of packageData.directories) {
if (!config) {
config = [BABELRC_FILENAME, BABELRC_JS_FILENAME].reduce(function (previousConfig, name) {
var filepath = _path().default.join(loc, name);
config = [BABELRC_FILENAME, BABELRC_JS_FILENAME].reduce((previousConfig, name) => {
const filepath = _path().default.join(loc, name);
var config = readConfig(filepath, envName);
const config = readConfig(filepath, envName, caller);
if (config && previousConfig) {
throw new Error("Multiple configuration files found. Please remove one:\n" + (" - " + _path().default.basename(previousConfig.filepath) + "\n") + (" - " + name + "\n") + ("from " + loc));
throw new Error(`Multiple configuration files found. Please remove one:\n` + ` - ${_path().default.basename(previousConfig.filepath)}\n` + ` - ${name}\n` + `from ${loc}`);
}
return config || previousConfig;
}, null);
var pkgConfig = packageData.pkg && packageData.pkg.dirname === loc ? packageToBabelConfig(packageData.pkg) : null;
const pkgConfig = packageData.pkg && packageData.pkg.dirname === loc ? packageToBabelConfig(packageData.pkg) : null;
if (pkgConfig) {
if (config) {
throw new Error("Multiple configuration files found. Please remove one:\n" + (" - " + _path().default.basename(pkgConfig.filepath) + "#babel\n") + (" - " + _path().default.basename(config.filepath) + "\n") + ("from " + loc));
throw new Error(`Multiple configuration files found. Please remove one:\n` + ` - ${_path().default.basename(pkgConfig.filepath)}#babel\n` + ` - ${_path().default.basename(config.filepath)}\n` + `from ${loc}`);
}
config = pkgConfig;
@@ -117,7 +126,7 @@ function findRelativeConfig(packageData, envName) {
}
if (!ignore) {
var ignoreLoc = _path().default.join(loc, BABELIGNORE_FILENAME);
const ignoreLoc = _path().default.join(loc, BABELIGNORE_FILENAME);
ignore = readIgnoreConfig(ignoreLoc);
@@ -125,26 +134,18 @@ function findRelativeConfig(packageData, envName) {
debug("Found ignore %o from %o.", ignore.filepath, dirname);
}
}
};
for (var _iterator = packageData.directories, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
var _ref;
var _ret = _loop();
if (_ret === "break") break;
}
return {
config: config,
ignore: ignore
config,
ignore
};
}
function findRootConfig(dirname, envName) {
var filepath = _path().default.resolve(dirname, BABEL_CONFIG_JS_FILENAME);
function findRootConfig(dirname, envName, caller) {
const filepath = _path().default.resolve(dirname, BABEL_CONFIG_JS_FILENAME);
var conf = readConfig(filepath, envName);
const conf = readConfig(filepath, envName, caller);
if (conf) {
debug("Found root config %o in $o.", BABEL_CONFIG_JS_FILENAME, dirname);
@@ -153,29 +154,30 @@ function findRootConfig(dirname, envName) {
return conf;
}
function loadConfig(name, dirname, envName) {
var filepath = _resolve().default.sync(name, {
function loadConfig(name, dirname, envName, caller) {
const filepath = _resolve().default.sync(name, {
basedir: dirname
});
var conf = readConfig(filepath, envName);
const conf = readConfig(filepath, envName, caller);
if (!conf) {
throw new Error("Config file " + filepath + " contains no configuration data");
throw new Error(`Config file ${filepath} contains no configuration data`);
}
debug("Loaded config %o from $o.", name, dirname);
return conf;
}
function readConfig(filepath, envName) {
function readConfig(filepath, envName, caller) {
return _path().default.extname(filepath) === ".js" ? readConfigJS(filepath, {
envName: envName
envName,
caller
}) : readConfigJSON5(filepath);
}
var LOADING_CONFIGS = new Set();
var readConfigJS = (0, _caching.makeStrongCache)(function (filepath, cache) {
const LOADING_CONFIGS = new Set();
const readConfigJS = (0, _caching.makeStrongCache)((filepath, cache) => {
if (!_fs().default.existsSync(filepath)) {
cache.forever();
return null;
@@ -185,22 +187,22 @@ var readConfigJS = (0, _caching.makeStrongCache)(function (filepath, cache) {
cache.never();
debug("Auto-ignoring usage of config %o.", filepath);
return {
filepath: filepath,
filepath,
dirname: _path().default.dirname(filepath),
options: {}
};
}
var options;
let options;
try {
LOADING_CONFIGS.add(filepath);
var configModule = require(filepath);
const configModule = require(filepath);
options = configModule && configModule.__esModule ? configModule.default || undefined : configModule;
} catch (err) {
err.message = filepath + ": Error while loading config - " + err.message;
err.message = `${filepath}: Error while loading config - ${err.message}`;
throw err;
} finally {
LOADING_CONFIGS.delete(filepath);
@@ -212,25 +214,25 @@ var readConfigJS = (0, _caching.makeStrongCache)(function (filepath, cache) {
}
if (!options || typeof options !== "object" || Array.isArray(options)) {
throw new Error(filepath + ": Configuration should be an exported JavaScript object.");
throw new Error(`${filepath}: Configuration should be an exported JavaScript object.`);
}
if (typeof options.then === "function") {
throw new Error("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.");
throw new Error(`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.`);
}
return {
filepath: filepath,
filepath,
dirname: _path().default.dirname(filepath),
options: options
options
};
});
var packageToBabelConfig = (0, _caching.makeWeakCache)(function (file) {
if (typeof file.options.babel === "undefined") return null;
var babel = file.options.babel;
const packageToBabelConfig = (0, _caching.makeWeakCache)(file => {
const babel = file.options["babel"];
if (typeof babel === "undefined") return null;
if (typeof babel !== "object" || Array.isArray(babel) || babel === null) {
throw new Error(file.filepath + ": .babel property must be an object");
throw new Error(`${file.filepath}: .babel property must be an object`);
}
return {
@@ -239,45 +241,83 @@ var packageToBabelConfig = (0, _caching.makeWeakCache)(function (file) {
options: babel
};
});
var readConfigJSON5 = (0, _utils.makeStaticFileCache)(function (filepath, content) {
var options;
const readConfigJSON5 = (0, _utils.makeStaticFileCache)((filepath, content) => {
let options;
try {
options = _json().default.parse(content);
} catch (err) {
err.message = filepath + ": Error while parsing config - " + err.message;
err.message = `${filepath}: Error while parsing config - ${err.message}`;
throw err;
}
if (!options) throw new Error(filepath + ": No config detected");
if (!options) throw new Error(`${filepath}: No config detected`);
if (typeof options !== "object") {
throw new Error(filepath + ": Config returned typeof " + typeof options);
throw new Error(`${filepath}: Config returned typeof ${typeof options}`);
}
if (Array.isArray(options)) {
throw new Error(filepath + ": Expected config object but found array");
throw new Error(`${filepath}: Expected config object but found array`);
}
return {
filepath: filepath,
filepath,
dirname: _path().default.dirname(filepath),
options: options
options
};
});
var readIgnoreConfig = (0, _utils.makeStaticFileCache)(function (filepath, content) {
var ignore = content.split("\n").map(function (line) {
return line.replace(/#(.*?)$/, "").trim();
}).filter(function (line) {
return !!line;
});
const readIgnoreConfig = (0, _utils.makeStaticFileCache)((filepath, content) => {
const ignoreDir = _path().default.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 Error(`Negation of file paths is not supported.`);
}
}
return {
filepath: filepath,
filepath,
dirname: _path().default.dirname(filepath),
ignore: ignore
ignore: ignorePatterns.map(pattern => (0, _patternToRegex.default)(pattern, ignoreDir))
};
});
function throwConfigError() {
throw new Error("Caching was left unconfigured. Babel's plugins, presets, and .babelrc.js files can be configured\nfor various types of caching, using the first param of their handler functions:\n\nmodule.exports = function(api) {\n // The API exposes the following:\n\n // Cache the returned value forever and don't call this function again.\n api.cache(true);\n\n // Don't cache at all. Not recommended because it will be very slow.\n api.cache(false);\n\n // Cached based on the value of some function. If this function returns a value different from\n // a previously-encountered value, the plugins will re-evaluate.\n var env = api.cache(() => process.env.NODE_ENV);\n\n // If testing for a specific env, we recommend specifics to avoid instantiating a plugin for\n // any possible NODE_ENV value that might come up during plugin execution.\n var isProd = api.cache(() => process.env.NODE_ENV === \"production\");\n\n // .cache(fn) will perform a linear search though instances to find the matching plugin based\n // based on previous instantiated plugins. If you want to recreate the plugin and discard the\n // previous instance whenever something changes, you may use:\n var isProd = api.cache.invalidate(() => process.env.NODE_ENV === \"production\");\n\n // Note, we also expose the following more-verbose versions of the above examples:\n api.cache.forever(); // api.cache(true)\n api.cache.never(); // api.cache(false)\n api.cache.using(fn); // api.cache(fn)\n\n // Return the value that will be cached.\n return { };\n};");
throw new Error(`\
Caching was left unconfigured. Babel's plugins, presets, and .babelrc.js files can be configured
for various types of caching, using the first param of their handler functions:
module.exports = function(api) {
// The API exposes the following:
// Cache the returned value forever and don't call this function again.
api.cache(true);
// Don't cache at all. Not recommended because it will be very slow.
api.cache(false);
// Cached based on the value of some function. If this function returns a value different from
// a previously-encountered value, the plugins will re-evaluate.
var env = api.cache(() => process.env.NODE_ENV);
// If testing for a specific env, we recommend specifics to avoid instantiating a plugin for
// any possible NODE_ENV value that might come up during plugin execution.
var isProd = api.cache(() => process.env.NODE_ENV === "production");
// .cache(fn) will perform a linear search though instances to find the matching plugin based
// based on previous instantiated plugins. If you want to recreate the plugin and discard the
// previous instance whenever something changes, you may use:
var isProd = api.cache.invalidate(() => process.env.NODE_ENV === "production");
// Note, we also expose the following more-verbose versions of the above examples:
api.cache.forever(); // api.cache(true)
api.cache.never(); // api.cache(false)
api.cache.using(fn); // api.cache(fn)
// Return the value that will be cached.
return { };
};`);
}

19
node_modules/@babel/core/lib/config/files/index-browser.js generated vendored
View File

@@ -3,6 +3,7 @@
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.findConfigUpwards = findConfigUpwards;
exports.findPackageData = findPackageData;
exports.findRelativeConfig = findRelativeConfig;
exports.findRootConfig = findRootConfig;
@@ -12,16 +13,20 @@ exports.resolvePreset = resolvePreset;
exports.loadPlugin = loadPlugin;
exports.loadPreset = loadPreset;
function findConfigUpwards(rootDir) {
return null;
}
function findPackageData(filepath) {
return {
filepath: filepath,
filepath,
directories: [],
pkg: null,
isPackage: false
};
}
function findRelativeConfig(pkgData, envName) {
function findRelativeConfig(pkgData, envName, caller) {
return {
pkg: null,
config: null,
@@ -29,12 +34,12 @@ function findRelativeConfig(pkgData, envName) {
};
}
function findRootConfig(dirname, envName) {
function findRootConfig(dirname, envName, caller) {
return null;
}
function loadConfig(name, dirname, envName) {
throw new Error("Cannot load " + name + " relative to " + dirname + " in a browser");
function loadConfig(name, dirname, envName, caller) {
throw new Error(`Cannot load ${name} relative to ${dirname} in a browser`);
}
function resolvePlugin(name, dirname) {
@@ -46,9 +51,9 @@ function resolvePreset(name, dirname) {
}
function loadPlugin(name, dirname) {
throw new Error("Cannot load plugin " + name + " relative to " + dirname + " in a browser");
throw new Error(`Cannot load plugin ${name} relative to ${dirname} in a browser`);
}
function loadPreset(name, dirname) {
throw new Error("Cannot load preset " + name + " relative to " + dirname + " in a browser");
throw new Error(`Cannot load preset ${name} relative to ${dirname} in a browser`);
}

22
node_modules/@babel/core/lib/config/files/index.js generated vendored
View File

@@ -5,49 +5,55 @@ Object.defineProperty(exports, "__esModule", {
});
Object.defineProperty(exports, "findPackageData", {
enumerable: true,
get: function get() {
get: function () {
return _package.findPackageData;
}
});
Object.defineProperty(exports, "findConfigUpwards", {
enumerable: true,
get: function () {
return _configuration.findConfigUpwards;
}
});
Object.defineProperty(exports, "findRelativeConfig", {
enumerable: true,
get: function get() {
get: function () {
return _configuration.findRelativeConfig;
}
});
Object.defineProperty(exports, "findRootConfig", {
enumerable: true,
get: function get() {
get: function () {
return _configuration.findRootConfig;
}
});
Object.defineProperty(exports, "loadConfig", {
enumerable: true,
get: function get() {
get: function () {
return _configuration.loadConfig;
}
});
Object.defineProperty(exports, "resolvePlugin", {
enumerable: true,
get: function get() {
get: function () {
return _plugins.resolvePlugin;
}
});
Object.defineProperty(exports, "resolvePreset", {
enumerable: true,
get: function get() {
get: function () {
return _plugins.resolvePreset;
}
});
Object.defineProperty(exports, "loadPlugin", {
enumerable: true,
get: function get() {
get: function () {
return _plugins.loadPlugin;
}
});
Object.defineProperty(exports, "loadPreset", {
enumerable: true,
get: function get() {
get: function () {
return _plugins.loadPreset;
}
});

38
node_modules/@babel/core/lib/config/files/package.js generated vendored
View File

@@ -6,9 +6,9 @@ Object.defineProperty(exports, "__esModule", {
exports.findPackageData = findPackageData;
function _path() {
var data = _interopRequireDefault(require("path"));
const data = _interopRequireDefault(require("path"));
_path = function _path() {
_path = function () {
return data;
};
@@ -19,20 +19,20 @@ var _utils = require("./utils");
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
var PACKAGE_FILENAME = "package.json";
const PACKAGE_FILENAME = "package.json";
function findPackageData(filepath) {
var pkg = null;
var directories = [];
var isPackage = true;
let pkg = null;
const directories = [];
let isPackage = true;
var dirname = _path().default.dirname(filepath);
let dirname = _path().default.dirname(filepath);
while (!pkg && _path().default.basename(dirname) !== "node_modules") {
directories.push(dirname);
pkg = readConfigPackage(_path().default.join(dirname, PACKAGE_FILENAME));
var nextLoc = _path().default.dirname(dirname);
const nextLoc = _path().default.dirname(dirname);
if (dirname === nextLoc) {
isPackage = false;
@@ -43,34 +43,34 @@ function findPackageData(filepath) {
}
return {
filepath: filepath,
directories: directories,
pkg: pkg,
isPackage: isPackage
filepath,
directories,
pkg,
isPackage
};
}
var readConfigPackage = (0, _utils.makeStaticFileCache)(function (filepath, content) {
var options;
const readConfigPackage = (0, _utils.makeStaticFileCache)((filepath, content) => {
let options;
try {
options = JSON.parse(content);
} catch (err) {
err.message = filepath + ": Error while parsing JSON - " + err.message;
err.message = `${filepath}: Error while parsing JSON - ${err.message}`;
throw err;
}
if (typeof options !== "object") {
throw new Error(filepath + ": Config returned typeof " + typeof options);
throw new Error(`${filepath}: Config returned typeof ${typeof options}`);
}
if (Array.isArray(options)) {
throw new Error(filepath + ": Expected config object but found array");
throw new Error(`${filepath}: Expected config object but found array`);
}
return {
filepath: filepath,
filepath,
dirname: _path().default.dirname(filepath),
options: options
options
};
});

79
node_modules/@babel/core/lib/config/files/plugins.js generated vendored
View File

@@ -9,9 +9,9 @@ exports.loadPlugin = loadPlugin;
exports.loadPreset = loadPreset;
function _debug() {
var data = _interopRequireDefault(require("debug"));
const data = _interopRequireDefault(require("debug"));
_debug = function _debug() {
_debug = function () {
return data;
};
@@ -19,9 +19,9 @@ function _debug() {
}
function _resolve() {
var data = _interopRequireDefault(require("resolve"));
const data = _interopRequireDefault(require("resolve"));
_resolve = function _resolve() {
_resolve = function () {
return data;
};
@@ -29,9 +29,9 @@ function _resolve() {
}
function _path() {
var data = _interopRequireDefault(require("path"));
const data = _interopRequireDefault(require("path"));
_path = function _path() {
_path = function () {
return data;
};
@@ -40,14 +40,15 @@ function _path() {
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
var debug = (0, _debug().default)("babel:config:loading:files:plugins");
var EXACT_RE = /^module:/;
var BABEL_PLUGIN_PREFIX_RE = /^(?!@|module:|[^/]+\/|babel-plugin-)/;
var BABEL_PRESET_PREFIX_RE = /^(?!@|module:|[^/]+\/|babel-preset-)/;
var BABEL_PLUGIN_ORG_RE = /^(@babel\/)(?!plugin-|[^/]+\/)/;
var BABEL_PRESET_ORG_RE = /^(@babel\/)(?!preset-|[^/]+\/)/;
var OTHER_PLUGIN_ORG_RE = /^(@(?!babel\/)[^/]+\/)(?!babel-plugin-|[^/]+\/)/;
var OTHER_PRESET_ORG_RE = /^(@(?!babel\/)[^/]+\/)(?!babel-preset-|[^/]+\/)/;
const debug = (0, _debug().default)("babel:config:loading:files:plugins");
const EXACT_RE = /^module:/;
const BABEL_PLUGIN_PREFIX_RE = /^(?!@|module:|[^/]+\/|babel-plugin-)/;
const BABEL_PRESET_PREFIX_RE = /^(?!@|module:|[^/]+\/|babel-preset-)/;
const BABEL_PLUGIN_ORG_RE = /^(@babel\/)(?!plugin-|[^/]+\/)/;
const BABEL_PRESET_ORG_RE = /^(@babel\/)(?!preset-|[^/]+\/)/;
const OTHER_PLUGIN_ORG_RE = /^(@(?!babel\/)[^/]+\/)(?![^/]*babel-plugin(?:-|\/|$)|[^/]+\/)/;
const OTHER_PRESET_ORG_RE = /^(@(?!babel\/)[^/]+\/)(?![^/]*babel-preset(?:-|\/|$)|[^/]+\/)/;
const OTHER_ORG_DEFAULT_RE = /^(@(?!babel$)[^/]+)$/;
function resolvePlugin(name, dirname) {
return resolveStandardizedName("plugin", name, dirname);
@@ -58,47 +59,43 @@ function resolvePreset(name, dirname) {
}
function loadPlugin(name, dirname) {
var filepath = resolvePlugin(name, dirname);
const filepath = resolvePlugin(name, dirname);
if (!filepath) {
throw new Error("Plugin " + name + " not found relative to " + dirname);
throw new Error(`Plugin ${name} not found relative to ${dirname}`);
}
var value = requireModule("plugin", filepath);
const value = requireModule("plugin", filepath);
debug("Loaded plugin %o from %o.", name, dirname);
return {
filepath: filepath,
value: value
filepath,
value
};
}
function loadPreset(name, dirname) {
var filepath = resolvePreset(name, dirname);
const filepath = resolvePreset(name, dirname);
if (!filepath) {
throw new Error("Preset " + name + " not found relative to " + dirname);
throw new Error(`Preset ${name} not found relative to ${dirname}`);
}
var value = requireModule("preset", filepath);
const value = requireModule("preset", filepath);
debug("Loaded preset %o from %o.", name, dirname);
return {
filepath: filepath,
value: value
filepath,
value
};
}
function standardizeName(type, name) {
if (_path().default.isAbsolute(name)) return name;
var isPreset = type === "preset";
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(EXACT_RE, "");
const isPreset = type === "preset";
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, "");
}
function resolveStandardizedName(type, name, dirname) {
if (dirname === void 0) {
dirname = process.cwd();
}
var standardizedName = standardizeName(type, name);
function resolveStandardizedName(type, name, dirname = process.cwd()) {
const standardizedName = standardizeName(type, name);
try {
return _resolve().default.sync(standardizedName, {
@@ -108,7 +105,7 @@ function resolveStandardizedName(type, name, dirname) {
if (e.code !== "MODULE_NOT_FOUND") throw e;
if (standardizedName !== name) {
var resolvedOriginal = false;
let resolvedOriginal = false;
try {
_resolve().default.sync(name, {
@@ -119,11 +116,11 @@ function resolveStandardizedName(type, name, dirname) {
} catch (e2) {}
if (resolvedOriginal) {
e.message += "\n- If you want to resolve \"" + name + "\", use \"module:" + name + "\"";
e.message += `\n- If you want to resolve "${name}", use "module:${name}"`;
}
}
var resolvedBabel = false;
let resolvedBabel = false;
try {
_resolve().default.sync(standardizeName(type, "@babel/" + name), {
@@ -134,11 +131,11 @@ function resolveStandardizedName(type, name, dirname) {
} catch (e2) {}
if (resolvedBabel) {
e.message += "\n- Did you mean \"@babel/" + name + "\"?";
e.message += `\n- Did you mean "@babel/${name}"?`;
}
var resolvedOppositeType = false;
var oppositeType = type === "preset" ? "plugin" : "preset";
let resolvedOppositeType = false;
const oppositeType = type === "preset" ? "plugin" : "preset";
try {
_resolve().default.sync(standardizeName(oppositeType, name), {
@@ -149,18 +146,18 @@ function resolveStandardizedName(type, name, dirname) {
} catch (e2) {}
if (resolvedOppositeType) {
e.message += "\n- Did you accidentally pass a " + type + " as a " + oppositeType + "?";
e.message += `\n- Did you accidentally pass a ${oppositeType} as a ${type}?`;
}
throw e;
}
}
var LOADING_MODULES = new Set();
const LOADING_MODULES = new Set();
function requireModule(type, name) {
if (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.');
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.');
}
try {

1
node_modules/@babel/core/lib/config/files/types.js generated vendored
View File

@@ -1 +0,0 @@
"use strict";

10
node_modules/@babel/core/lib/config/files/utils.js generated vendored
View File

@@ -6,9 +6,9 @@ Object.defineProperty(exports, "__esModule", {
exports.makeStaticFileCache = makeStaticFileCache;
function _fs() {
var data = _interopRequireDefault(require("fs"));
const data = _interopRequireDefault(require("fs"));
_fs = function _fs() {
_fs = function () {
return data;
};
@@ -20,10 +20,8 @@ var _caching = require("../caching");
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function makeStaticFileCache(fn) {
return (0, _caching.makeStrongCache)(function (filepath, cache) {
if (cache.invalidate(function () {
return fileMtime(filepath);
}) === null) {
return (0, _caching.makeStrongCache)((filepath, cache) => {
if (cache.invalidate(() => fileMtime(filepath)) === null) {
cache.forever();
return null;
}

199
node_modules/@babel/core/lib/config/full.js generated vendored
View File

@@ -16,9 +16,9 @@ var _item = require("./item");
var _configChain = require("./config-chain");
function _traverse() {
var data = _interopRequireDefault(require("@babel/traverse"));
const data = _interopRequireDefault(require("@babel/traverse"));
_traverse = function _traverse() {
_traverse = function () {
return data;
};
@@ -40,78 +40,74 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
function loadFullConfig(inputOpts) {
var result = (0, _partial.default)(inputOpts);
const result = (0, _partial.default)(inputOpts);
if (!result) {
return null;
}
var options = result.options,
context = result.context;
var optionDefaults = {};
var passes = [[]];
const {
options,
context
} = result;
const optionDefaults = {};
const passes = [[]];
try {
var plugins = options.plugins,
presets = options.presets;
const {
plugins,
presets
} = options;
if (!plugins || !presets) {
throw new Error("Assertion failure - plugins and presets exist");
}
var ignored = function recurseDescriptors(config, pass) {
var plugins = config.plugins.map(function (descriptor) {
return loadPluginDescriptor(descriptor, context);
});
var presets = config.presets.map(function (descriptor) {
return {
preset: loadPresetDescriptor(descriptor, context),
pass: descriptor.ownPass ? [] : pass
};
});
const ignored = function recurseDescriptors(config, pass) {
const plugins = config.plugins.reduce((acc, descriptor) => {
if (descriptor.options !== false) {
acc.push(loadPluginDescriptor(descriptor, context));
}
return acc;
}, []);
const presets = config.presets.reduce((acc, descriptor) => {
if (descriptor.options !== false) {
acc.push({
preset: loadPresetDescriptor(descriptor, context),
pass: descriptor.ownPass ? [] : pass
});
}
return acc;
}, []);
if (presets.length > 0) {
passes.splice.apply(passes, [1, 0].concat(presets.map(function (o) {
return o.pass;
}).filter(function (p) {
return p !== pass;
})));
passes.splice(1, 0, ...presets.map(o => o.pass).filter(p => p !== pass));
for (var _iterator = presets, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
var _ref2;
if (_isArray) {
if (_i >= _iterator.length) break;
_ref2 = _iterator[_i++];
} else {
_i = _iterator.next();
if (_i.done) break;
_ref2 = _i.value;
}
var _ref3 = _ref2;
var preset = _ref3.preset,
_pass = _ref3.pass;
for (const _ref of presets) {
const {
preset,
pass
} = _ref;
if (!preset) return true;
var _ignored = recurseDescriptors({
const ignored = recurseDescriptors({
plugins: preset.plugins,
presets: preset.presets
}, _pass);
if (_ignored) return true;
preset.options.forEach(function (opts) {
}, pass);
if (ignored) return true;
preset.options.forEach(opts => {
(0, _util.mergeOptions)(optionDefaults, opts);
});
}
}
if (plugins.length > 0) {
pass.unshift.apply(pass, plugins);
pass.unshift(...plugins);
}
}({
plugins: plugins.map(function (item) {
var desc = (0, _item.getItemDescriptor)(item);
plugins: plugins.map(item => {
const desc = (0, _item.getItemDescriptor)(item);
if (!desc) {
throw new Error("Assertion failure - must be config item");
@@ -119,8 +115,8 @@ function loadFullConfig(inputOpts) {
return desc;
}),
presets: presets.map(function (item) {
var desc = (0, _item.getItemDescriptor)(item);
presets: presets.map(item => {
const desc = (0, _item.getItemDescriptor)(item);
if (!desc) {
throw new Error("Assertion failure - must be config item");
@@ -133,22 +129,18 @@ function loadFullConfig(inputOpts) {
if (ignored) return null;
} catch (e) {
if (!/^\[BABEL\]/.test(e.message)) {
e.message = "[BABEL] " + (context.filename || "unknown") + ": " + e.message;
e.message = `[BABEL] ${context.filename || "unknown"}: ${e.message}`;
}
throw e;
}
var opts = optionDefaults;
const opts = optionDefaults;
(0, _util.mergeOptions)(opts, options);
opts.plugins = passes[0];
opts.presets = passes.slice(1).filter(function (plugins) {
return plugins.length > 0;
}).map(function (plugins) {
return {
plugins: plugins
};
});
opts.presets = passes.slice(1).filter(plugins => plugins.length > 0).map(plugins => ({
plugins
}));
opts.passPerPreset = opts.presets.length > 0;
return {
options: opts,
@@ -156,23 +148,24 @@ function loadFullConfig(inputOpts) {
};
}
var loadDescriptor = (0, _caching.makeWeakCache)(function (_ref4, cache) {
var value = _ref4.value,
options = _ref4.options,
dirname = _ref4.dirname,
alias = _ref4.alias;
const loadDescriptor = (0, _caching.makeWeakCache)(({
value,
options,
dirname,
alias
}, cache) => {
if (options === false) throw new Error("Assertion failure");
options = options || {};
var item = value;
let item = value;
if (typeof value === "function") {
var api = Object.assign({}, context, (0, _configApi.default)(cache));
const api = Object.assign({}, context, (0, _configApi.default)(cache));
try {
item = value(api, options, dirname);
} catch (e) {
if (alias) {
e.message += " (While processing: " + JSON.stringify(alias) + ")";
e.message += ` (While processing: ${JSON.stringify(alias)})`;
}
throw e;
@@ -184,14 +177,14 @@ var loadDescriptor = (0, _caching.makeWeakCache)(function (_ref4, cache) {
}
if (typeof item.then === "function") {
throw new Error("You appear to be using an async 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.");
throw new Error(`You appear to be using an async 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.`);
}
return {
value: item,
options: options,
dirname: dirname,
alias: alias
options,
dirname,
alias
};
});
@@ -207,29 +200,28 @@ function loadPluginDescriptor(descriptor, context) {
return instantiatePlugin(loadDescriptor(descriptor, context), context);
}
var instantiatePlugin = (0, _caching.makeWeakCache)(function (_ref5, cache) {
var value = _ref5.value,
options = _ref5.options,
dirname = _ref5.dirname,
alias = _ref5.alias;
var pluginObj = (0, _plugins.validatePluginObject)(value);
var plugin = Object.assign({}, pluginObj);
const instantiatePlugin = (0, _caching.makeWeakCache)(({
value,
options,
dirname,
alias
}, cache) => {
const pluginObj = (0, _plugins.validatePluginObject)(value);
const plugin = Object.assign({}, pluginObj);
if (plugin.visitor) {
plugin.visitor = _traverse().default.explode(Object.assign({}, plugin.visitor));
}
if (plugin.inherits) {
var inheritsDescriptor = {
const inheritsDescriptor = {
name: undefined,
alias: alias + "$inherits",
alias: `${alias}$inherits`,
value: plugin.inherits,
options: options,
dirname: dirname
options,
dirname
};
var inherits = cache.invalidate(function (data) {
return loadPluginDescriptor(inheritsDescriptor, data);
});
const inherits = cache.invalidate(data => loadPluginDescriptor(inheritsDescriptor, data));
plugin.pre = chain(inherits.pre, plugin.pre);
plugin.post = chain(inherits.post, plugin.post);
plugin.manipulateOptions = chain(inherits.manipulateOptions, plugin.manipulateOptions);
@@ -239,42 +231,27 @@ var instantiatePlugin = (0, _caching.makeWeakCache)(function (_ref5, cache) {
return new _plugin.default(plugin, options, alias);
});
var loadPresetDescriptor = function loadPresetDescriptor(descriptor, context) {
const loadPresetDescriptor = (descriptor, context) => {
return (0, _configChain.buildPresetChain)(instantiatePreset(loadDescriptor(descriptor, context)), context);
};
var instantiatePreset = (0, _caching.makeWeakCache)(function (_ref6) {
var value = _ref6.value,
dirname = _ref6.dirname,
alias = _ref6.alias;
const instantiatePreset = (0, _caching.makeWeakCache)(({
value,
dirname,
alias
}) => {
return {
options: (0, _options.validate)("preset", value),
alias: alias,
dirname: dirname
alias,
dirname
};
});
function chain(a, b) {
var fns = [a, b].filter(Boolean);
const fns = [a, b].filter(Boolean);
if (fns.length <= 1) return fns[0];
return function () {
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
for (var _iterator2 = fns, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
var _ref7;
if (_isArray2) {
if (_i2 >= _iterator2.length) break;
_ref7 = _iterator2[_i2++];
} else {
_i2 = _iterator2.next();
if (_i2.done) break;
_ref7 = _i2.value;
}
var fn = _ref7;
return function (...args) {
for (const fn of fns) {
fn.apply(this, args);
}
};

52
node_modules/@babel/core/lib/config/helpers/config-api.js generated vendored
View File

@@ -6,9 +6,9 @@ Object.defineProperty(exports, "__esModule", {
exports.default = makeAPI;
function _semver() {
var data = _interopRequireDefault(require("semver"));
const data = _interopRequireDefault(require("semver"));
_semver = function _semver() {
_semver = function () {
return data;
};
@@ -17,32 +17,38 @@ function _semver() {
var _ = require("../../");
var _caching = require("../caching");
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function makeAPI(cache) {
var env = function env(value) {
return cache.using(function (data) {
if (typeof value === "undefined") return data.envName;
if (typeof value === "function") return value(data.envName);
if (!Array.isArray(value)) value = [value];
return value.some(function (entry) {
if (typeof entry !== "string") {
throw new Error("Unexpected non-string value");
}
const env = value => cache.using(data => {
if (typeof value === "undefined") return data.envName;
return entry === data.envName;
});
if (typeof value === "function") {
return (0, _caching.assertSimpleType)(value(data.envName));
}
if (!Array.isArray(value)) value = [value];
return value.some(entry => {
if (typeof entry !== "string") {
throw new Error("Unexpected non-string value");
}
return entry === data.envName;
});
};
});
const caller = cb => cache.using(data => (0, _caching.assertSimpleType)(cb(data.caller)));
return {
version: _.version,
cache: cache.simple(),
env: env,
async: function async() {
return false;
},
assertVersion: assertVersion
env,
async: () => false,
caller,
assertVersion,
tokTypes: undefined
};
}
@@ -52,7 +58,7 @@ function assertVersion(range) {
throw new Error("Expected string or integer value.");
}
range = "^" + range + ".0.0-0";
range = `^${range}.0.0-0`;
}
if (typeof range !== "string") {
@@ -60,13 +66,13 @@ function assertVersion(range) {
}
if (_semver().default.satisfies(_.version, range)) return;
var limit = Error.stackTraceLimit;
const limit = Error.stackTraceLimit;
if (typeof limit === "number" && limit < 25) {
Error.stackTraceLimit = 25;
}
var 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 "${_.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.`);
if (typeof limit === "number") {
Error.stackTraceLimit = limit;
@@ -75,6 +81,6 @@ function assertVersion(range) {
throw Object.assign(err, {
code: "BABEL_VERSION_UNSUPPORTED",
version: _.version,
range: range
range
});
}

6
node_modules/@babel/core/lib/config/helpers/environment.js generated vendored
View File

@@ -5,10 +5,6 @@ Object.defineProperty(exports, "__esModule", {
});
exports.getEnv = getEnv;
function getEnv(defaultValue) {
if (defaultValue === void 0) {
defaultValue = "development";
}
function getEnv(defaultValue = "development") {
return process.env.BABEL_ENV || process.env.NODE_ENV || defaultValue;
}

23
node_modules/@babel/core/lib/config/index.js generated vendored
View File

@@ -6,17 +6,16 @@ Object.defineProperty(exports, "__esModule", {
exports.loadOptions = loadOptions;
Object.defineProperty(exports, "default", {
enumerable: true,
get: function get() {
get: function () {
return _full.default;
}
});
Object.defineProperty(exports, "loadPartialConfig", {
enumerable: true,
get: function get() {
get: function () {
return _partial.loadPartialConfig;
}
});
exports.OptionManager = void 0;
var _full = _interopRequireDefault(require("./full"));
@@ -25,20 +24,6 @@ var _partial = require("./partial");
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function loadOptions(opts) {
var config = (0, _full.default)(opts);
const config = (0, _full.default)(opts);
return config ? config.options : null;
}
var OptionManager = function () {
function OptionManager() {}
var _proto = OptionManager.prototype;
_proto.init = function init(opts) {
return loadOptions(opts);
};
return OptionManager;
}();
exports.OptionManager = OptionManager;
}

52
node_modules/@babel/core/lib/config/item.js generated vendored
View File

@@ -8,9 +8,9 @@ exports.createConfigItem = createConfigItem;
exports.getItemDescriptor = getItemDescriptor;
function _path() {
var data = _interopRequireDefault(require("path"));
const data = _interopRequireDefault(require("path"));
_path = function _path() {
_path = function () {
return data;
};
@@ -25,14 +25,12 @@ function createItemFromDescriptor(desc) {
return new ConfigItem(desc);
}
function createConfigItem(value, _temp) {
var _ref = _temp === void 0 ? {} : _temp,
_ref$dirname = _ref.dirname,
dirname = _ref$dirname === void 0 ? "." : _ref$dirname,
type = _ref.type;
var descriptor = (0, _configDescriptors.createDescriptor)(value, _path().default.resolve(dirname), {
type: type,
function createConfigItem(value, {
dirname = ".",
type
} = {}) {
const descriptor = (0, _configDescriptors.createDescriptor)(value, _path().default.resolve(dirname), {
type,
alias: "programmatic item"
});
return createItemFromDescriptor(descriptor);
@@ -46,25 +44,23 @@ function getItemDescriptor(item) {
return undefined;
}
var ConfigItem = function ConfigItem(descriptor) {
this._descriptor = descriptor;
Object.defineProperty(this, "_descriptor", {
enumerable: false
});
if (this._descriptor.options === false) {
throw new Error("Assertion failure - unexpected false options");
class ConfigItem {
constructor(descriptor) {
this._descriptor = descriptor;
Object.defineProperty(this, "_descriptor", {
enumerable: false
});
this.value = this._descriptor.value;
this.options = this._descriptor.options;
this.dirname = this._descriptor.dirname;
this.name = this._descriptor.name;
this.file = this._descriptor.file ? {
request: this._descriptor.file.request,
resolved: this._descriptor.file.resolved
} : undefined;
Object.freeze(this);
}
this.value = this._descriptor.value;
this.options = this._descriptor.options;
this.dirname = this._descriptor.dirname;
this.name = this._descriptor.name;
this.file = this._descriptor.file ? {
request: this._descriptor.file.request,
resolved: this._descriptor.file.resolved
} : undefined;
Object.freeze(this);
};
}
Object.freeze(ConfigItem.prototype);

108
node_modules/@babel/core/lib/config/partial.js generated vendored
View File

@@ -7,9 +7,9 @@ exports.default = loadPrivatePartialConfig;
exports.loadPartialConfig = loadPartialConfig;
function _path() {
var data = _interopRequireDefault(require("path"));
const data = _interopRequireDefault(require("path"));
_path = function _path() {
_path = function () {
return data;
};
@@ -28,45 +28,78 @@ var _environment = require("./helpers/environment");
var _options = require("./validation/options");
var _files = require("./files");
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function resolveRootMode(rootDir, rootMode) {
switch (rootMode) {
case "root":
return rootDir;
case "upward-optional":
{
const upwardRootDir = (0, _files.findConfigUpwards)(rootDir);
return upwardRootDir === null ? rootDir : upwardRootDir;
}
case "upward":
{
const upwardRootDir = (0, _files.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}"`), {
code: "BABEL_ROOT_NOT_FOUND",
dirname: rootDir
});
}
default:
throw new Error(`Assertion failure - unknown rootMode value`);
}
}
function loadPrivatePartialConfig(inputOpts) {
if (inputOpts != null && (typeof inputOpts !== "object" || Array.isArray(inputOpts))) {
throw new Error("Babel options must be an object, null, or undefined");
}
var args = inputOpts ? (0, _options.validate)("arguments", inputOpts) : {};
var _args$envName = args.envName,
envName = _args$envName === void 0 ? (0, _environment.getEnv)() : _args$envName,
_args$cwd = args.cwd,
cwd = _args$cwd === void 0 ? "." : _args$cwd;
const args = inputOpts ? (0, _options.validate)("arguments", inputOpts) : {};
const {
envName = (0, _environment.getEnv)(),
cwd = ".",
root: rootDir = ".",
rootMode = "root",
caller
} = args;
var absoluteCwd = _path().default.resolve(cwd);
const absoluteCwd = _path().default.resolve(cwd);
var context = {
filename: args.filename ? _path().default.resolve(cwd, args.filename) : null,
const absoluteRootDir = resolveRootMode(_path().default.resolve(absoluteCwd, rootDir), rootMode);
const context = {
filename: typeof args.filename === "string" ? _path().default.resolve(cwd, args.filename) : undefined,
cwd: absoluteCwd,
envName: envName
root: absoluteRootDir,
envName,
caller
};
var configChain = (0, _configChain.buildRootChain)(args, context);
const configChain = (0, _configChain.buildRootChain)(args, context);
if (!configChain) return null;
var options = {};
configChain.options.forEach(function (opts) {
const options = {};
configChain.options.forEach(opts => {
(0, _util.mergeOptions)(options, opts);
});
options.babelrc = false;
options.envName = envName;
options.cwd = absoluteCwd;
options.configFile = false;
options.passPerPreset = false;
options.plugins = configChain.plugins.map(function (descriptor) {
return (0, _item.createItemFromDescriptor)(descriptor);
});
options.presets = configChain.presets.map(function (descriptor) {
return (0, _item.createItemFromDescriptor)(descriptor);
});
options.envName = context.envName;
options.cwd = context.cwd;
options.root = context.root;
options.filename = typeof context.filename === "string" ? context.filename : undefined;
options.plugins = configChain.plugins.map(descriptor => (0, _item.createItemFromDescriptor)(descriptor));
options.presets = configChain.presets.map(descriptor => (0, _item.createItemFromDescriptor)(descriptor));
return {
options: options,
context: context,
options,
context,
ignore: configChain.ignore,
babelrc: configChain.babelrc,
config: configChain.config
@@ -74,13 +107,15 @@ function loadPrivatePartialConfig(inputOpts) {
}
function loadPartialConfig(inputOpts) {
var result = loadPrivatePartialConfig(inputOpts);
const result = loadPrivatePartialConfig(inputOpts);
if (!result) return null;
var options = result.options,
babelrc = result.babelrc,
ignore = result.ignore,
config = result.config;
(options.plugins || []).forEach(function (item) {
const {
options,
babelrc,
ignore,
config
} = result;
(options.plugins || []).forEach(item => {
if (item.value instanceof _plugin.default) {
throw new Error("Passing cached plugin instances is not supported in " + "babel.loadPartialConfig()");
}
@@ -88,8 +123,8 @@ function loadPartialConfig(inputOpts) {
return new PartialConfig(options, babelrc ? babelrc.filepath : undefined, ignore ? ignore.filepath : undefined, config ? config.filepath : undefined);
}
var PartialConfig = function () {
function PartialConfig(options, babelrc, ignore, config) {
class PartialConfig {
constructor(options, babelrc, ignore, config) {
this.options = options;
this.babelignore = ignore;
this.babelrc = babelrc;
@@ -97,13 +132,10 @@ var PartialConfig = function () {
Object.freeze(this);
}
var _proto = PartialConfig.prototype;
_proto.hasFilesystemConfig = function hasFilesystemConfig() {
hasFilesystemConfig() {
return this.babelrc !== undefined || this.config !== undefined;
};
}
return PartialConfig;
}();
}
Object.freeze(PartialConfig.prototype);

52
node_modules/@babel/core/lib/config/pattern-to-regex.js generated vendored Normal file
View File

@@ -0,0 +1,52 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = pathToPattern;
function _path() {
const data = _interopRequireDefault(require("path"));
_path = function () {
return data;
};
return data;
}
function _escapeRegExp() {
const data = _interopRequireDefault(require("lodash/escapeRegExp"));
_escapeRegExp = function () {
return data;
};
return data;
}
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
const sep = `\\${_path().default.sep}`;
const endSep = `(?:${sep}|$)`;
const substitution = `[^${sep}]+`;
const starPat = `(?:${substitution}${sep})`;
const starPatLast = `(?:${substitution}${endSep})`;
const starStarPat = `${starPat}*?`;
const starStarPatLast = `${starPat}*?${starPatLast}?`;
function pathToPattern(pattern, dirname) {
const parts = _path().default.resolve(dirname, pattern).split(_path().default.sep);
return new RegExp(["^", ...parts.map((part, i) => {
const last = i === parts.length - 1;
if (part === "**") return last ? starStarPatLast : starStarPat;
if (part === "*") return last ? starPatLast : starPat;
if (part.indexOf("*.") === 0) {
return substitution + (0, _escapeRegExp().default)(part.slice(1)) + (last ? endSep : sep);
}
return (0, _escapeRegExp().default)(part) + (last ? endSep : sep);
})].join(""));
}

23
node_modules/@babel/core/lib/config/plugin.js generated vendored
View File

@@ -5,15 +5,18 @@ Object.defineProperty(exports, "__esModule", {
});
exports.default = void 0;
var Plugin = function Plugin(plugin, options, key) {
this.key = plugin.name || key;
this.manipulateOptions = plugin.manipulateOptions;
this.post = plugin.post;
this.pre = plugin.pre;
this.visitor = plugin.visitor || {};
this.parserOverride = plugin.parserOverride;
this.generatorOverride = plugin.generatorOverride;
this.options = options;
};
class Plugin {
constructor(plugin, options, key) {
this.key = plugin.name || key;
this.manipulateOptions = plugin.manipulateOptions;
this.post = plugin.post;
this.pre = plugin.pre;
this.visitor = plugin.visitor || {};
this.parserOverride = plugin.parserOverride;
this.generatorOverride = plugin.generatorOverride;
this.options = options;
}
}
exports.default = Plugin;

27
node_modules/@babel/core/lib/config/util.js generated vendored
View File

@@ -6,34 +6,25 @@ Object.defineProperty(exports, "__esModule", {
exports.mergeOptions = mergeOptions;
function mergeOptions(target, source) {
var _arr = Object.keys(source);
for (var _i = 0; _i < _arr.length; _i++) {
var k = _arr[_i];
for (const k of Object.keys(source)) {
if (k === "parserOpts" && source.parserOpts) {
var parserOpts = source.parserOpts;
var targetObj = target.parserOpts = target.parserOpts || {};
const parserOpts = source.parserOpts;
const targetObj = target.parserOpts = target.parserOpts || {};
mergeDefaultFields(targetObj, parserOpts);
} else if (k === "generatorOpts" && source.generatorOpts) {
var generatorOpts = source.generatorOpts;
var _targetObj = target.generatorOpts = target.generatorOpts || {};
mergeDefaultFields(_targetObj, generatorOpts);
const generatorOpts = source.generatorOpts;
const targetObj = target.generatorOpts = target.generatorOpts || {};
mergeDefaultFields(targetObj, generatorOpts);
} else {
var val = source[k];
const val = source[k];
if (val !== undefined) target[k] = val;
}
}
}
function mergeDefaultFields(target, source) {
var _arr2 = Object.keys(source);
for (var _i2 = 0; _i2 < _arr2.length; _i2++) {
var k = _arr2[_i2];
var val = source[k];
for (const k of Object.keys(source)) {
const val = source[k];
if (val !== undefined) target[k] = val;
}
}

165
node_modules/@babel/core/lib/config/validation/option-assertions.js generated vendored
View File

@@ -3,9 +3,13 @@
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.msg = msg;
exports.access = access;
exports.assertRootMode = assertRootMode;
exports.assertSourceMaps = assertSourceMaps;
exports.assertCompact = assertCompact;
exports.assertSourceType = assertSourceType;
exports.assertCallerMetadata = assertCallerMetadata;
exports.assertInputSourceMap = assertInputSourceMap;
exports.assertString = assertString;
exports.assertFunction = assertFunction;
@@ -18,109 +22,166 @@ exports.assertConfigFileSearch = assertConfigFileSearch;
exports.assertBabelrcSearch = assertBabelrcSearch;
exports.assertPluginList = assertPluginList;
function assertSourceMaps(key, value) {
function msg(loc) {
switch (loc.type) {
case "root":
return ``;
case "env":
return `${msg(loc.parent)}.env["${loc.name}"]`;
case "overrides":
return `${msg(loc.parent)}.overrides[${loc.index}]`;
case "option":
return `${msg(loc.parent)}.${loc.name}`;
case "access":
return `${msg(loc.parent)}[${JSON.stringify(loc.name)}]`;
default:
throw new Error(`Assertion failure: Unknown type ${loc.type}`);
}
}
function access(loc, name) {
return {
type: "access",
name,
parent: loc
};
}
function assertRootMode(loc, value) {
if (value !== undefined && value !== "root" && value !== "upward" && value !== "upward-optional") {
throw new Error(`${msg(loc)} must be a "root", "upward", "upward-optional" or undefined`);
}
return value;
}
function assertSourceMaps(loc, value) {
if (value !== undefined && typeof value !== "boolean" && value !== "inline" && value !== "both") {
throw new Error("." + key + " must be a boolean, \"inline\", \"both\", or undefined");
throw new Error(`${msg(loc)} must be a boolean, "inline", "both", or undefined`);
}
return value;
}
function assertCompact(key, value) {
function assertCompact(loc, value) {
if (value !== undefined && typeof value !== "boolean" && value !== "auto") {
throw new Error("." + key + " must be a boolean, \"auto\", or undefined");
throw new Error(`${msg(loc)} must be a boolean, "auto", or undefined`);
}
return value;
}
function assertSourceType(key, value) {
function assertSourceType(loc, value) {
if (value !== undefined && value !== "module" && value !== "script" && value !== "unambiguous") {
throw new Error("." + key + " must be \"module\", \"script\", \"unambiguous\", or undefined");
throw new Error(`${msg(loc)} must be "module", "script", "unambiguous", or undefined`);
}
return value;
}
function assertInputSourceMap(key, value) {
function assertCallerMetadata(loc, value) {
const obj = assertObject(loc, value);
if (obj) {
if (typeof obj["name"] !== "string") {
throw new Error(`${msg(loc)} set but does not contain "name" property string`);
}
for (const prop of Object.keys(obj)) {
const propLoc = access(loc, prop);
const value = obj[prop];
if (value != null && typeof value !== "boolean" && typeof value !== "string" && typeof value !== "number") {
throw new Error(`${msg(propLoc)} must be null, undefined, a boolean, a string, or a number.`);
}
}
}
return value;
}
function assertInputSourceMap(loc, value) {
if (value !== undefined && typeof value !== "boolean" && (typeof value !== "object" || !value)) {
throw new Error(".inputSourceMap must be a boolean, object, or undefined");
throw new Error(`${msg(loc)} must be a boolean, object, or undefined`);
}
return value;
}
function assertString(key, value) {
function assertString(loc, value) {
if (value !== undefined && typeof value !== "string") {
throw new Error("." + key + " must be a string, or undefined");
throw new Error(`${msg(loc)} must be a string, or undefined`);
}
return value;
}
function assertFunction(key, value) {
function assertFunction(loc, value) {
if (value !== undefined && typeof value !== "function") {
throw new Error("." + key + " must be a function, or undefined");
throw new Error(`${msg(loc)} must be a function, or undefined`);
}
return value;
}
function assertBoolean(key, value) {
function assertBoolean(loc, value) {
if (value !== undefined && typeof value !== "boolean") {
throw new Error("." + key + " must be a boolean, or undefined");
throw new Error(`${msg(loc)} must be a boolean, or undefined`);
}
return value;
}
function assertObject(key, value) {
function assertObject(loc, value) {
if (value !== undefined && (typeof value !== "object" || Array.isArray(value) || !value)) {
throw new Error("." + key + " must be an object, or undefined");
throw new Error(`${msg(loc)} must be an object, or undefined`);
}
return value;
}
function assertArray(key, value) {
function assertArray(loc, value) {
if (value != null && !Array.isArray(value)) {
throw new Error("." + key + " must be an array, or undefined");
throw new Error(`${msg(loc)} must be an array, or undefined`);
}
return value;
}
function assertIgnoreList(key, value) {
var arr = assertArray(key, value);
function assertIgnoreList(loc, value) {
const arr = assertArray(loc, value);
if (arr) {
arr.forEach(function (item, i) {
return assertIgnoreItem(key, i, item);
});
arr.forEach((item, i) => assertIgnoreItem(access(loc, i), item));
}
return arr;
}
function assertIgnoreItem(key, index, value) {
function assertIgnoreItem(loc, value) {
if (typeof value !== "string" && typeof value !== "function" && !(value instanceof RegExp)) {
throw new Error("." + key + "[" + index + "] must be an array of string/Funtion/RegExp values, or undefined");
throw new Error(`${msg(loc)} must be an array of string/Funtion/RegExp values, or undefined`);
}
return value;
}
function assertConfigApplicableTest(key, value) {
function assertConfigApplicableTest(loc, value) {
if (value === undefined) return value;
if (Array.isArray(value)) {
value.forEach(function (item, i) {
value.forEach((item, i) => {
if (!checkValidTest(item)) {
throw new Error("." + key + "[" + i + "] must be a string/Function/RegExp.");
throw new Error(`${msg(access(loc, i))} must be a string/Function/RegExp.`);
}
});
} else if (!checkValidTest(value)) {
throw new Error("." + key + " must be a string/Function/RegExp, or an array of those");
throw new Error(`${msg(loc)} must be a string/Function/RegExp, or an array of those`);
}
return value;
@@ -130,79 +191,77 @@ function checkValidTest(value) {
return typeof value === "string" || typeof value === "function" || value instanceof RegExp;
}
function assertConfigFileSearch(key, value) {
function assertConfigFileSearch(loc, value) {
if (value !== undefined && typeof value !== "boolean" && typeof value !== "string") {
throw new Error("." + key + " must be a undefined, a boolean, a string, " + ("got " + JSON.stringify(value)));
throw new Error(`${msg(loc)} must be a undefined, a boolean, a string, ` + `got ${JSON.stringify(value)}`);
}
return value;
}
function assertBabelrcSearch(key, value) {
function assertBabelrcSearch(loc, value) {
if (value === undefined || typeof value === "boolean") return value;
if (Array.isArray(value)) {
value.forEach(function (item, i) {
if (typeof item !== "string") {
throw new Error("." + key + "[" + i + "] must be a string.");
value.forEach((item, i) => {
if (!checkValidTest(item)) {
throw new Error(`${msg(access(loc, i))} must be a string/Function/RegExp.`);
}
});
} else if (typeof value !== "string") {
throw new Error("." + key + " must be a undefined, a boolean, a string, " + ("or an array of strings, got " + JSON.stringify(value)));
} else if (!checkValidTest(value)) {
throw new Error(`${msg(loc)} must be a undefined, a boolean, a string/Function/RegExp ` + `or an array of those, got ${JSON.stringify(value)}`);
}
return value;
}
function assertPluginList(key, value) {
var arr = assertArray(key, value);
function assertPluginList(loc, value) {
const arr = assertArray(loc, value);
if (arr) {
arr.forEach(function (item, i) {
return assertPluginItem(key, i, item);
});
arr.forEach((item, i) => assertPluginItem(access(loc, i), item));
}
return arr;
}
function assertPluginItem(key, index, value) {
function assertPluginItem(loc, value) {
if (Array.isArray(value)) {
if (value.length === 0) {
throw new Error("." + key + "[" + index + "] must include an object");
throw new Error(`${msg(loc)} must include an object`);
}
if (value.length > 3) {
throw new Error("." + key + "[" + index + "] may only be a two-tuple or three-tuple");
throw new Error(`${msg(loc)} may only be a two-tuple or three-tuple`);
}
assertPluginTarget(key, index, true, value[0]);
assertPluginTarget(access(loc, 0), value[0]);
if (value.length > 1) {
var opts = value[1];
const opts = value[1];
if (opts !== undefined && opts !== false && (typeof opts !== "object" || Array.isArray(opts))) {
throw new Error("." + key + "[" + index + "][1] must be an object, false, or undefined");
throw new Error(`${msg(access(loc, 1))} must be an object, false, or undefined`);
}
}
if (value.length === 3) {
var name = value[2];
const name = value[2];
if (name !== undefined && typeof name !== "string") {
throw new Error("." + key + "[" + index + "][2] must be a string, or undefined");
throw new Error(`${msg(access(loc, 2))} must be a string, or undefined`);
}
}
} else {
assertPluginTarget(key, index, false, value);
assertPluginTarget(loc, value);
}
return value;
}
function assertPluginTarget(key, index, inArray, value) {
function assertPluginTarget(loc, value) {
if ((typeof value !== "object" || !value) && typeof value !== "string" && typeof value !== "function") {
throw new Error("." + key + "[" + index + "]" + (inArray ? "[0]" : "") + " must be a string, object, function");
throw new Error(`${msg(loc)} must be a string, object, function`);
}
return value;

159
node_modules/@babel/core/lib/config/validation/options.js generated vendored
View File

@@ -13,33 +13,37 @@ var _optionAssertions = require("./option-assertions");
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
var ROOT_VALIDATORS = {
const ROOT_VALIDATORS = {
cwd: _optionAssertions.assertString,
root: _optionAssertions.assertString,
rootMode: _optionAssertions.assertRootMode,
configFile: _optionAssertions.assertConfigFileSearch,
caller: _optionAssertions.assertCallerMetadata,
filename: _optionAssertions.assertString,
filenameRelative: _optionAssertions.assertString,
babelrc: _optionAssertions.assertBoolean,
babelrcRoots: _optionAssertions.assertBabelrcSearch,
code: _optionAssertions.assertBoolean,
ast: _optionAssertions.assertBoolean,
envName: _optionAssertions.assertString
};
var NONPRESET_VALIDATORS = {
extends: _optionAssertions.assertString,
env: assertEnvSet,
ignore: _optionAssertions.assertIgnoreList,
only: _optionAssertions.assertIgnoreList,
overrides: assertOverridesList,
test: _optionAssertions.assertConfigApplicableTest,
include: _optionAssertions.assertConfigApplicableTest,
exclude: _optionAssertions.assertConfigApplicableTest
const BABELRC_VALIDATORS = {
babelrc: _optionAssertions.assertBoolean,
babelrcRoots: _optionAssertions.assertBabelrcSearch
};
var COMMON_VALIDATORS = {
const NONPRESET_VALIDATORS = {
extends: _optionAssertions.assertString,
ignore: _optionAssertions.assertIgnoreList,
only: _optionAssertions.assertIgnoreList
};
const COMMON_VALIDATORS = {
inputSourceMap: _optionAssertions.assertInputSourceMap,
presets: _optionAssertions.assertPluginList,
plugins: _optionAssertions.assertPluginList,
passPerPreset: _optionAssertions.assertBoolean,
env: assertEnvSet,
overrides: assertOverridesList,
test: _optionAssertions.assertConfigApplicableTest,
include: _optionAssertions.assertConfigApplicableTest,
exclude: _optionAssertions.assertConfigApplicableTest,
retainLines: _optionAssertions.assertBoolean,
comments: _optionAssertions.assertBoolean,
shouldPrintComment: _optionAssertions.assertFunction,
@@ -62,44 +66,60 @@ var COMMON_VALIDATORS = {
generatorOpts: _optionAssertions.assertObject
};
function getSource(loc) {
return loc.type === "root" ? loc.source : getSource(loc.parent);
}
function validate(type, opts) {
return validateNested({
type: "root",
source: type
}, opts);
}
function validateNested(loc, opts) {
const type = getSource(loc);
assertNoDuplicateSourcemap(opts);
Object.keys(opts).forEach(function (key) {
Object.keys(opts).forEach(key => {
const optLoc = {
type: "option",
name: key,
parent: loc
};
if (type === "preset" && NONPRESET_VALIDATORS[key]) {
throw new Error("." + key + " is not allowed in preset options");
throw new Error(`${(0, _optionAssertions.msg)(optLoc)} is not allowed in preset options`);
}
if (type !== "arguments" && ROOT_VALIDATORS[key]) {
throw new Error("." + key + " is only allowed in root programmatic options");
throw new Error(`${(0, _optionAssertions.msg)(optLoc)} is only allowed in root programmatic options`);
}
if (type === "env" && key === "env") {
throw new Error("." + key + " is not allowed inside another env block");
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(`${(0, _optionAssertions.msg)(optLoc)} is only allowed in root programmatic options, or babel.config.js/config file options`);
}
if (type === "env" && key === "overrides") {
throw new Error("." + key + " is not allowed inside an env block");
}
if (type === "override" && key === "overrides") {
throw new Error("." + key + " is not allowed inside an overrides block");
}
var validator = COMMON_VALIDATORS[key] || NONPRESET_VALIDATORS[key] || ROOT_VALIDATORS[key];
if (validator) validator(key, opts[key]);else throw buildUnknownError(key);
const validator = COMMON_VALIDATORS[key] || NONPRESET_VALIDATORS[key] || BABELRC_VALIDATORS[key] || ROOT_VALIDATORS[key] || throwUnknownError;
validator(optLoc, opts[key]);
});
return opts;
}
function buildUnknownError(key) {
function throwUnknownError(loc) {
const key = loc.name;
if (_removed.default[key]) {
var _removed$key = _removed.default[key],
message = _removed$key.message,
_removed$key$version = _removed$key.version,
version = _removed$key$version === void 0 ? 5 : _removed$key$version;
throw new ReferenceError("Using removed Babel " + version + " option: ." + key + " - " + message);
const {
message,
version = 5
} = _removed.default[key];
throw new ReferenceError(`Using removed Babel ${version} option: ${(0, _optionAssertions.msg)(loc)} - ${message}`);
} else {
var unknownOptErr = "Unknown option: ." + key + ". Check out http://babeljs.io/docs/usage/options/ for more information about options.";
const unknownOptErr = `Unknown option: ${(0, _optionAssertions.msg)(loc)}. Check out https://babeljs.io/docs/en/babel-core/#options for more information about options.`;
throw new ReferenceError(unknownOptErr);
}
}
@@ -114,48 +134,53 @@ function assertNoDuplicateSourcemap(opts) {
}
}
function assertEnvSet(key, value) {
var obj = (0, _optionAssertions.assertObject)(key, value);
function assertEnvSet(loc, value) {
if (loc.parent.type === "env") {
throw new Error(`${(0, _optionAssertions.msg)(loc)} is not allowed inside of another .env block`);
}
const parent = loc.parent;
const obj = (0, _optionAssertions.assertObject)(loc, value);
if (obj) {
var _arr = Object.keys(obj);
for (var _i = 0; _i < _arr.length; _i++) {
var _key = _arr[_i];
var _env = (0, _optionAssertions.assertObject)(_key, obj[_key]);
if (_env) validate("env", _env);
for (const envName of Object.keys(obj)) {
const env = (0, _optionAssertions.assertObject)((0, _optionAssertions.access)(loc, envName), obj[envName]);
if (!env) continue;
const envLoc = {
type: "env",
name: envName,
parent
};
validateNested(envLoc, env);
}
}
return obj;
}
function assertOverridesList(key, value) {
var arr = (0, _optionAssertions.assertArray)(key, value);
function assertOverridesList(loc, value) {
if (loc.parent.type === "env") {
throw new Error(`${(0, _optionAssertions.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`);
}
const parent = loc.parent;
const arr = (0, _optionAssertions.assertArray)(loc, value);
if (arr) {
for (var _iterator = arr.entries(), _isArray = Array.isArray(_iterator), _i2 = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
var _ref;
if (_isArray) {
if (_i2 >= _iterator.length) break;
_ref = _iterator[_i2++];
} else {
_i2 = _iterator.next();
if (_i2.done) break;
_ref = _i2.value;
}
var _ref2 = _ref,
index = _ref2[0],
item = _ref2[1];
var _env2 = (0, _optionAssertions.assertObject)("" + index, item);
if (!_env2) throw new Error("." + key + "[" + index + "] must be an object");
validate("override", _env2);
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 overridesLoc = {
type: "overrides",
index,
parent
};
validateNested(overridesLoc, env);
}
}

22
node_modules/@babel/core/lib/config/validation/plugins.js generated vendored
View File

@@ -7,7 +7,7 @@ exports.validatePluginObject = validatePluginObject;
var _optionAssertions = require("./option-assertions");
var VALIDATORS = {
const VALIDATORS = {
name: _optionAssertions.assertString,
manipulateOptions: _optionAssertions.assertFunction,
pre: _optionAssertions.assertFunction,
@@ -19,15 +19,13 @@ var VALIDATORS = {
};
function assertVisitorMap(key, value) {
var obj = (0, _optionAssertions.assertObject)(key, value);
const obj = (0, _optionAssertions.assertObject)(key, value);
if (obj) {
Object.keys(obj).forEach(function (prop) {
return assertVisitorHandler(prop, obj[prop]);
});
Object.keys(obj).forEach(prop => assertVisitorHandler(prop, obj[prop]));
if (obj.enter || obj.exit) {
throw new Error("." + key + " cannot contain catch-all \"enter\" or \"exit\" handlers. Please target individual nodes.");
throw new Error(`.${key} cannot contain catch-all "enter" or "exit" handlers. Please target individual nodes.`);
}
}
@@ -36,22 +34,22 @@ function assertVisitorMap(key, value) {
function assertVisitorHandler(key, value) {
if (value && typeof value === "object") {
Object.keys(value).forEach(function (handler) {
Object.keys(value).forEach(handler => {
if (handler !== "enter" && handler !== "exit") {
throw new Error(".visitor[\"" + key + "\"] may only have .enter and/or .exit handlers.");
throw new Error(`.visitor["${key}"] may only have .enter and/or .exit handlers.`);
}
});
} else if (typeof value !== "function") {
throw new Error(".visitor[\"" + key + "\"] must be a function");
throw new Error(`.visitor["${key}"] must be a function`);
}
return value;
}
function validatePluginObject(obj) {
Object.keys(obj).forEach(function (key) {
var validator = VALIDATORS[key];
if (validator) validator(key, obj[key]);else throw new Error("." + key + " is not a valid Plugin property");
Object.keys(obj).forEach(key => {
const validator = VALIDATORS[key];
if (validator) validator(key, obj[key]);else throw new Error(`.${key} is not a valid Plugin property`);
});
return obj;
}

163
node_modules/@babel/core/lib/index.js generated vendored
View File

@@ -6,119 +6,149 @@ Object.defineProperty(exports, "__esModule", {
exports.Plugin = Plugin;
Object.defineProperty(exports, "File", {
enumerable: true,
get: function get() {
get: function () {
return _file.default;
}
});
Object.defineProperty(exports, "buildExternalHelpers", {
enumerable: true,
get: function get() {
get: function () {
return _buildExternalHelpers.default;
}
});
Object.defineProperty(exports, "resolvePlugin", {
enumerable: true,
get: function get() {
get: function () {
return _files.resolvePlugin;
}
});
Object.defineProperty(exports, "resolvePreset", {
enumerable: true,
get: function get() {
get: function () {
return _files.resolvePreset;
}
});
Object.defineProperty(exports, "version", {
enumerable: true,
get: function get() {
get: function () {
return _package.version;
}
});
Object.defineProperty(exports, "getEnv", {
enumerable: true,
get: function get() {
get: function () {
return _environment.getEnv;
}
});
Object.defineProperty(exports, "tokTypes", {
enumerable: true,
get: function () {
return _parser().tokTypes;
}
});
Object.defineProperty(exports, "traverse", {
enumerable: true,
get: function get() {
get: function () {
return _traverse().default;
}
});
Object.defineProperty(exports, "template", {
enumerable: true,
get: function get() {
get: function () {
return _template().default;
}
});
Object.defineProperty(exports, "createConfigItem", {
enumerable: true,
get: function () {
return _item.createConfigItem;
}
});
Object.defineProperty(exports, "loadPartialConfig", {
enumerable: true,
get: function get() {
get: function () {
return _config.loadPartialConfig;
}
});
Object.defineProperty(exports, "loadOptions", {
enumerable: true,
get: function get() {
get: function () {
return _config.loadOptions;
}
});
Object.defineProperty(exports, "OptionManager", {
enumerable: true,
get: function get() {
return _config.OptionManager;
}
});
Object.defineProperty(exports, "createConfigItem", {
enumerable: true,
get: function get() {
return _item.createConfigItem;
}
});
Object.defineProperty(exports, "transform", {
enumerable: true,
get: function get() {
return _transform.default;
get: function () {
return _transform.transform;
}
});
Object.defineProperty(exports, "transformSync", {
enumerable: true,
get: function get() {
return _transformSync.default;
get: function () {
return _transform.transformSync;
}
});
Object.defineProperty(exports, "transformAsync", {
enumerable: true,
get: function () {
return _transform.transformAsync;
}
});
Object.defineProperty(exports, "transformFile", {
enumerable: true,
get: function get() {
return _transformFile.default;
get: function () {
return _transformFile.transformFile;
}
});
Object.defineProperty(exports, "transformFileSync", {
enumerable: true,
get: function get() {
return _transformFileSync.default;
get: function () {
return _transformFile.transformFileSync;
}
});
Object.defineProperty(exports, "transformFileAsync", {
enumerable: true,
get: function () {
return _transformFile.transformFileAsync;
}
});
Object.defineProperty(exports, "transformFromAst", {
enumerable: true,
get: function get() {
return _transformAst.default;
get: function () {
return _transformAst.transformFromAst;
}
});
Object.defineProperty(exports, "transformFromAstSync", {
enumerable: true,
get: function get() {
return _transformAstSync.default;
get: function () {
return _transformAst.transformFromAstSync;
}
});
Object.defineProperty(exports, "transformFromAstAsync", {
enumerable: true,
get: function () {
return _transformAst.transformFromAstAsync;
}
});
Object.defineProperty(exports, "parse", {
enumerable: true,
get: function get() {
return _parse.default;
get: function () {
return _parse.parse;
}
});
exports.types = exports.DEFAULT_EXTENSIONS = void 0;
Object.defineProperty(exports, "parseSync", {
enumerable: true,
get: function () {
return _parse.parseSync;
}
});
Object.defineProperty(exports, "parseAsync", {
enumerable: true,
get: function () {
return _parse.parseAsync;
}
});
exports.types = exports.OptionManager = exports.DEFAULT_EXTENSIONS = void 0;
var _file = _interopRequireDefault(require("./transformation/file/file"));
@@ -131,9 +161,9 @@ var _package = require("../package.json");
var _environment = require("./config/helpers/environment");
function _types() {
var data = _interopRequireWildcard(require("@babel/types"));
const data = _interopRequireWildcard(require("@babel/types"));
_types = function _types() {
_types = function () {
return data;
};
@@ -142,15 +172,25 @@ function _types() {
Object.defineProperty(exports, "types", {
enumerable: true,
get: function get() {
get: function () {
return _types();
}
});
function _traverse() {
var data = _interopRequireDefault(require("@babel/traverse"));
function _parser() {
const data = require("@babel/parser");
_traverse = function _traverse() {
_parser = function () {
return data;
};
return data;
}
function _traverse() {
const data = _interopRequireDefault(require("@babel/traverse"));
_traverse = function () {
return data;
};
@@ -158,40 +198,43 @@ function _traverse() {
}
function _template() {
var data = _interopRequireDefault(require("@babel/template"));
const data = _interopRequireDefault(require("@babel/template"));
_template = function _template() {
_template = function () {
return data;
};
return data;
}
var _config = require("./config");
var _item = require("./config/item");
var _transform = _interopRequireDefault(require("./transform"));
var _config = require("./config");
var _transformSync = _interopRequireDefault(require("./transform-sync"));
var _transform = require("./transform");
var _transformFile = _interopRequireDefault(require("./transform-file"));
var _transformFile = require("./transform-file");
var _transformFileSync = _interopRequireDefault(require("./transform-file-sync"));
var _transformAst = require("./transform-ast");
var _transformAst = _interopRequireDefault(require("./transform-ast"));
var _transformAstSync = _interopRequireDefault(require("./transform-ast-sync"));
var _parse = _interopRequireDefault(require("./parse"));
var _parse = require("./parse");
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function Plugin(alias) {
throw new Error("The (" + alias + ") Babel 5 plugin is being run with an unsupported Babel version.");
const DEFAULT_EXTENSIONS = Object.freeze([".js", ".jsx", ".es6", ".es", ".mjs"]);
exports.DEFAULT_EXTENSIONS = DEFAULT_EXTENSIONS;
class OptionManager {
init(opts) {
return (0, _config.loadOptions)(opts);
}
}
var DEFAULT_EXTENSIONS = Object.freeze([".js", ".jsx", ".es6", ".es", ".mjs"]);
exports.DEFAULT_EXTENSIONS = DEFAULT_EXTENSIONS;
exports.OptionManager = OptionManager;
function Plugin(alias) {
throw new Error(`The (${alias}) Babel 5 plugin is being run with an unsupported Babel version.`);
}

50
node_modules/@babel/core/lib/parse.js generated vendored
View File

@@ -3,7 +3,9 @@
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = parse;
exports.parseSync = parseSync;
exports.parseAsync = parseAsync;
exports.parse = void 0;
var _config = _interopRequireDefault(require("./config"));
@@ -13,13 +15,51 @@ var _normalizeOpts = _interopRequireDefault(require("./transformation/normalize-
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function parse(code, opts) {
var config = (0, _config.default)(opts);
const parse = function parse(code, opts, callback) {
if (typeof opts === "function") {
callback = opts;
opts = undefined;
}
if (callback === undefined) return parseSync(code, opts);
const config = (0, _config.default)(opts);
if (config === null) {
return null;
}
var file = (0, _normalizeFile.default)(config.passes, (0, _normalizeOpts.default)(config), code);
return file.ast;
const cb = callback;
process.nextTick(() => {
let ast = null;
try {
const cfg = (0, _config.default)(opts);
if (cfg === null) return cb(null, null);
ast = (0, _normalizeFile.default)(cfg.passes, (0, _normalizeOpts.default)(cfg), code).ast;
} catch (err) {
return cb(err);
}
cb(null, ast);
});
};
exports.parse = parse;
function parseSync(code, opts) {
const config = (0, _config.default)(opts);
if (config === null) {
return null;
}
return (0, _normalizeFile.default)(config.passes, (0, _normalizeOpts.default)(config), code).ast;
}
function parseAsync(code, opts) {
return new Promise((res, rej) => {
parse(code, opts, (err, result) => {
if (err == null) res(result);else rej(err);
});
});
}

89
node_modules/@babel/core/lib/tools/build-external-helpers.js generated vendored
View File

@@ -6,9 +6,9 @@ Object.defineProperty(exports, "__esModule", {
exports.default = _default;
function helpers() {
var data = _interopRequireWildcard(require("@babel/helpers"));
const data = _interopRequireWildcard(require("@babel/helpers"));
helpers = function helpers() {
helpers = function () {
return data;
};
@@ -16,9 +16,9 @@ function helpers() {
}
function _generator() {
var data = _interopRequireDefault(require("@babel/generator"));
const data = _interopRequireDefault(require("@babel/generator"));
_generator = function _generator() {
_generator = function () {
return data;
};
@@ -26,9 +26,9 @@ function _generator() {
}
function _template() {
var data = _interopRequireDefault(require("@babel/template"));
const data = _interopRequireDefault(require("@babel/template"));
_template = function _template() {
_template = function () {
return data;
};
@@ -36,49 +36,55 @@ function _template() {
}
function t() {
var data = _interopRequireWildcard(require("@babel/types"));
const data = _interopRequireWildcard(require("@babel/types"));
t = function t() {
t = function () {
return data;
};
return data;
}
var _templateObject = _taggedTemplateLiteralLoose(["\n (function (root, factory) {\n if (typeof define === \"function\" && define.amd) {\n define(AMD_ARGUMENTS, factory);\n } else if (typeof exports === \"object\") {\n factory(COMMON_ARGUMENTS);\n } else {\n factory(BROWSER_ARGUMENTS);\n }\n })(UMD_ROOT, function (FACTORY_PARAMETERS) {\n FACTORY_BODY\n });\n "]);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
function _taggedTemplateLiteralLoose(strings, raw) { if (!raw) { raw = strings.slice(0); } strings.raw = raw; return strings; }
var buildUmdWrapper = function buildUmdWrapper(replacements) {
return (0, _template().default)(_templateObject)(replacements);
};
const buildUmdWrapper = replacements => _template().default`
(function (root, factory) {
if (typeof define === "function" && define.amd) {
define(AMD_ARGUMENTS, factory);
} else if (typeof exports === "object") {
factory(COMMON_ARGUMENTS);
} else {
factory(BROWSER_ARGUMENTS);
}
})(UMD_ROOT, function (FACTORY_PARAMETERS) {
FACTORY_BODY
});
`(replacements);
function buildGlobal(whitelist) {
var namespace = t().identifier("babelHelpers");
var body = [];
var container = t().functionExpression(null, [t().identifier("global")], t().blockStatement(body));
var tree = t().program([t().expressionStatement(t().callExpression(container, [t().conditionalExpression(t().binaryExpression("===", t().unaryExpression("typeof", t().identifier("global")), t().stringLiteral("undefined")), t().identifier("self"), t().identifier("global"))]))]);
const namespace = t().identifier("babelHelpers");
const body = [];
const container = t().functionExpression(null, [t().identifier("global")], t().blockStatement(body));
const tree = t().program([t().expressionStatement(t().callExpression(container, [t().conditionalExpression(t().binaryExpression("===", t().unaryExpression("typeof", t().identifier("global")), t().stringLiteral("undefined")), t().identifier("self"), t().identifier("global"))]))]);
body.push(t().variableDeclaration("var", [t().variableDeclarator(namespace, t().assignmentExpression("=", t().memberExpression(t().identifier("global"), namespace), t().objectExpression([])))]));
buildHelpers(body, namespace, whitelist);
return tree;
}
function buildModule(whitelist) {
var body = [];
var refs = buildHelpers(body, null, whitelist);
body.unshift(t().exportNamedDeclaration(null, Object.keys(refs).map(function (name) {
const body = [];
const refs = buildHelpers(body, null, whitelist);
body.unshift(t().exportNamedDeclaration(null, Object.keys(refs).map(name => {
return t().exportSpecifier(t().cloneNode(refs[name]), t().identifier(name));
})));
return t().program(body, [], "module");
}
function buildUmd(whitelist) {
var namespace = t().identifier("babelHelpers");
var body = [];
const namespace = t().identifier("babelHelpers");
const body = [];
body.push(t().variableDeclaration("var", [t().variableDeclarator(namespace, t().identifier("global"))]));
buildHelpers(body, namespace, whitelist);
return t().program([buildUmdWrapper({
@@ -92,40 +98,35 @@ function buildUmd(whitelist) {
}
function buildVar(whitelist) {
var namespace = t().identifier("babelHelpers");
var body = [];
const namespace = t().identifier("babelHelpers");
const body = [];
body.push(t().variableDeclaration("var", [t().variableDeclarator(namespace, t().objectExpression([]))]));
var tree = t().program(body);
const tree = t().program(body);
buildHelpers(body, namespace, whitelist);
body.push(t().expressionStatement(namespace));
return tree;
}
function buildHelpers(body, namespace, whitelist) {
var getHelperReference = function getHelperReference(name) {
return namespace ? t().memberExpression(namespace, t().identifier(name)) : t().identifier("_" + name);
const getHelperReference = name => {
return namespace ? t().memberExpression(namespace, t().identifier(name)) : t().identifier(`_${name}`);
};
var refs = {};
const refs = {};
helpers().list.forEach(function (name) {
if (whitelist && whitelist.indexOf(name) < 0) return;
var ref = refs[name] = getHelperReference(name);
var _helpers$get = helpers().get(name, getHelperReference, ref),
nodes = _helpers$get.nodes;
body.push.apply(body, nodes);
const ref = refs[name] = getHelperReference(name);
const {
nodes
} = helpers().get(name, getHelperReference, ref);
body.push(...nodes);
});
return refs;
}
function _default(whitelist, outputType) {
if (outputType === void 0) {
outputType = "global";
}
var tree;
var build = {
function _default(whitelist, outputType = "global") {
let tree;
const build = {
global: buildGlobal,
module: buildModule,
umd: buildUmd,
@@ -135,7 +136,7 @@ function _default(whitelist, outputType) {
if (build) {
tree = build(whitelist);
} else {
throw new Error("Unsupported output type " + outputType);
throw new Error(`Unsupported output type ${outputType}`);
}
return (0, _generator().default)(tree).code;

19
node_modules/@babel/core/lib/transform-ast-sync.js generated vendored
View File

@@ -1,19 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = transformFromAstSync;
var _config = _interopRequireDefault(require("./config"));
var _transformation = require("./transformation");
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function transformFromAstSync(ast, code, opts) {
var config = (0, _config.default)(opts);
if (config === null) return null;
if (!ast) throw new Error("No AST given");
return (0, _transformation.runSync)(config, code, ast);
}

35
node_modules/@babel/core/lib/transform-ast.js generated vendored
View File

@@ -3,26 +3,26 @@
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
exports.transformFromAstSync = transformFromAstSync;
exports.transformFromAstAsync = transformFromAstAsync;
exports.transformFromAst = void 0;
var _config = _interopRequireDefault(require("./config"));
var _transformation = require("./transformation");
var _transformAstSync = _interopRequireDefault(require("./transform-ast-sync"));
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
var transformFromAst = function transformFromAst(ast, code, opts, callback) {
const transformFromAst = function transformFromAst(ast, code, opts, callback) {
if (typeof opts === "function") {
opts = undefined;
callback = opts;
opts = undefined;
}
if (callback === undefined) return (0, _transformAstSync.default)(ast, code, opts);
var cb = callback;
process.nextTick(function () {
var cfg;
if (callback === undefined) return transformFromAstSync(ast, code, opts);
const cb = callback;
process.nextTick(() => {
let cfg;
try {
cfg = (0, _config.default)(opts);
@@ -36,4 +36,19 @@ var transformFromAst = function transformFromAst(ast, code, opts, callback) {
});
};
exports.default = transformFromAst;
exports.transformFromAst = transformFromAst;
function transformFromAstSync(ast, code, opts) {
const config = (0, _config.default)(opts);
if (config === null) return null;
if (!ast) throw new Error("No AST given");
return (0, _transformation.runSync)(config, code, ast);
}
function transformFromAstAsync(ast, code, opts) {
return new Promise((res, rej) => {
transformFromAst(ast, code, opts, (err, result) => {
if (err == null) res(result);else rej(err);
});
});
}

20
node_modules/@babel/core/lib/transform-file-browser.js generated vendored
View File

@@ -3,16 +3,24 @@
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = transformFile;
function transformFile(filename, opts, callback) {
if (opts === void 0) {
opts = {};
}
exports.transformFileSync = transformFileSync;
exports.transformFileAsync = transformFileAsync;
exports.transformFile = void 0;
const transformFile = function transformFile(filename, opts, callback) {
if (typeof opts === "function") {
callback = opts;
}
callback(new Error("Transforming files is not supported in browsers"), null);
};
exports.transformFile = transformFile;
function transformFileSync() {
throw new Error("Transforming files is not supported in browsers");
}
function transformFileAsync() {
return Promise.reject(new Error("Transforming files is not supported in browsers"));
}

10
node_modules/@babel/core/lib/transform-file-sync-browser.js generated vendored
View File

@@ -1,10 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = transformFileSync;
function transformFileSync() {
throw new Error("Transforming files is not supported in browsers");
}

40
node_modules/@babel/core/lib/transform-file-sync.js generated vendored
View File

@@ -1,40 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = transformFileSync;
function _fs() {
var data = _interopRequireDefault(require("fs"));
_fs = function _fs() {
return data;
};
return data;
}
var _config = _interopRequireDefault(require("./config"));
var _transformation = require("./transformation");
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function transformFileSync(filename, opts) {
var options;
if (opts == null) {
options = {
filename: filename
};
} else if (opts && typeof opts === "object") {
options = Object.assign({}, opts, {
filename: filename
});
}
var config = (0, _config.default)(options);
if (config === null) return null;
return (0, _transformation.runSync)(config, _fs().default.readFileSync(filename, "utf8"));
}

52
node_modules/@babel/core/lib/transform-file.js generated vendored
View File

@@ -3,12 +3,14 @@
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
exports.transformFileSync = transformFileSync;
exports.transformFileAsync = transformFileAsync;
exports.transformFile = void 0;
function _fs() {
var data = _interopRequireDefault(require("fs"));
const data = _interopRequireDefault(require("fs"));
_fs = function _fs() {
_fs = function () {
return data;
};
@@ -21,8 +23,10 @@ var _transformation = require("./transformation");
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
var transformFile = function transformFile(filename, opts, callback) {
var options;
({});
const transformFile = function transformFile(filename, opts, callback) {
let options;
if (typeof opts === "function") {
callback = opts;
@@ -31,16 +35,16 @@ var transformFile = function transformFile(filename, opts, callback) {
if (opts == null) {
options = {
filename: filename
filename
};
} else if (opts && typeof opts === "object") {
options = Object.assign({}, opts, {
filename: filename
filename
});
}
process.nextTick(function () {
var cfg;
process.nextTick(() => {
let cfg;
try {
cfg = (0, _config.default)(options);
@@ -49,7 +53,7 @@ var transformFile = function transformFile(filename, opts, callback) {
return callback(err);
}
var config = cfg;
const config = cfg;
_fs().default.readFile(filename, "utf8", function (err, code) {
if (err) return callback(err, null);
@@ -58,4 +62,30 @@ var transformFile = function transformFile(filename, opts, callback) {
});
};
exports.default = transformFile;
exports.transformFile = transformFile;
function transformFileSync(filename, opts) {
let options;
if (opts == null) {
options = {
filename
};
} else if (opts && typeof opts === "object") {
options = Object.assign({}, opts, {
filename
});
}
const config = (0, _config.default)(options);
if (config === null) return null;
return (0, _transformation.runSync)(config, _fs().default.readFileSync(filename, "utf8"));
}
function transformFileAsync(filename, opts) {
return new Promise((res, rej) => {
transformFile(filename, opts, (err, result) => {
if (err == null) res(result);else rej(err);
});
});
}

18
node_modules/@babel/core/lib/transform-sync.js generated vendored
View File

@@ -1,18 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = transformSync;
var _config = _interopRequireDefault(require("./config"));
var _transformation = require("./transformation");
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function transformSync(code, opts) {
var config = (0, _config.default)(opts);
if (config === null) return null;
return (0, _transformation.runSync)(config, code);
}

34
node_modules/@babel/core/lib/transform.js generated vendored
View File

@@ -3,26 +3,26 @@
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
exports.transformSync = transformSync;
exports.transformAsync = transformAsync;
exports.transform = void 0;
var _config = _interopRequireDefault(require("./config"));
var _transformation = require("./transformation");
var _transformSync = _interopRequireDefault(require("./transform-sync"));
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
var transform = function transform(code, opts, callback) {
const transform = function transform(code, opts, callback) {
if (typeof opts === "function") {
opts = undefined;
callback = opts;
opts = undefined;
}
if (callback === undefined) return (0, _transformSync.default)(code, opts);
var cb = callback;
process.nextTick(function () {
var cfg;
if (callback === undefined) return transformSync(code, opts);
const cb = callback;
process.nextTick(() => {
let cfg;
try {
cfg = (0, _config.default)(opts);
@@ -35,4 +35,18 @@ var transform = function transform(code, opts, callback) {
});
};
exports.default = transform;
exports.transform = transform;
function transformSync(code, opts) {
const config = (0, _config.default)(opts);
if (config === null) return null;
return (0, _transformation.runSync)(config, code);
}
function transformAsync(code, opts) {
return new Promise((res, rej) => {
transform(code, opts, (err, result) => {
if (err == null) res(result);else rej(err);
});
});
}

24
node_modules/@babel/core/lib/transformation/block-hoist-plugin.js generated vendored
View File

@@ -6,9 +6,9 @@ Object.defineProperty(exports, "__esModule", {
exports.default = loadBlockHoistPlugin;
function _sortBy() {
var data = _interopRequireDefault(require("lodash/sortBy"));
const data = _interopRequireDefault(require("lodash/sortBy"));
_sortBy = function _sortBy() {
_sortBy = function () {
return data;
};
@@ -19,11 +19,11 @@ var _config = _interopRequireDefault(require("../config"));
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
var LOADED_PLUGIN;
let LOADED_PLUGIN;
function loadBlockHoistPlugin() {
if (!LOADED_PLUGIN) {
var config = (0, _config.default)({
const config = (0, _config.default)({
babelrc: false,
configFile: false,
plugins: [blockHoistPlugin]
@@ -35,16 +35,17 @@ function loadBlockHoistPlugin() {
return LOADED_PLUGIN;
}
var blockHoistPlugin = {
const blockHoistPlugin = {
name: "internal.blockHoist",
visitor: {
Block: {
exit: function exit(_ref) {
var node = _ref.node;
var hasChange = false;
exit({
node
}) {
let hasChange = false;
for (var i = 0; i < node.body.length; i++) {
var bodyNode = node.body[i];
for (let i = 0; i < node.body.length; i++) {
const bodyNode = node.body[i];
if (bodyNode && bodyNode._blockHoist != null) {
hasChange = true;
@@ -54,12 +55,13 @@ var blockHoistPlugin = {
if (!hasChange) return;
node.body = (0, _sortBy().default)(node.body, function (bodyNode) {
var priority = bodyNode && bodyNode._blockHoist;
let priority = bodyNode && bodyNode._blockHoist;
if (priority == null) priority = 1;
if (priority === true) priority = 2;
return -1 * priority;
});
}
}
}
};

231
node_modules/@babel/core/lib/transformation/file/file.js generated vendored
View File

@@ -6,9 +6,9 @@ Object.defineProperty(exports, "__esModule", {
exports.default = void 0;
function helpers() {
var data = _interopRequireWildcard(require("@babel/helpers"));
const data = _interopRequireWildcard(require("@babel/helpers"));
helpers = function helpers() {
helpers = function () {
return data;
};
@@ -16,9 +16,9 @@ function helpers() {
}
function _traverse() {
var data = _interopRequireWildcard(require("@babel/traverse"));
const data = _interopRequireWildcard(require("@babel/traverse"));
_traverse = function _traverse() {
_traverse = function () {
return data;
};
@@ -26,9 +26,9 @@ function _traverse() {
}
function _codeFrame() {
var data = require("@babel/code-frame");
const data = require("@babel/code-frame");
_codeFrame = function _codeFrame() {
_codeFrame = function () {
return data;
};
@@ -36,47 +36,64 @@ function _codeFrame() {
}
function t() {
var data = _interopRequireWildcard(require("@babel/types"));
const data = _interopRequireWildcard(require("@babel/types"));
t = function t() {
t = function () {
return data;
};
return data;
}
function _semver() {
const data = _interopRequireDefault(require("semver"));
_semver = function () {
return data;
};
return data;
}
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
var errorVisitor = {
enter: function enter(path, state) {
var loc = path.node.loc;
const errorVisitor = {
enter(path, state) {
const loc = path.node.loc;
if (loc) {
state.loc = loc;
path.stop();
}
}
};
var File = function () {
function File(options, _ref) {
var code = _ref.code,
ast = _ref.ast,
shebang = _ref.shebang,
inputMap = _ref.inputMap;
class File {
constructor(options, {
code,
ast,
inputMap
}) {
this._map = new Map();
this.declarations = {};
this.path = null;
this.ast = {};
this.metadata = {};
this.hub = new (_traverse().Hub)(this);
this.code = "";
this.shebang = "";
this.inputMap = null;
this.hub = {
file: this,
getCode: () => this.code,
getScope: () => this.scope,
addHelper: this.addHelper.bind(this),
buildError: this.buildCodeFrameError.bind(this)
};
this.opts = options;
this.code = code;
this.ast = ast;
this.shebang = shebang;
this.inputMap = inputMap;
this.path = _traverse().NodePath.get({
hub: this.hub,
@@ -88,44 +105,58 @@ var File = function () {
this.scope = this.path.scope;
}
var _proto = File.prototype;
get shebang() {
const {
interpreter
} = this.path.node;
return interpreter ? interpreter.value : "";
}
set shebang(value) {
if (value) {
this.path.get("interpreter").replaceWith(t().interpreterDirective(value));
} else {
this.path.get("interpreter").remove();
}
}
set(key, val) {
if (key === "helpersNamespace") {
throw new Error("Babel 7.0.0-beta.56 has dropped support for the 'helpersNamespace' utility." + "If you are using @babel/plugin-external-helpers you will need to use a newer " + "version than the one you currently have installed. " + "If you have your own implementation, you'll want to explore using 'helperGenerator' " + "alongside 'file.availableHelper()'.");
}
_proto.set = function set(key, val) {
this._map.set(key, val);
};
}
_proto.get = function get(key) {
get(key) {
return this._map.get(key);
};
}
_proto.has = function has(key) {
has(key) {
return this._map.has(key);
};
}
_proto.getModuleName = function getModuleName() {
var _opts = this.opts,
filename = _opts.filename,
_opts$filenameRelativ = _opts.filenameRelative,
filenameRelative = _opts$filenameRelativ === void 0 ? filename : _opts$filenameRelativ,
moduleId = _opts.moduleId,
_opts$moduleIds = _opts.moduleIds,
moduleIds = _opts$moduleIds === void 0 ? !!moduleId : _opts$moduleIds,
getModuleId = _opts.getModuleId,
sourceRootTmp = _opts.sourceRoot,
_opts$moduleRoot = _opts.moduleRoot,
moduleRoot = _opts$moduleRoot === void 0 ? sourceRootTmp : _opts$moduleRoot,
_opts$sourceRoot = _opts.sourceRoot,
sourceRoot = _opts$sourceRoot === void 0 ? moduleRoot : _opts$sourceRoot;
getModuleName() {
const {
filename,
filenameRelative = filename,
moduleId,
moduleIds = !!moduleId,
getModuleId,
sourceRoot: sourceRootTmp,
moduleRoot = sourceRootTmp,
sourceRoot = moduleRoot
} = this.opts;
if (!moduleIds) return null;
if (moduleId != null && !getModuleId) {
return moduleId;
}
var moduleName = moduleRoot != null ? moduleRoot + "/" : "";
let moduleName = moduleRoot != null ? moduleRoot + "/" : "";
if (filenameRelative) {
var sourceRootReplacer = sourceRoot != null ? new RegExp("^" + sourceRoot + "/?") : "";
const sourceRootReplacer = sourceRoot != null ? new RegExp("^" + sourceRoot + "/?") : "";
moduleName += filenameRelative.replace(sourceRootReplacer, "").replace(/\.(\w*?)$/, "");
}
@@ -136,112 +167,100 @@ var File = function () {
} else {
return moduleName;
}
};
}
_proto.resolveModuleSource = function resolveModuleSource(source) {
return source;
};
_proto.addImport = function addImport() {
addImport() {
throw new Error("This API has been removed. If you're looking for this " + "functionality in Babel 7, you should import the " + "'@babel/helper-module-imports' module and use the functions exposed " + " from that module, such as 'addNamed' or 'addDefault'.");
};
}
_proto.addHelper = function addHelper(name) {
var _this = this;
availableHelper(name, versionRange) {
let minVersion;
var declar = this.declarations[name];
if (declar) return t().cloneNode(declar);
var generator = this.get("helperGenerator");
var runtime = this.get("helpersNamespace");
if (generator) {
var res = generator(name);
if (res) return res;
} else if (runtime) {
return t().memberExpression(t().cloneNode(runtime), t().identifier(name));
try {
minVersion = helpers().minVersion(name);
} catch (err) {
if (err.code !== "BABEL_HELPER_UNKNOWN") throw err;
return false;
}
var uid = this.declarations[name] = this.scope.generateUidIdentifier(name);
var dependencies = {};
if (typeof versionRange !== "string") return true;
if (_semver().default.valid(versionRange)) versionRange = `^${versionRange}`;
return !_semver().default.intersects(`<${minVersion}`, versionRange) && !_semver().default.intersects(`>=8.0.0`, versionRange);
}
for (var _iterator = helpers().getDependencies(name), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
var _ref2;
addHelper(name) {
const declar = this.declarations[name];
if (declar) return t().cloneNode(declar);
const generator = this.get("helperGenerator");
if (_isArray) {
if (_i >= _iterator.length) break;
_ref2 = _iterator[_i++];
} else {
_i = _iterator.next();
if (_i.done) break;
_ref2 = _i.value;
}
if (generator) {
const res = generator(name);
if (res) return res;
}
var dep = _ref2;
const uid = this.declarations[name] = this.scope.generateUidIdentifier(name);
const dependencies = {};
for (const dep of helpers().getDependencies(name)) {
dependencies[dep] = this.addHelper(dep);
}
var _helpers$get = helpers().get(name, function (dep) {
return dependencies[dep];
}, uid, Object.keys(this.scope.getAllBindings())),
nodes = _helpers$get.nodes,
globals = _helpers$get.globals;
globals.forEach(function (name) {
if (_this.path.scope.hasBinding(name, true)) {
_this.path.scope.rename(name);
const {
nodes,
globals
} = helpers().get(name, dep => dependencies[dep], uid, Object.keys(this.scope.getAllBindings()));
globals.forEach(name => {
if (this.path.scope.hasBinding(name, true)) {
this.path.scope.rename(name);
}
});
nodes.forEach(function (node) {
nodes.forEach(node => {
node._compact = true;
});
this.path.unshiftContainer("body", nodes);
this.path.get("body").forEach(function (path) {
this.path.get("body").forEach(path => {
if (nodes.indexOf(path.node) === -1) return;
if (path.isVariableDeclaration()) _this.scope.registerDeclaration(path);
if (path.isVariableDeclaration()) this.scope.registerDeclaration(path);
});
return uid;
};
}
_proto.addTemplateObject = function addTemplateObject() {
addTemplateObject() {
throw new Error("This function has been moved into the template literal transform itself.");
};
}
_proto.buildCodeFrameError = function buildCodeFrameError(node, msg, Error) {
if (Error === void 0) {
Error = SyntaxError;
}
var loc = node && (node.loc || node._loc);
msg = this.opts.filename + ": " + msg;
buildCodeFrameError(node, msg, Error = SyntaxError) {
let loc = node && (node.loc || node._loc);
msg = `${this.opts.filename}: ${msg}`;
if (!loc && node) {
var state = {
const state = {
loc: null
};
(0, _traverse().default)(node, errorVisitor, this.scope, state);
loc = state.loc;
var txt = "This is an error on an internal node. Probably an internal error.";
let txt = "This is an error on an internal node. Probably an internal error.";
if (loc) txt += " Location has been estimated.";
msg += " (" + txt + ")";
msg += ` (${txt})`;
}
if (loc) {
var _opts$highlightCode = this.opts.highlightCode,
highlightCode = _opts$highlightCode === void 0 ? true : _opts$highlightCode;
const {
highlightCode = true
} = this.opts;
msg += "\n" + (0, _codeFrame().codeFrameColumns)(this.code, {
start: {
line: loc.start.line,
column: loc.start.column + 1
}
}, {
highlightCode: highlightCode
highlightCode
});
}
return new Error(msg);
};
}
return File;
}();
}
exports.default = File;

124
node_modules/@babel/core/lib/transformation/file/generate.js generated vendored
View File

@@ -6,19 +6,9 @@ Object.defineProperty(exports, "__esModule", {
exports.default = generateCode;
function _convertSourceMap() {
var data = _interopRequireDefault(require("convert-source-map"));
const data = _interopRequireDefault(require("convert-source-map"));
_convertSourceMap = function _convertSourceMap() {
return data;
};
return data;
}
function _sourceMap() {
var data = _interopRequireDefault(require("source-map"));
_sourceMap = function _sourceMap() {
_convertSourceMap = function () {
return data;
};
@@ -26,63 +16,42 @@ function _sourceMap() {
}
function _generator() {
var data = _interopRequireDefault(require("@babel/generator"));
const data = _interopRequireDefault(require("@babel/generator"));
_generator = function _generator() {
_generator = function () {
return data;
};
return data;
}
var _mergeMap = _interopRequireDefault(require("./merge-map"));
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function generateCode(pluginPasses, file) {
var opts = file.opts,
ast = file.ast,
shebang = file.shebang,
code = file.code,
inputMap = file.inputMap;
var results = [];
const {
opts,
ast,
code,
inputMap
} = file;
const results = [];
for (var _iterator = pluginPasses, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
var _ref;
if (_isArray) {
if (_i >= _iterator.length) break;
_ref = _iterator[_i++];
} else {
_i = _iterator.next();
if (_i.done) break;
_ref = _i.value;
}
var plugins = _ref;
for (var _iterator2 = plugins, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
var _ref2;
if (_isArray2) {
if (_i2 >= _iterator2.length) break;
_ref2 = _iterator2[_i2++];
} else {
_i2 = _iterator2.next();
if (_i2.done) break;
_ref2 = _i2.value;
}
var plugin = _ref2;
var generatorOverride = plugin.generatorOverride;
for (const plugins of pluginPasses) {
for (const plugin of plugins) {
const {
generatorOverride
} = plugin;
if (generatorOverride) {
var _result2 = generatorOverride(ast, opts.generatorOpts, code, _generator().default);
if (_result2 !== undefined) results.push(_result2);
const result = generatorOverride(ast, opts.generatorOpts, code, _generator().default);
if (result !== undefined) results.push(result);
}
}
}
var result;
let result;
if (results.length === 0) {
result = (0, _generator().default)(ast, opts.generatorOpts, code);
@@ -90,22 +59,19 @@ function generateCode(pluginPasses, file) {
result = results[0];
if (typeof result.then === "function") {
throw new Error("You appear to be using an async parser 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.");
throw new Error(`You appear to be using an async parser 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.`);
}
} else {
throw new Error("More than one plugin attempted to override codegen.");
}
var _result = result,
outputCode = _result.code,
outputMap = _result.map;
if (shebang) {
outputCode = shebang + "\n" + outputCode;
}
let {
code: outputCode,
map: outputMap
} = result;
if (outputMap && inputMap) {
outputMap = mergeSourceMap(inputMap.toObject(), outputMap);
outputMap = (0, _mergeMap.default)(inputMap.toObject(), outputMap);
}
if (opts.sourceMaps === "inline" || opts.sourceMaps === "both") {
@@ -117,39 +83,7 @@ function generateCode(pluginPasses, file) {
}
return {
outputCode: outputCode,
outputMap: outputMap
outputCode,
outputMap
};
}
function mergeSourceMap(inputMap, map) {
var inputMapConsumer = new (_sourceMap().default.SourceMapConsumer)(inputMap);
var outputMapConsumer = new (_sourceMap().default.SourceMapConsumer)(map);
var mergedGenerator = new (_sourceMap().default.SourceMapGenerator)({
file: inputMapConsumer.file,
sourceRoot: inputMapConsumer.sourceRoot
});
var source = outputMapConsumer.sources[0];
inputMapConsumer.eachMapping(function (mapping) {
var generatedPosition = outputMapConsumer.generatedPositionFor({
line: mapping.generatedLine,
column: mapping.generatedColumn,
source: source
});
if (generatedPosition.column != null) {
mergedGenerator.addMapping({
source: mapping.source,
original: mapping.source == null ? null : {
line: mapping.originalLine,
column: mapping.originalColumn
},
generated: generatedPosition,
name: mapping.name
});
}
});
var mergedMap = mergedGenerator.toJSON();
inputMap.mappings = mergedMap.mappings;
return inputMap;
}

255
node_modules/@babel/core/lib/transformation/file/merge-map.js generated vendored Normal file
View File

@@ -0,0 +1,255 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = mergeSourceMap;
function _sourceMap() {
const data = _interopRequireDefault(require("source-map"));
_sourceMap = function () {
return data;
};
return data;
}
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function mergeSourceMap(inputMap, map) {
const input = buildMappingData(inputMap);
const output = buildMappingData(map);
const mergedGenerator = new (_sourceMap().default.SourceMapGenerator)();
for (const _ref of input.sources) {
const {
source
} = _ref;
if (typeof source.content === "string") {
mergedGenerator.setSourceContent(source.path, source.content);
}
}
if (output.sources.length === 1) {
const defaultSource = output.sources[0];
const insertedMappings = new Map();
eachInputGeneratedRange(input, (generated, original, source) => {
eachOverlappingGeneratedOutputRange(defaultSource, generated, item => {
const key = makeMappingKey(item);
if (insertedMappings.has(key)) return;
insertedMappings.set(key, item);
mergedGenerator.addMapping({
source: source.path,
original: {
line: original.line,
column: original.columnStart
},
generated: {
line: item.line,
column: item.columnStart
},
name: original.name
});
});
});
for (const item of insertedMappings.values()) {
if (item.columnEnd === Infinity) {
continue;
}
const clearItem = {
line: item.line,
columnStart: item.columnEnd
};
const key = makeMappingKey(clearItem);
if (insertedMappings.has(key)) {
continue;
}
mergedGenerator.addMapping({
generated: {
line: clearItem.line,
column: clearItem.columnStart
}
});
}
}
const result = mergedGenerator.toJSON();
if (typeof input.sourceRoot === "string") {
result.sourceRoot = input.sourceRoot;
}
return result;
}
function makeMappingKey(item) {
return `${item.line}/${item.columnStart}`;
}
function eachOverlappingGeneratedOutputRange(outputFile, inputGeneratedRange, callback) {
const overlappingOriginal = filterApplicableOriginalRanges(outputFile, inputGeneratedRange);
for (const _ref2 of overlappingOriginal) {
const {
generated
} = _ref2;
for (const item of generated) {
callback(item);
}
}
}
function filterApplicableOriginalRanges({
mappings
}, {
line,
columnStart,
columnEnd
}) {
return filterSortedArray(mappings, ({
original: outOriginal
}) => {
if (line > outOriginal.line) return -1;
if (line < outOriginal.line) return 1;
if (columnStart >= outOriginal.columnEnd) return -1;
if (columnEnd <= outOriginal.columnStart) return 1;
return 0;
});
}
function eachInputGeneratedRange(map, callback) {
for (const _ref3 of map.sources) {
const {
source,
mappings
} = _ref3;
for (const _ref4 of mappings) {
const {
original,
generated
} = _ref4;
for (const item of generated) {
callback(item, original, source);
}
}
}
}
function buildMappingData(map) {
const consumer = new (_sourceMap().default.SourceMapConsumer)(Object.assign({}, map, {
sourceRoot: null
}));
const sources = new Map();
const mappings = new Map();
let last = null;
consumer.computeColumnSpans();
consumer.eachMapping(m => {
if (m.originalLine === null) return;
let source = sources.get(m.source);
if (!source) {
source = {
path: m.source,
content: consumer.sourceContentFor(m.source, true)
};
sources.set(m.source, source);
}
let sourceData = mappings.get(source);
if (!sourceData) {
sourceData = {
source,
mappings: []
};
mappings.set(source, sourceData);
}
const obj = {
line: m.originalLine,
columnStart: m.originalColumn,
columnEnd: Infinity,
name: m.name
};
if (last && last.source === source && last.mapping.line === m.originalLine) {
last.mapping.columnEnd = m.originalColumn;
}
last = {
source,
mapping: obj
};
sourceData.mappings.push({
original: obj,
generated: consumer.allGeneratedPositionsFor({
source: m.source,
line: m.originalLine,
column: m.originalColumn
}).map(item => ({
line: item.line,
columnStart: item.column,
columnEnd: item.lastColumn + 1
}))
});
}, null, _sourceMap().default.SourceMapConsumer.ORIGINAL_ORDER);
return {
file: map.file,
sourceRoot: map.sourceRoot,
sources: Array.from(mappings.values())
};
}
function findInsertionLocation(array, callback) {
let left = 0;
let right = array.length;
while (left < right) {
const mid = Math.floor((left + right) / 2);
const item = array[mid];
const result = callback(item);
if (result === 0) {
left = mid;
break;
}
if (result >= 0) {
right = mid;
} else {
left = mid + 1;
}
}
let i = left;
if (i < array.length) {
while (i >= 0 && callback(array[i]) >= 0) {
i--;
}
return i + 1;
}
return i;
}
function filterSortedArray(array, callback) {
const start = findInsertionLocation(array, callback);
const results = [];
for (let i = start; i < array.length && callback(array[i]) === 0; i++) {
results.push(array[i]);
}
return results;
}

85
node_modules/@babel/core/lib/transformation/index.js generated vendored
View File

@@ -7,9 +7,9 @@ exports.runAsync = runAsync;
exports.runSync = runSync;
function _traverse() {
var data = _interopRequireDefault(require("@babel/traverse"));
const data = _interopRequireDefault(require("@babel/traverse"));
_traverse = function _traverse() {
_traverse = function () {
return data;
};
@@ -29,7 +29,7 @@ var _generate = _interopRequireDefault(require("./file/generate"));
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function runAsync(config, code, ast, callback) {
var result;
let result;
try {
result = runSync(config, code, ast);
@@ -41,14 +41,13 @@ function runAsync(config, code, ast, callback) {
}
function runSync(config, code, ast) {
var file = (0, _normalizeFile.default)(config.passes, (0, _normalizeOpts.default)(config), code, ast);
const file = (0, _normalizeFile.default)(config.passes, (0, _normalizeOpts.default)(config), code, ast);
transformFile(file, config.passes);
var opts = file.opts;
var _ref = opts.code !== false ? (0, _generate.default)(config.passes, file) : {},
outputCode = _ref.outputCode,
outputMap = _ref.outputMap;
const opts = file.opts;
const {
outputCode,
outputMap
} = opts.code !== false ? (0, _generate.default)(config.passes, file) : {};
return {
metadata: file.metadata,
options: opts,
@@ -60,72 +59,42 @@ function runSync(config, code, ast) {
}
function transformFile(file, pluginPasses) {
for (var _iterator = pluginPasses, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
var _ref2;
for (const pluginPairs of pluginPasses) {
const passPairs = [];
const passes = [];
const visitors = [];
if (_isArray) {
if (_i >= _iterator.length) break;
_ref2 = _iterator[_i++];
} else {
_i = _iterator.next();
if (_i.done) break;
_ref2 = _i.value;
}
var pluginPairs = _ref2;
var passPairs = [];
var passes = [];
var visitors = [];
for (var _iterator2 = pluginPairs.concat([(0, _blockHoistPlugin.default)()]), _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
var _ref3;
if (_isArray2) {
if (_i2 >= _iterator2.length) break;
_ref3 = _iterator2[_i2++];
} else {
_i2 = _iterator2.next();
if (_i2.done) break;
_ref3 = _i2.value;
}
var plugin = _ref3;
var pass = new _pluginPass.default(file, plugin.key, plugin.options);
for (const plugin of pluginPairs.concat([(0, _blockHoistPlugin.default)()])) {
const pass = new _pluginPass.default(file, plugin.key, plugin.options);
passPairs.push([plugin, pass]);
passes.push(pass);
visitors.push(plugin.visitor);
}
for (var _i3 = 0; _i3 < passPairs.length; _i3++) {
var _passPairs$_i = passPairs[_i3],
_plugin = _passPairs$_i[0],
_pass = _passPairs$_i[1];
var fn = _plugin.pre;
for (const [plugin, pass] of passPairs) {
const fn = plugin.pre;
if (fn) {
var result = fn.call(_pass, file);
const result = fn.call(pass, file);
if (isThenable(result)) {
throw new Error("You appear to be using an plugin with an async .pre, " + "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.");
throw new Error(`You appear to be using an plugin with an async .pre, ` + `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.`);
}
}
}
var visitor = _traverse().default.visitors.merge(visitors, passes, file.opts.wrapPluginVisitorMethod);
const visitor = _traverse().default.visitors.merge(visitors, passes, file.opts.wrapPluginVisitorMethod);
(0, _traverse().default)(file.ast, visitor, file.scope);
for (var _i4 = 0; _i4 < passPairs.length; _i4++) {
var _passPairs$_i2 = passPairs[_i4],
_plugin2 = _passPairs$_i2[0],
_pass2 = _passPairs$_i2[1];
var _fn = _plugin2.post;
for (const [plugin, pass] of passPairs) {
const fn = plugin.post;
if (_fn) {
var _result = _fn.call(_pass2, file);
if (fn) {
const result = fn.call(pass, file);
if (isThenable(_result)) {
throw new Error("You appear to be using an plugin with an async .post, " + "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.");
if (isThenable(result)) {
throw new Error(`You appear to be using an plugin with an async .post, ` + `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.`);
}
}
}
@@ -133,5 +102,5 @@ function transformFile(file, pluginPasses) {
}
function isThenable(val) {
return !!val && (typeof val === "object" || typeof val === "function") && typeof val.then === "function";
return !!val && (typeof val === "object" || typeof val === "function") && !!val.then && typeof val.then === "function";
}

176
node_modules/@babel/core/lib/transformation/normalize-file.js generated vendored
View File

@@ -5,10 +5,40 @@ Object.defineProperty(exports, "__esModule", {
});
exports.default = normalizeFile;
function t() {
var data = _interopRequireWildcard(require("@babel/types"));
function _path() {
const data = _interopRequireDefault(require("path"));
t = function t() {
_path = function () {
return data;
};
return data;
}
function _debug() {
const data = _interopRequireDefault(require("debug"));
_debug = function () {
return data;
};
return data;
}
function _cloneDeep() {
const data = _interopRequireDefault(require("lodash/cloneDeep"));
_cloneDeep = function () {
return data;
};
return data;
}
function t() {
const data = _interopRequireWildcard(require("@babel/types"));
t = function () {
return data;
};
@@ -16,19 +46,19 @@ function t() {
}
function _convertSourceMap() {
var data = _interopRequireDefault(require("convert-source-map"));
const data = _interopRequireDefault(require("convert-source-map"));
_convertSourceMap = function _convertSourceMap() {
_convertSourceMap = function () {
return data;
};
return data;
}
function _babylon() {
var data = require("babylon");
function _parser() {
const data = require("@babel/parser");
_babylon = function _babylon() {
_parser = function () {
return data;
};
@@ -36,9 +66,9 @@ function _babylon() {
}
function _codeFrame() {
var data = require("@babel/code-frame");
const data = require("@babel/code-frame");
_codeFrame = function _codeFrame() {
_codeFrame = function () {
return data;
};
@@ -49,32 +79,51 @@ var _file = _interopRequireDefault(require("./file/file"));
var _missingPluginHelper = _interopRequireDefault(require("./util/missing-plugin-helper"));
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
var shebangRegex = /^#!.*/;
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
const debug = (0, _debug().default)("babel:transform:file");
function normalizeFile(pluginPasses, options, code, ast) {
code = "" + (code || "");
var shebang = null;
var inputMap = null;
code = `${code || ""}`;
let inputMap = null;
if (options.inputSourceMap !== false) {
inputMap = _convertSourceMap().default.fromSource(code);
if (inputMap) {
code = _convertSourceMap().default.removeComments(code);
} else if (typeof options.inputSourceMap === "object") {
if (typeof options.inputSourceMap === "object") {
inputMap = _convertSourceMap().default.fromObject(options.inputSourceMap);
}
}
var shebangMatch = shebangRegex.exec(code);
if (!inputMap) {
try {
inputMap = _convertSourceMap().default.fromSource(code);
if (shebangMatch) {
shebang = shebangMatch[0];
code = code.replace(shebangRegex, "");
if (inputMap) {
code = _convertSourceMap().default.removeComments(code);
}
} catch (err) {
debug("discarding unknown inline input sourcemap", err);
code = _convertSourceMap().default.removeComments(code);
}
}
if (!inputMap) {
if (typeof options.filename === "string") {
try {
inputMap = _convertSourceMap().default.fromMapFileSource(code, _path().default.dirname(options.filename));
if (inputMap) {
code = _convertSourceMap().default.removeMapFileComments(code);
}
} catch (err) {
debug("discarding unknown file input sourcemap", err);
code = _convertSourceMap().default.removeMapFileComments(code);
}
} else {
debug("discarding un-loadable file input sourcemap");
code = _convertSourceMap().default.removeMapFileComments(code);
}
}
}
if (ast) {
@@ -83,64 +132,45 @@ function normalizeFile(pluginPasses, options, code, ast) {
} else if (ast.type !== "File") {
throw new Error("AST root must be a Program or File node");
}
ast = (0, _cloneDeep().default)(ast);
} else {
ast = parser(pluginPasses, options, code);
}
return new _file.default(options, {
code: code,
ast: ast,
shebang: shebang,
inputMap: inputMap
code,
ast,
inputMap
});
}
function parser(pluginPasses, options, code) {
function parser(pluginPasses, {
parserOpts,
highlightCode = true,
filename = "unknown"
}, code) {
try {
var results = [];
const results = [];
for (var _iterator = pluginPasses, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
var _ref;
if (_isArray) {
if (_i >= _iterator.length) break;
_ref = _iterator[_i++];
} else {
_i = _iterator.next();
if (_i.done) break;
_ref = _i.value;
}
var plugins = _ref;
for (var _iterator2 = plugins, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
var _ref2;
if (_isArray2) {
if (_i2 >= _iterator2.length) break;
_ref2 = _iterator2[_i2++];
} else {
_i2 = _iterator2.next();
if (_i2.done) break;
_ref2 = _i2.value;
}
var plugin = _ref2;
var parserOverride = plugin.parserOverride;
for (const plugins of pluginPasses) {
for (const plugin of plugins) {
const {
parserOverride
} = plugin;
if (parserOverride) {
var _ast = parserOverride(code, options.parserOpts, _babylon().parse);
if (_ast !== undefined) results.push(_ast);
const ast = parserOverride(code, parserOpts, _parser().parse);
if (ast !== undefined) results.push(ast);
}
}
}
if (results.length === 0) {
return (0, _babylon().parse)(code, options.parserOpts);
return (0, _parser().parse)(code, parserOpts);
} else if (results.length === 1) {
if (typeof results[0].then === "function") {
throw new Error("You appear to be using an async codegen 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.");
throw new Error(`You appear to be using an async codegen 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.`);
}
return results[0];
@@ -152,21 +182,25 @@ function parser(pluginPasses, options, code) {
err.message += "\nConsider renaming the file to '.mjs', or setting sourceType:module " + "or sourceType:unambiguous in your Babel config for this file.";
}
var loc = err.loc,
missingPlugin = err.missingPlugin;
const {
loc,
missingPlugin
} = err;
if (loc) {
var codeFrame = (0, _codeFrame().codeFrameColumns)(code, {
const codeFrame = (0, _codeFrame().codeFrameColumns)(code, {
start: {
line: loc.line,
column: loc.column + 1
}
}, options);
}, {
highlightCode
});
if (missingPlugin) {
err.message = (options.filename || "unknown") + ": " + (0, _missingPluginHelper.default)(missingPlugin[0], loc, codeFrame);
err.message = `${filename}: ` + (0, _missingPluginHelper.default)(missingPlugin[0], loc, codeFrame);
} else {
err.message = (options.filename || "unknown") + ": " + err.message + "\n\n" + codeFrame;
err.message = `${filename}: ${err.message}\n\n` + codeFrame;
}
err.code = "BABEL_PARSE_ERROR";

81
node_modules/@babel/core/lib/transformation/normalize-opts.js generated vendored
View File

@@ -6,9 +6,9 @@ Object.defineProperty(exports, "__esModule", {
exports.default = normalizeOptions;
function _path() {
var data = _interopRequireDefault(require("path"));
const data = _interopRequireDefault(require("path"));
_path = function _path() {
_path = function () {
return data;
};
@@ -18,74 +18,43 @@ function _path() {
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function normalizeOptions(config) {
var _config$options = config.options,
filename = _config$options.filename,
_config$options$filen = _config$options.filenameRelative,
filenameRelative = _config$options$filen === void 0 ? filename || "unknown" : _config$options$filen,
_config$options$sourc = _config$options.sourceType,
sourceType = _config$options$sourc === void 0 ? "module" : _config$options$sourc,
inputSourceMap = _config$options.inputSourceMap,
_config$options$sourc2 = _config$options.sourceMaps,
sourceMaps = _config$options$sourc2 === void 0 ? !!inputSourceMap : _config$options$sourc2,
moduleRoot = _config$options.moduleRoot,
_config$options$sourc3 = _config$options.sourceRoot,
sourceRoot = _config$options$sourc3 === void 0 ? moduleRoot : _config$options$sourc3,
_config$options$sourc4 = _config$options.sourceFileName,
sourceFileName = _config$options$sourc4 === void 0 ? filenameRelative : _config$options$sourc4,
_config$options$comme = _config$options.comments,
comments = _config$options$comme === void 0 ? true : _config$options$comme,
_config$options$compa = _config$options.compact,
compact = _config$options$compa === void 0 ? "auto" : _config$options$compa;
var opts = config.options;
var options = Object.assign({}, opts, {
const {
filename,
cwd,
filenameRelative = typeof filename === "string" ? _path().default.relative(cwd, filename) : "unknown",
sourceType = "module",
inputSourceMap,
sourceMaps = !!inputSourceMap,
moduleRoot,
sourceRoot = moduleRoot,
sourceFileName = _path().default.basename(filenameRelative),
comments = true,
compact = "auto"
} = config.options;
const opts = config.options;
const options = Object.assign({}, opts, {
parserOpts: Object.assign({
sourceType: _path().default.extname(filenameRelative) === ".mjs" ? "module" : sourceType,
sourceFileName: filename,
plugins: []
}, opts.parserOpts),
generatorOpts: Object.assign({
filename: filename,
filename,
auxiliaryCommentBefore: opts.auxiliaryCommentBefore,
auxiliaryCommentAfter: opts.auxiliaryCommentAfter,
retainLines: opts.retainLines,
comments: comments,
comments,
shouldPrintComment: opts.shouldPrintComment,
compact: compact,
compact,
minified: opts.minified,
sourceMaps: sourceMaps,
sourceRoot: sourceRoot,
sourceFileName: sourceFileName
sourceMaps,
sourceRoot,
sourceFileName
}, opts.generatorOpts)
});
for (var _iterator = config.passes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
var _ref;
if (_isArray) {
if (_i >= _iterator.length) break;
_ref = _iterator[_i++];
} else {
_i = _iterator.next();
if (_i.done) break;
_ref = _i.value;
}
var plugins = _ref;
for (var _iterator2 = plugins, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
var _ref2;
if (_isArray2) {
if (_i2 >= _iterator2.length) break;
_ref2 = _iterator2[_i2++];
} else {
_i2 = _iterator2.next();
if (_i2.done) break;
_ref2 = _i2.value;
}
var plugin = _ref2;
for (const plugins of config.passes) {
for (const plugin of plugins) {
if (plugin.manipulateOptions) {
plugin.manipulateOptions(options, options.parserOpts);
}

40
node_modules/@babel/core/lib/transformation/plugin-pass.js generated vendored
View File

@@ -5,42 +5,44 @@ Object.defineProperty(exports, "__esModule", {
});
exports.default = void 0;
var PluginPass = function () {
function PluginPass(file, key, options) {
class PluginPass {
constructor(file, key, options) {
this._map = new Map();
this.key = key;
this.file = file;
this.opts = options || {};
this.filename = typeof file.opts.filename === "string" ? file.opts.filename : undefined;
this.cwd = file.opts.cwd;
this.filename = file.opts.filename;
}
var _proto = PluginPass.prototype;
_proto.set = function set(key, val) {
set(key, val) {
this._map.set(key, val);
};
}
_proto.get = function get(key) {
get(key) {
return this._map.get(key);
};
}
_proto.addHelper = function addHelper(name) {
availableHelper(name, versionRange) {
return this.file.availableHelper(name, versionRange);
}
addHelper(name) {
return this.file.addHelper(name);
};
}
_proto.addImport = function addImport() {
addImport() {
return this.file.addImport();
};
}
_proto.getModuleName = function getModuleName() {
getModuleName() {
return this.file.getModuleName();
};
}
_proto.buildCodeFrameError = function buildCodeFrameError(node, msg, Error) {
buildCodeFrameError(node, msg, Error) {
return this.file.buildCodeFrameError(node, msg, Error);
};
}
return PluginPass;
}();
}
exports.default = PluginPass;

89
node_modules/@babel/core/lib/transformation/util/missing-plugin-helper.js generated vendored
View File

@@ -4,17 +4,7 @@ Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = generateMissingPluginMessage;
var pluginNameMap = {
asyncGenerators: {
syntax: {
name: "@babel/plugin-syntax-async-generators",
url: "https://git.io/vb4SY"
},
transform: {
name: "@babel/plugin-proposal-async-generator-functions",
url: "https://git.io/vb4yp"
}
},
const pluginNameMap = {
classProperties: {
syntax: {
name: "@babel/plugin-syntax-class-properties",
@@ -147,26 +137,6 @@ var pluginNameMap = {
url: "https://git.io/vb4yS"
}
},
objectRestSpread: {
syntax: {
name: "@babel/plugin-syntax-object-rest-spread",
url: "https://git.io/vb4y5"
},
transform: {
name: "@babel/plugin-proposal-object-rest-spread",
url: "https://git.io/vb4Ss"
}
},
optionalCatchBinding: {
syntax: {
name: "@babel/plugin-syntax-optional-catch-binding",
url: "https://git.io/vb4Sn"
},
transform: {
name: "@babel/plugin-proposal-optional-catch-binding",
url: "https://git.io/vb4SI"
}
},
optionalChaining: {
syntax: {
name: "@babel/plugin-syntax-optional-chaining",
@@ -206,30 +176,61 @@ var pluginNameMap = {
name: "@babel/plugin-transform-typescript",
url: "https://git.io/vb4Sm"
}
},
asyncGenerators: {
syntax: {
name: "@babel/plugin-syntax-async-generators",
url: "https://git.io/vb4SY"
},
transform: {
name: "@babel/plugin-proposal-async-generator-functions",
url: "https://git.io/vb4yp"
}
},
objectRestSpread: {
syntax: {
name: "@babel/plugin-syntax-object-rest-spread",
url: "https://git.io/vb4y5"
},
transform: {
name: "@babel/plugin-proposal-object-rest-spread",
url: "https://git.io/vb4Ss"
}
},
optionalCatchBinding: {
syntax: {
name: "@babel/plugin-syntax-optional-catch-binding",
url: "https://git.io/vb4Sn"
},
transform: {
name: "@babel/plugin-proposal-optional-catch-binding",
url: "https://git.io/vb4SI"
}
}
};
var getNameURLCombination = function getNameURLCombination(_ref) {
var name = _ref.name,
url = _ref.url;
return name + " (" + url + ")";
};
const getNameURLCombination = ({
name,
url
}) => `${name} (${url})`;
function generateMissingPluginMessage(missingPluginName, loc, codeFrame) {
var helpMessage = "Support for the experimental syntax '" + missingPluginName + "' isn't currently enabled " + ("(" + loc.line + ":" + (loc.column + 1) + "):\n\n") + codeFrame;
var pluginInfo = pluginNameMap[missingPluginName];
let helpMessage = `Support for the experimental syntax '${missingPluginName}' isn't currently enabled ` + `(${loc.line}:${loc.column + 1}):\n\n` + codeFrame;
const pluginInfo = pluginNameMap[missingPluginName];
if (pluginInfo) {
var syntaxPlugin = pluginInfo.syntax,
transformPlugin = pluginInfo.transform;
const {
syntax: syntaxPlugin,
transform: transformPlugin
} = pluginInfo;
if (syntaxPlugin) {
if (transformPlugin) {
var transformPluginInfo = getNameURLCombination(transformPlugin);
helpMessage += "\n\nAdd " + transformPluginInfo + " to the 'plugins' section of your Babel config " + "to enable transformation.";
const transformPluginInfo = getNameURLCombination(transformPlugin);
helpMessage += `\n\nAdd ${transformPluginInfo} to the 'plugins' section of your Babel config ` + `to enable transformation.`;
} else {
var syntaxPluginInfo = getNameURLCombination(syntaxPlugin);
helpMessage += "\n\nAdd " + syntaxPluginInfo + " to the 'plugins' section of your Babel config " + "to enable parsing.";
const syntaxPluginInfo = getNameURLCombination(syntaxPlugin);
helpMessage += `\n\nAdd ${syntaxPluginInfo} to the 'plugins' section of your Babel config ` + `to enable parsing.`;
}
}
}