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", ["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 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 } = { entryInjectRegenerator: false }, [runtimeCompat]: { useBabelRuntime, runtimeVersion, ext = ".js" } = { useBabelRuntime: "", runtimeVersion: "" } }) { 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 ? `${useBabelRuntime}/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) { const { pure, meta, name } = desc; if (!pure || !shouldInjectPolyfill(name)) return; if (runtimeVersion && meta && meta.minRuntimeVersion && !hasMinVersion(meta && meta.minRuntimeVersion, runtimeVersion)) { return; } return utils.injectDefaultImport(`${coreJSBase}/${pure}${ext}`, hint); } return { name: "corejs2", 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