diff options
Diffstat (limited to 'node_modules/babel-plugin-polyfill-corejs2/esm/index.mjs')
| -rw-r--r-- | node_modules/babel-plugin-polyfill-corejs2/esm/index.mjs | 395 |
1 files changed, 395 insertions, 0 deletions
diff --git a/node_modules/babel-plugin-polyfill-corejs2/esm/index.mjs b/node_modules/babel-plugin-polyfill-corejs2/esm/index.mjs new file mode 100644 index 00000000..d697ca4f --- /dev/null +++ b/node_modules/babel-plugin-polyfill-corejs2/esm/index.mjs @@ -0,0 +1,395 @@ +import corejs2Polyfills from '@babel/compat-data/corejs2-built-ins'; +import semver from 'semver'; +import defineProvider from '@babel/helper-define-polyfill-provider'; +import * as _babel from '@babel/core'; + +const define = (name, pure, global = [], meta) => { + return { + name, + pure, + global, + meta + }; +}; +const pureAndGlobal = (pure, global, minRuntimeVersion = null) => define(global[0], pure, global, { + minRuntimeVersion +}); +const globalOnly = global => define(global[0], null, global); +const pureOnly = (pure, name) => define(name, pure, []); +const ArrayNatureIterators = ["es6.object.to-string", "es6.array.iterator", "web.dom.iterable"]; +const CommonIterators = ["es6.string.iterator", ...ArrayNatureIterators]; +const PromiseDependencies = ["es6.object.to-string", "es6.promise"]; +const BuiltIns = { + DataView: globalOnly(["es6.typed.data-view"]), + Float32Array: globalOnly(["es6.typed.float32-array"]), + Float64Array: globalOnly(["es6.typed.float64-array"]), + Int8Array: globalOnly(["es6.typed.int8-array"]), + Int16Array: globalOnly(["es6.typed.int16-array"]), + Int32Array: globalOnly(["es6.typed.int32-array"]), + Map: pureAndGlobal("map", ["es6.map", ...CommonIterators]), + Number: globalOnly(["es6.number.constructor"]), + Promise: pureAndGlobal("promise", PromiseDependencies), + RegExp: globalOnly(["es6.regexp.constructor"]), + Set: pureAndGlobal("set", ["es6.set", ...CommonIterators]), + Symbol: pureAndGlobal("symbol/index", ["es6.symbol"]), + Uint8Array: globalOnly(["es6.typed.uint8-array"]), + Uint8ClampedArray: globalOnly(["es6.typed.uint8-clamped-array"]), + Uint16Array: globalOnly(["es6.typed.uint16-array"]), + Uint32Array: globalOnly(["es6.typed.uint32-array"]), + WeakMap: pureAndGlobal("weak-map", ["es6.weak-map", ...CommonIterators]), + WeakSet: pureAndGlobal("weak-set", ["es6.weak-set", ...CommonIterators]), + setImmediate: pureOnly("set-immediate", "web.immediate"), + clearImmediate: pureOnly("clear-immediate", "web.immediate"), + parseFloat: pureOnly("parse-float", "es6.parse-float"), + parseInt: pureOnly("parse-int", "es6.parse-int") +}; +const InstanceProperties = { + __defineGetter__: globalOnly(["es7.object.define-getter"]), + __defineSetter__: globalOnly(["es7.object.define-setter"]), + __lookupGetter__: globalOnly(["es7.object.lookup-getter"]), + __lookupSetter__: globalOnly(["es7.object.lookup-setter"]), + anchor: globalOnly(["es6.string.anchor"]), + big: globalOnly(["es6.string.big"]), + bind: globalOnly(["es6.function.bind"]), + blink: globalOnly(["es6.string.blink"]), + bold: globalOnly(["es6.string.bold"]), + codePointAt: globalOnly(["es6.string.code-point-at"]), + copyWithin: globalOnly(["es6.array.copy-within"]), + endsWith: globalOnly(["es6.string.ends-with"]), + entries: globalOnly(ArrayNatureIterators), + every: globalOnly(["es6.array.every"]), + fill: globalOnly(["es6.array.fill"]), + filter: globalOnly(["es6.array.filter"]), + finally: globalOnly(["es7.promise.finally", ...PromiseDependencies]), + find: globalOnly(["es6.array.find"]), + findIndex: globalOnly(["es6.array.find-index"]), + fixed: globalOnly(["es6.string.fixed"]), + flags: globalOnly(["es6.regexp.flags"]), + flatMap: globalOnly(["es7.array.flat-map"]), + fontcolor: globalOnly(["es6.string.fontcolor"]), + fontsize: globalOnly(["es6.string.fontsize"]), + forEach: globalOnly(["es6.array.for-each"]), + includes: globalOnly(["es6.string.includes", "es7.array.includes"]), + indexOf: globalOnly(["es6.array.index-of"]), + italics: globalOnly(["es6.string.italics"]), + keys: globalOnly(ArrayNatureIterators), + lastIndexOf: globalOnly(["es6.array.last-index-of"]), + link: globalOnly(["es6.string.link"]), + map: globalOnly(["es6.array.map"]), + match: globalOnly(["es6.regexp.match"]), + name: globalOnly(["es6.function.name"]), + padStart: globalOnly(["es7.string.pad-start"]), + padEnd: globalOnly(["es7.string.pad-end"]), + reduce: globalOnly(["es6.array.reduce"]), + reduceRight: globalOnly(["es6.array.reduce-right"]), + repeat: globalOnly(["es6.string.repeat"]), + replace: globalOnly(["es6.regexp.replace"]), + search: globalOnly(["es6.regexp.search"]), + small: globalOnly(["es6.string.small"]), + some: globalOnly(["es6.array.some"]), + sort: globalOnly(["es6.array.sort"]), + split: globalOnly(["es6.regexp.split"]), + startsWith: globalOnly(["es6.string.starts-with"]), + strike: globalOnly(["es6.string.strike"]), + sub: globalOnly(["es6.string.sub"]), + sup: globalOnly(["es6.string.sup"]), + toISOString: globalOnly(["es6.date.to-iso-string"]), + toJSON: globalOnly(["es6.date.to-json"]), + toString: globalOnly(["es6.object.to-string", "es6.date.to-string", "es6.regexp.to-string"]), + trim: globalOnly(["es6.string.trim"]), + trimEnd: globalOnly(["es7.string.trim-right"]), + trimLeft: globalOnly(["es7.string.trim-left"]), + trimRight: globalOnly(["es7.string.trim-right"]), + trimStart: globalOnly(["es7.string.trim-left"]), + values: globalOnly(ArrayNatureIterators) +}; + +// This isn't present in older @babel/compat-data versions +if ("es6.array.slice" in corejs2Polyfills) { + InstanceProperties.slice = globalOnly(["es6.array.slice"]); +} +const StaticProperties = { + Array: { + from: pureAndGlobal("array/from", ["es6.symbol", "es6.array.from", ...CommonIterators]), + isArray: pureAndGlobal("array/is-array", ["es6.array.is-array"]), + of: pureAndGlobal("array/of", ["es6.array.of"]) + }, + Date: { + now: pureAndGlobal("date/now", ["es6.date.now"]) + }, + JSON: { + stringify: pureOnly("json/stringify", "es6.symbol") + }, + Math: { + // 'Math' was not included in the 7.0.0 + // release of '@babel/runtime'. See issue https://github.com/babel/babel/pull/8616. + acosh: pureAndGlobal("math/acosh", ["es6.math.acosh"], "7.0.1"), + asinh: pureAndGlobal("math/asinh", ["es6.math.asinh"], "7.0.1"), + atanh: pureAndGlobal("math/atanh", ["es6.math.atanh"], "7.0.1"), + cbrt: pureAndGlobal("math/cbrt", ["es6.math.cbrt"], "7.0.1"), + clz32: pureAndGlobal("math/clz32", ["es6.math.clz32"], "7.0.1"), + cosh: pureAndGlobal("math/cosh", ["es6.math.cosh"], "7.0.1"), + expm1: pureAndGlobal("math/expm1", ["es6.math.expm1"], "7.0.1"), + fround: pureAndGlobal("math/fround", ["es6.math.fround"], "7.0.1"), + hypot: pureAndGlobal("math/hypot", ["es6.math.hypot"], "7.0.1"), + imul: pureAndGlobal("math/imul", ["es6.math.imul"], "7.0.1"), + log1p: pureAndGlobal("math/log1p", ["es6.math.log1p"], "7.0.1"), + log10: pureAndGlobal("math/log10", ["es6.math.log10"], "7.0.1"), + log2: pureAndGlobal("math/log2", ["es6.math.log2"], "7.0.1"), + sign: pureAndGlobal("math/sign", ["es6.math.sign"], "7.0.1"), + sinh: pureAndGlobal("math/sinh", ["es6.math.sinh"], "7.0.1"), + tanh: pureAndGlobal("math/tanh", ["es6.math.tanh"], "7.0.1"), + trunc: pureAndGlobal("math/trunc", ["es6.math.trunc"], "7.0.1") + }, + Number: { + EPSILON: pureAndGlobal("number/epsilon", ["es6.number.epsilon"]), + MIN_SAFE_INTEGER: pureAndGlobal("number/min-safe-integer", ["es6.number.min-safe-integer"]), + MAX_SAFE_INTEGER: pureAndGlobal("number/max-safe-integer", ["es6.number.max-safe-integer"]), + isFinite: pureAndGlobal("number/is-finite", ["es6.number.is-finite"]), + isInteger: pureAndGlobal("number/is-integer", ["es6.number.is-integer"]), + isSafeInteger: pureAndGlobal("number/is-safe-integer", ["es6.number.is-safe-integer"]), + isNaN: pureAndGlobal("number/is-nan", ["es6.number.is-nan"]), + parseFloat: pureAndGlobal("number/parse-float", ["es6.number.parse-float"]), + parseInt: pureAndGlobal("number/parse-int", ["es6.number.parse-int"]) + }, + Object: { + assign: pureAndGlobal("object/assign", ["es6.object.assign"]), + create: pureAndGlobal("object/create", ["es6.object.create"]), + defineProperties: pureAndGlobal("object/define-properties", ["es6.object.define-properties"]), + defineProperty: pureAndGlobal("object/define-property", ["es6.object.define-property"]), + entries: pureAndGlobal("object/entries", ["es7.object.entries"]), + freeze: pureAndGlobal("object/freeze", ["es6.object.freeze"]), + getOwnPropertyDescriptor: pureAndGlobal("object/get-own-property-descriptor", ["es6.object.get-own-property-descriptor"]), + getOwnPropertyDescriptors: pureAndGlobal("object/get-own-property-descriptors", ["es7.object.get-own-property-descriptors"]), + getOwnPropertyNames: pureAndGlobal("object/get-own-property-names", ["es6.object.get-own-property-names"]), + getOwnPropertySymbols: pureAndGlobal("object/get-own-property-symbols", ["es6.symbol"]), + getPrototypeOf: pureAndGlobal("object/get-prototype-of", ["es6.object.get-prototype-of"]), + is: pureAndGlobal("object/is", ["es6.object.is"]), + isExtensible: pureAndGlobal("object/is-extensible", ["es6.object.is-extensible"]), + isFrozen: pureAndGlobal("object/is-frozen", ["es6.object.is-frozen"]), + isSealed: pureAndGlobal("object/is-sealed", ["es6.object.is-sealed"]), + keys: pureAndGlobal("object/keys", ["es6.object.keys"]), + preventExtensions: pureAndGlobal("object/prevent-extensions", ["es6.object.prevent-extensions"]), + seal: pureAndGlobal("object/seal", ["es6.object.seal"]), + setPrototypeOf: pureAndGlobal("object/set-prototype-of", ["es6.object.set-prototype-of"]), + values: pureAndGlobal("object/values", ["es7.object.values"]) + }, + Promise: { + all: globalOnly(CommonIterators), + race: globalOnly(CommonIterators) + }, + Reflect: { + apply: pureAndGlobal("reflect/apply", ["es6.reflect.apply"]), + construct: pureAndGlobal("reflect/construct", ["es6.reflect.construct"]), + defineProperty: pureAndGlobal("reflect/define-property", ["es6.reflect.define-property"]), + deleteProperty: pureAndGlobal("reflect/delete-property", ["es6.reflect.delete-property"]), + get: pureAndGlobal("reflect/get", ["es6.reflect.get"]), + getOwnPropertyDescriptor: pureAndGlobal("reflect/get-own-property-descriptor", ["es6.reflect.get-own-property-descriptor"]), + getPrototypeOf: pureAndGlobal("reflect/get-prototype-of", ["es6.reflect.get-prototype-of"]), + has: pureAndGlobal("reflect/has", ["es6.reflect.has"]), + isExtensible: pureAndGlobal("reflect/is-extensible", ["es6.reflect.is-extensible"]), + ownKeys: pureAndGlobal("reflect/own-keys", ["es6.reflect.own-keys"]), + preventExtensions: pureAndGlobal("reflect/prevent-extensions", ["es6.reflect.prevent-extensions"]), + set: pureAndGlobal("reflect/set", ["es6.reflect.set"]), + setPrototypeOf: pureAndGlobal("reflect/set-prototype-of", ["es6.reflect.set-prototype-of"]) + }, + String: { + at: pureOnly("string/at", "es7.string.at"), + fromCodePoint: pureAndGlobal("string/from-code-point", ["es6.string.from-code-point"]), + raw: pureAndGlobal("string/raw", ["es6.string.raw"]) + }, + Symbol: { + // FIXME: Pure disabled to work around zloirock/core-js#262. + asyncIterator: globalOnly(["es6.symbol", "es7.symbol.async-iterator"]), + for: pureOnly("symbol/for", "es6.symbol"), + hasInstance: pureOnly("symbol/has-instance", "es6.symbol"), + isConcatSpreadable: pureOnly("symbol/is-concat-spreadable", "es6.symbol"), + iterator: define("es6.symbol", "symbol/iterator", CommonIterators), + keyFor: pureOnly("symbol/key-for", "es6.symbol"), + match: pureAndGlobal("symbol/match", ["es6.regexp.match"]), + replace: pureOnly("symbol/replace", "es6.symbol"), + search: pureOnly("symbol/search", "es6.symbol"), + species: pureOnly("symbol/species", "es6.symbol"), + split: pureOnly("symbol/split", "es6.symbol"), + toPrimitive: pureOnly("symbol/to-primitive", "es6.symbol"), + toStringTag: pureOnly("symbol/to-string-tag", "es6.symbol"), + unscopables: pureOnly("symbol/unscopables", "es6.symbol") + } +}; + +const webPolyfills = { + "web.timers": {}, + "web.immediate": {}, + "web.dom.iterable": {} +}; +const purePolyfills = { + "es6.parse-float": {}, + "es6.parse-int": {}, + "es7.string.at": {} +}; +function addPlatformSpecificPolyfills (targets, method, polyfills) { + const targetNames = Object.keys(targets); + const isAnyTarget = !targetNames.length; + const isWebTarget = targetNames.some(name => name !== "node"); + return { + ...polyfills, + ...(method === "usage-pure" ? purePolyfills : null), + ...(isAnyTarget || isWebTarget ? webPolyfills : null) + }; +} + +function hasMinVersion(minVersion, runtimeVersion) { + // If the range is unavailable, we're running the script during Babel's + // build process, and we want to assume that all versions are satisfied so + // that the built output will include all definitions. + if (!runtimeVersion || !minVersion) return true; + + // semver.intersects() has some surprising behavior with comparing ranges + // with preprelease versions. We add '^' to ensure that we are always + // comparing ranges with ranges, which sidesteps this logic. + // For example: + // + // semver.intersects(`<7.0.1`, "7.0.0-beta.0") // false - surprising + // semver.intersects(`<7.0.1`, "^7.0.0-beta.0") // true - expected + // + // This is because the first falls back to + // + // semver.satisfies("7.0.0-beta.0", `<7.0.1`) // false - surprising + // + // and this fails because a prerelease version can only satisfy a range + // if it is a prerelease within the same major/minor/patch range. + // + // Note: If this is found to have issues, please also revist the logic in + // babel-core's availableHelper() API. + if (semver.valid(runtimeVersion)) runtimeVersion = `^${runtimeVersion}`; + return !semver.intersects(`<${minVersion}`, runtimeVersion) && !semver.intersects(`>=8.0.0`, runtimeVersion); +} + +const { + types: t +} = _babel.default || _babel; +const BABEL_RUNTIME = "@babel/runtime-corejs2"; +const presetEnvCompat = "#__secret_key__@babel/preset-env__compatibility"; +const runtimeCompat = "#__secret_key__@babel/runtime__compatibility"; +const has = Function.call.bind(Object.hasOwnProperty); +var index = defineProvider(function (api, { + [presetEnvCompat]: { + entryInjectRegenerator = false, + noRuntimeName = false + } = {}, + [runtimeCompat]: { + useBabelRuntime = false, + runtimeVersion = "", + ext = ".js" + } = {} +}) { + const resolve = api.createMetaResolver({ + global: BuiltIns, + static: StaticProperties, + instance: InstanceProperties + }); + const { + debug, + shouldInjectPolyfill, + method + } = api; + const polyfills = addPlatformSpecificPolyfills(api.targets, method, corejs2Polyfills); + const coreJSBase = useBabelRuntime ? `${BABEL_RUNTIME}/core-js` : method === "usage-pure" ? "core-js/library/fn" : "core-js/modules"; + function inject(name, utils) { + if (typeof name === "string") { + // Some polyfills aren't always available, for example + // web.dom.iterable when targeting node + if (has(polyfills, name) && shouldInjectPolyfill(name)) { + debug(name); + utils.injectGlobalImport(`${coreJSBase}/${name}.js`); + } + return; + } + name.forEach(name => inject(name, utils)); + } + function maybeInjectPure(desc, hint, utils) { + let { + pure, + meta, + name + } = desc; + if (!pure || !shouldInjectPolyfill(name)) return; + if (runtimeVersion && meta && meta.minRuntimeVersion && !hasMinVersion(meta && meta.minRuntimeVersion, runtimeVersion)) { + return; + } + + // Unfortunately core-js and @babel/runtime-corejs2 don't have the same + // directory structure, so we need to special case this. + if (useBabelRuntime && pure === "symbol/index") pure = "symbol"; + return utils.injectDefaultImport(`${coreJSBase}/${pure}${ext}`, hint); + } + return { + name: "corejs2", + runtimeName: noRuntimeName ? null : BABEL_RUNTIME, + polyfills, + entryGlobal(meta, utils, path) { + if (meta.kind === "import" && meta.source === "core-js") { + debug(null); + inject(Object.keys(polyfills), utils); + if (entryInjectRegenerator) { + utils.injectGlobalImport("regenerator-runtime/runtime.js"); + } + path.remove(); + } + }, + usageGlobal(meta, utils) { + const resolved = resolve(meta); + if (!resolved) return; + let deps = resolved.desc.global; + if (resolved.kind !== "global" && "object" in meta && meta.object && meta.placement === "prototype") { + const low = meta.object.toLowerCase(); + deps = deps.filter(m => m.includes(low)); + } + inject(deps, utils); + }, + usagePure(meta, utils, path) { + if (meta.kind === "in") { + if (meta.key === "Symbol.iterator") { + path.replaceWith(t.callExpression(utils.injectDefaultImport(`${coreJSBase}/is-iterable${ext}`, "isIterable"), [path.node.right] // meta.kind === "in" narrows this + )); + } + + return; + } + if (path.parentPath.isUnaryExpression({ + operator: "delete" + })) return; + if (meta.kind === "property") { + // We can't compile destructuring. + if (!path.isMemberExpression()) return; + if (!path.isReferenced()) return; + if (meta.key === "Symbol.iterator" && shouldInjectPolyfill("es6.symbol") && path.parentPath.isCallExpression({ + callee: path.node + }) && path.parentPath.node.arguments.length === 0) { + path.parentPath.replaceWith(t.callExpression(utils.injectDefaultImport(`${coreJSBase}/get-iterator${ext}`, "getIterator"), [path.node.object])); + path.skip(); + return; + } + } + const resolved = resolve(meta); + if (!resolved) return; + const id = maybeInjectPure(resolved.desc, resolved.name, utils); + if (id) path.replaceWith(id); + }, + visitor: method === "usage-global" && { + // yield* + YieldExpression(path) { + if (path.node.delegate) { + inject("web.dom.iterable", api.getUtils(path)); + } + }, + // for-of, [a, b] = c + "ForOfStatement|ArrayPattern"(path) { + CommonIterators.forEach(name => inject(name, api.getUtils(path))); + } + } + }; +}); + +export default index; +//# sourceMappingURL=index.mjs.map |