From aa773172311dcada759dfbaac485f4bc6e00bc21 Mon Sep 17 00:00:00 2001 From: littleblack111 Date: Sat, 14 Oct 2023 15:31:11 +0800 Subject: added babel --- .../lib/browser/dependencies.js | 22 ++ .../lib/debug-utils.js | 15 ++ .../lib/define-provider.js | 9 + .../lib/imports-cache.js | 96 +++++++ .../helper-define-polyfill-provider/lib/index.js | 275 +++++++++++++++++++++ .../lib/meta-resolver.js | 52 ++++ .../lib/node/dependencies.js | 67 +++++ .../lib/normalize-options.js | 70 ++++++ .../helper-define-polyfill-provider/lib/types.js | 3 + .../helper-define-polyfill-provider/lib/utils.js | 165 +++++++++++++ .../lib/visitors/entry.js | 26 ++ .../lib/visitors/index.js | 9 + .../lib/visitors/usage.js | 91 +++++++ 13 files changed, 900 insertions(+) create mode 100644 node_modules/@babel/helper-define-polyfill-provider/lib/browser/dependencies.js create mode 100644 node_modules/@babel/helper-define-polyfill-provider/lib/debug-utils.js create mode 100644 node_modules/@babel/helper-define-polyfill-provider/lib/define-provider.js create mode 100644 node_modules/@babel/helper-define-polyfill-provider/lib/imports-cache.js create mode 100644 node_modules/@babel/helper-define-polyfill-provider/lib/index.js create mode 100644 node_modules/@babel/helper-define-polyfill-provider/lib/meta-resolver.js create mode 100644 node_modules/@babel/helper-define-polyfill-provider/lib/node/dependencies.js create mode 100644 node_modules/@babel/helper-define-polyfill-provider/lib/normalize-options.js create mode 100644 node_modules/@babel/helper-define-polyfill-provider/lib/types.js create mode 100644 node_modules/@babel/helper-define-polyfill-provider/lib/utils.js create mode 100644 node_modules/@babel/helper-define-polyfill-provider/lib/visitors/entry.js create mode 100644 node_modules/@babel/helper-define-polyfill-provider/lib/visitors/index.js create mode 100644 node_modules/@babel/helper-define-polyfill-provider/lib/visitors/usage.js (limited to 'node_modules/@babel/helper-define-polyfill-provider/lib') diff --git a/node_modules/@babel/helper-define-polyfill-provider/lib/browser/dependencies.js b/node_modules/@babel/helper-define-polyfill-provider/lib/browser/dependencies.js new file mode 100644 index 00000000..b676f61c --- /dev/null +++ b/node_modules/@babel/helper-define-polyfill-provider/lib/browser/dependencies.js @@ -0,0 +1,22 @@ +"use strict"; + +exports.__esModule = true; +exports.has = has; +exports.laterLogMissing = laterLogMissing; +exports.logMissing = logMissing; +exports.resolve = resolve; +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 @typescript-eslint/no-unused-vars +function has(basedir, name) { + return true; +} + +// eslint-disable-next-line @typescript-eslint/no-unused-vars +function logMissing(missingDeps) {} + +// eslint-disable-next-line @typescript-eslint/no-unused-vars +function laterLogMissing(missingDeps) {} \ No newline at end of file diff --git a/node_modules/@babel/helper-define-polyfill-provider/lib/debug-utils.js b/node_modules/@babel/helper-define-polyfill-provider/lib/debug-utils.js new file mode 100644 index 00000000..0f30c856 --- /dev/null +++ b/node_modules/@babel/helper-define-polyfill-provider/lib/debug-utils.js @@ -0,0 +1,15 @@ +"use strict"; + +exports.__esModule = true; +exports.presetEnvSilentDebugHeader = void 0; +exports.stringifyTargets = stringifyTargets; +exports.stringifyTargetsMultiline = stringifyTargetsMultiline; +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(/"\}$/, '" }'); +} \ No newline at end of file diff --git a/node_modules/@babel/helper-define-polyfill-provider/lib/define-provider.js b/node_modules/@babel/helper-define-polyfill-provider/lib/define-provider.js new file mode 100644 index 00000000..e5a6f0e5 --- /dev/null +++ b/node_modules/@babel/helper-define-polyfill-provider/lib/define-provider.js @@ -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; +} \ No newline at end of file diff --git a/node_modules/@babel/helper-define-polyfill-provider/lib/imports-cache.js b/node_modules/@babel/helper-define-polyfill-provider/lib/imports-cache.js new file mode 100644 index 00000000..553c8930 --- /dev/null +++ b/node_modules/@babel/helper-define-polyfill-provider/lib/imports-cache.js @@ -0,0 +1,96 @@ +"use strict"; + +exports.__esModule = true; +exports.default = void 0; +var _babel = _interopRequireWildcard(require("@babel/core")); +function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } +function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && 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) { + const lastImport = this._lastImports.get(programPath); + let newNodes; + 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) { + newNodes = lastImport.insertAfter(node); + } else { + newNodes = programPath.unshiftContainer("body", node); + } + const newNode = newNodes[newNodes.length - 1]; + this._lastImports.set(programPath, newNode); + + /* + 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; \ No newline at end of file diff --git a/node_modules/@babel/helper-define-polyfill-provider/lib/index.js b/node_modules/@babel/helper-define-polyfill-provider/lib/index.js new file mode 100644 index 00000000..2d9dcb84 --- /dev/null +++ b/node_modules/@babel/helper-define-polyfill-provider/lib/index.js @@ -0,0 +1,275 @@ +"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")); +const _excluded = ["method", "targets", "ignoreBrowserslistConfig", "configPath", "debug", "shouldInjectPolyfill", "absoluteImports"]; +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } +function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } +function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && 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, _excluded); + if (isEmpty(options)) { + throw new Error(`\ +This plugin requires options, for example: + { + "plugins": [ + ["", { method: "usage-pure" }] + ] + } + +See more options at https://github.com/babel/babel-polyfills/blob/main/docs/usage.md`); + } + 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 ${providerName} 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) { + var _debugLog, _debugLog$polyfillsSu; + debugLog().found = true; + if (!debug || !name) return; + if (debugLog().polyfills.has(providerName)) return; + debugLog().polyfills.add(name); + (_debugLog$polyfillsSu = (_debugLog = debugLog()).polyfillsSupport) != null ? _debugLog$polyfillsSu : _debugLog.polyfillsSupport = polyfillsSupport; + }, + 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); + const providerName = provider.name || factory.name; + if (typeof provider[methodName] !== "function") { + throw new Error(`The "${providerName}" 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)(providerName, polyfillsNames, providerOptions.include || [], providerOptions.exclude || [])); + return { + debug, + method, + targets, + provider, + providerName, + callProvider(payload, path) { + const utils = getUtils(path); + 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, + providerName, + 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(`${providerName}: \`DEBUG\` option`); + console.log(`\nUsing targets: ${(0, _debugUtils.stringifyTargetsMultiline)(targets)}`); + console.log(`\nUsing polyfills with \`${method}\` method:`); + } + const { + runtimeName + } = provider; + return { + name: "inject-polyfills", + visitor, + pre(file) { + var _provider$pre; + if (runtimeName) { + if (file.get("runtimeHelpersModuleName") && file.get("runtimeHelpersModuleName") !== runtimeName) { + console.warn(`Two different polyfill providers` + ` (${file.get("runtimeHelpersModuleProvider")}` + ` and ${providerName}) are trying to define two` + ` conflicting @babel/runtime alternatives:` + ` ${file.get("runtimeHelpersModuleName")} and ${runtimeName}.` + ` The second one will be ignored.`); + } else { + file.set("runtimeHelpersModuleName", runtimeName); + file.set("runtimeHelpersModuleProvider", providerName); + } + } + debugLog = { + polyfills: new Set(), + polyfillsSupport: undefined, + found: false, + providers: new Set(), + missingDeps: new Set() + }; + (_provider$pre = provider.pre) == null ? void 0 : _provider$pre.apply(this, arguments); + }, + post() { + var _provider$post; + (_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 ${providerName} polyfill did not add any polyfill.` : `The entry point for the ${providerName} polyfill has not been found.` : `Based on your code and targets, the ${providerName} polyfill did not add any polyfill.`); + return; + } + if (method === "entry-global") { + console.log(`The ${providerName} polyfill entry has been replaced with ` + `the following polyfills:`); + } else { + console.log(`The ${providerName} polyfill added the following polyfills:`); + } + for (const name of debugLog.polyfills) { + var _debugLog$polyfillsSu2; + if ((_debugLog$polyfillsSu2 = debugLog.polyfillsSupport) != null && _debugLog$polyfillsSu2[name]) { + const filteredTargets = (0, _helperCompilationTargets.getInclusionReasons)(name, targets, debugLog.polyfillsSupport); + 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; +} +function isEmpty(obj) { + return Object.keys(obj).length === 0; +} \ No newline at end of file diff --git a/node_modules/@babel/helper-define-polyfill-provider/lib/meta-resolver.js b/node_modules/@babel/helper-define-polyfill-provider/lib/meta-resolver.js new file mode 100644 index 00000000..502320bc --- /dev/null +++ b/node_modules/@babel/helper-define-polyfill-provider/lib/meta-resolver.js @@ -0,0 +1,52 @@ +"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}` + }; + } + } + }; +} \ No newline at end of file diff --git a/node_modules/@babel/helper-define-polyfill-provider/lib/node/dependencies.js b/node_modules/@babel/helper-define-polyfill-provider/lib/node/dependencies.js new file mode 100644 index 00000000..44900240 --- /dev/null +++ b/node_modules/@babel/helper-define-polyfill-provider/lib/node/dependencies.js @@ -0,0 +1,67 @@ +"use strict"; + +exports.__esModule = true; +exports.has = has; +exports.laterLogMissing = laterLogMissing; +exports.logMissing = logMissing; +exports.resolve = resolve; +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; +// eslint-disable-line + +function myResolve(name, basedir) { + if (nativeRequireResolve) { + return require.resolve(name, { + paths: [basedir] + }).replace(/\\/g, "/"); + } else { + return _resolve.default.sync(name, { + basedir + }).replace(/\\/g, "/"); + } +} +function resolve(dirname, moduleName, absoluteImports) { + if (absoluteImports === false) return moduleName; + let basedir = dirname; + if (typeof absoluteImports === "string") { + basedir = _path.default.resolve(basedir, absoluteImports); + } + try { + return myResolve(moduleName, basedir); + } catch (err) { + if (err.code !== "MODULE_NOT_FOUND") throw err; + 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 { + myResolve(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(); +} \ No newline at end of file diff --git a/node_modules/@babel/helper-define-polyfill-provider/lib/normalize-options.js b/node_modules/@babel/helper-define-polyfill-provider/lib/normalize-options.js new file mode 100644 index 00000000..62937764 --- /dev/null +++ b/node_modules/@babel/helper-define-polyfill-provider/lib/normalize-options.js @@ -0,0 +1,70 @@ +"use strict"; + +exports.__esModule = true; +exports.applyMissingDependenciesDefaults = applyMissingDependenciesDefaults; +exports.validateIncludeExclude = validateIncludeExclude; +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 + }; +} \ No newline at end of file diff --git a/node_modules/@babel/helper-define-polyfill-provider/lib/types.js b/node_modules/@babel/helper-define-polyfill-provider/lib/types.js new file mode 100644 index 00000000..bf95ee70 --- /dev/null +++ b/node_modules/@babel/helper-define-polyfill-provider/lib/types.js @@ -0,0 +1,3 @@ +"use strict"; + +exports.__esModule = true; \ No newline at end of file diff --git a/node_modules/@babel/helper-define-polyfill-provider/lib/utils.js b/node_modules/@babel/helper-define-polyfill-provider/lib/utils.js new file mode 100644 index 00000000..0aff88b1 --- /dev/null +++ b/node_modules/@babel/helper-define-polyfill-provider/lib/utils.js @@ -0,0 +1,165 @@ +"use strict"; + +exports.__esModule = true; +exports.createUtilsGetter = createUtilsGetter; +exports.getImportSource = getImportSource; +exports.getRequireSource = getRequireSource; +exports.has = has; +exports.intersection = intersection; +exports.resolveKey = resolveKey; +exports.resolveSource = resolveSource; +var _babel = _interopRequireWildcard(require("@babel/core")); +function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } +function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && 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: 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; + } + if (path.isPure()) { + const { + deopt + } = path.evaluate(); + if (deopt && deopt.isIdentifier()) { + return deopt.node.name; + } + } +} +function resolveKey(path, computed = false) { + const { + scope + } = path; + if (path.isStringLiteral()) return path.node.value; + const isIdentifier = path.isIdentifier(); + if (isIdentifier && !(computed || path.parent.computed)) { + return path.node.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(path.node.name, /* noGlobals */true) : path.isPure()) { + 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" + }; + } + if (obj.isRegExpLiteral()) { + return { + id: "RegExp", + placement: "prototype" + }; + } else if (obj.isFunction()) { + return { + id: "Function", + placement: "prototype" + }; + } else if (obj.isPure()) { + const { + value + } = obj.evaluate(); + if (value !== undefined) { + return { + id: getType(value), + 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; + if (t.isCallExpression(expression) && t.isIdentifier(expression.callee) && expression.callee.name === "require" && expression.arguments.length === 1 && t.isStringLiteral(expression.arguments[0])) { + return expression.arguments[0].value; + } +} +function hoist(node) { + // @ts-expect-error + 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 + }; + }); + } + }; + }; +} \ No newline at end of file diff --git a/node_modules/@babel/helper-define-polyfill-provider/lib/visitors/entry.js b/node_modules/@babel/helper-define-polyfill-provider/lib/visitors/entry.js new file mode 100644 index 00000000..e8b09030 --- /dev/null +++ b/node_modules/@babel/helper-define-polyfill-provider/lib/visitors/entry.js @@ -0,0 +1,26 @@ +"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; \ No newline at end of file diff --git a/node_modules/@babel/helper-define-polyfill-provider/lib/visitors/index.js b/node_modules/@babel/helper-define-polyfill-provider/lib/visitors/index.js new file mode 100644 index 00000000..056559b9 --- /dev/null +++ b/node_modules/@babel/helper-define-polyfill-provider/lib/visitors/index.js @@ -0,0 +1,9 @@ +"use strict"; + +exports.__esModule = true; +exports.usage = exports.entry = 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 }; } \ No newline at end of file diff --git a/node_modules/@babel/helper-define-polyfill-provider/lib/visitors/usage.js b/node_modules/@babel/helper-define-polyfill-provider/lib/visitors/usage.js new file mode 100644 index 00000000..4a4c5472 --- /dev/null +++ b/node_modules/@babel/helper-define-polyfill-provider/lib/visitors/usage.js @@ -0,0 +1,91 @@ +"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"); + if (object.isIdentifier()) { + 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; \ No newline at end of file -- cgit v1.2.3