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 | 396 |
1 files changed, 0 insertions, 396 deletions
diff --git a/node_modules/babel-plugin-polyfill-corejs2/esm/index.mjs b/node_modules/babel-plugin-polyfill-corejs2/esm/index.mjs deleted file mode 100644 index 8b3c34e8..00000000 --- a/node_modules/babel-plugin-polyfill-corejs2/esm/index.mjs +++ /dev/null @@ -1,396 +0,0 @@ -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; - runtimeVersion = String(runtimeVersion); - - // 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 |