ui
This commit is contained in:
+22
@@ -0,0 +1,22 @@
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2014-present Nicolò Ribaudo and other contributors
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining
|
||||
a copy of this software and associated documentation files (the
|
||||
"Software"), to deal in the Software without restriction, including
|
||||
without limitation the rights to use, copy, modify, merge, publish,
|
||||
distribute, sublicense, and/or sell copies of the Software, and to
|
||||
permit persons to whom the Software is furnished to do so, subject to
|
||||
the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be
|
||||
included in all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
+15
@@ -0,0 +1,15 @@
|
||||
# @babel/helper-define-polyfill-provider
|
||||
|
||||
## Install
|
||||
|
||||
Using npm:
|
||||
|
||||
```sh
|
||||
npm install --save-dev @babel/helper-define-polyfill-provider
|
||||
```
|
||||
|
||||
or using yarn:
|
||||
|
||||
```sh
|
||||
yarn add @babel/helper-define-polyfill-provider --dev
|
||||
```
|
||||
Generated
Vendored
+805
@@ -0,0 +1,805 @@
|
||||
import { declare } from '@babel/helper-plugin-utils';
|
||||
import _getTargets, { prettifyTargets, getInclusionReasons, isRequired } from '@babel/helper-compilation-targets';
|
||||
import * as babel from '@babel/core';
|
||||
|
||||
const {
|
||||
types: t$1,
|
||||
template
|
||||
} = babel.default || babel;
|
||||
function intersection(a, b) {
|
||||
const result = new Set();
|
||||
a.forEach(v => b.has(v) && result.add(v));
|
||||
return result;
|
||||
}
|
||||
function has$1(object, key) {
|
||||
return Object.prototype.hasOwnProperty.call(object, key);
|
||||
}
|
||||
|
||||
function getType(target) {
|
||||
return Object.prototype.toString.call(target).slice(8, -1);
|
||||
}
|
||||
|
||||
function resolveId(path) {
|
||||
if (path.isIdentifier() && !path.scope.hasBinding(path.node.name,
|
||||
/* noGlobals */
|
||||
true)) {
|
||||
return path.node.name;
|
||||
}
|
||||
|
||||
const {
|
||||
deopt
|
||||
} = path.evaluate();
|
||||
|
||||
if (deopt && deopt.isIdentifier()) {
|
||||
return deopt.node.name;
|
||||
}
|
||||
}
|
||||
|
||||
function resolveKey(path, computed = false) {
|
||||
const {
|
||||
node,
|
||||
parent,
|
||||
scope
|
||||
} = path;
|
||||
if (path.isStringLiteral()) return node.value;
|
||||
const {
|
||||
name
|
||||
} = node;
|
||||
const isIdentifier = path.isIdentifier();
|
||||
if (isIdentifier && !(computed || parent.computed)) return name;
|
||||
|
||||
if (computed && path.isMemberExpression() && path.get("object").isIdentifier({
|
||||
name: "Symbol"
|
||||
}) && !scope.hasBinding("Symbol",
|
||||
/* noGlobals */
|
||||
true)) {
|
||||
const sym = resolveKey(path.get("property"), path.node.computed);
|
||||
if (sym) return "Symbol." + sym;
|
||||
}
|
||||
|
||||
if (!isIdentifier || scope.hasBinding(name,
|
||||
/* noGlobals */
|
||||
true)) {
|
||||
const {
|
||||
value
|
||||
} = path.evaluate();
|
||||
if (typeof value === "string") return value;
|
||||
}
|
||||
}
|
||||
function resolveSource(obj) {
|
||||
if (obj.isMemberExpression() && obj.get("property").isIdentifier({
|
||||
name: "prototype"
|
||||
})) {
|
||||
const id = resolveId(obj.get("object"));
|
||||
|
||||
if (id) {
|
||||
return {
|
||||
id,
|
||||
placement: "prototype"
|
||||
};
|
||||
}
|
||||
|
||||
return {
|
||||
id: null,
|
||||
placement: null
|
||||
};
|
||||
}
|
||||
|
||||
const id = resolveId(obj);
|
||||
|
||||
if (id) {
|
||||
return {
|
||||
id,
|
||||
placement: "static"
|
||||
};
|
||||
}
|
||||
|
||||
const {
|
||||
value
|
||||
} = obj.evaluate();
|
||||
|
||||
if (value !== undefined) {
|
||||
return {
|
||||
id: getType(value),
|
||||
placement: "prototype"
|
||||
};
|
||||
} else if (obj.isRegExpLiteral()) {
|
||||
return {
|
||||
id: "RegExp",
|
||||
placement: "prototype"
|
||||
};
|
||||
} else if (obj.isFunction()) {
|
||||
return {
|
||||
id: "Function",
|
||||
placement: "prototype"
|
||||
};
|
||||
}
|
||||
|
||||
return {
|
||||
id: null,
|
||||
placement: null
|
||||
};
|
||||
}
|
||||
function getImportSource({
|
||||
node
|
||||
}) {
|
||||
if (node.specifiers.length === 0) return node.source.value;
|
||||
}
|
||||
function getRequireSource({
|
||||
node
|
||||
}) {
|
||||
if (!t$1.isExpressionStatement(node)) return;
|
||||
const {
|
||||
expression
|
||||
} = node;
|
||||
const isRequire = t$1.isCallExpression(expression) && t$1.isIdentifier(expression.callee) && expression.callee.name === "require" && expression.arguments.length === 1 && t$1.isStringLiteral(expression.arguments[0]);
|
||||
if (isRequire) return expression.arguments[0].value;
|
||||
}
|
||||
|
||||
function hoist(node) {
|
||||
node._blockHoist = 3;
|
||||
return node;
|
||||
}
|
||||
|
||||
function createUtilsGetter(cache) {
|
||||
return path => {
|
||||
const prog = path.findParent(p => p.isProgram());
|
||||
return {
|
||||
injectGlobalImport(url) {
|
||||
cache.storeAnonymous(prog, url, (isScript, source) => {
|
||||
return isScript ? template.statement.ast`require(${source})` : t$1.importDeclaration([], source);
|
||||
});
|
||||
},
|
||||
|
||||
injectNamedImport(url, name, hint = name) {
|
||||
return cache.storeNamed(prog, url, name, (isScript, source, name) => {
|
||||
const id = prog.scope.generateUidIdentifier(hint);
|
||||
return {
|
||||
node: isScript ? hoist(template.statement.ast`
|
||||
var ${id} = require(${source}).${name}
|
||||
`) : t$1.importDeclaration([t$1.importSpecifier(id, name)], source),
|
||||
name: id.name
|
||||
};
|
||||
});
|
||||
},
|
||||
|
||||
injectDefaultImport(url, hint = url) {
|
||||
return cache.storeNamed(prog, url, "default", (isScript, source) => {
|
||||
const id = prog.scope.generateUidIdentifier(hint);
|
||||
return {
|
||||
node: isScript ? hoist(template.statement.ast`var ${id} = require(${source})`) : t$1.importDeclaration([t$1.importDefaultSpecifier(id)], source),
|
||||
name: id.name
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
};
|
||||
};
|
||||
}
|
||||
|
||||
const {
|
||||
types: t
|
||||
} = babel.default || babel;
|
||||
class ImportsCache {
|
||||
constructor(resolver) {
|
||||
this._imports = new WeakMap();
|
||||
this._anonymousImports = new WeakMap();
|
||||
this._lastImports = new WeakMap();
|
||||
this._resolver = resolver;
|
||||
}
|
||||
|
||||
storeAnonymous(programPath, url, // eslint-disable-next-line no-undef
|
||||
getVal) {
|
||||
const key = this._normalizeKey(programPath, url);
|
||||
|
||||
const imports = this._ensure(this._anonymousImports, programPath, Set);
|
||||
|
||||
if (imports.has(key)) return;
|
||||
const node = getVal(programPath.node.sourceType === "script", t.stringLiteral(this._resolver(url)));
|
||||
imports.add(key);
|
||||
|
||||
this._injectImport(programPath, node);
|
||||
}
|
||||
|
||||
storeNamed(programPath, url, name, getVal) {
|
||||
const key = this._normalizeKey(programPath, url, name);
|
||||
|
||||
const imports = this._ensure(this._imports, programPath, Map);
|
||||
|
||||
if (!imports.has(key)) {
|
||||
const {
|
||||
node,
|
||||
name: id
|
||||
} = getVal(programPath.node.sourceType === "script", t.stringLiteral(this._resolver(url)), t.identifier(name));
|
||||
imports.set(key, id);
|
||||
|
||||
this._injectImport(programPath, node);
|
||||
}
|
||||
|
||||
return t.identifier(imports.get(key));
|
||||
}
|
||||
|
||||
_injectImport(programPath, node) {
|
||||
let lastImport = this._lastImports.get(programPath);
|
||||
|
||||
if (lastImport && lastImport.node && // Sometimes the AST is modified and the "last import"
|
||||
// we have has been replaced
|
||||
lastImport.parent === programPath.node && lastImport.container === programPath.node.body) {
|
||||
lastImport = lastImport.insertAfter(node);
|
||||
} else {
|
||||
lastImport = programPath.unshiftContainer("body", node);
|
||||
}
|
||||
|
||||
lastImport = lastImport[lastImport.length - 1];
|
||||
|
||||
this._lastImports.set(programPath, lastImport);
|
||||
/*
|
||||
let lastImport;
|
||||
programPath.get("body").forEach(path => {
|
||||
if (path.isImportDeclaration()) lastImport = path;
|
||||
if (
|
||||
path.isExpressionStatement() &&
|
||||
isRequireCall(path.get("expression"))
|
||||
) {
|
||||
lastImport = path;
|
||||
}
|
||||
if (
|
||||
path.isVariableDeclaration() &&
|
||||
path.get("declarations").length === 1 &&
|
||||
(isRequireCall(path.get("declarations.0.init")) ||
|
||||
(path.get("declarations.0.init").isMemberExpression() &&
|
||||
isRequireCall(path.get("declarations.0.init.object"))))
|
||||
) {
|
||||
lastImport = path;
|
||||
}
|
||||
});*/
|
||||
|
||||
}
|
||||
|
||||
_ensure(map, programPath, Collection) {
|
||||
let collection = map.get(programPath);
|
||||
|
||||
if (!collection) {
|
||||
collection = new Collection();
|
||||
map.set(programPath, collection);
|
||||
}
|
||||
|
||||
return collection;
|
||||
}
|
||||
|
||||
_normalizeKey(programPath, url, name = "") {
|
||||
const {
|
||||
sourceType
|
||||
} = programPath.node; // If we rely on the imported binding (the "name" parameter), we also need to cache
|
||||
// based on the sourceType. This is because the module transforms change the names
|
||||
// of the import variables.
|
||||
|
||||
return `${name && sourceType}::${url}::${name}`;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
const presetEnvSilentDebugHeader = "#__secret_key__@babel/preset-env__don't_log_debug_header_and_resolved_targets";
|
||||
function stringifyTargetsMultiline(targets) {
|
||||
return JSON.stringify(prettifyTargets(targets), null, 2);
|
||||
}
|
||||
|
||||
function patternToRegExp(pattern) {
|
||||
if (pattern instanceof RegExp) return pattern;
|
||||
|
||||
try {
|
||||
return new RegExp(`^${pattern}$`);
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
function buildUnusedError(label, unused) {
|
||||
if (!unused.length) return "";
|
||||
return ` - The following "${label}" patterns didn't match any polyfill:\n` + unused.map(original => ` ${String(original)}\n`).join("");
|
||||
}
|
||||
|
||||
function buldDuplicatesError(duplicates) {
|
||||
if (!duplicates.size) return "";
|
||||
return ` - The following polyfills were matched both by "include" and "exclude" patterns:\n` + Array.from(duplicates, name => ` ${name}\n`).join("");
|
||||
}
|
||||
|
||||
function validateIncludeExclude(provider, polyfills, includePatterns, excludePatterns) {
|
||||
let current;
|
||||
|
||||
const filter = pattern => {
|
||||
const regexp = patternToRegExp(pattern);
|
||||
if (!regexp) return false;
|
||||
let matched = false;
|
||||
|
||||
for (const polyfill of polyfills) {
|
||||
if (regexp.test(polyfill)) {
|
||||
matched = true;
|
||||
current.add(polyfill);
|
||||
}
|
||||
}
|
||||
|
||||
return !matched;
|
||||
}; // prettier-ignore
|
||||
|
||||
|
||||
const include = current = new Set();
|
||||
const unusedInclude = Array.from(includePatterns).filter(filter); // prettier-ignore
|
||||
|
||||
const exclude = current = new Set();
|
||||
const unusedExclude = Array.from(excludePatterns).filter(filter);
|
||||
const duplicates = intersection(include, exclude);
|
||||
|
||||
if (duplicates.size > 0 || unusedInclude.length > 0 || unusedExclude.length > 0) {
|
||||
throw new Error(`Error while validating the "${provider}" provider options:\n` + buildUnusedError("include", unusedInclude) + buildUnusedError("exclude", unusedExclude) + buldDuplicatesError(duplicates));
|
||||
}
|
||||
|
||||
return {
|
||||
include,
|
||||
exclude
|
||||
};
|
||||
}
|
||||
function applyMissingDependenciesDefaults(options, babelApi) {
|
||||
const {
|
||||
missingDependencies = {}
|
||||
} = options;
|
||||
if (missingDependencies === false) return false;
|
||||
const caller = babelApi.caller(caller => caller == null ? void 0 : caller.name);
|
||||
const {
|
||||
log = "deferred",
|
||||
inject = caller === "rollup-plugin-babel" ? "throw" : "import",
|
||||
all = false
|
||||
} = missingDependencies;
|
||||
return {
|
||||
log,
|
||||
inject,
|
||||
all
|
||||
};
|
||||
}
|
||||
|
||||
var usage = (callProvider => {
|
||||
function property(object, key, placement, path) {
|
||||
return callProvider({
|
||||
kind: "property",
|
||||
object,
|
||||
key,
|
||||
placement
|
||||
}, path);
|
||||
}
|
||||
|
||||
return {
|
||||
// Symbol(), new Promise
|
||||
ReferencedIdentifier(path) {
|
||||
const {
|
||||
node: {
|
||||
name
|
||||
},
|
||||
scope
|
||||
} = path;
|
||||
if (scope.getBindingIdentifier(name)) return;
|
||||
callProvider({
|
||||
kind: "global",
|
||||
name
|
||||
}, path);
|
||||
},
|
||||
|
||||
MemberExpression(path) {
|
||||
const key = resolveKey(path.get("property"), path.node.computed);
|
||||
if (!key || key === "prototype") return;
|
||||
const object = path.get("object");
|
||||
const binding = object.scope.getBinding(object.node.name);
|
||||
if (binding && binding.path.isImportNamespaceSpecifier()) return;
|
||||
const source = resolveSource(object);
|
||||
return property(source.id, key, source.placement, path);
|
||||
},
|
||||
|
||||
ObjectPattern(path) {
|
||||
const {
|
||||
parentPath,
|
||||
parent
|
||||
} = path;
|
||||
let obj; // const { keys, values } = Object
|
||||
|
||||
if (parentPath.isVariableDeclarator()) {
|
||||
obj = parentPath.get("init"); // ({ keys, values } = Object)
|
||||
} else if (parentPath.isAssignmentExpression()) {
|
||||
obj = parentPath.get("right"); // !function ({ keys, values }) {...} (Object)
|
||||
// resolution does not work after properties transform :-(
|
||||
} else if (parentPath.isFunction()) {
|
||||
const grand = parentPath.parentPath;
|
||||
|
||||
if (grand.isCallExpression() || grand.isNewExpression()) {
|
||||
if (grand.node.callee === parent) {
|
||||
obj = grand.get("arguments")[path.key];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let id = null;
|
||||
let placement = null;
|
||||
if (obj) ({
|
||||
id,
|
||||
placement
|
||||
} = resolveSource(obj));
|
||||
|
||||
for (const prop of path.get("properties")) {
|
||||
if (prop.isObjectProperty()) {
|
||||
const key = resolveKey(prop.get("key"));
|
||||
if (key) property(id, key, placement, prop);
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
BinaryExpression(path) {
|
||||
if (path.node.operator !== "in") return;
|
||||
const source = resolveSource(path.get("right"));
|
||||
const key = resolveKey(path.get("left"), true);
|
||||
if (!key) return;
|
||||
callProvider({
|
||||
kind: "in",
|
||||
object: source.id,
|
||||
key,
|
||||
placement: source.placement
|
||||
}, path);
|
||||
}
|
||||
|
||||
};
|
||||
});
|
||||
|
||||
var entry = (callProvider => ({
|
||||
ImportDeclaration(path) {
|
||||
const source = getImportSource(path);
|
||||
if (!source) return;
|
||||
callProvider({
|
||||
kind: "import",
|
||||
source
|
||||
}, path);
|
||||
},
|
||||
|
||||
Program(path) {
|
||||
path.get("body").forEach(bodyPath => {
|
||||
const source = getRequireSource(bodyPath);
|
||||
if (!source) return;
|
||||
callProvider({
|
||||
kind: "import",
|
||||
source
|
||||
}, bodyPath);
|
||||
});
|
||||
}
|
||||
|
||||
}));
|
||||
|
||||
function resolve(dirname, moduleName, absoluteImports) {
|
||||
if (absoluteImports === false) return moduleName;
|
||||
throw new Error(`"absoluteImports" is not supported in bundles prepared for the browser.`);
|
||||
} // eslint-disable-next-line no-unused-vars
|
||||
|
||||
function has(basedir, name) {
|
||||
return true;
|
||||
} // eslint-disable-next-line no-unused-vars
|
||||
|
||||
function logMissing(missingDeps) {} // eslint-disable-next-line no-unused-vars
|
||||
|
||||
function laterLogMissing(missingDeps) {}
|
||||
|
||||
const PossibleGlobalObjects = new Set(["global", "globalThis", "self", "window"]);
|
||||
function createMetaResolver(polyfills) {
|
||||
const {
|
||||
static: staticP,
|
||||
instance: instanceP,
|
||||
global: globalP
|
||||
} = polyfills;
|
||||
return meta => {
|
||||
if (meta.kind === "global" && globalP && has$1(globalP, meta.name)) {
|
||||
return {
|
||||
kind: "global",
|
||||
desc: globalP[meta.name],
|
||||
name: meta.name
|
||||
};
|
||||
}
|
||||
|
||||
if (meta.kind === "property" || meta.kind === "in") {
|
||||
const {
|
||||
placement,
|
||||
object,
|
||||
key
|
||||
} = meta;
|
||||
|
||||
if (object && placement === "static") {
|
||||
if (globalP && PossibleGlobalObjects.has(object) && has$1(globalP, key)) {
|
||||
return {
|
||||
kind: "global",
|
||||
desc: globalP[key],
|
||||
name: key
|
||||
};
|
||||
}
|
||||
|
||||
if (staticP && has$1(staticP, object) && has$1(staticP[object], key)) {
|
||||
return {
|
||||
kind: "static",
|
||||
desc: staticP[object][key],
|
||||
name: `${object}$${key}`
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
if (instanceP && has$1(instanceP, key)) {
|
||||
return {
|
||||
kind: "instance",
|
||||
desc: instanceP[key],
|
||||
name: `${key}`
|
||||
};
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
const getTargets = _getTargets.default || _getTargets;
|
||||
|
||||
function resolveOptions(options, babelApi) {
|
||||
const {
|
||||
method,
|
||||
targets: targetsOption,
|
||||
ignoreBrowserslistConfig,
|
||||
configPath,
|
||||
debug,
|
||||
shouldInjectPolyfill,
|
||||
absoluteImports,
|
||||
...providerOptions
|
||||
} = options;
|
||||
let methodName;
|
||||
if (method === "usage-global") methodName = "usageGlobal";else if (method === "entry-global") methodName = "entryGlobal";else if (method === "usage-pure") methodName = "usagePure";else if (typeof method !== "string") {
|
||||
throw new Error(".method must be a string");
|
||||
} else {
|
||||
throw new Error(`.method must be one of "entry-global", "usage-global"` + ` or "usage-pure" (received ${JSON.stringify(method)})`);
|
||||
}
|
||||
|
||||
if (typeof shouldInjectPolyfill === "function") {
|
||||
if (options.include || options.exclude) {
|
||||
throw new Error(`.include and .exclude are not supported when using the` + ` .shouldInjectPolyfill function.`);
|
||||
}
|
||||
} else if (shouldInjectPolyfill != null) {
|
||||
throw new Error(`.shouldInjectPolyfill must be a function, or undefined` + ` (received ${JSON.stringify(shouldInjectPolyfill)})`);
|
||||
}
|
||||
|
||||
if (absoluteImports != null && typeof absoluteImports !== "boolean" && typeof absoluteImports !== "string") {
|
||||
throw new Error(`.absoluteImports must be a boolean, a string, or undefined` + ` (received ${JSON.stringify(absoluteImports)})`);
|
||||
}
|
||||
|
||||
let targets;
|
||||
|
||||
if ( // If any browserslist-related option is specified, fallback to the old
|
||||
// behavior of not using the targets specified in the top-level options.
|
||||
targetsOption || configPath || ignoreBrowserslistConfig) {
|
||||
const targetsObj = typeof targetsOption === "string" || Array.isArray(targetsOption) ? {
|
||||
browsers: targetsOption
|
||||
} : targetsOption;
|
||||
targets = getTargets(targetsObj, {
|
||||
ignoreBrowserslistConfig,
|
||||
configPath
|
||||
});
|
||||
} else {
|
||||
targets = babelApi.targets();
|
||||
}
|
||||
|
||||
return {
|
||||
method,
|
||||
methodName,
|
||||
targets,
|
||||
absoluteImports: absoluteImports != null ? absoluteImports : false,
|
||||
shouldInjectPolyfill,
|
||||
debug: !!debug,
|
||||
providerOptions: providerOptions
|
||||
};
|
||||
}
|
||||
|
||||
function instantiateProvider(factory, options, missingDependencies, dirname, debugLog, babelApi) {
|
||||
const {
|
||||
method,
|
||||
methodName,
|
||||
targets,
|
||||
debug,
|
||||
shouldInjectPolyfill,
|
||||
providerOptions,
|
||||
absoluteImports
|
||||
} = resolveOptions(options, babelApi);
|
||||
const getUtils = createUtilsGetter(new ImportsCache(moduleName => resolve(dirname, moduleName, absoluteImports))); // eslint-disable-next-line prefer-const
|
||||
|
||||
let include, exclude;
|
||||
let polyfillsSupport;
|
||||
let polyfillsNames;
|
||||
let filterPolyfills;
|
||||
const depsCache = new Map();
|
||||
const api = {
|
||||
babel: babelApi,
|
||||
getUtils,
|
||||
method: options.method,
|
||||
targets,
|
||||
createMetaResolver,
|
||||
|
||||
shouldInjectPolyfill(name) {
|
||||
if (polyfillsNames === undefined) {
|
||||
throw new Error(`Internal error in the ${factory.name} provider: ` + `shouldInjectPolyfill() can't be called during initialization.`);
|
||||
}
|
||||
|
||||
if (!polyfillsNames.has(name)) {
|
||||
console.warn(`Internal error in the ${provider.name} provider: ` + `unknown polyfill "${name}".`);
|
||||
}
|
||||
|
||||
if (filterPolyfills && !filterPolyfills(name)) return false;
|
||||
let shouldInject = isRequired(name, targets, {
|
||||
compatData: polyfillsSupport,
|
||||
includes: include,
|
||||
excludes: exclude
|
||||
});
|
||||
|
||||
if (shouldInjectPolyfill) {
|
||||
shouldInject = shouldInjectPolyfill(name, shouldInject);
|
||||
|
||||
if (typeof shouldInject !== "boolean") {
|
||||
throw new Error(`.shouldInjectPolyfill must return a boolean.`);
|
||||
}
|
||||
}
|
||||
|
||||
return shouldInject;
|
||||
},
|
||||
|
||||
debug(name) {
|
||||
debugLog().found = true;
|
||||
if (!debug || !name) return;
|
||||
if (debugLog().polyfills.has(provider.name)) return;
|
||||
debugLog().polyfills.set(name, polyfillsSupport && name && polyfillsSupport[name]);
|
||||
},
|
||||
|
||||
assertDependency(name, version = "*") {
|
||||
if (missingDependencies === false) return;
|
||||
|
||||
if (absoluteImports) {
|
||||
// If absoluteImports is not false, we will try resolving
|
||||
// the dependency and throw if it's not possible. We can
|
||||
// skip the check here.
|
||||
return;
|
||||
}
|
||||
|
||||
const dep = version === "*" ? name : `${name}@^${version}`;
|
||||
const found = missingDependencies.all ? false : mapGetOr(depsCache, `${name} :: ${dirname}`, () => has());
|
||||
|
||||
if (!found) {
|
||||
debugLog().missingDeps.add(dep);
|
||||
}
|
||||
}
|
||||
|
||||
};
|
||||
const provider = factory(api, providerOptions, dirname);
|
||||
|
||||
if (typeof provider[methodName] !== "function") {
|
||||
throw new Error(`The "${provider.name || factory.name}" provider doesn't ` + `support the "${method}" polyfilling method.`);
|
||||
}
|
||||
|
||||
if (Array.isArray(provider.polyfills)) {
|
||||
polyfillsNames = new Set(provider.polyfills);
|
||||
filterPolyfills = provider.filterPolyfills;
|
||||
} else if (provider.polyfills) {
|
||||
polyfillsNames = new Set(Object.keys(provider.polyfills));
|
||||
polyfillsSupport = provider.polyfills;
|
||||
filterPolyfills = provider.filterPolyfills;
|
||||
} else {
|
||||
polyfillsNames = new Set();
|
||||
}
|
||||
|
||||
({
|
||||
include,
|
||||
exclude
|
||||
} = validateIncludeExclude(provider.name || factory.name, polyfillsNames, providerOptions.include || [], providerOptions.exclude || []));
|
||||
return {
|
||||
debug,
|
||||
method,
|
||||
targets,
|
||||
provider,
|
||||
|
||||
callProvider(payload, path) {
|
||||
const utils = getUtils(path); // $FlowIgnore
|
||||
|
||||
provider[methodName](payload, utils, path);
|
||||
}
|
||||
|
||||
};
|
||||
}
|
||||
|
||||
function definePolyfillProvider(factory) {
|
||||
return declare((babelApi, options, dirname) => {
|
||||
babelApi.assertVersion(7);
|
||||
const {
|
||||
traverse
|
||||
} = babelApi;
|
||||
let debugLog;
|
||||
const missingDependencies = applyMissingDependenciesDefaults(options, babelApi);
|
||||
const {
|
||||
debug,
|
||||
method,
|
||||
targets,
|
||||
provider,
|
||||
callProvider
|
||||
} = instantiateProvider(factory, options, missingDependencies, dirname, () => debugLog, babelApi);
|
||||
const createVisitor = method === "entry-global" ? entry : usage;
|
||||
const visitor = provider.visitor ? traverse.visitors.merge([createVisitor(callProvider), provider.visitor]) : createVisitor(callProvider);
|
||||
|
||||
if (debug && debug !== presetEnvSilentDebugHeader) {
|
||||
console.log(`${provider.name}: \`DEBUG\` option`);
|
||||
console.log(`\nUsing targets: ${stringifyTargetsMultiline(targets)}`);
|
||||
console.log(`\nUsing polyfills with \`${method}\` method:`);
|
||||
}
|
||||
|
||||
return {
|
||||
name: "inject-polyfills",
|
||||
visitor,
|
||||
|
||||
pre() {
|
||||
var _provider$pre;
|
||||
|
||||
debugLog = {
|
||||
polyfills: new Map(),
|
||||
found: false,
|
||||
providers: new Set(),
|
||||
missingDeps: new Set()
|
||||
}; // $FlowIgnore - Flow doesn't support optional calls
|
||||
|
||||
(_provider$pre = provider.pre) == null ? void 0 : _provider$pre.apply(this, arguments);
|
||||
},
|
||||
|
||||
post() {
|
||||
var _provider$post;
|
||||
|
||||
// $FlowIgnore - Flow doesn't support optional calls
|
||||
(_provider$post = provider.post) == null ? void 0 : _provider$post.apply(this, arguments);
|
||||
|
||||
if (missingDependencies !== false) {
|
||||
if (missingDependencies.log === "per-file") {
|
||||
logMissing(debugLog.missingDeps);
|
||||
} else {
|
||||
laterLogMissing(debugLog.missingDeps);
|
||||
}
|
||||
}
|
||||
|
||||
if (!debug) return;
|
||||
if (this.filename) console.log(`\n[${this.filename}]`);
|
||||
|
||||
if (debugLog.polyfills.size === 0) {
|
||||
console.log(method === "entry-global" ? debugLog.found ? `Based on your targets, the ${provider.name} polyfill did not add any polyfill.` : `The entry point for the ${provider.name} polyfill has not been found.` : `Based on your code and targets, the ${provider.name} polyfill did not add any polyfill.`);
|
||||
return;
|
||||
}
|
||||
|
||||
if (method === "entry-global") {
|
||||
console.log(`The ${provider.name} polyfill entry has been replaced with ` + `the following polyfills:`);
|
||||
} else {
|
||||
console.log(`The ${provider.name} polyfill added the following polyfills:`);
|
||||
}
|
||||
|
||||
for (const [name, support] of debugLog.polyfills) {
|
||||
if (support) {
|
||||
const filteredTargets = getInclusionReasons(name, targets, support);
|
||||
const formattedTargets = JSON.stringify(filteredTargets).replace(/,/g, ", ").replace(/^\{"/, '{ "').replace(/"\}$/, '" }');
|
||||
console.log(` ${name} ${formattedTargets}`);
|
||||
} else {
|
||||
console.log(` ${name}`);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
function mapGetOr(map, key, getDefault) {
|
||||
let val = map.get(key);
|
||||
|
||||
if (val === undefined) {
|
||||
val = getDefault();
|
||||
map.set(key, val);
|
||||
}
|
||||
|
||||
return val;
|
||||
}
|
||||
|
||||
export default definePolyfillProvider;
|
||||
//# sourceMappingURL=index.browser.mjs.map
|
||||
Generated
Vendored
+1
File diff suppressed because one or more lines are too long
+865
@@ -0,0 +1,865 @@
|
||||
import { declare } from '@babel/helper-plugin-utils';
|
||||
import _getTargets, { prettifyTargets, getInclusionReasons, isRequired } from '@babel/helper-compilation-targets';
|
||||
import * as babel from '@babel/core';
|
||||
import path from 'path';
|
||||
import debounce from 'lodash.debounce';
|
||||
import requireResolve from 'resolve';
|
||||
import { createRequire } from 'module';
|
||||
|
||||
const {
|
||||
types: t$1,
|
||||
template
|
||||
} = babel.default || babel;
|
||||
function intersection(a, b) {
|
||||
const result = new Set();
|
||||
a.forEach(v => b.has(v) && result.add(v));
|
||||
return result;
|
||||
}
|
||||
function has$1(object, key) {
|
||||
return Object.prototype.hasOwnProperty.call(object, key);
|
||||
}
|
||||
|
||||
function getType(target) {
|
||||
return Object.prototype.toString.call(target).slice(8, -1);
|
||||
}
|
||||
|
||||
function resolveId(path) {
|
||||
if (path.isIdentifier() && !path.scope.hasBinding(path.node.name,
|
||||
/* noGlobals */
|
||||
true)) {
|
||||
return path.node.name;
|
||||
}
|
||||
|
||||
const {
|
||||
deopt
|
||||
} = path.evaluate();
|
||||
|
||||
if (deopt && deopt.isIdentifier()) {
|
||||
return deopt.node.name;
|
||||
}
|
||||
}
|
||||
|
||||
function resolveKey(path, computed = false) {
|
||||
const {
|
||||
node,
|
||||
parent,
|
||||
scope
|
||||
} = path;
|
||||
if (path.isStringLiteral()) return node.value;
|
||||
const {
|
||||
name
|
||||
} = node;
|
||||
const isIdentifier = path.isIdentifier();
|
||||
if (isIdentifier && !(computed || parent.computed)) return name;
|
||||
|
||||
if (computed && path.isMemberExpression() && path.get("object").isIdentifier({
|
||||
name: "Symbol"
|
||||
}) && !scope.hasBinding("Symbol",
|
||||
/* noGlobals */
|
||||
true)) {
|
||||
const sym = resolveKey(path.get("property"), path.node.computed);
|
||||
if (sym) return "Symbol." + sym;
|
||||
}
|
||||
|
||||
if (!isIdentifier || scope.hasBinding(name,
|
||||
/* noGlobals */
|
||||
true)) {
|
||||
const {
|
||||
value
|
||||
} = path.evaluate();
|
||||
if (typeof value === "string") return value;
|
||||
}
|
||||
}
|
||||
function resolveSource(obj) {
|
||||
if (obj.isMemberExpression() && obj.get("property").isIdentifier({
|
||||
name: "prototype"
|
||||
})) {
|
||||
const id = resolveId(obj.get("object"));
|
||||
|
||||
if (id) {
|
||||
return {
|
||||
id,
|
||||
placement: "prototype"
|
||||
};
|
||||
}
|
||||
|
||||
return {
|
||||
id: null,
|
||||
placement: null
|
||||
};
|
||||
}
|
||||
|
||||
const id = resolveId(obj);
|
||||
|
||||
if (id) {
|
||||
return {
|
||||
id,
|
||||
placement: "static"
|
||||
};
|
||||
}
|
||||
|
||||
const {
|
||||
value
|
||||
} = obj.evaluate();
|
||||
|
||||
if (value !== undefined) {
|
||||
return {
|
||||
id: getType(value),
|
||||
placement: "prototype"
|
||||
};
|
||||
} else if (obj.isRegExpLiteral()) {
|
||||
return {
|
||||
id: "RegExp",
|
||||
placement: "prototype"
|
||||
};
|
||||
} else if (obj.isFunction()) {
|
||||
return {
|
||||
id: "Function",
|
||||
placement: "prototype"
|
||||
};
|
||||
}
|
||||
|
||||
return {
|
||||
id: null,
|
||||
placement: null
|
||||
};
|
||||
}
|
||||
function getImportSource({
|
||||
node
|
||||
}) {
|
||||
if (node.specifiers.length === 0) return node.source.value;
|
||||
}
|
||||
function getRequireSource({
|
||||
node
|
||||
}) {
|
||||
if (!t$1.isExpressionStatement(node)) return;
|
||||
const {
|
||||
expression
|
||||
} = node;
|
||||
const isRequire = t$1.isCallExpression(expression) && t$1.isIdentifier(expression.callee) && expression.callee.name === "require" && expression.arguments.length === 1 && t$1.isStringLiteral(expression.arguments[0]);
|
||||
if (isRequire) return expression.arguments[0].value;
|
||||
}
|
||||
|
||||
function hoist(node) {
|
||||
node._blockHoist = 3;
|
||||
return node;
|
||||
}
|
||||
|
||||
function createUtilsGetter(cache) {
|
||||
return path => {
|
||||
const prog = path.findParent(p => p.isProgram());
|
||||
return {
|
||||
injectGlobalImport(url) {
|
||||
cache.storeAnonymous(prog, url, (isScript, source) => {
|
||||
return isScript ? template.statement.ast`require(${source})` : t$1.importDeclaration([], source);
|
||||
});
|
||||
},
|
||||
|
||||
injectNamedImport(url, name, hint = name) {
|
||||
return cache.storeNamed(prog, url, name, (isScript, source, name) => {
|
||||
const id = prog.scope.generateUidIdentifier(hint);
|
||||
return {
|
||||
node: isScript ? hoist(template.statement.ast`
|
||||
var ${id} = require(${source}).${name}
|
||||
`) : t$1.importDeclaration([t$1.importSpecifier(id, name)], source),
|
||||
name: id.name
|
||||
};
|
||||
});
|
||||
},
|
||||
|
||||
injectDefaultImport(url, hint = url) {
|
||||
return cache.storeNamed(prog, url, "default", (isScript, source) => {
|
||||
const id = prog.scope.generateUidIdentifier(hint);
|
||||
return {
|
||||
node: isScript ? hoist(template.statement.ast`var ${id} = require(${source})`) : t$1.importDeclaration([t$1.importDefaultSpecifier(id)], source),
|
||||
name: id.name
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
};
|
||||
};
|
||||
}
|
||||
|
||||
const {
|
||||
types: t
|
||||
} = babel.default || babel;
|
||||
class ImportsCache {
|
||||
constructor(resolver) {
|
||||
this._imports = new WeakMap();
|
||||
this._anonymousImports = new WeakMap();
|
||||
this._lastImports = new WeakMap();
|
||||
this._resolver = resolver;
|
||||
}
|
||||
|
||||
storeAnonymous(programPath, url, // eslint-disable-next-line no-undef
|
||||
getVal) {
|
||||
const key = this._normalizeKey(programPath, url);
|
||||
|
||||
const imports = this._ensure(this._anonymousImports, programPath, Set);
|
||||
|
||||
if (imports.has(key)) return;
|
||||
const node = getVal(programPath.node.sourceType === "script", t.stringLiteral(this._resolver(url)));
|
||||
imports.add(key);
|
||||
|
||||
this._injectImport(programPath, node);
|
||||
}
|
||||
|
||||
storeNamed(programPath, url, name, getVal) {
|
||||
const key = this._normalizeKey(programPath, url, name);
|
||||
|
||||
const imports = this._ensure(this._imports, programPath, Map);
|
||||
|
||||
if (!imports.has(key)) {
|
||||
const {
|
||||
node,
|
||||
name: id
|
||||
} = getVal(programPath.node.sourceType === "script", t.stringLiteral(this._resolver(url)), t.identifier(name));
|
||||
imports.set(key, id);
|
||||
|
||||
this._injectImport(programPath, node);
|
||||
}
|
||||
|
||||
return t.identifier(imports.get(key));
|
||||
}
|
||||
|
||||
_injectImport(programPath, node) {
|
||||
let lastImport = this._lastImports.get(programPath);
|
||||
|
||||
if (lastImport && lastImport.node && // Sometimes the AST is modified and the "last import"
|
||||
// we have has been replaced
|
||||
lastImport.parent === programPath.node && lastImport.container === programPath.node.body) {
|
||||
lastImport = lastImport.insertAfter(node);
|
||||
} else {
|
||||
lastImport = programPath.unshiftContainer("body", node);
|
||||
}
|
||||
|
||||
lastImport = lastImport[lastImport.length - 1];
|
||||
|
||||
this._lastImports.set(programPath, lastImport);
|
||||
/*
|
||||
let lastImport;
|
||||
programPath.get("body").forEach(path => {
|
||||
if (path.isImportDeclaration()) lastImport = path;
|
||||
if (
|
||||
path.isExpressionStatement() &&
|
||||
isRequireCall(path.get("expression"))
|
||||
) {
|
||||
lastImport = path;
|
||||
}
|
||||
if (
|
||||
path.isVariableDeclaration() &&
|
||||
path.get("declarations").length === 1 &&
|
||||
(isRequireCall(path.get("declarations.0.init")) ||
|
||||
(path.get("declarations.0.init").isMemberExpression() &&
|
||||
isRequireCall(path.get("declarations.0.init.object"))))
|
||||
) {
|
||||
lastImport = path;
|
||||
}
|
||||
});*/
|
||||
|
||||
}
|
||||
|
||||
_ensure(map, programPath, Collection) {
|
||||
let collection = map.get(programPath);
|
||||
|
||||
if (!collection) {
|
||||
collection = new Collection();
|
||||
map.set(programPath, collection);
|
||||
}
|
||||
|
||||
return collection;
|
||||
}
|
||||
|
||||
_normalizeKey(programPath, url, name = "") {
|
||||
const {
|
||||
sourceType
|
||||
} = programPath.node; // If we rely on the imported binding (the "name" parameter), we also need to cache
|
||||
// based on the sourceType. This is because the module transforms change the names
|
||||
// of the import variables.
|
||||
|
||||
return `${name && sourceType}::${url}::${name}`;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
const presetEnvSilentDebugHeader = "#__secret_key__@babel/preset-env__don't_log_debug_header_and_resolved_targets";
|
||||
function stringifyTargetsMultiline(targets) {
|
||||
return JSON.stringify(prettifyTargets(targets), null, 2);
|
||||
}
|
||||
|
||||
function patternToRegExp(pattern) {
|
||||
if (pattern instanceof RegExp) return pattern;
|
||||
|
||||
try {
|
||||
return new RegExp(`^${pattern}$`);
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
function buildUnusedError(label, unused) {
|
||||
if (!unused.length) return "";
|
||||
return ` - The following "${label}" patterns didn't match any polyfill:\n` + unused.map(original => ` ${String(original)}\n`).join("");
|
||||
}
|
||||
|
||||
function buldDuplicatesError(duplicates) {
|
||||
if (!duplicates.size) return "";
|
||||
return ` - The following polyfills were matched both by "include" and "exclude" patterns:\n` + Array.from(duplicates, name => ` ${name}\n`).join("");
|
||||
}
|
||||
|
||||
function validateIncludeExclude(provider, polyfills, includePatterns, excludePatterns) {
|
||||
let current;
|
||||
|
||||
const filter = pattern => {
|
||||
const regexp = patternToRegExp(pattern);
|
||||
if (!regexp) return false;
|
||||
let matched = false;
|
||||
|
||||
for (const polyfill of polyfills) {
|
||||
if (regexp.test(polyfill)) {
|
||||
matched = true;
|
||||
current.add(polyfill);
|
||||
}
|
||||
}
|
||||
|
||||
return !matched;
|
||||
}; // prettier-ignore
|
||||
|
||||
|
||||
const include = current = new Set();
|
||||
const unusedInclude = Array.from(includePatterns).filter(filter); // prettier-ignore
|
||||
|
||||
const exclude = current = new Set();
|
||||
const unusedExclude = Array.from(excludePatterns).filter(filter);
|
||||
const duplicates = intersection(include, exclude);
|
||||
|
||||
if (duplicates.size > 0 || unusedInclude.length > 0 || unusedExclude.length > 0) {
|
||||
throw new Error(`Error while validating the "${provider}" provider options:\n` + buildUnusedError("include", unusedInclude) + buildUnusedError("exclude", unusedExclude) + buldDuplicatesError(duplicates));
|
||||
}
|
||||
|
||||
return {
|
||||
include,
|
||||
exclude
|
||||
};
|
||||
}
|
||||
function applyMissingDependenciesDefaults(options, babelApi) {
|
||||
const {
|
||||
missingDependencies = {}
|
||||
} = options;
|
||||
if (missingDependencies === false) return false;
|
||||
const caller = babelApi.caller(caller => caller == null ? void 0 : caller.name);
|
||||
const {
|
||||
log = "deferred",
|
||||
inject = caller === "rollup-plugin-babel" ? "throw" : "import",
|
||||
all = false
|
||||
} = missingDependencies;
|
||||
return {
|
||||
log,
|
||||
inject,
|
||||
all
|
||||
};
|
||||
}
|
||||
|
||||
var usage = (callProvider => {
|
||||
function property(object, key, placement, path) {
|
||||
return callProvider({
|
||||
kind: "property",
|
||||
object,
|
||||
key,
|
||||
placement
|
||||
}, path);
|
||||
}
|
||||
|
||||
return {
|
||||
// Symbol(), new Promise
|
||||
ReferencedIdentifier(path) {
|
||||
const {
|
||||
node: {
|
||||
name
|
||||
},
|
||||
scope
|
||||
} = path;
|
||||
if (scope.getBindingIdentifier(name)) return;
|
||||
callProvider({
|
||||
kind: "global",
|
||||
name
|
||||
}, path);
|
||||
},
|
||||
|
||||
MemberExpression(path) {
|
||||
const key = resolveKey(path.get("property"), path.node.computed);
|
||||
if (!key || key === "prototype") return;
|
||||
const object = path.get("object");
|
||||
const binding = object.scope.getBinding(object.node.name);
|
||||
if (binding && binding.path.isImportNamespaceSpecifier()) return;
|
||||
const source = resolveSource(object);
|
||||
return property(source.id, key, source.placement, path);
|
||||
},
|
||||
|
||||
ObjectPattern(path) {
|
||||
const {
|
||||
parentPath,
|
||||
parent
|
||||
} = path;
|
||||
let obj; // const { keys, values } = Object
|
||||
|
||||
if (parentPath.isVariableDeclarator()) {
|
||||
obj = parentPath.get("init"); // ({ keys, values } = Object)
|
||||
} else if (parentPath.isAssignmentExpression()) {
|
||||
obj = parentPath.get("right"); // !function ({ keys, values }) {...} (Object)
|
||||
// resolution does not work after properties transform :-(
|
||||
} else if (parentPath.isFunction()) {
|
||||
const grand = parentPath.parentPath;
|
||||
|
||||
if (grand.isCallExpression() || grand.isNewExpression()) {
|
||||
if (grand.node.callee === parent) {
|
||||
obj = grand.get("arguments")[path.key];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let id = null;
|
||||
let placement = null;
|
||||
if (obj) ({
|
||||
id,
|
||||
placement
|
||||
} = resolveSource(obj));
|
||||
|
||||
for (const prop of path.get("properties")) {
|
||||
if (prop.isObjectProperty()) {
|
||||
const key = resolveKey(prop.get("key"));
|
||||
if (key) property(id, key, placement, prop);
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
BinaryExpression(path) {
|
||||
if (path.node.operator !== "in") return;
|
||||
const source = resolveSource(path.get("right"));
|
||||
const key = resolveKey(path.get("left"), true);
|
||||
if (!key) return;
|
||||
callProvider({
|
||||
kind: "in",
|
||||
object: source.id,
|
||||
key,
|
||||
placement: source.placement
|
||||
}, path);
|
||||
}
|
||||
|
||||
};
|
||||
});
|
||||
|
||||
var entry = (callProvider => ({
|
||||
ImportDeclaration(path) {
|
||||
const source = getImportSource(path);
|
||||
if (!source) return;
|
||||
callProvider({
|
||||
kind: "import",
|
||||
source
|
||||
}, path);
|
||||
},
|
||||
|
||||
Program(path) {
|
||||
path.get("body").forEach(bodyPath => {
|
||||
const source = getRequireSource(bodyPath);
|
||||
if (!source) return;
|
||||
callProvider({
|
||||
kind: "import",
|
||||
source
|
||||
}, bodyPath);
|
||||
});
|
||||
}
|
||||
|
||||
}));
|
||||
|
||||
const nativeRequireResolve = parseFloat(process.versions.node) >= 8.9; // $FlowIgnore
|
||||
|
||||
const require = createRequire(import
|
||||
/*::(_)*/
|
||||
.meta.url); // eslint-disable-line
|
||||
|
||||
|
||||
function resolve(dirname, moduleName, absoluteImports) {
|
||||
if (absoluteImports === false) return moduleName;
|
||||
let basedir = dirname;
|
||||
|
||||
if (typeof absoluteImports === "string") {
|
||||
basedir = path.resolve(basedir, absoluteImports);
|
||||
}
|
||||
|
||||
try {
|
||||
if (nativeRequireResolve) {
|
||||
return require.resolve(moduleName, {
|
||||
paths: [basedir]
|
||||
});
|
||||
} else {
|
||||
return requireResolve.sync(moduleName, {
|
||||
basedir
|
||||
});
|
||||
}
|
||||
} catch (err) {
|
||||
if (err.code !== "MODULE_NOT_FOUND") throw err; // $FlowIgnore
|
||||
|
||||
throw Object.assign(new Error(`Failed to resolve "${moduleName}" relative to "${dirname}"`), {
|
||||
code: "BABEL_POLYFILL_NOT_FOUND",
|
||||
polyfill: moduleName,
|
||||
dirname
|
||||
});
|
||||
}
|
||||
}
|
||||
function has(basedir, name) {
|
||||
try {
|
||||
if (nativeRequireResolve) {
|
||||
require.resolve(name, {
|
||||
paths: [basedir]
|
||||
});
|
||||
} else {
|
||||
requireResolve.sync(name, {
|
||||
basedir
|
||||
});
|
||||
}
|
||||
|
||||
return true;
|
||||
} catch {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
function logMissing(missingDeps) {
|
||||
if (missingDeps.size === 0) return;
|
||||
const deps = Array.from(missingDeps).sort().join(" ");
|
||||
console.warn("\nSome polyfills have been added but are not present in your dependencies.\n" + "Please run one of the following commands:\n" + `\tnpm install --save ${deps}\n` + `\tyarn add ${deps}\n`);
|
||||
process.exitCode = 1;
|
||||
}
|
||||
let allMissingDeps = new Set();
|
||||
const laterLogMissingDependencies = debounce(() => {
|
||||
logMissing(allMissingDeps);
|
||||
allMissingDeps = new Set();
|
||||
}, 100);
|
||||
function laterLogMissing(missingDeps) {
|
||||
if (missingDeps.size === 0) return;
|
||||
missingDeps.forEach(name => allMissingDeps.add(name));
|
||||
laterLogMissingDependencies();
|
||||
}
|
||||
|
||||
const PossibleGlobalObjects = new Set(["global", "globalThis", "self", "window"]);
|
||||
function createMetaResolver(polyfills) {
|
||||
const {
|
||||
static: staticP,
|
||||
instance: instanceP,
|
||||
global: globalP
|
||||
} = polyfills;
|
||||
return meta => {
|
||||
if (meta.kind === "global" && globalP && has$1(globalP, meta.name)) {
|
||||
return {
|
||||
kind: "global",
|
||||
desc: globalP[meta.name],
|
||||
name: meta.name
|
||||
};
|
||||
}
|
||||
|
||||
if (meta.kind === "property" || meta.kind === "in") {
|
||||
const {
|
||||
placement,
|
||||
object,
|
||||
key
|
||||
} = meta;
|
||||
|
||||
if (object && placement === "static") {
|
||||
if (globalP && PossibleGlobalObjects.has(object) && has$1(globalP, key)) {
|
||||
return {
|
||||
kind: "global",
|
||||
desc: globalP[key],
|
||||
name: key
|
||||
};
|
||||
}
|
||||
|
||||
if (staticP && has$1(staticP, object) && has$1(staticP[object], key)) {
|
||||
return {
|
||||
kind: "static",
|
||||
desc: staticP[object][key],
|
||||
name: `${object}$${key}`
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
if (instanceP && has$1(instanceP, key)) {
|
||||
return {
|
||||
kind: "instance",
|
||||
desc: instanceP[key],
|
||||
name: `${key}`
|
||||
};
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
const getTargets = _getTargets.default || _getTargets;
|
||||
|
||||
function resolveOptions(options, babelApi) {
|
||||
const {
|
||||
method,
|
||||
targets: targetsOption,
|
||||
ignoreBrowserslistConfig,
|
||||
configPath,
|
||||
debug,
|
||||
shouldInjectPolyfill,
|
||||
absoluteImports,
|
||||
...providerOptions
|
||||
} = options;
|
||||
let methodName;
|
||||
if (method === "usage-global") methodName = "usageGlobal";else if (method === "entry-global") methodName = "entryGlobal";else if (method === "usage-pure") methodName = "usagePure";else if (typeof method !== "string") {
|
||||
throw new Error(".method must be a string");
|
||||
} else {
|
||||
throw new Error(`.method must be one of "entry-global", "usage-global"` + ` or "usage-pure" (received ${JSON.stringify(method)})`);
|
||||
}
|
||||
|
||||
if (typeof shouldInjectPolyfill === "function") {
|
||||
if (options.include || options.exclude) {
|
||||
throw new Error(`.include and .exclude are not supported when using the` + ` .shouldInjectPolyfill function.`);
|
||||
}
|
||||
} else if (shouldInjectPolyfill != null) {
|
||||
throw new Error(`.shouldInjectPolyfill must be a function, or undefined` + ` (received ${JSON.stringify(shouldInjectPolyfill)})`);
|
||||
}
|
||||
|
||||
if (absoluteImports != null && typeof absoluteImports !== "boolean" && typeof absoluteImports !== "string") {
|
||||
throw new Error(`.absoluteImports must be a boolean, a string, or undefined` + ` (received ${JSON.stringify(absoluteImports)})`);
|
||||
}
|
||||
|
||||
let targets;
|
||||
|
||||
if ( // If any browserslist-related option is specified, fallback to the old
|
||||
// behavior of not using the targets specified in the top-level options.
|
||||
targetsOption || configPath || ignoreBrowserslistConfig) {
|
||||
const targetsObj = typeof targetsOption === "string" || Array.isArray(targetsOption) ? {
|
||||
browsers: targetsOption
|
||||
} : targetsOption;
|
||||
targets = getTargets(targetsObj, {
|
||||
ignoreBrowserslistConfig,
|
||||
configPath
|
||||
});
|
||||
} else {
|
||||
targets = babelApi.targets();
|
||||
}
|
||||
|
||||
return {
|
||||
method,
|
||||
methodName,
|
||||
targets,
|
||||
absoluteImports: absoluteImports != null ? absoluteImports : false,
|
||||
shouldInjectPolyfill,
|
||||
debug: !!debug,
|
||||
providerOptions: providerOptions
|
||||
};
|
||||
}
|
||||
|
||||
function instantiateProvider(factory, options, missingDependencies, dirname, debugLog, babelApi) {
|
||||
const {
|
||||
method,
|
||||
methodName,
|
||||
targets,
|
||||
debug,
|
||||
shouldInjectPolyfill,
|
||||
providerOptions,
|
||||
absoluteImports
|
||||
} = resolveOptions(options, babelApi);
|
||||
const getUtils = createUtilsGetter(new ImportsCache(moduleName => resolve(dirname, moduleName, absoluteImports))); // eslint-disable-next-line prefer-const
|
||||
|
||||
let include, exclude;
|
||||
let polyfillsSupport;
|
||||
let polyfillsNames;
|
||||
let filterPolyfills;
|
||||
const depsCache = new Map();
|
||||
const api = {
|
||||
babel: babelApi,
|
||||
getUtils,
|
||||
method: options.method,
|
||||
targets,
|
||||
createMetaResolver,
|
||||
|
||||
shouldInjectPolyfill(name) {
|
||||
if (polyfillsNames === undefined) {
|
||||
throw new Error(`Internal error in the ${factory.name} provider: ` + `shouldInjectPolyfill() can't be called during initialization.`);
|
||||
}
|
||||
|
||||
if (!polyfillsNames.has(name)) {
|
||||
console.warn(`Internal error in the ${provider.name} provider: ` + `unknown polyfill "${name}".`);
|
||||
}
|
||||
|
||||
if (filterPolyfills && !filterPolyfills(name)) return false;
|
||||
let shouldInject = isRequired(name, targets, {
|
||||
compatData: polyfillsSupport,
|
||||
includes: include,
|
||||
excludes: exclude
|
||||
});
|
||||
|
||||
if (shouldInjectPolyfill) {
|
||||
shouldInject = shouldInjectPolyfill(name, shouldInject);
|
||||
|
||||
if (typeof shouldInject !== "boolean") {
|
||||
throw new Error(`.shouldInjectPolyfill must return a boolean.`);
|
||||
}
|
||||
}
|
||||
|
||||
return shouldInject;
|
||||
},
|
||||
|
||||
debug(name) {
|
||||
debugLog().found = true;
|
||||
if (!debug || !name) return;
|
||||
if (debugLog().polyfills.has(provider.name)) return;
|
||||
debugLog().polyfills.set(name, polyfillsSupport && name && polyfillsSupport[name]);
|
||||
},
|
||||
|
||||
assertDependency(name, version = "*") {
|
||||
if (missingDependencies === false) return;
|
||||
|
||||
if (absoluteImports) {
|
||||
// If absoluteImports is not false, we will try resolving
|
||||
// the dependency and throw if it's not possible. We can
|
||||
// skip the check here.
|
||||
return;
|
||||
}
|
||||
|
||||
const dep = version === "*" ? name : `${name}@^${version}`;
|
||||
const found = missingDependencies.all ? false : mapGetOr(depsCache, `${name} :: ${dirname}`, () => has(dirname, name));
|
||||
|
||||
if (!found) {
|
||||
debugLog().missingDeps.add(dep);
|
||||
}
|
||||
}
|
||||
|
||||
};
|
||||
const provider = factory(api, providerOptions, dirname);
|
||||
|
||||
if (typeof provider[methodName] !== "function") {
|
||||
throw new Error(`The "${provider.name || factory.name}" provider doesn't ` + `support the "${method}" polyfilling method.`);
|
||||
}
|
||||
|
||||
if (Array.isArray(provider.polyfills)) {
|
||||
polyfillsNames = new Set(provider.polyfills);
|
||||
filterPolyfills = provider.filterPolyfills;
|
||||
} else if (provider.polyfills) {
|
||||
polyfillsNames = new Set(Object.keys(provider.polyfills));
|
||||
polyfillsSupport = provider.polyfills;
|
||||
filterPolyfills = provider.filterPolyfills;
|
||||
} else {
|
||||
polyfillsNames = new Set();
|
||||
}
|
||||
|
||||
({
|
||||
include,
|
||||
exclude
|
||||
} = validateIncludeExclude(provider.name || factory.name, polyfillsNames, providerOptions.include || [], providerOptions.exclude || []));
|
||||
return {
|
||||
debug,
|
||||
method,
|
||||
targets,
|
||||
provider,
|
||||
|
||||
callProvider(payload, path) {
|
||||
const utils = getUtils(path); // $FlowIgnore
|
||||
|
||||
provider[methodName](payload, utils, path);
|
||||
}
|
||||
|
||||
};
|
||||
}
|
||||
|
||||
function definePolyfillProvider(factory) {
|
||||
return declare((babelApi, options, dirname) => {
|
||||
babelApi.assertVersion(7);
|
||||
const {
|
||||
traverse
|
||||
} = babelApi;
|
||||
let debugLog;
|
||||
const missingDependencies = applyMissingDependenciesDefaults(options, babelApi);
|
||||
const {
|
||||
debug,
|
||||
method,
|
||||
targets,
|
||||
provider,
|
||||
callProvider
|
||||
} = instantiateProvider(factory, options, missingDependencies, dirname, () => debugLog, babelApi);
|
||||
const createVisitor = method === "entry-global" ? entry : usage;
|
||||
const visitor = provider.visitor ? traverse.visitors.merge([createVisitor(callProvider), provider.visitor]) : createVisitor(callProvider);
|
||||
|
||||
if (debug && debug !== presetEnvSilentDebugHeader) {
|
||||
console.log(`${provider.name}: \`DEBUG\` option`);
|
||||
console.log(`\nUsing targets: ${stringifyTargetsMultiline(targets)}`);
|
||||
console.log(`\nUsing polyfills with \`${method}\` method:`);
|
||||
}
|
||||
|
||||
return {
|
||||
name: "inject-polyfills",
|
||||
visitor,
|
||||
|
||||
pre() {
|
||||
var _provider$pre;
|
||||
|
||||
debugLog = {
|
||||
polyfills: new Map(),
|
||||
found: false,
|
||||
providers: new Set(),
|
||||
missingDeps: new Set()
|
||||
}; // $FlowIgnore - Flow doesn't support optional calls
|
||||
|
||||
(_provider$pre = provider.pre) == null ? void 0 : _provider$pre.apply(this, arguments);
|
||||
},
|
||||
|
||||
post() {
|
||||
var _provider$post;
|
||||
|
||||
// $FlowIgnore - Flow doesn't support optional calls
|
||||
(_provider$post = provider.post) == null ? void 0 : _provider$post.apply(this, arguments);
|
||||
|
||||
if (missingDependencies !== false) {
|
||||
if (missingDependencies.log === "per-file") {
|
||||
logMissing(debugLog.missingDeps);
|
||||
} else {
|
||||
laterLogMissing(debugLog.missingDeps);
|
||||
}
|
||||
}
|
||||
|
||||
if (!debug) return;
|
||||
if (this.filename) console.log(`\n[${this.filename}]`);
|
||||
|
||||
if (debugLog.polyfills.size === 0) {
|
||||
console.log(method === "entry-global" ? debugLog.found ? `Based on your targets, the ${provider.name} polyfill did not add any polyfill.` : `The entry point for the ${provider.name} polyfill has not been found.` : `Based on your code and targets, the ${provider.name} polyfill did not add any polyfill.`);
|
||||
return;
|
||||
}
|
||||
|
||||
if (method === "entry-global") {
|
||||
console.log(`The ${provider.name} polyfill entry has been replaced with ` + `the following polyfills:`);
|
||||
} else {
|
||||
console.log(`The ${provider.name} polyfill added the following polyfills:`);
|
||||
}
|
||||
|
||||
for (const [name, support] of debugLog.polyfills) {
|
||||
if (support) {
|
||||
const filteredTargets = getInclusionReasons(name, targets, support);
|
||||
const formattedTargets = JSON.stringify(filteredTargets).replace(/,/g, ", ").replace(/^\{"/, '{ "').replace(/"\}$/, '" }');
|
||||
console.log(` ${name} ${formattedTargets}`);
|
||||
} else {
|
||||
console.log(` ${name}`);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
function mapGetOr(map, key, getDefault) {
|
||||
let val = map.get(key);
|
||||
|
||||
if (val === undefined) {
|
||||
val = getDefault();
|
||||
map.set(key, val);
|
||||
}
|
||||
|
||||
return val;
|
||||
}
|
||||
|
||||
export default definePolyfillProvider;
|
||||
//# sourceMappingURL=index.node.mjs.map
|
||||
Generated
Vendored
+1
File diff suppressed because one or more lines are too long
Generated
Vendored
+23
@@ -0,0 +1,23 @@
|
||||
"use strict";
|
||||
|
||||
exports.__esModule = true;
|
||||
exports.resolve = resolve;
|
||||
exports.has = has;
|
||||
exports.logMissing = logMissing;
|
||||
exports.laterLogMissing = laterLogMissing;
|
||||
|
||||
function resolve(dirname, moduleName, absoluteImports) {
|
||||
if (absoluteImports === false) return moduleName;
|
||||
throw new Error(`"absoluteImports" is not supported in bundles prepared for the browser.`);
|
||||
} // eslint-disable-next-line no-unused-vars
|
||||
|
||||
|
||||
function has(basedir, name) {
|
||||
return true;
|
||||
} // eslint-disable-next-line no-unused-vars
|
||||
|
||||
|
||||
function logMissing(missingDeps) {} // eslint-disable-next-line no-unused-vars
|
||||
|
||||
|
||||
function laterLogMissing(missingDeps) {}
|
||||
+19
@@ -0,0 +1,19 @@
|
||||
"use strict";
|
||||
|
||||
exports.__esModule = true;
|
||||
exports.stringifyTargetsMultiline = stringifyTargetsMultiline;
|
||||
exports.stringifyTargets = stringifyTargets;
|
||||
exports.presetEnvSilentDebugHeader = void 0;
|
||||
|
||||
var _helperCompilationTargets = require("@babel/helper-compilation-targets");
|
||||
|
||||
const presetEnvSilentDebugHeader = "#__secret_key__@babel/preset-env__don't_log_debug_header_and_resolved_targets";
|
||||
exports.presetEnvSilentDebugHeader = presetEnvSilentDebugHeader;
|
||||
|
||||
function stringifyTargetsMultiline(targets) {
|
||||
return JSON.stringify((0, _helperCompilationTargets.prettifyTargets)(targets), null, 2);
|
||||
}
|
||||
|
||||
function stringifyTargets(targets) {
|
||||
return JSON.stringify(targets).replace(/,/g, ", ").replace(/^\{"/, '{ "').replace(/"\}$/, '" }');
|
||||
}
|
||||
Generated
Vendored
+9
@@ -0,0 +1,9 @@
|
||||
"use strict";
|
||||
|
||||
exports.__esModule = true;
|
||||
exports.defineProvider = defineProvider;
|
||||
|
||||
function defineProvider(factory) {
|
||||
// This will allow us to do some things
|
||||
return factory;
|
||||
}
|
||||
Generated
Vendored
+115
@@ -0,0 +1,115 @@
|
||||
"use strict";
|
||||
|
||||
exports.__esModule = true;
|
||||
exports.default = void 0;
|
||||
|
||||
var babel = _interopRequireWildcard(require("@babel/core"));
|
||||
|
||||
function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
|
||||
|
||||
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
|
||||
|
||||
const {
|
||||
types: t
|
||||
} = babel.default || babel;
|
||||
|
||||
class ImportsCache {
|
||||
constructor(resolver) {
|
||||
this._imports = new WeakMap();
|
||||
this._anonymousImports = new WeakMap();
|
||||
this._lastImports = new WeakMap();
|
||||
this._resolver = resolver;
|
||||
}
|
||||
|
||||
storeAnonymous(programPath, url, // eslint-disable-next-line no-undef
|
||||
getVal) {
|
||||
const key = this._normalizeKey(programPath, url);
|
||||
|
||||
const imports = this._ensure(this._anonymousImports, programPath, Set);
|
||||
|
||||
if (imports.has(key)) return;
|
||||
const node = getVal(programPath.node.sourceType === "script", t.stringLiteral(this._resolver(url)));
|
||||
imports.add(key);
|
||||
|
||||
this._injectImport(programPath, node);
|
||||
}
|
||||
|
||||
storeNamed(programPath, url, name, getVal) {
|
||||
const key = this._normalizeKey(programPath, url, name);
|
||||
|
||||
const imports = this._ensure(this._imports, programPath, Map);
|
||||
|
||||
if (!imports.has(key)) {
|
||||
const {
|
||||
node,
|
||||
name: id
|
||||
} = getVal(programPath.node.sourceType === "script", t.stringLiteral(this._resolver(url)), t.identifier(name));
|
||||
imports.set(key, id);
|
||||
|
||||
this._injectImport(programPath, node);
|
||||
}
|
||||
|
||||
return t.identifier(imports.get(key));
|
||||
}
|
||||
|
||||
_injectImport(programPath, node) {
|
||||
let lastImport = this._lastImports.get(programPath);
|
||||
|
||||
if (lastImport && lastImport.node && // Sometimes the AST is modified and the "last import"
|
||||
// we have has been replaced
|
||||
lastImport.parent === programPath.node && lastImport.container === programPath.node.body) {
|
||||
lastImport = lastImport.insertAfter(node);
|
||||
} else {
|
||||
lastImport = programPath.unshiftContainer("body", node);
|
||||
}
|
||||
|
||||
lastImport = lastImport[lastImport.length - 1];
|
||||
|
||||
this._lastImports.set(programPath, lastImport);
|
||||
/*
|
||||
let lastImport;
|
||||
programPath.get("body").forEach(path => {
|
||||
if (path.isImportDeclaration()) lastImport = path;
|
||||
if (
|
||||
path.isExpressionStatement() &&
|
||||
isRequireCall(path.get("expression"))
|
||||
) {
|
||||
lastImport = path;
|
||||
}
|
||||
if (
|
||||
path.isVariableDeclaration() &&
|
||||
path.get("declarations").length === 1 &&
|
||||
(isRequireCall(path.get("declarations.0.init")) ||
|
||||
(path.get("declarations.0.init").isMemberExpression() &&
|
||||
isRequireCall(path.get("declarations.0.init.object"))))
|
||||
) {
|
||||
lastImport = path;
|
||||
}
|
||||
});*/
|
||||
|
||||
}
|
||||
|
||||
_ensure(map, programPath, Collection) {
|
||||
let collection = map.get(programPath);
|
||||
|
||||
if (!collection) {
|
||||
collection = new Collection();
|
||||
map.set(programPath, collection);
|
||||
}
|
||||
|
||||
return collection;
|
||||
}
|
||||
|
||||
_normalizeKey(programPath, url, name = "") {
|
||||
const {
|
||||
sourceType
|
||||
} = programPath.node; // If we rely on the imported binding (the "name" parameter), we also need to cache
|
||||
// based on the sourceType. This is because the module transforms change the names
|
||||
// of the import variables.
|
||||
|
||||
return `${name && sourceType}::${url}::${name}`;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
exports.default = ImportsCache;
|
||||
+298
@@ -0,0 +1,298 @@
|
||||
"use strict";
|
||||
|
||||
exports.__esModule = true;
|
||||
exports.default = definePolyfillProvider;
|
||||
|
||||
var _helperPluginUtils = require("@babel/helper-plugin-utils");
|
||||
|
||||
var _helperCompilationTargets = _interopRequireWildcard(require("@babel/helper-compilation-targets"));
|
||||
|
||||
var _utils = require("./utils");
|
||||
|
||||
var _importsCache = _interopRequireDefault(require("./imports-cache"));
|
||||
|
||||
var _debugUtils = require("./debug-utils");
|
||||
|
||||
var _normalizeOptions = require("./normalize-options");
|
||||
|
||||
var v = _interopRequireWildcard(require("./visitors"));
|
||||
|
||||
var deps = _interopRequireWildcard(require("./node/dependencies"));
|
||||
|
||||
var _metaResolver = _interopRequireDefault(require("./meta-resolver"));
|
||||
|
||||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||||
|
||||
function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
|
||||
|
||||
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
|
||||
|
||||
function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
|
||||
|
||||
const getTargets = _helperCompilationTargets.default.default || _helperCompilationTargets.default;
|
||||
|
||||
function resolveOptions(options, babelApi) {
|
||||
const {
|
||||
method,
|
||||
targets: targetsOption,
|
||||
ignoreBrowserslistConfig,
|
||||
configPath,
|
||||
debug,
|
||||
shouldInjectPolyfill,
|
||||
absoluteImports
|
||||
} = options,
|
||||
providerOptions = _objectWithoutPropertiesLoose(options, ["method", "targets", "ignoreBrowserslistConfig", "configPath", "debug", "shouldInjectPolyfill", "absoluteImports"]);
|
||||
|
||||
let methodName;
|
||||
if (method === "usage-global") methodName = "usageGlobal";else if (method === "entry-global") methodName = "entryGlobal";else if (method === "usage-pure") methodName = "usagePure";else if (typeof method !== "string") {
|
||||
throw new Error(".method must be a string");
|
||||
} else {
|
||||
throw new Error(`.method must be one of "entry-global", "usage-global"` + ` or "usage-pure" (received ${JSON.stringify(method)})`);
|
||||
}
|
||||
|
||||
if (typeof shouldInjectPolyfill === "function") {
|
||||
if (options.include || options.exclude) {
|
||||
throw new Error(`.include and .exclude are not supported when using the` + ` .shouldInjectPolyfill function.`);
|
||||
}
|
||||
} else if (shouldInjectPolyfill != null) {
|
||||
throw new Error(`.shouldInjectPolyfill must be a function, or undefined` + ` (received ${JSON.stringify(shouldInjectPolyfill)})`);
|
||||
}
|
||||
|
||||
if (absoluteImports != null && typeof absoluteImports !== "boolean" && typeof absoluteImports !== "string") {
|
||||
throw new Error(`.absoluteImports must be a boolean, a string, or undefined` + ` (received ${JSON.stringify(absoluteImports)})`);
|
||||
}
|
||||
|
||||
let targets;
|
||||
|
||||
if ( // If any browserslist-related option is specified, fallback to the old
|
||||
// behavior of not using the targets specified in the top-level options.
|
||||
targetsOption || configPath || ignoreBrowserslistConfig) {
|
||||
const targetsObj = typeof targetsOption === "string" || Array.isArray(targetsOption) ? {
|
||||
browsers: targetsOption
|
||||
} : targetsOption;
|
||||
targets = getTargets(targetsObj, {
|
||||
ignoreBrowserslistConfig,
|
||||
configPath
|
||||
});
|
||||
} else {
|
||||
targets = babelApi.targets();
|
||||
}
|
||||
|
||||
return {
|
||||
method,
|
||||
methodName,
|
||||
targets,
|
||||
absoluteImports: absoluteImports != null ? absoluteImports : false,
|
||||
shouldInjectPolyfill,
|
||||
debug: !!debug,
|
||||
providerOptions: providerOptions
|
||||
};
|
||||
}
|
||||
|
||||
function instantiateProvider(factory, options, missingDependencies, dirname, debugLog, babelApi) {
|
||||
const {
|
||||
method,
|
||||
methodName,
|
||||
targets,
|
||||
debug,
|
||||
shouldInjectPolyfill,
|
||||
providerOptions,
|
||||
absoluteImports
|
||||
} = resolveOptions(options, babelApi);
|
||||
const getUtils = (0, _utils.createUtilsGetter)(new _importsCache.default(moduleName => deps.resolve(dirname, moduleName, absoluteImports))); // eslint-disable-next-line prefer-const
|
||||
|
||||
let include, exclude;
|
||||
let polyfillsSupport;
|
||||
let polyfillsNames;
|
||||
let filterPolyfills;
|
||||
const depsCache = new Map();
|
||||
const api = {
|
||||
babel: babelApi,
|
||||
getUtils,
|
||||
method: options.method,
|
||||
targets,
|
||||
createMetaResolver: _metaResolver.default,
|
||||
|
||||
shouldInjectPolyfill(name) {
|
||||
if (polyfillsNames === undefined) {
|
||||
throw new Error(`Internal error in the ${factory.name} provider: ` + `shouldInjectPolyfill() can't be called during initialization.`);
|
||||
}
|
||||
|
||||
if (!polyfillsNames.has(name)) {
|
||||
console.warn(`Internal error in the ${provider.name} provider: ` + `unknown polyfill "${name}".`);
|
||||
}
|
||||
|
||||
if (filterPolyfills && !filterPolyfills(name)) return false;
|
||||
let shouldInject = (0, _helperCompilationTargets.isRequired)(name, targets, {
|
||||
compatData: polyfillsSupport,
|
||||
includes: include,
|
||||
excludes: exclude
|
||||
});
|
||||
|
||||
if (shouldInjectPolyfill) {
|
||||
shouldInject = shouldInjectPolyfill(name, shouldInject);
|
||||
|
||||
if (typeof shouldInject !== "boolean") {
|
||||
throw new Error(`.shouldInjectPolyfill must return a boolean.`);
|
||||
}
|
||||
}
|
||||
|
||||
return shouldInject;
|
||||
},
|
||||
|
||||
debug(name) {
|
||||
debugLog().found = true;
|
||||
if (!debug || !name) return;
|
||||
if (debugLog().polyfills.has(provider.name)) return;
|
||||
debugLog().polyfills.set(name, polyfillsSupport && name && polyfillsSupport[name]);
|
||||
},
|
||||
|
||||
assertDependency(name, version = "*") {
|
||||
if (missingDependencies === false) return;
|
||||
|
||||
if (absoluteImports) {
|
||||
// If absoluteImports is not false, we will try resolving
|
||||
// the dependency and throw if it's not possible. We can
|
||||
// skip the check here.
|
||||
return;
|
||||
}
|
||||
|
||||
const dep = version === "*" ? name : `${name}@^${version}`;
|
||||
const found = missingDependencies.all ? false : mapGetOr(depsCache, `${name} :: ${dirname}`, () => deps.has(dirname, name));
|
||||
|
||||
if (!found) {
|
||||
debugLog().missingDeps.add(dep);
|
||||
}
|
||||
}
|
||||
|
||||
};
|
||||
const provider = factory(api, providerOptions, dirname);
|
||||
|
||||
if (typeof provider[methodName] !== "function") {
|
||||
throw new Error(`The "${provider.name || factory.name}" provider doesn't ` + `support the "${method}" polyfilling method.`);
|
||||
}
|
||||
|
||||
if (Array.isArray(provider.polyfills)) {
|
||||
polyfillsNames = new Set(provider.polyfills);
|
||||
filterPolyfills = provider.filterPolyfills;
|
||||
} else if (provider.polyfills) {
|
||||
polyfillsNames = new Set(Object.keys(provider.polyfills));
|
||||
polyfillsSupport = provider.polyfills;
|
||||
filterPolyfills = provider.filterPolyfills;
|
||||
} else {
|
||||
polyfillsNames = new Set();
|
||||
}
|
||||
|
||||
({
|
||||
include,
|
||||
exclude
|
||||
} = (0, _normalizeOptions.validateIncludeExclude)(provider.name || factory.name, polyfillsNames, providerOptions.include || [], providerOptions.exclude || []));
|
||||
return {
|
||||
debug,
|
||||
method,
|
||||
targets,
|
||||
provider,
|
||||
|
||||
callProvider(payload, path) {
|
||||
const utils = getUtils(path); // $FlowIgnore
|
||||
|
||||
provider[methodName](payload, utils, path);
|
||||
}
|
||||
|
||||
};
|
||||
}
|
||||
|
||||
function definePolyfillProvider(factory) {
|
||||
return (0, _helperPluginUtils.declare)((babelApi, options, dirname) => {
|
||||
babelApi.assertVersion(7);
|
||||
const {
|
||||
traverse
|
||||
} = babelApi;
|
||||
let debugLog;
|
||||
const missingDependencies = (0, _normalizeOptions.applyMissingDependenciesDefaults)(options, babelApi);
|
||||
const {
|
||||
debug,
|
||||
method,
|
||||
targets,
|
||||
provider,
|
||||
callProvider
|
||||
} = instantiateProvider(factory, options, missingDependencies, dirname, () => debugLog, babelApi);
|
||||
const createVisitor = method === "entry-global" ? v.entry : v.usage;
|
||||
const visitor = provider.visitor ? traverse.visitors.merge([createVisitor(callProvider), provider.visitor]) : createVisitor(callProvider);
|
||||
|
||||
if (debug && debug !== _debugUtils.presetEnvSilentDebugHeader) {
|
||||
console.log(`${provider.name}: \`DEBUG\` option`);
|
||||
console.log(`\nUsing targets: ${(0, _debugUtils.stringifyTargetsMultiline)(targets)}`);
|
||||
console.log(`\nUsing polyfills with \`${method}\` method:`);
|
||||
}
|
||||
|
||||
return {
|
||||
name: "inject-polyfills",
|
||||
visitor,
|
||||
|
||||
pre() {
|
||||
var _provider$pre;
|
||||
|
||||
debugLog = {
|
||||
polyfills: new Map(),
|
||||
found: false,
|
||||
providers: new Set(),
|
||||
missingDeps: new Set()
|
||||
}; // $FlowIgnore - Flow doesn't support optional calls
|
||||
|
||||
(_provider$pre = provider.pre) == null ? void 0 : _provider$pre.apply(this, arguments);
|
||||
},
|
||||
|
||||
post() {
|
||||
var _provider$post;
|
||||
|
||||
// $FlowIgnore - Flow doesn't support optional calls
|
||||
(_provider$post = provider.post) == null ? void 0 : _provider$post.apply(this, arguments);
|
||||
|
||||
if (missingDependencies !== false) {
|
||||
if (missingDependencies.log === "per-file") {
|
||||
deps.logMissing(debugLog.missingDeps);
|
||||
} else {
|
||||
deps.laterLogMissing(debugLog.missingDeps);
|
||||
}
|
||||
}
|
||||
|
||||
if (!debug) return;
|
||||
if (this.filename) console.log(`\n[${this.filename}]`);
|
||||
|
||||
if (debugLog.polyfills.size === 0) {
|
||||
console.log(method === "entry-global" ? debugLog.found ? `Based on your targets, the ${provider.name} polyfill did not add any polyfill.` : `The entry point for the ${provider.name} polyfill has not been found.` : `Based on your code and targets, the ${provider.name} polyfill did not add any polyfill.`);
|
||||
return;
|
||||
}
|
||||
|
||||
if (method === "entry-global") {
|
||||
console.log(`The ${provider.name} polyfill entry has been replaced with ` + `the following polyfills:`);
|
||||
} else {
|
||||
console.log(`The ${provider.name} polyfill added the following polyfills:`);
|
||||
}
|
||||
|
||||
for (const [name, support] of debugLog.polyfills) {
|
||||
if (support) {
|
||||
const filteredTargets = (0, _helperCompilationTargets.getInclusionReasons)(name, targets, support);
|
||||
const formattedTargets = JSON.stringify(filteredTargets).replace(/,/g, ", ").replace(/^\{"/, '{ "').replace(/"\}$/, '" }');
|
||||
console.log(` ${name} ${formattedTargets}`);
|
||||
} else {
|
||||
console.log(` ${name}`);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
function mapGetOr(map, key, getDefault) {
|
||||
let val = map.get(key);
|
||||
|
||||
if (val === undefined) {
|
||||
val = getDefault();
|
||||
map.set(key, val);
|
||||
}
|
||||
|
||||
return val;
|
||||
}
|
||||
Generated
Vendored
+59
@@ -0,0 +1,59 @@
|
||||
"use strict";
|
||||
|
||||
exports.__esModule = true;
|
||||
exports.default = createMetaResolver;
|
||||
|
||||
var _utils = require("./utils");
|
||||
|
||||
const PossibleGlobalObjects = new Set(["global", "globalThis", "self", "window"]);
|
||||
|
||||
function createMetaResolver(polyfills) {
|
||||
const {
|
||||
static: staticP,
|
||||
instance: instanceP,
|
||||
global: globalP
|
||||
} = polyfills;
|
||||
return meta => {
|
||||
if (meta.kind === "global" && globalP && (0, _utils.has)(globalP, meta.name)) {
|
||||
return {
|
||||
kind: "global",
|
||||
desc: globalP[meta.name],
|
||||
name: meta.name
|
||||
};
|
||||
}
|
||||
|
||||
if (meta.kind === "property" || meta.kind === "in") {
|
||||
const {
|
||||
placement,
|
||||
object,
|
||||
key
|
||||
} = meta;
|
||||
|
||||
if (object && placement === "static") {
|
||||
if (globalP && PossibleGlobalObjects.has(object) && (0, _utils.has)(globalP, key)) {
|
||||
return {
|
||||
kind: "global",
|
||||
desc: globalP[key],
|
||||
name: key
|
||||
};
|
||||
}
|
||||
|
||||
if (staticP && (0, _utils.has)(staticP, object) && (0, _utils.has)(staticP[object], key)) {
|
||||
return {
|
||||
kind: "static",
|
||||
desc: staticP[object][key],
|
||||
name: `${object}$${key}`
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
if (instanceP && (0, _utils.has)(instanceP, key)) {
|
||||
return {
|
||||
kind: "instance",
|
||||
desc: instanceP[key],
|
||||
name: `${key}`
|
||||
};
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
Generated
Vendored
+86
@@ -0,0 +1,86 @@
|
||||
"use strict";
|
||||
|
||||
exports.__esModule = true;
|
||||
exports.resolve = resolve;
|
||||
exports.has = has;
|
||||
exports.logMissing = logMissing;
|
||||
exports.laterLogMissing = laterLogMissing;
|
||||
|
||||
var _path = _interopRequireDefault(require("path"));
|
||||
|
||||
var _lodash = _interopRequireDefault(require("lodash.debounce"));
|
||||
|
||||
var _resolve = _interopRequireDefault(require("resolve"));
|
||||
|
||||
var _module = require("module");
|
||||
|
||||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||||
|
||||
const nativeRequireResolve = parseFloat(process.versions.node) >= 8.9; // $FlowIgnore
|
||||
|
||||
// eslint-disable-line
|
||||
function resolve(dirname, moduleName, absoluteImports) {
|
||||
if (absoluteImports === false) return moduleName;
|
||||
let basedir = dirname;
|
||||
|
||||
if (typeof absoluteImports === "string") {
|
||||
basedir = _path.default.resolve(basedir, absoluteImports);
|
||||
}
|
||||
|
||||
try {
|
||||
if (nativeRequireResolve) {
|
||||
return require.resolve(moduleName, {
|
||||
paths: [basedir]
|
||||
});
|
||||
} else {
|
||||
return _resolve.default.sync(moduleName, {
|
||||
basedir
|
||||
});
|
||||
}
|
||||
} catch (err) {
|
||||
if (err.code !== "MODULE_NOT_FOUND") throw err; // $FlowIgnore
|
||||
|
||||
throw Object.assign(new Error(`Failed to resolve "${moduleName}" relative to "${dirname}"`), {
|
||||
code: "BABEL_POLYFILL_NOT_FOUND",
|
||||
polyfill: moduleName,
|
||||
dirname
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
function has(basedir, name) {
|
||||
try {
|
||||
if (nativeRequireResolve) {
|
||||
require.resolve(name, {
|
||||
paths: [basedir]
|
||||
});
|
||||
} else {
|
||||
_resolve.default.sync(name, {
|
||||
basedir
|
||||
});
|
||||
}
|
||||
|
||||
return true;
|
||||
} catch (_unused) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
function logMissing(missingDeps) {
|
||||
if (missingDeps.size === 0) return;
|
||||
const deps = Array.from(missingDeps).sort().join(" ");
|
||||
console.warn("\nSome polyfills have been added but are not present in your dependencies.\n" + "Please run one of the following commands:\n" + `\tnpm install --save ${deps}\n` + `\tyarn add ${deps}\n`);
|
||||
process.exitCode = 1;
|
||||
}
|
||||
|
||||
let allMissingDeps = new Set();
|
||||
const laterLogMissingDependencies = (0, _lodash.default)(() => {
|
||||
logMissing(allMissingDeps);
|
||||
allMissingDeps = new Set();
|
||||
}, 100);
|
||||
|
||||
function laterLogMissing(missingDeps) {
|
||||
if (missingDeps.size === 0) return;
|
||||
missingDeps.forEach(name => allMissingDeps.add(name));
|
||||
laterLogMissingDependencies();
|
||||
}
|
||||
Generated
Vendored
+81
@@ -0,0 +1,81 @@
|
||||
"use strict";
|
||||
|
||||
exports.__esModule = true;
|
||||
exports.validateIncludeExclude = validateIncludeExclude;
|
||||
exports.applyMissingDependenciesDefaults = applyMissingDependenciesDefaults;
|
||||
|
||||
var _utils = require("./utils");
|
||||
|
||||
function patternToRegExp(pattern) {
|
||||
if (pattern instanceof RegExp) return pattern;
|
||||
|
||||
try {
|
||||
return new RegExp(`^${pattern}$`);
|
||||
} catch (_unused) {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
function buildUnusedError(label, unused) {
|
||||
if (!unused.length) return "";
|
||||
return ` - The following "${label}" patterns didn't match any polyfill:\n` + unused.map(original => ` ${String(original)}\n`).join("");
|
||||
}
|
||||
|
||||
function buldDuplicatesError(duplicates) {
|
||||
if (!duplicates.size) return "";
|
||||
return ` - The following polyfills were matched both by "include" and "exclude" patterns:\n` + Array.from(duplicates, name => ` ${name}\n`).join("");
|
||||
}
|
||||
|
||||
function validateIncludeExclude(provider, polyfills, includePatterns, excludePatterns) {
|
||||
let current;
|
||||
|
||||
const filter = pattern => {
|
||||
const regexp = patternToRegExp(pattern);
|
||||
if (!regexp) return false;
|
||||
let matched = false;
|
||||
|
||||
for (const polyfill of polyfills) {
|
||||
if (regexp.test(polyfill)) {
|
||||
matched = true;
|
||||
current.add(polyfill);
|
||||
}
|
||||
}
|
||||
|
||||
return !matched;
|
||||
}; // prettier-ignore
|
||||
|
||||
|
||||
const include = current = new Set();
|
||||
const unusedInclude = Array.from(includePatterns).filter(filter); // prettier-ignore
|
||||
|
||||
const exclude = current = new Set();
|
||||
const unusedExclude = Array.from(excludePatterns).filter(filter);
|
||||
const duplicates = (0, _utils.intersection)(include, exclude);
|
||||
|
||||
if (duplicates.size > 0 || unusedInclude.length > 0 || unusedExclude.length > 0) {
|
||||
throw new Error(`Error while validating the "${provider}" provider options:\n` + buildUnusedError("include", unusedInclude) + buildUnusedError("exclude", unusedExclude) + buldDuplicatesError(duplicates));
|
||||
}
|
||||
|
||||
return {
|
||||
include,
|
||||
exclude
|
||||
};
|
||||
}
|
||||
|
||||
function applyMissingDependenciesDefaults(options, babelApi) {
|
||||
const {
|
||||
missingDependencies = {}
|
||||
} = options;
|
||||
if (missingDependencies === false) return false;
|
||||
const caller = babelApi.caller(caller => caller == null ? void 0 : caller.name);
|
||||
const {
|
||||
log = "deferred",
|
||||
inject = caller === "rollup-plugin-babel" ? "throw" : "import",
|
||||
all = false
|
||||
} = missingDependencies;
|
||||
return {
|
||||
log,
|
||||
inject,
|
||||
all
|
||||
};
|
||||
}
|
||||
+15
@@ -0,0 +1,15 @@
|
||||
"use strict";
|
||||
|
||||
var babel = _interopRequireWildcard(require("@babel/core"));
|
||||
|
||||
var _metaResolver = _interopRequireDefault(require("./meta-resolver"));
|
||||
|
||||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||||
|
||||
function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
|
||||
|
||||
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
|
||||
|
||||
const {
|
||||
types: t
|
||||
} = babel.default || babel;
|
||||
+196
@@ -0,0 +1,196 @@
|
||||
"use strict";
|
||||
|
||||
exports.__esModule = true;
|
||||
exports.intersection = intersection;
|
||||
exports.has = has;
|
||||
exports.resolveKey = resolveKey;
|
||||
exports.resolveSource = resolveSource;
|
||||
exports.getImportSource = getImportSource;
|
||||
exports.getRequireSource = getRequireSource;
|
||||
exports.createUtilsGetter = createUtilsGetter;
|
||||
|
||||
var babel = _interopRequireWildcard(require("@babel/core"));
|
||||
|
||||
function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
|
||||
|
||||
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
|
||||
|
||||
const {
|
||||
types: t,
|
||||
template
|
||||
} = babel.default || babel;
|
||||
|
||||
function intersection(a, b) {
|
||||
const result = new Set();
|
||||
a.forEach(v => b.has(v) && result.add(v));
|
||||
return result;
|
||||
}
|
||||
|
||||
function has(object, key) {
|
||||
return Object.prototype.hasOwnProperty.call(object, key);
|
||||
}
|
||||
|
||||
function getType(target) {
|
||||
return Object.prototype.toString.call(target).slice(8, -1);
|
||||
}
|
||||
|
||||
function resolveId(path) {
|
||||
if (path.isIdentifier() && !path.scope.hasBinding(path.node.name,
|
||||
/* noGlobals */
|
||||
true)) {
|
||||
return path.node.name;
|
||||
}
|
||||
|
||||
const {
|
||||
deopt
|
||||
} = path.evaluate();
|
||||
|
||||
if (deopt && deopt.isIdentifier()) {
|
||||
return deopt.node.name;
|
||||
}
|
||||
}
|
||||
|
||||
function resolveKey(path, computed = false) {
|
||||
const {
|
||||
node,
|
||||
parent,
|
||||
scope
|
||||
} = path;
|
||||
if (path.isStringLiteral()) return node.value;
|
||||
const {
|
||||
name
|
||||
} = node;
|
||||
const isIdentifier = path.isIdentifier();
|
||||
if (isIdentifier && !(computed || parent.computed)) return name;
|
||||
|
||||
if (computed && path.isMemberExpression() && path.get("object").isIdentifier({
|
||||
name: "Symbol"
|
||||
}) && !scope.hasBinding("Symbol",
|
||||
/* noGlobals */
|
||||
true)) {
|
||||
const sym = resolveKey(path.get("property"), path.node.computed);
|
||||
if (sym) return "Symbol." + sym;
|
||||
}
|
||||
|
||||
if (!isIdentifier || scope.hasBinding(name,
|
||||
/* noGlobals */
|
||||
true)) {
|
||||
const {
|
||||
value
|
||||
} = path.evaluate();
|
||||
if (typeof value === "string") return value;
|
||||
}
|
||||
}
|
||||
|
||||
function resolveSource(obj) {
|
||||
if (obj.isMemberExpression() && obj.get("property").isIdentifier({
|
||||
name: "prototype"
|
||||
})) {
|
||||
const id = resolveId(obj.get("object"));
|
||||
|
||||
if (id) {
|
||||
return {
|
||||
id,
|
||||
placement: "prototype"
|
||||
};
|
||||
}
|
||||
|
||||
return {
|
||||
id: null,
|
||||
placement: null
|
||||
};
|
||||
}
|
||||
|
||||
const id = resolveId(obj);
|
||||
|
||||
if (id) {
|
||||
return {
|
||||
id,
|
||||
placement: "static"
|
||||
};
|
||||
}
|
||||
|
||||
const {
|
||||
value
|
||||
} = obj.evaluate();
|
||||
|
||||
if (value !== undefined) {
|
||||
return {
|
||||
id: getType(value),
|
||||
placement: "prototype"
|
||||
};
|
||||
} else if (obj.isRegExpLiteral()) {
|
||||
return {
|
||||
id: "RegExp",
|
||||
placement: "prototype"
|
||||
};
|
||||
} else if (obj.isFunction()) {
|
||||
return {
|
||||
id: "Function",
|
||||
placement: "prototype"
|
||||
};
|
||||
}
|
||||
|
||||
return {
|
||||
id: null,
|
||||
placement: null
|
||||
};
|
||||
}
|
||||
|
||||
function getImportSource({
|
||||
node
|
||||
}) {
|
||||
if (node.specifiers.length === 0) return node.source.value;
|
||||
}
|
||||
|
||||
function getRequireSource({
|
||||
node
|
||||
}) {
|
||||
if (!t.isExpressionStatement(node)) return;
|
||||
const {
|
||||
expression
|
||||
} = node;
|
||||
const isRequire = t.isCallExpression(expression) && t.isIdentifier(expression.callee) && expression.callee.name === "require" && expression.arguments.length === 1 && t.isStringLiteral(expression.arguments[0]);
|
||||
if (isRequire) return expression.arguments[0].value;
|
||||
}
|
||||
|
||||
function hoist(node) {
|
||||
node._blockHoist = 3;
|
||||
return node;
|
||||
}
|
||||
|
||||
function createUtilsGetter(cache) {
|
||||
return path => {
|
||||
const prog = path.findParent(p => p.isProgram());
|
||||
return {
|
||||
injectGlobalImport(url) {
|
||||
cache.storeAnonymous(prog, url, (isScript, source) => {
|
||||
return isScript ? template.statement.ast`require(${source})` : t.importDeclaration([], source);
|
||||
});
|
||||
},
|
||||
|
||||
injectNamedImport(url, name, hint = name) {
|
||||
return cache.storeNamed(prog, url, name, (isScript, source, name) => {
|
||||
const id = prog.scope.generateUidIdentifier(hint);
|
||||
return {
|
||||
node: isScript ? hoist(template.statement.ast`
|
||||
var ${id} = require(${source}).${name}
|
||||
`) : t.importDeclaration([t.importSpecifier(id, name)], source),
|
||||
name: id.name
|
||||
};
|
||||
});
|
||||
},
|
||||
|
||||
injectDefaultImport(url, hint = url) {
|
||||
return cache.storeNamed(prog, url, "default", (isScript, source) => {
|
||||
const id = prog.scope.generateUidIdentifier(hint);
|
||||
return {
|
||||
node: isScript ? hoist(template.statement.ast`var ${id} = require(${source})`) : t.importDeclaration([t.importDefaultSpecifier(id)], source),
|
||||
name: id.name
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
};
|
||||
};
|
||||
}
|
||||
Generated
Vendored
+31
@@ -0,0 +1,31 @@
|
||||
"use strict";
|
||||
|
||||
exports.__esModule = true;
|
||||
exports.default = void 0;
|
||||
|
||||
var _utils = require("../utils");
|
||||
|
||||
var _default = callProvider => ({
|
||||
ImportDeclaration(path) {
|
||||
const source = (0, _utils.getImportSource)(path);
|
||||
if (!source) return;
|
||||
callProvider({
|
||||
kind: "import",
|
||||
source
|
||||
}, path);
|
||||
},
|
||||
|
||||
Program(path) {
|
||||
path.get("body").forEach(bodyPath => {
|
||||
const source = (0, _utils.getRequireSource)(bodyPath);
|
||||
if (!source) return;
|
||||
callProvider({
|
||||
kind: "import",
|
||||
source
|
||||
}, bodyPath);
|
||||
});
|
||||
}
|
||||
|
||||
});
|
||||
|
||||
exports.default = _default;
|
||||
Generated
Vendored
+14
@@ -0,0 +1,14 @@
|
||||
"use strict";
|
||||
|
||||
exports.__esModule = true;
|
||||
exports.entry = exports.usage = void 0;
|
||||
|
||||
var _usage = _interopRequireDefault(require("./usage"));
|
||||
|
||||
exports.usage = _usage.default;
|
||||
|
||||
var _entry = _interopRequireDefault(require("./entry"));
|
||||
|
||||
exports.entry = _entry.default;
|
||||
|
||||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||||
Generated
Vendored
+97
@@ -0,0 +1,97 @@
|
||||
"use strict";
|
||||
|
||||
exports.__esModule = true;
|
||||
exports.default = void 0;
|
||||
|
||||
var _utils = require("../utils");
|
||||
|
||||
var _default = callProvider => {
|
||||
function property(object, key, placement, path) {
|
||||
return callProvider({
|
||||
kind: "property",
|
||||
object,
|
||||
key,
|
||||
placement
|
||||
}, path);
|
||||
}
|
||||
|
||||
return {
|
||||
// Symbol(), new Promise
|
||||
ReferencedIdentifier(path) {
|
||||
const {
|
||||
node: {
|
||||
name
|
||||
},
|
||||
scope
|
||||
} = path;
|
||||
if (scope.getBindingIdentifier(name)) return;
|
||||
callProvider({
|
||||
kind: "global",
|
||||
name
|
||||
}, path);
|
||||
},
|
||||
|
||||
MemberExpression(path) {
|
||||
const key = (0, _utils.resolveKey)(path.get("property"), path.node.computed);
|
||||
if (!key || key === "prototype") return;
|
||||
const object = path.get("object");
|
||||
const binding = object.scope.getBinding(object.node.name);
|
||||
if (binding && binding.path.isImportNamespaceSpecifier()) return;
|
||||
const source = (0, _utils.resolveSource)(object);
|
||||
return property(source.id, key, source.placement, path);
|
||||
},
|
||||
|
||||
ObjectPattern(path) {
|
||||
const {
|
||||
parentPath,
|
||||
parent
|
||||
} = path;
|
||||
let obj; // const { keys, values } = Object
|
||||
|
||||
if (parentPath.isVariableDeclarator()) {
|
||||
obj = parentPath.get("init"); // ({ keys, values } = Object)
|
||||
} else if (parentPath.isAssignmentExpression()) {
|
||||
obj = parentPath.get("right"); // !function ({ keys, values }) {...} (Object)
|
||||
// resolution does not work after properties transform :-(
|
||||
} else if (parentPath.isFunction()) {
|
||||
const grand = parentPath.parentPath;
|
||||
|
||||
if (grand.isCallExpression() || grand.isNewExpression()) {
|
||||
if (grand.node.callee === parent) {
|
||||
obj = grand.get("arguments")[path.key];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let id = null;
|
||||
let placement = null;
|
||||
if (obj) ({
|
||||
id,
|
||||
placement
|
||||
} = (0, _utils.resolveSource)(obj));
|
||||
|
||||
for (const prop of path.get("properties")) {
|
||||
if (prop.isObjectProperty()) {
|
||||
const key = (0, _utils.resolveKey)(prop.get("key"));
|
||||
if (key) property(id, key, placement, prop);
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
BinaryExpression(path) {
|
||||
if (path.node.operator !== "in") return;
|
||||
const source = (0, _utils.resolveSource)(path.get("right"));
|
||||
const key = (0, _utils.resolveKey)(path.get("left"), true);
|
||||
if (!key) return;
|
||||
callProvider({
|
||||
kind: "in",
|
||||
object: source.id,
|
||||
key,
|
||||
placement: source.placement
|
||||
}, path);
|
||||
}
|
||||
|
||||
};
|
||||
};
|
||||
|
||||
exports.default = _default;
|
||||
Generated
Vendored
Symlink
+1
@@ -0,0 +1 @@
|
||||
../semver/bin/semver.js
|
||||
Generated
Vendored
+70
@@ -0,0 +1,70 @@
|
||||
# changes log
|
||||
|
||||
## 6.2.0
|
||||
|
||||
* Coerce numbers to strings when passed to semver.coerce()
|
||||
* Add `rtl` option to coerce from right to left
|
||||
|
||||
## 6.1.3
|
||||
|
||||
* Handle X-ranges properly in includePrerelease mode
|
||||
|
||||
## 6.1.2
|
||||
|
||||
* Do not throw when testing invalid version strings
|
||||
|
||||
## 6.1.1
|
||||
|
||||
* Add options support for semver.coerce()
|
||||
* Handle undefined version passed to Range.test
|
||||
|
||||
## 6.1.0
|
||||
|
||||
* Add semver.compareBuild function
|
||||
* Support `*` in semver.intersects
|
||||
|
||||
## 6.0
|
||||
|
||||
* Fix `intersects` logic.
|
||||
|
||||
This is technically a bug fix, but since it is also a change to behavior
|
||||
that may require users updating their code, it is marked as a major
|
||||
version increment.
|
||||
|
||||
## 5.7
|
||||
|
||||
* Add `minVersion` method
|
||||
|
||||
## 5.6
|
||||
|
||||
* Move boolean `loose` param to an options object, with
|
||||
backwards-compatibility protection.
|
||||
* Add ability to opt out of special prerelease version handling with
|
||||
the `includePrerelease` option flag.
|
||||
|
||||
## 5.5
|
||||
|
||||
* Add version coercion capabilities
|
||||
|
||||
## 5.4
|
||||
|
||||
* Add intersection checking
|
||||
|
||||
## 5.3
|
||||
|
||||
* Add `minSatisfying` method
|
||||
|
||||
## 5.2
|
||||
|
||||
* Add `prerelease(v)` that returns prerelease components
|
||||
|
||||
## 5.1
|
||||
|
||||
* Add Backus-Naur for ranges
|
||||
* Remove excessively cute inspection methods
|
||||
|
||||
## 5.0
|
||||
|
||||
* Remove AMD/Browserified build artifacts
|
||||
* Fix ltr and gtr when using the `*` range
|
||||
* Fix for range `*` with a prerelease identifier
|
||||
Generated
Vendored
+15
@@ -0,0 +1,15 @@
|
||||
The ISC License
|
||||
|
||||
Copyright (c) Isaac Z. Schlueter and Contributors
|
||||
|
||||
Permission to use, copy, modify, and/or distribute this software for any
|
||||
purpose with or without fee is hereby granted, provided that the above
|
||||
copyright notice and this permission notice appear in all copies.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
||||
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
||||
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
||||
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
|
||||
IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
Generated
Vendored
+443
@@ -0,0 +1,443 @@
|
||||
semver(1) -- The semantic versioner for npm
|
||||
===========================================
|
||||
|
||||
## Install
|
||||
|
||||
```bash
|
||||
npm install semver
|
||||
````
|
||||
|
||||
## Usage
|
||||
|
||||
As a node module:
|
||||
|
||||
```js
|
||||
const semver = require('semver')
|
||||
|
||||
semver.valid('1.2.3') // '1.2.3'
|
||||
semver.valid('a.b.c') // null
|
||||
semver.clean(' =v1.2.3 ') // '1.2.3'
|
||||
semver.satisfies('1.2.3', '1.x || >=2.5.0 || 5.0.0 - 7.2.3') // true
|
||||
semver.gt('1.2.3', '9.8.7') // false
|
||||
semver.lt('1.2.3', '9.8.7') // true
|
||||
semver.minVersion('>=1.0.0') // '1.0.0'
|
||||
semver.valid(semver.coerce('v2')) // '2.0.0'
|
||||
semver.valid(semver.coerce('42.6.7.9.3-alpha')) // '42.6.7'
|
||||
```
|
||||
|
||||
As a command-line utility:
|
||||
|
||||
```
|
||||
$ semver -h
|
||||
|
||||
A JavaScript implementation of the https://semver.org/ specification
|
||||
Copyright Isaac Z. Schlueter
|
||||
|
||||
Usage: semver [options] <version> [<version> [...]]
|
||||
Prints valid versions sorted by SemVer precedence
|
||||
|
||||
Options:
|
||||
-r --range <range>
|
||||
Print versions that match the specified range.
|
||||
|
||||
-i --increment [<level>]
|
||||
Increment a version by the specified level. Level can
|
||||
be one of: major, minor, patch, premajor, preminor,
|
||||
prepatch, or prerelease. Default level is 'patch'.
|
||||
Only one version may be specified.
|
||||
|
||||
--preid <identifier>
|
||||
Identifier to be used to prefix premajor, preminor,
|
||||
prepatch or prerelease version increments.
|
||||
|
||||
-l --loose
|
||||
Interpret versions and ranges loosely
|
||||
|
||||
-p --include-prerelease
|
||||
Always include prerelease versions in range matching
|
||||
|
||||
-c --coerce
|
||||
Coerce a string into SemVer if possible
|
||||
(does not imply --loose)
|
||||
|
||||
--rtl
|
||||
Coerce version strings right to left
|
||||
|
||||
--ltr
|
||||
Coerce version strings left to right (default)
|
||||
|
||||
Program exits successfully if any valid version satisfies
|
||||
all supplied ranges, and prints all satisfying versions.
|
||||
|
||||
If no satisfying versions are found, then exits failure.
|
||||
|
||||
Versions are printed in ascending order, so supplying
|
||||
multiple versions to the utility will just sort them.
|
||||
```
|
||||
|
||||
## Versions
|
||||
|
||||
A "version" is described by the `v2.0.0` specification found at
|
||||
<https://semver.org/>.
|
||||
|
||||
A leading `"="` or `"v"` character is stripped off and ignored.
|
||||
|
||||
## Ranges
|
||||
|
||||
A `version range` is a set of `comparators` which specify versions
|
||||
that satisfy the range.
|
||||
|
||||
A `comparator` is composed of an `operator` and a `version`. The set
|
||||
of primitive `operators` is:
|
||||
|
||||
* `<` Less than
|
||||
* `<=` Less than or equal to
|
||||
* `>` Greater than
|
||||
* `>=` Greater than or equal to
|
||||
* `=` Equal. If no operator is specified, then equality is assumed,
|
||||
so this operator is optional, but MAY be included.
|
||||
|
||||
For example, the comparator `>=1.2.7` would match the versions
|
||||
`1.2.7`, `1.2.8`, `2.5.3`, and `1.3.9`, but not the versions `1.2.6`
|
||||
or `1.1.0`.
|
||||
|
||||
Comparators can be joined by whitespace to form a `comparator set`,
|
||||
which is satisfied by the **intersection** of all of the comparators
|
||||
it includes.
|
||||
|
||||
A range is composed of one or more comparator sets, joined by `||`. A
|
||||
version matches a range if and only if every comparator in at least
|
||||
one of the `||`-separated comparator sets is satisfied by the version.
|
||||
|
||||
For example, the range `>=1.2.7 <1.3.0` would match the versions
|
||||
`1.2.7`, `1.2.8`, and `1.2.99`, but not the versions `1.2.6`, `1.3.0`,
|
||||
or `1.1.0`.
|
||||
|
||||
The range `1.2.7 || >=1.2.9 <2.0.0` would match the versions `1.2.7`,
|
||||
`1.2.9`, and `1.4.6`, but not the versions `1.2.8` or `2.0.0`.
|
||||
|
||||
### Prerelease Tags
|
||||
|
||||
If a version has a prerelease tag (for example, `1.2.3-alpha.3`) then
|
||||
it will only be allowed to satisfy comparator sets if at least one
|
||||
comparator with the same `[major, minor, patch]` tuple also has a
|
||||
prerelease tag.
|
||||
|
||||
For example, the range `>1.2.3-alpha.3` would be allowed to match the
|
||||
version `1.2.3-alpha.7`, but it would *not* be satisfied by
|
||||
`3.4.5-alpha.9`, even though `3.4.5-alpha.9` is technically "greater
|
||||
than" `1.2.3-alpha.3` according to the SemVer sort rules. The version
|
||||
range only accepts prerelease tags on the `1.2.3` version. The
|
||||
version `3.4.5` *would* satisfy the range, because it does not have a
|
||||
prerelease flag, and `3.4.5` is greater than `1.2.3-alpha.7`.
|
||||
|
||||
The purpose for this behavior is twofold. First, prerelease versions
|
||||
frequently are updated very quickly, and contain many breaking changes
|
||||
that are (by the author's design) not yet fit for public consumption.
|
||||
Therefore, by default, they are excluded from range matching
|
||||
semantics.
|
||||
|
||||
Second, a user who has opted into using a prerelease version has
|
||||
clearly indicated the intent to use *that specific* set of
|
||||
alpha/beta/rc versions. By including a prerelease tag in the range,
|
||||
the user is indicating that they are aware of the risk. However, it
|
||||
is still not appropriate to assume that they have opted into taking a
|
||||
similar risk on the *next* set of prerelease versions.
|
||||
|
||||
Note that this behavior can be suppressed (treating all prerelease
|
||||
versions as if they were normal versions, for the purpose of range
|
||||
matching) by setting the `includePrerelease` flag on the options
|
||||
object to any
|
||||
[functions](https://github.com/npm/node-semver#functions) that do
|
||||
range matching.
|
||||
|
||||
#### Prerelease Identifiers
|
||||
|
||||
The method `.inc` takes an additional `identifier` string argument that
|
||||
will append the value of the string as a prerelease identifier:
|
||||
|
||||
```javascript
|
||||
semver.inc('1.2.3', 'prerelease', 'beta')
|
||||
// '1.2.4-beta.0'
|
||||
```
|
||||
|
||||
command-line example:
|
||||
|
||||
```bash
|
||||
$ semver 1.2.3 -i prerelease --preid beta
|
||||
1.2.4-beta.0
|
||||
```
|
||||
|
||||
Which then can be used to increment further:
|
||||
|
||||
```bash
|
||||
$ semver 1.2.4-beta.0 -i prerelease
|
||||
1.2.4-beta.1
|
||||
```
|
||||
|
||||
### Advanced Range Syntax
|
||||
|
||||
Advanced range syntax desugars to primitive comparators in
|
||||
deterministic ways.
|
||||
|
||||
Advanced ranges may be combined in the same way as primitive
|
||||
comparators using white space or `||`.
|
||||
|
||||
#### Hyphen Ranges `X.Y.Z - A.B.C`
|
||||
|
||||
Specifies an inclusive set.
|
||||
|
||||
* `1.2.3 - 2.3.4` := `>=1.2.3 <=2.3.4`
|
||||
|
||||
If a partial version is provided as the first version in the inclusive
|
||||
range, then the missing pieces are replaced with zeroes.
|
||||
|
||||
* `1.2 - 2.3.4` := `>=1.2.0 <=2.3.4`
|
||||
|
||||
If a partial version is provided as the second version in the
|
||||
inclusive range, then all versions that start with the supplied parts
|
||||
of the tuple are accepted, but nothing that would be greater than the
|
||||
provided tuple parts.
|
||||
|
||||
* `1.2.3 - 2.3` := `>=1.2.3 <2.4.0`
|
||||
* `1.2.3 - 2` := `>=1.2.3 <3.0.0`
|
||||
|
||||
#### X-Ranges `1.2.x` `1.X` `1.2.*` `*`
|
||||
|
||||
Any of `X`, `x`, or `*` may be used to "stand in" for one of the
|
||||
numeric values in the `[major, minor, patch]` tuple.
|
||||
|
||||
* `*` := `>=0.0.0` (Any version satisfies)
|
||||
* `1.x` := `>=1.0.0 <2.0.0` (Matching major version)
|
||||
* `1.2.x` := `>=1.2.0 <1.3.0` (Matching major and minor versions)
|
||||
|
||||
A partial version range is treated as an X-Range, so the special
|
||||
character is in fact optional.
|
||||
|
||||
* `""` (empty string) := `*` := `>=0.0.0`
|
||||
* `1` := `1.x.x` := `>=1.0.0 <2.0.0`
|
||||
* `1.2` := `1.2.x` := `>=1.2.0 <1.3.0`
|
||||
|
||||
#### Tilde Ranges `~1.2.3` `~1.2` `~1`
|
||||
|
||||
Allows patch-level changes if a minor version is specified on the
|
||||
comparator. Allows minor-level changes if not.
|
||||
|
||||
* `~1.2.3` := `>=1.2.3 <1.(2+1).0` := `>=1.2.3 <1.3.0`
|
||||
* `~1.2` := `>=1.2.0 <1.(2+1).0` := `>=1.2.0 <1.3.0` (Same as `1.2.x`)
|
||||
* `~1` := `>=1.0.0 <(1+1).0.0` := `>=1.0.0 <2.0.0` (Same as `1.x`)
|
||||
* `~0.2.3` := `>=0.2.3 <0.(2+1).0` := `>=0.2.3 <0.3.0`
|
||||
* `~0.2` := `>=0.2.0 <0.(2+1).0` := `>=0.2.0 <0.3.0` (Same as `0.2.x`)
|
||||
* `~0` := `>=0.0.0 <(0+1).0.0` := `>=0.0.0 <1.0.0` (Same as `0.x`)
|
||||
* `~1.2.3-beta.2` := `>=1.2.3-beta.2 <1.3.0` Note that prereleases in
|
||||
the `1.2.3` version will be allowed, if they are greater than or
|
||||
equal to `beta.2`. So, `1.2.3-beta.4` would be allowed, but
|
||||
`1.2.4-beta.2` would not, because it is a prerelease of a
|
||||
different `[major, minor, patch]` tuple.
|
||||
|
||||
#### Caret Ranges `^1.2.3` `^0.2.5` `^0.0.4`
|
||||
|
||||
Allows changes that do not modify the left-most non-zero element in the
|
||||
`[major, minor, patch]` tuple. In other words, this allows patch and
|
||||
minor updates for versions `1.0.0` and above, patch updates for
|
||||
versions `0.X >=0.1.0`, and *no* updates for versions `0.0.X`.
|
||||
|
||||
Many authors treat a `0.x` version as if the `x` were the major
|
||||
"breaking-change" indicator.
|
||||
|
||||
Caret ranges are ideal when an author may make breaking changes
|
||||
between `0.2.4` and `0.3.0` releases, which is a common practice.
|
||||
However, it presumes that there will *not* be breaking changes between
|
||||
`0.2.4` and `0.2.5`. It allows for changes that are presumed to be
|
||||
additive (but non-breaking), according to commonly observed practices.
|
||||
|
||||
* `^1.2.3` := `>=1.2.3 <2.0.0`
|
||||
* `^0.2.3` := `>=0.2.3 <0.3.0`
|
||||
* `^0.0.3` := `>=0.0.3 <0.0.4`
|
||||
* `^1.2.3-beta.2` := `>=1.2.3-beta.2 <2.0.0` Note that prereleases in
|
||||
the `1.2.3` version will be allowed, if they are greater than or
|
||||
equal to `beta.2`. So, `1.2.3-beta.4` would be allowed, but
|
||||
`1.2.4-beta.2` would not, because it is a prerelease of a
|
||||
different `[major, minor, patch]` tuple.
|
||||
* `^0.0.3-beta` := `>=0.0.3-beta <0.0.4` Note that prereleases in the
|
||||
`0.0.3` version *only* will be allowed, if they are greater than or
|
||||
equal to `beta`. So, `0.0.3-pr.2` would be allowed.
|
||||
|
||||
When parsing caret ranges, a missing `patch` value desugars to the
|
||||
number `0`, but will allow flexibility within that value, even if the
|
||||
major and minor versions are both `0`.
|
||||
|
||||
* `^1.2.x` := `>=1.2.0 <2.0.0`
|
||||
* `^0.0.x` := `>=0.0.0 <0.1.0`
|
||||
* `^0.0` := `>=0.0.0 <0.1.0`
|
||||
|
||||
A missing `minor` and `patch` values will desugar to zero, but also
|
||||
allow flexibility within those values, even if the major version is
|
||||
zero.
|
||||
|
||||
* `^1.x` := `>=1.0.0 <2.0.0`
|
||||
* `^0.x` := `>=0.0.0 <1.0.0`
|
||||
|
||||
### Range Grammar
|
||||
|
||||
Putting all this together, here is a Backus-Naur grammar for ranges,
|
||||
for the benefit of parser authors:
|
||||
|
||||
```bnf
|
||||
range-set ::= range ( logical-or range ) *
|
||||
logical-or ::= ( ' ' ) * '||' ( ' ' ) *
|
||||
range ::= hyphen | simple ( ' ' simple ) * | ''
|
||||
hyphen ::= partial ' - ' partial
|
||||
simple ::= primitive | partial | tilde | caret
|
||||
primitive ::= ( '<' | '>' | '>=' | '<=' | '=' ) partial
|
||||
partial ::= xr ( '.' xr ( '.' xr qualifier ? )? )?
|
||||
xr ::= 'x' | 'X' | '*' | nr
|
||||
nr ::= '0' | ['1'-'9'] ( ['0'-'9'] ) *
|
||||
tilde ::= '~' partial
|
||||
caret ::= '^' partial
|
||||
qualifier ::= ( '-' pre )? ( '+' build )?
|
||||
pre ::= parts
|
||||
build ::= parts
|
||||
parts ::= part ( '.' part ) *
|
||||
part ::= nr | [-0-9A-Za-z]+
|
||||
```
|
||||
|
||||
## Functions
|
||||
|
||||
All methods and classes take a final `options` object argument. All
|
||||
options in this object are `false` by default. The options supported
|
||||
are:
|
||||
|
||||
- `loose` Be more forgiving about not-quite-valid semver strings.
|
||||
(Any resulting output will always be 100% strict compliant, of
|
||||
course.) For backwards compatibility reasons, if the `options`
|
||||
argument is a boolean value instead of an object, it is interpreted
|
||||
to be the `loose` param.
|
||||
- `includePrerelease` Set to suppress the [default
|
||||
behavior](https://github.com/npm/node-semver#prerelease-tags) of
|
||||
excluding prerelease tagged versions from ranges unless they are
|
||||
explicitly opted into.
|
||||
|
||||
Strict-mode Comparators and Ranges will be strict about the SemVer
|
||||
strings that they parse.
|
||||
|
||||
* `valid(v)`: Return the parsed version, or null if it's not valid.
|
||||
* `inc(v, release)`: Return the version incremented by the release
|
||||
type (`major`, `premajor`, `minor`, `preminor`, `patch`,
|
||||
`prepatch`, or `prerelease`), or null if it's not valid
|
||||
* `premajor` in one call will bump the version up to the next major
|
||||
version and down to a prerelease of that major version.
|
||||
`preminor`, and `prepatch` work the same way.
|
||||
* If called from a non-prerelease version, the `prerelease` will work the
|
||||
same as `prepatch`. It increments the patch version, then makes a
|
||||
prerelease. If the input version is already a prerelease it simply
|
||||
increments it.
|
||||
* `prerelease(v)`: Returns an array of prerelease components, or null
|
||||
if none exist. Example: `prerelease('1.2.3-alpha.1') -> ['alpha', 1]`
|
||||
* `major(v)`: Return the major version number.
|
||||
* `minor(v)`: Return the minor version number.
|
||||
* `patch(v)`: Return the patch version number.
|
||||
* `intersects(r1, r2, loose)`: Return true if the two supplied ranges
|
||||
or comparators intersect.
|
||||
* `parse(v)`: Attempt to parse a string as a semantic version, returning either
|
||||
a `SemVer` object or `null`.
|
||||
|
||||
### Comparison
|
||||
|
||||
* `gt(v1, v2)`: `v1 > v2`
|
||||
* `gte(v1, v2)`: `v1 >= v2`
|
||||
* `lt(v1, v2)`: `v1 < v2`
|
||||
* `lte(v1, v2)`: `v1 <= v2`
|
||||
* `eq(v1, v2)`: `v1 == v2` This is true if they're logically equivalent,
|
||||
even if they're not the exact same string. You already know how to
|
||||
compare strings.
|
||||
* `neq(v1, v2)`: `v1 != v2` The opposite of `eq`.
|
||||
* `cmp(v1, comparator, v2)`: Pass in a comparison string, and it'll call
|
||||
the corresponding function above. `"==="` and `"!=="` do simple
|
||||
string comparison, but are included for completeness. Throws if an
|
||||
invalid comparison string is provided.
|
||||
* `compare(v1, v2)`: Return `0` if `v1 == v2`, or `1` if `v1` is greater, or `-1` if
|
||||
`v2` is greater. Sorts in ascending order if passed to `Array.sort()`.
|
||||
* `rcompare(v1, v2)`: The reverse of compare. Sorts an array of versions
|
||||
in descending order when passed to `Array.sort()`.
|
||||
* `compareBuild(v1, v2)`: The same as `compare` but considers `build` when two versions
|
||||
are equal. Sorts in ascending order if passed to `Array.sort()`.
|
||||
`v2` is greater. Sorts in ascending order if passed to `Array.sort()`.
|
||||
* `diff(v1, v2)`: Returns difference between two versions by the release type
|
||||
(`major`, `premajor`, `minor`, `preminor`, `patch`, `prepatch`, or `prerelease`),
|
||||
or null if the versions are the same.
|
||||
|
||||
### Comparators
|
||||
|
||||
* `intersects(comparator)`: Return true if the comparators intersect
|
||||
|
||||
### Ranges
|
||||
|
||||
* `validRange(range)`: Return the valid range or null if it's not valid
|
||||
* `satisfies(version, range)`: Return true if the version satisfies the
|
||||
range.
|
||||
* `maxSatisfying(versions, range)`: Return the highest version in the list
|
||||
that satisfies the range, or `null` if none of them do.
|
||||
* `minSatisfying(versions, range)`: Return the lowest version in the list
|
||||
that satisfies the range, or `null` if none of them do.
|
||||
* `minVersion(range)`: Return the lowest version that can possibly match
|
||||
the given range.
|
||||
* `gtr(version, range)`: Return `true` if version is greater than all the
|
||||
versions possible in the range.
|
||||
* `ltr(version, range)`: Return `true` if version is less than all the
|
||||
versions possible in the range.
|
||||
* `outside(version, range, hilo)`: Return true if the version is outside
|
||||
the bounds of the range in either the high or low direction. The
|
||||
`hilo` argument must be either the string `'>'` or `'<'`. (This is
|
||||
the function called by `gtr` and `ltr`.)
|
||||
* `intersects(range)`: Return true if any of the ranges comparators intersect
|
||||
|
||||
Note that, since ranges may be non-contiguous, a version might not be
|
||||
greater than a range, less than a range, *or* satisfy a range! For
|
||||
example, the range `1.2 <1.2.9 || >2.0.0` would have a hole from `1.2.9`
|
||||
until `2.0.0`, so the version `1.2.10` would not be greater than the
|
||||
range (because `2.0.1` satisfies, which is higher), nor less than the
|
||||
range (since `1.2.8` satisfies, which is lower), and it also does not
|
||||
satisfy the range.
|
||||
|
||||
If you want to know if a version satisfies or does not satisfy a
|
||||
range, use the `satisfies(version, range)` function.
|
||||
|
||||
### Coercion
|
||||
|
||||
* `coerce(version, options)`: Coerces a string to semver if possible
|
||||
|
||||
This aims to provide a very forgiving translation of a non-semver string to
|
||||
semver. It looks for the first digit in a string, and consumes all
|
||||
remaining characters which satisfy at least a partial semver (e.g., `1`,
|
||||
`1.2`, `1.2.3`) up to the max permitted length (256 characters). Longer
|
||||
versions are simply truncated (`4.6.3.9.2-alpha2` becomes `4.6.3`). All
|
||||
surrounding text is simply ignored (`v3.4 replaces v3.3.1` becomes
|
||||
`3.4.0`). Only text which lacks digits will fail coercion (`version one`
|
||||
is not valid). The maximum length for any semver component considered for
|
||||
coercion is 16 characters; longer components will be ignored
|
||||
(`10000000000000000.4.7.4` becomes `4.7.4`). The maximum value for any
|
||||
semver component is `Integer.MAX_SAFE_INTEGER || (2**53 - 1)`; higher value
|
||||
components are invalid (`9999999999999999.4.7.4` is likely invalid).
|
||||
|
||||
If the `options.rtl` flag is set, then `coerce` will return the right-most
|
||||
coercible tuple that does not share an ending index with a longer coercible
|
||||
tuple. For example, `1.2.3.4` will return `2.3.4` in rtl mode, not
|
||||
`4.0.0`. `1.2.3/4` will return `4.0.0`, because the `4` is not a part of
|
||||
any other overlapping SemVer tuple.
|
||||
|
||||
### Clean
|
||||
|
||||
* `clean(version)`: Clean a string to be a valid semver if possible
|
||||
|
||||
This will return a cleaned and trimmed semver version. If the provided version is not valid a null will be returned. This does not work for ranges.
|
||||
|
||||
ex.
|
||||
* `s.clean(' = v 2.1.5foo')`: `null`
|
||||
* `s.clean(' = v 2.1.5foo', { loose: true })`: `'2.1.5-foo'`
|
||||
* `s.clean(' = v 2.1.5-foo')`: `null`
|
||||
* `s.clean(' = v 2.1.5-foo', { loose: true })`: `'2.1.5-foo'`
|
||||
* `s.clean('=v2.1.5')`: `'2.1.5'`
|
||||
* `s.clean(' =v2.1.5')`: `2.1.5`
|
||||
* `s.clean(' 2.1.5 ')`: `'2.1.5'`
|
||||
* `s.clean('~1.0.0')`: `null`
|
||||
Generated
Vendored
Executable
+174
@@ -0,0 +1,174 @@
|
||||
#!/usr/bin/env node
|
||||
// Standalone semver comparison program.
|
||||
// Exits successfully and prints matching version(s) if
|
||||
// any supplied version is valid and passes all tests.
|
||||
|
||||
var argv = process.argv.slice(2)
|
||||
|
||||
var versions = []
|
||||
|
||||
var range = []
|
||||
|
||||
var inc = null
|
||||
|
||||
var version = require('../package.json').version
|
||||
|
||||
var loose = false
|
||||
|
||||
var includePrerelease = false
|
||||
|
||||
var coerce = false
|
||||
|
||||
var rtl = false
|
||||
|
||||
var identifier
|
||||
|
||||
var semver = require('../semver')
|
||||
|
||||
var reverse = false
|
||||
|
||||
var options = {}
|
||||
|
||||
main()
|
||||
|
||||
function main () {
|
||||
if (!argv.length) return help()
|
||||
while (argv.length) {
|
||||
var a = argv.shift()
|
||||
var indexOfEqualSign = a.indexOf('=')
|
||||
if (indexOfEqualSign !== -1) {
|
||||
a = a.slice(0, indexOfEqualSign)
|
||||
argv.unshift(a.slice(indexOfEqualSign + 1))
|
||||
}
|
||||
switch (a) {
|
||||
case '-rv': case '-rev': case '--rev': case '--reverse':
|
||||
reverse = true
|
||||
break
|
||||
case '-l': case '--loose':
|
||||
loose = true
|
||||
break
|
||||
case '-p': case '--include-prerelease':
|
||||
includePrerelease = true
|
||||
break
|
||||
case '-v': case '--version':
|
||||
versions.push(argv.shift())
|
||||
break
|
||||
case '-i': case '--inc': case '--increment':
|
||||
switch (argv[0]) {
|
||||
case 'major': case 'minor': case 'patch': case 'prerelease':
|
||||
case 'premajor': case 'preminor': case 'prepatch':
|
||||
inc = argv.shift()
|
||||
break
|
||||
default:
|
||||
inc = 'patch'
|
||||
break
|
||||
}
|
||||
break
|
||||
case '--preid':
|
||||
identifier = argv.shift()
|
||||
break
|
||||
case '-r': case '--range':
|
||||
range.push(argv.shift())
|
||||
break
|
||||
case '-c': case '--coerce':
|
||||
coerce = true
|
||||
break
|
||||
case '--rtl':
|
||||
rtl = true
|
||||
break
|
||||
case '--ltr':
|
||||
rtl = false
|
||||
break
|
||||
case '-h': case '--help': case '-?':
|
||||
return help()
|
||||
default:
|
||||
versions.push(a)
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
var options = { loose: loose, includePrerelease: includePrerelease, rtl: rtl }
|
||||
|
||||
versions = versions.map(function (v) {
|
||||
return coerce ? (semver.coerce(v, options) || { version: v }).version : v
|
||||
}).filter(function (v) {
|
||||
return semver.valid(v)
|
||||
})
|
||||
if (!versions.length) return fail()
|
||||
if (inc && (versions.length !== 1 || range.length)) { return failInc() }
|
||||
|
||||
for (var i = 0, l = range.length; i < l; i++) {
|
||||
versions = versions.filter(function (v) {
|
||||
return semver.satisfies(v, range[i], options)
|
||||
})
|
||||
if (!versions.length) return fail()
|
||||
}
|
||||
return success(versions)
|
||||
}
|
||||
|
||||
function failInc () {
|
||||
console.error('--inc can only be used on a single version with no range')
|
||||
fail()
|
||||
}
|
||||
|
||||
function fail () { process.exit(1) }
|
||||
|
||||
function success () {
|
||||
var compare = reverse ? 'rcompare' : 'compare'
|
||||
versions.sort(function (a, b) {
|
||||
return semver[compare](a, b, options)
|
||||
}).map(function (v) {
|
||||
return semver.clean(v, options)
|
||||
}).map(function (v) {
|
||||
return inc ? semver.inc(v, inc, options, identifier) : v
|
||||
}).forEach(function (v, i, _) { console.log(v) })
|
||||
}
|
||||
|
||||
function help () {
|
||||
console.log(['SemVer ' + version,
|
||||
'',
|
||||
'A JavaScript implementation of the https://semver.org/ specification',
|
||||
'Copyright Isaac Z. Schlueter',
|
||||
'',
|
||||
'Usage: semver [options] <version> [<version> [...]]',
|
||||
'Prints valid versions sorted by SemVer precedence',
|
||||
'',
|
||||
'Options:',
|
||||
'-r --range <range>',
|
||||
' Print versions that match the specified range.',
|
||||
'',
|
||||
'-i --increment [<level>]',
|
||||
' Increment a version by the specified level. Level can',
|
||||
' be one of: major, minor, patch, premajor, preminor,',
|
||||
" prepatch, or prerelease. Default level is 'patch'.",
|
||||
' Only one version may be specified.',
|
||||
'',
|
||||
'--preid <identifier>',
|
||||
' Identifier to be used to prefix premajor, preminor,',
|
||||
' prepatch or prerelease version increments.',
|
||||
'',
|
||||
'-l --loose',
|
||||
' Interpret versions and ranges loosely',
|
||||
'',
|
||||
'-p --include-prerelease',
|
||||
' Always include prerelease versions in range matching',
|
||||
'',
|
||||
'-c --coerce',
|
||||
' Coerce a string into SemVer if possible',
|
||||
' (does not imply --loose)',
|
||||
'',
|
||||
'--rtl',
|
||||
' Coerce version strings right to left',
|
||||
'',
|
||||
'--ltr',
|
||||
' Coerce version strings left to right (default)',
|
||||
'',
|
||||
'Program exits successfully if any valid version satisfies',
|
||||
'all supplied ranges, and prints all satisfying versions.',
|
||||
'',
|
||||
'If no satisfying versions are found, then exits failure.',
|
||||
'',
|
||||
'Versions are printed in ascending order, so supplying',
|
||||
'multiple versions to the utility will just sort them.'
|
||||
].join('\n'))
|
||||
}
|
||||
Generated
Vendored
+28
@@ -0,0 +1,28 @@
|
||||
{
|
||||
"name": "semver",
|
||||
"version": "6.3.0",
|
||||
"description": "The semantic version parser used by npm.",
|
||||
"main": "semver.js",
|
||||
"scripts": {
|
||||
"test": "tap",
|
||||
"preversion": "npm test",
|
||||
"postversion": "npm publish",
|
||||
"postpublish": "git push origin --follow-tags"
|
||||
},
|
||||
"devDependencies": {
|
||||
"tap": "^14.3.1"
|
||||
},
|
||||
"license": "ISC",
|
||||
"repository": "https://github.com/npm/node-semver",
|
||||
"bin": {
|
||||
"semver": "./bin/semver.js"
|
||||
},
|
||||
"files": [
|
||||
"bin",
|
||||
"range.bnf",
|
||||
"semver.js"
|
||||
],
|
||||
"tap": {
|
||||
"check-coverage": true
|
||||
}
|
||||
}
|
||||
Generated
Vendored
+16
@@ -0,0 +1,16 @@
|
||||
range-set ::= range ( logical-or range ) *
|
||||
logical-or ::= ( ' ' ) * '||' ( ' ' ) *
|
||||
range ::= hyphen | simple ( ' ' simple ) * | ''
|
||||
hyphen ::= partial ' - ' partial
|
||||
simple ::= primitive | partial | tilde | caret
|
||||
primitive ::= ( '<' | '>' | '>=' | '<=' | '=' ) partial
|
||||
partial ::= xr ( '.' xr ( '.' xr qualifier ? )? )?
|
||||
xr ::= 'x' | 'X' | '*' | nr
|
||||
nr ::= '0' | [1-9] ( [0-9] ) *
|
||||
tilde ::= '~' partial
|
||||
caret ::= '^' partial
|
||||
qualifier ::= ( '-' pre )? ( '+' build )?
|
||||
pre ::= parts
|
||||
build ::= parts
|
||||
parts ::= part ( '.' part ) *
|
||||
part ::= nr | [-0-9A-Za-z]+
|
||||
Generated
Vendored
+1596
File diff suppressed because it is too large
Load Diff
+60
@@ -0,0 +1,60 @@
|
||||
{
|
||||
"name": "@babel/helper-define-polyfill-provider",
|
||||
"version": "0.3.1",
|
||||
"description": "Babel helper to create your own polyfill provider",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "https://github.com/babel/babel-polyfills.git",
|
||||
"directory": "packages/babel-helper-define-polyfill-provider"
|
||||
},
|
||||
"keywords": [
|
||||
"babel-plugin"
|
||||
],
|
||||
"license": "MIT",
|
||||
"publishConfig": {
|
||||
"access": "public"
|
||||
},
|
||||
"main": "lib/index.js",
|
||||
"browser": {
|
||||
"./lib/node/dependencies.js": "./lib/browser/dependencies.js",
|
||||
"./src/node/dependencies.js": "./src/browser/dependencies.js"
|
||||
},
|
||||
"exports": {
|
||||
".": [
|
||||
{
|
||||
"import": {
|
||||
"node": "./esm/index.node.mjs",
|
||||
"browser": "./esm/index.browser.mjs"
|
||||
},
|
||||
"default": "./lib/index.js"
|
||||
},
|
||||
"./lib/index.js"
|
||||
],
|
||||
"./package.json": "./package.json"
|
||||
},
|
||||
"dependencies": {
|
||||
"@babel/helper-compilation-targets": "^7.13.0",
|
||||
"@babel/helper-module-imports": "^7.12.13",
|
||||
"@babel/helper-plugin-utils": "^7.13.0",
|
||||
"@babel/traverse": "^7.13.0",
|
||||
"debug": "^4.1.1",
|
||||
"lodash.debounce": "^4.0.8",
|
||||
"resolve": "^1.14.2",
|
||||
"semver": "^6.1.2"
|
||||
},
|
||||
"peerDependencies": {
|
||||
"@babel/core": "^7.4.0-0"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@babel/cli": "^7.11.5",
|
||||
"@babel/core": "^7.13.0",
|
||||
"@babel/generator": "^7.11.5",
|
||||
"@babel/plugin-transform-modules-commonjs": "^7.10.4",
|
||||
"babel-loader": "^8.1.0",
|
||||
"rollup": "^2.3.2",
|
||||
"rollup-plugin-babel": "^4.4.0",
|
||||
"webpack": "^4.42.1",
|
||||
"webpack-cli": "^3.3.11"
|
||||
},
|
||||
"gitHead": "f5eb1c6d74fa29afdb0a3a533dfc5742557197bc"
|
||||
}
|
||||
Generated
Vendored
+24
@@ -0,0 +1,24 @@
|
||||
// @flow
|
||||
|
||||
export function resolve(
|
||||
dirname: string,
|
||||
moduleName: string,
|
||||
absoluteImports: boolean | string,
|
||||
): string {
|
||||
if (absoluteImports === false) return moduleName;
|
||||
|
||||
throw new Error(
|
||||
`"absoluteImports" is not supported in bundles prepared for the browser.`,
|
||||
);
|
||||
}
|
||||
|
||||
// eslint-disable-next-line no-unused-vars
|
||||
export function has(basedir: string, name: string) {
|
||||
return true;
|
||||
}
|
||||
|
||||
// eslint-disable-next-line no-unused-vars
|
||||
export function logMissing(missingDeps: Set<string>) {}
|
||||
|
||||
// eslint-disable-next-line no-unused-vars
|
||||
export function laterLogMissing(missingDeps: Set<string>) {}
|
||||
Generated
Vendored
+91
@@ -0,0 +1,91 @@
|
||||
// @flow
|
||||
|
||||
import path from "path";
|
||||
import debounce from "lodash.debounce";
|
||||
import requireResolve from "resolve";
|
||||
|
||||
const nativeRequireResolve = parseFloat(process.versions.node) >= 8.9;
|
||||
|
||||
// $FlowIgnore
|
||||
import { createRequire } from "module";
|
||||
// $FlowIgnore
|
||||
const require = createRequire(import/*::(_)*/.meta.url); // eslint-disable-line
|
||||
|
||||
export function resolve(
|
||||
dirname: string,
|
||||
moduleName: string,
|
||||
absoluteImports: boolean | string,
|
||||
): string {
|
||||
if (absoluteImports === false) return moduleName;
|
||||
|
||||
let basedir = dirname;
|
||||
if (typeof absoluteImports === "string") {
|
||||
basedir = path.resolve(basedir, absoluteImports);
|
||||
}
|
||||
|
||||
try {
|
||||
if (nativeRequireResolve) {
|
||||
return require.resolve(moduleName, {
|
||||
paths: [basedir],
|
||||
});
|
||||
} else {
|
||||
return requireResolve.sync(moduleName, { basedir });
|
||||
}
|
||||
} catch (err) {
|
||||
if (err.code !== "MODULE_NOT_FOUND") throw err;
|
||||
|
||||
// $FlowIgnore
|
||||
throw Object.assign(
|
||||
new Error(`Failed to resolve "${moduleName}" relative to "${dirname}"`),
|
||||
{
|
||||
code: "BABEL_POLYFILL_NOT_FOUND",
|
||||
polyfill: moduleName,
|
||||
dirname,
|
||||
},
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
export function has(basedir: string, name: string) {
|
||||
try {
|
||||
if (nativeRequireResolve) {
|
||||
require.resolve(name, { paths: [basedir] });
|
||||
} else {
|
||||
requireResolve.sync(name, { basedir });
|
||||
}
|
||||
return true;
|
||||
} catch {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
export function logMissing(missingDeps: Set<string>) {
|
||||
if (missingDeps.size === 0) return;
|
||||
|
||||
const deps = Array.from(missingDeps)
|
||||
.sort()
|
||||
.join(" ");
|
||||
|
||||
console.warn(
|
||||
"\nSome polyfills have been added but are not present in your dependencies.\n" +
|
||||
"Please run one of the following commands:\n" +
|
||||
`\tnpm install --save ${deps}\n` +
|
||||
`\tyarn add ${deps}\n`,
|
||||
);
|
||||
|
||||
process.exitCode = 1;
|
||||
}
|
||||
|
||||
let allMissingDeps = new Set();
|
||||
|
||||
const laterLogMissingDependencies = debounce(() => {
|
||||
logMissing(allMissingDeps);
|
||||
allMissingDeps = new Set();
|
||||
}, 100);
|
||||
|
||||
export function laterLogMissing(missingDeps: Set<string>) {
|
||||
if (missingDeps.size === 0) return;
|
||||
|
||||
missingDeps.forEach(name => allMissingDeps.add(name));
|
||||
laterLogMissingDependencies();
|
||||
}
|
||||
Reference in New Issue
Block a user