diff options
Diffstat (limited to 'node_modules/@babel/preset-env')
35 files changed, 7032 insertions, 0 deletions
diff --git a/node_modules/@babel/preset-env/CHANGELOG.md b/node_modules/@babel/preset-env/CHANGELOG.md new file mode 100644 index 00000000..c550b987 --- /dev/null +++ b/node_modules/@babel/preset-env/CHANGELOG.md @@ -0,0 +1,668 @@ +# Changelog + +## v1.6.1 (2017-10-17) + +### :bug: Bug Fix + +- Update compat table to fix two small issues ([#445](https://github.com/babel/babel-preset-env/pull/445)) (@danez) + +ES2015 destructuring is not fully supported in Edge 15 and the polyfill required again. `es6.math.imul` is supported on Android as of version 4.4 + +- Add polyfills for ES6 static Object methods ([#441](https://github.com/babel/babel-preset-env/pull/441)) (@danez) + +Functions such as `Object.keys`, `Object.freeze`, ... do already exist in ES5, but their behaviour changed in ES2015. `babel-preset-env` with `builtIns: true` now adds the core-js polyfills for this methods if the browser only supports the ES5 variant of the method (like IE11 for example) + +- Normalize module format of plugins/built-ins data ([#376](https://github.com/babel/babel-preset-env/pull/376)) (@rtsao) + +## v1.6.0 (2017-07-04) + +### :rocket: New Feature + +- Bump compat-table for node8 support ([#363](https://github.com/babel/babel-preset-env/pull/363)) (@existentialism) + +We updated our mappings to support native trailing function commas and string paddings in Node.js 8+. + +### :bug: Bug Fix + +- Handle `chromeandroid` browserslist value ([#367](https://github.com/babel/babel-preset-env/pull/367)) (@yavorsky) + +We added support for using browserslist's `chromeandroid` in `targets`. + +### :memo: Documentation + +- Tweak uglify option docs ([#368](https://github.com/babel/babel-preset-env/pull/368)) (@existentialism) + +Thanks to @graingert and @pfiaux for pointing out some needed updates to the `uglify-js`-related docs. + +## v1.5.2 (2017-06-07) + +### :bug: Bug Fix + +- Ensure explicit targets always override browsers key targets ([#346](https://github.com/babel/babel-preset-env/pull/346)) (@existentialism) + +`browser` targets should be overridden by explicit targets, and we inadvertently broke this when we landed string version support. + +## v1.5.1 (2017-05-22) + +### :bug: Bug Fix + +- Compile with loose mode ([#322](https://github.com/babel/babel-preset-env/pull/332)) (@existentialism) + +## v1.5.0 (2017-05-19) + +### :rocket: New Feature + +- Support target versions as strings ([#321](https://github.com/babel/babel-preset-env/pull/321)) (@existentialism) + +We were originally waiting on 2.x for a breaking change, but since node v7.10 +and other targets are causing some pain, we decided to land a backwards +compatible version. + +### :house: Internal + +- Backport: use preset-env and remove flow-strip-types ([#324](https://github.com/babel/babel-preset-env/pull/324)) (@yavorsky) +- Bump electron-to-chromium ([#329](https://github.com/babel/babel-preset-env/pull/329)) (@existentialism) +- Tweak version mappings to match compat-table updates ([#323](https://github.com/babel/babel-preset-env/pull/323)) (@existentialism) +- Bump browserslist ([#319](https://github.com/babel/babel-preset-env/pull/319)) (@existentialism) +- Bump compat-table ([#307](https://github.com/babel/babel-preset-env/pull/307)) (@existentialism) +- Add debug-fixtures and test/tmp to .eslintignore ([#305](https://github.com/babel/babel-preset-env/pull/305)) (@yavorsky) + +## v1.4.0 (2017-04-14) + +### :rocket: New Feature + +- Support `spec` option ([#98](https://github.com/babel/babel-preset-env/pull/98)) (@Kovensky) + +Added an option to enable more spec compliant, but potentially slower, transformations for any plugins in this preset that support them. + +- Bump compat-table for Edge 15 support ([#273](https://github.com/babel/babel-preset-env/pull/273)) (@existentialism) + +We updated our mappings so that you can get native support for async/await and other goodies when targeting Edge 15! + +### :bug: Bug Fix + +- Add Android browser to name map ([#270](https://github.com/babel/babel-preset-env/pull/270)) (@existentialism) + +Fixed a bug that was ignoring Android targets in browserslist queries (for example: "Android >= 4"). + +### :memo: Documentation + +- Clarify note about loading polyfills only once ([#282](https://github.com/babel/babel-preset-env/pull/282)) (@darahak) +- Add a reminder about include/exclude options ([#275](https://github.com/babel/babel-preset-env/pull/275)) (@existentialism) + +### :house: Internal + +- Chore: reduce package size. ([#281](https://github.com/babel/babel-preset-env/pull/281)) (@evilebottnawi) +- Remove deprecated comment ([#271](https://github.com/babel/babel-preset-env/pull/271)) (@yavorsky) + +## v1.3.3 (2017-04-07) + +### :bug: Bug Fix + +- Support electron version in a string format ([#252](https://github.com/babel/babel-preset-env/pull/252)) (@yavorsky) + +Adding electron as a target was an inadvertent breaking change as it no longer +allowed string versions. We added an exception for now, even though it is +inconsistent with other versions. Just as a note, the upcoming version 2.x will +allow _both_ number and string versions. + +- Ensure const-check plugin order ([#257](https://github.com/babel/babel-preset-env/pull/257)) (@existentialism) + +We now force the `const-es2015-check` plugin to run first (so that it can +correctly report issues before they get transpiled away). + +### :rocket: New Feature + +- Allow use `babel-plugin-` prefix for include and exclude ([#242](https://github.com/babel/babel-preset-env/pull/242)) (@yavorsky) + +The `include` and `exclude` options now allow both prefixed (`babel-plugin-transform-es2015-spread`) +and prefix-less (`transform-es2015-spread`) plugin names. + +### :memo: Documentation + +- Note babel plugin prefix handling in include/exclude ([#245](https://github.com/babel/babel-preset-env/pull/245)) (@existentialism) +- Fix README: debug option shows info in stdout. ([#236](https://github.com/babel/babel-preset-env/pull/236)) (@Gerhut) + +### :house: Internal + +- Add simple smoke-test ([#240](https://github.com/babel/babel-preset-env/pull/240)) (@existentialism) +- Add prepublish script (@existentialism) + +## v1.3.2 (2017-03-30) + +- Fixed an issue with a broken publish + +## v1.3.1 (2017-03-30) + +- Fixed a regression with missing files due to `.npmignore`. + +## v1.3.0 (2017-03-30) + +### :bug: Bug Fix + +- Add check for ArrayBuffer[Symbol.species] ([#233](https://github.com/babel/babel-preset-env/pull/233)) (@existentialism) + +We now properly check for `Symbol.species` support in ArrayBuffer and include the +polyfill if necessary. This should, as a side effect, fix ArrayBuffer-related +errors on IE9. + +### :nail_care: Polish + +- Fill data with electron as a target. ([#229](https://github.com/babel/babel-preset-env/pull/229)) (@yavorsky) + +We've simplified things by adding `electron` as a target instead of doing a bunch of +things at runtime. Electron targets should now also be displayed in the debug output. + +- separate default builtins for platforms ([#226](https://github.com/babel/babel-preset-env/pull/226)) (@restrry) + +If you are targeting the `node` environment exclusively, the always-included web polyfills +(like `dom.iterable`, and a few others) will now no longer be included. + +### :memo: Documentation + + * remove deprecated projects ([#223](https://github.com/babel/babel-preset-env/pull/223)) [skip ci] (@stevemao) + +### :house: Internal + + * npmignore: Add related to build data and codecov. ([#216](https://github.com/babel/babel-preset-env/pull/216)) (@yavorsky) + +## v1.2.2 (2017-03-14) + +### :bug: Bug Fix + +- Refactor browser data parsing to handle families ([#208](https://github.com/babel/babel-preset-env/pull/208)) (@existentialism) + +When parsing plugin data, we weren't properly handling browser families. This caused +`transform-es2015-block-scoping` and other plugins to be incorrectly added for Edge >= 12. +(s/o to @mgol for the the report and review!) + +- Add typed array methods to built-ins features. ([#198](https://github.com/babel/babel-preset-env/pull/198)) (@yavorsky) + +Fixes an issue where some TypedArray features were not being polyfilled properly. (s/o to @alippai for the report!) + +### :memo: Documentation + +- Fixed minor typo in readme ([#199](https://github.com/babel/babel-preset-env/pull/199)) (@bl4ckdu5t) +- Add built-ins, better links, compat-table url, etc ([#195](https://github.com/babel/babel-preset-env/pull/195)) (@yavorsky) +- Change CONTRIBUTING.md to use absolute paths ([#194](https://github.com/babel/babel-preset-env/pull/194)) (@aaronang) + +### :house: Internal + +- Bump plugins ([#201](https://github.com/babel/babel-preset-env/pull/201)) (@yavorsky) +- Enable code coverage ([#200](https://github.com/babel/babel-preset-env/pull/200)) (@alxpy) +- Increase mocha timeout to 10s ([#202](https://github.com/babel/babel-preset-env/pull/202)) (@yavorsky) + +## v1.2.1 (2017-03-06) + +### :bug: Bug Fix + +- Add transform-duplicate-keys mapping ([#192](https://github.com/babel/babel-preset-env/pull/192)) (@existentialism) + +Our plugin data was missing a mapping for the `transform-duplicate-keys` plugin which caused it to never be included. (s/o to @Timer for the report!) + +### :memo: Documentation + +- Clarify reasons for the uglify option in README.md ([#188](https://github.com/babel/babel-preset-env/pull/188)) (@mikegreiling) + +## v1.2.0 (2017-03-03) + +### :rocket: New Feature + +- Add uglify as a target ([#178](https://github.com/babel/babel-preset-env/pull/178)) (@yavorsky) + +Support for `uglify` as a target is now available! This will enable all plugins and, as a result, fully compiles your code to ES5. Note, that useBuiltIns will work as before, and only the polyfills that your other target(s) need will be included. + +```json +{ + "presets": [ + ["env", { + "targets": { + "chrome": 55, + "uglify": true + }, + "useBuiltIns": true, + "modules": false + }] + ] +} +``` + +### :bug: Bug Fix + +- Respect older versions in invert equals map ([#180](https://github.com/babel/babel-preset-env/pull/180)) (@danez) + +Fixes a number of bugs that caused some incorrect and/or missing environment data when parsing `compat-table`. + +## v1.1.11 (2017-03-01) + +This release primarily upgrades `compat-table`, which adds support for async on Node 7.6! + +### :bug: Bug Fix + +- Fix hasBeenWarned condition. ([#175](https://github.com/babel/babel-preset-env/pull/175)) (@yavorsky) + +### :memo: Documentation + +- Add yarn example. ([#174](https://github.com/babel/babel-preset-env/pull/174)) (@yavorsky) + +### :house: Internal + +- Bump compat-table ([#177](https://github.com/babel/babel-preset-env/pull/177)) (@existentialism) +- Add electron version exception test ([#176](https://github.com/babel/babel-preset-env/pull/176)) (@existentialism) + +## v1.1.10 (2017-02-24) + +### :bug: Bug Fix + +- Drop use of lodash/intersection from checkDuplicateIncludeExcludes ([#173](https://github.com/babel/babel-preset-env/pull/173)) (@existentialism) + +## v1.1.9 (2017-02-24) + +### :bug: Bug Fix + +- Add tests for debug output ([#156](https://github.com/babel/babel-preset-env/pull/156)) (@existentialism) + +Since we've (mostly @yavorsky) have fixed a number of bugs recently with the `debug` option output, we added the ability to assert stdout matches what we expect. Read the updated [CONTRIBUTING.md](https://github.com/babel/experimental/babel-preset-env/blob/master/CONTRIBUTING.md#testing-the-debug-option) for more info. + +- Fixes #143. Log correct targets. ([#155](https://github.com/babel/babel-preset-env/pull/155)) (@yavorsky) + +This fixes a bug in the `debug` output where incorrect target(s) were being displayed for why a particular plugin/preset was being included. + +Given targets: + +```txt +{ + "firefox": 52, + "node": 7.4 +} +``` + +Before: + +```txt +Using plugins: + transform-es2015-destructuring {"node":6.5} + transform-es2015-for-of {"node":6.5} + transform-es2015-function-name {"node":6.5} + transform-es2015-literals {"node":4} + transform-exponentiation-operator {"firefox":52} + syntax-trailing-function-commas {"firefox":52} +``` + +After: + +```txt +Using plugins: + transform-es2015-destructuring {"firefox":52} + transform-es2015-for-of {"firefox":52} + transform-es2015-function-name {"firefox":52} + transform-es2015-literals {"firefox":52} + transform-exponentiation-operator {"node":7.4} + syntax-trailing-function-commas {"node":7.4} +``` + +### :memo: Documentation + +- Fix compat-table link in contributing.md (@existentialism) +- Update README examples to fix website ([#151](https://github.com/babel/babel-preset-env/pull/)) (@existentialism) +- Fix few typos ([#146](https://github.com/babel/babel-preset-env/pull/146)) (@existentialism) +- Add configuration example to clarify `debug: true` ([#138](https://github.com/babel/babel-preset-env/pull/138)) (@yavorsky) +- Fix CHANGELOG’s v1.1.8 updates typo. ([#136](https://github.com/babel/babel-preset-env/pull/136)) (@yavorsky) +- README: Update `debug: true` example. ([#138](https://github.com/babel/babel-preset-env/pull/138)) (@yavorsky) + +### :house: Internal + +- update compat ([#169](https://github.com/babel/babel-preset-env/pull/169)) (@hzoo) +- Use external Electron to Chromium library ([#144](https://github.com/babel/babel-preset-env/pull/144)) (@Kilian) +- Update yarn lockfile ([#152](https://github.com/babel/babel-preset-env/pull/152)) (@existentialism) +- Extract option normalization into independant file ([#125](https://github.com/babel/babel-preset-env/pull/125)) (@baer) +- Update yarnfile ([#145](https://github.com/babel/babel-preset-env/pull/145)) (@baer) +- devDeps: eslint-config-babel v5.0.0 ([#139](https://github.com/babel/babel-preset-env/pull/139)) (@kaicataldo) +- Update compat-table, build data ([#135](https://github.com/babel/babel-preset-env/pull/135)) (@hzoo) + +## v1.1.8 (2017-01-10) + +### :bug: Bug Fix + +- Debug: Transformations before logs. ([#128](https://github.com/babel/babel-preset-env/pull/128)) (@yavorsky) + +Makes sure that all transformations on `targets` (such as `exclude`/`include`) are run before logging out with the `debug` option. Fixes ([#127](https://github.com/babel/babel-preset-env/issues/127)). + +### :house: Internal + +- Remove unnecessary extension. ([#131](https://github.com/babel/babel-preset-env/pull/131)) (@roman-yakobnyuk) +- Include yarn.lock and update CI. ([#124](https://github.com/babel/babel-preset-env/pull/124)) (@existentialism) + +## v1.1.7 (2017-01-09) + +Had a publishing issue in the previous release. + +## v1.1.6 (2017-01-06) + +### :bug: Bug Fix + +- Explicitly resolve lowest browser version. ([#121](https://github.com/babel/babel-preset-env/pull/121)) (@brokenmass) + +```js +{ + "targets": { + "browsers": ["ios >= 6"] // was resolving to {ios: 10} rather than {ios: 6} + } +} +``` + +## v1.1.5 (2017-01-04) + +### :bug: Bug Fix + +- Show error if target version is not a number. ([#107](https://github.com/babel/babel-preset-env/pull/107)) (@existentialism) + +```js +{ + "presets": [ + ["env", { + "targets": { + "chrome": "52", // will error since it's not a number, + "chrome": 52 // correct! + } + }] + ] +} +``` + +- Fix targets for the `debug` option. ([#109](https://github.com/babel/babel-preset-env/pull/109)) (@yavorsky) + +Now it prints the transformed targets/environments rather than the browsers query. + +```txt +Using targets: +{ + "chrome": 53, + "ie": 10, + "node": 6 +} + +Modules transform: false + +Using plugins: + transform-es2015-arrow-functions {"chrome":47,"node":6} + transform-es2015-block-scoped-functions {"chrome":41,"ie":11,"node":4} + +Using polyfills: + es6.typed.uint8-clamped-array {"chrome":5,"node":0.12} + es6.map {"chrome":51,"node":6.5} +``` + +## v1.1.4 (2016-12-16) + +v1.1.2-v1.1.4 + +### :bug: Bug Fix + +The new `exclude`/`include` options weren't working correctly for built-ins. ([#102](https://github.com/babel/babel-preset-env/pull/102)). + +Also fixes an issue with debug option. + +## v1.1.1 (2016-12-13) + +### :bug: Bug Fix + +Regression with the previous release due to using `Object.values` (ES2017). This wasn't caught because we are using babel-register to run tests and includes polyfills so it didn't fail on CI even though we have Node 0.10 as an env. Looking into fixing this to prevent future issues. + +## v1.1.0 (2016-12-13) + +### :rocket: New Feature + +- Add `exclude` option, rename `whitelist` to `include` ([#89](https://github.com/babel/babel-preset-env/pull/89)) (@hzoo) + +Example: + +```js +{ + "presets": [ + ["env", { + "targets": { + "browsers": ["last 2 versions", "safari >= 7"] + }, + "include": ["transform-es2015-arrow-functions"], + "exclude": [ + "transform-regenerator", + "transform-async-to-generator", + "map" + ], + "useBuiltIns": true + }] + ] +} +``` + +`"exclude": ["transform-regenerator"]` doesn't transform generators and removes `regeneratorRuntime` from being imported. + +`"exclude": ["transform-async-to-generator"]` doesn't use the built-in async-to-gen transform so you can use something like [fast-async](https://github.com/MatAtBread/fast-async). + +`"exclude": ["map"]` doesn't include the `Map` polyfill if you know you aren't using it in your code (w/ `useBuiltIns`). (We will figure out a way to automatically do this [#84](https://github.com/babel/babel-preset-env/issues/84)). + +If you pass a wrong plugin it will error: valid options for `include/exclude` are in [/data/plugin-features.js](https://github.com/babel/experimental/babel-preset-env/blob/master/data/plugin-features.js) and [/data/built-in-features.js](https://github.com/babel/experimental/babel-preset-env/blob/master/data/built-in-features.js) (without the `es6.`) + +### :house: Internal + +- Optimize result filtration. ([#77](https://github.com/babel/babel-preset-env/pull/77)) (@yavorsky) +- Update eslint config to align with other babel projects ([#79](https://github.com/babel/babel-preset-env/pull/79)) (@baer) +- Update pathnames to avoid uppercase ([#80](https://github.com/babel/babel-preset-env/pull/80)) (@baer) +- Refactor build data for clarity/consistency ([#81](https://github.com/babel/babel-preset-env/pull/81)) (@baer) +- Update linting rules to cover all js ([#82](https://github.com/babel/babel-preset-env/pull/82)) (@baer) +- Cleanup lib before rebuilding ([#87](https://github.com/babel/babel-preset-env/pull/87)) (@baer) +- Move linting dependency to be dev only ([#88](https://github.com/babel/babel-preset-env/pull/88)) (@baer) + +### :memo: Documentation + +- Fix typo ([#78](https://github.com/babel/babel-preset-env/pull/78)) (@rohmanhm) +- Fix PR link in changelog. ([#75](https://github.com/babel/babel-preset-env/pull/75)) (@nhajidin) + +## v1.0.2 (2016-12-10) + +### :bug: Bug Fix + +* Fix issue with Object.getOwnPropertySymbols ([#71](https://github.com/babel/babel-preset-env/pull/71)) ([@existentialism](https://github.com/existentialism)) + +Was requiring the wrong module kinda of like in v1.0.1: + +https://github.com/zloirock/core-js#ecmascript-6-symbol + +```diff +-import "core-js/modules/es6.object.get-own-property-symbols"; +``` + +The test is just a part of `Symbol`. + +## v1.0.1 (2016-12-10) + +### :bug: Bug Fix + +* Fix regenerator import ([#68](https://github.com/babel/babel-preset-env/pull/68)) ([@hzoo](https://github.com/hzoo)) + +We were outputting an invalid path for `regenerator`! + +```diff ++import "regenerator-runtime/runtime"; +-import "core-js/modules/regenerator-runtime/runtime"- +``` + +## v1.0.0 (2016-12-09) + +### :rocket: New Feature + +* Add `useBuiltIns` option ([#56](https://github.com/babel/babel-preset-env/pull/56)) ([@hzoo](https://github.com/hzoo)), ([@yavorsky](https://github.com/yavorsky)), ([@existentialism](https://github.com/existentialism)) + +A way to apply `babel-preset-env` for polyfills (via `"babel-polyfill"``). + +> This option will apply a new Babel plugin that replaces `require("babel-polyfill")` with the individual requires for `babel-polyfill` based on the target environments. + +Install + +``` +npm install babel-polyfill --save +``` + +In + +```js +import "babel-polyfill"; // create an entry js file that contains this +// or +import "core-js"; +``` + +Out (different based on environment) + +```js +// chrome 55 +import "core-js/modules/es7.string.pad-start"; // haha left_pad +import "core-js/modules/es7.string.pad-end"; +import "core-js/modules/web.timers"; +import "core-js/modules/web.immediate"; +import "core-js/modules/web.dom.iterable"; +``` + +`.babelrc` Usage + +```js +{ + "presets": [ + ["env", { + "targets": { + "electron": 1.4 + }, + "modules": false, // webpack 2 + "useBuiltIns": true // new option + }] + ] +} +``` + +> Also looking to make an easier integration point via Webpack with this method. Please reach out if you have ideas! + +--- + +* Support [Electron](http://electron.atom.io/) ([#55](https://github.com/babel/babel-preset-env/pull/55)) ([@paulcbetts](https://github.com/paulcbetts)) + +Electron is also an environment, so [Paul went ahead](https://twitter.com/paulcbetts/status/804507070103851008) and added support for this! + +`.babelrc` Usage + +```js +{ + "presets": [ ["env", {"targets": { "electron": 1.4 }}]] +} +``` + +> Currently we are manually updating the data in [/data/electron-to-chromium.js](https://github.com/babel/experimental/babel-preset-env/blob/master/data/electron-to-chromium.js), but [@kevinsawicki](https://github.com/kevinsawicki) says we could generate the data from [atom-shell/dist/index.json](https://gh-contractor-zcbenz.s3.amazonaws.com/atom-shell/dist/index.json) as well! (Someone should make a PR :smile:) + + + +## v0.0.9 (2016-11-24) + +### :rocket: New Feature + +* Support Opera ([#48](https://github.com/babel/babel-preset-env/pull/48)) (Henry Zhu) + +Was as simple as modifying the chrome version and subtracting 13! (so chrome 54 = opera 41) + +```js +{ + "presets": [ + ["env", { + "targets": { + "opera": 41 + } + }] + ] +} +``` + +## v0.0.8 (2016-11-16) + +### :nail_care: Polish + +* Only print the debug info once ([#46](https://github.com/babel/babel-preset-env/pull/46) (Henry Zhu) + +When using the `debug` option it was printing the data for each file processed rather than once. + +```js +{ + "presets": [ + ["env", { + "debug": true + }] + ] +} +``` + +## v0.0.7 (2016-11-02) + +### :rocket: New Feature + +* hardcode a current node version option ([#35](https://github.com/babel/babel-preset-env/pull/35)) (Henry Zhu) + +```js +{ + "presets": [ + ["env", { + "targets": { + "node": "current" // parseFloat(process.versions.node) + } + }] + ] +} +``` + +* add 'whitelist' option ([#31](https://github.com/babel/babel-preset-env/pull/31)) (Henry Zhu) + +```js + { + "presets": [ + ["env", { + "targets": { + "chrome": 52 + }, + "whitelist": ["transform-es2015-arrow-functions"] + }] + ] +} +``` + +* Add more aliases (Henry Zhu) +* Update plugin data: firefox 52 supports async/await! ([#29](https://github.com/babel/babel-preset-env/pull/29)) (Henry Zhu) + +### :bug: Bug Fixes + +* Use compat-table equals option ([#36](https://github.com/babel/babel-preset-env/pull/36)) (Henry Zhu) + +Compute and use `compat-table` equivalents + +```js +{ + "safari6": "phantom", + "chrome44": "iojs", + "chrome50": "node64", + "chrome51": "node65", + "chrome54": "node7", + "chrome30": "android44", + "chrome37": "android50", + "chrome39": "android51", + "safari7": "ios7", + "safari71_8": "ios8", + "safari9": "ios9", + "safari10": "ios10", + "chrome50": "node6" +} +``` + +* Change default behavior to act the same as babel-preset-latest ([#33](https://github.com/babel/babel-preset-env/pull/33)) (Henry Zhu) + +```js +{ "presets": ["env"] } // should act the same as babel-preset-latest +``` + +## Internal + +* Add fixture helper for tests ([#28](https://github.com/babel/babel-preset-env/pull/28)) (Henry Zhu) diff --git a/node_modules/@babel/preset-env/CONTRIBUTING.md b/node_modules/@babel/preset-env/CONTRIBUTING.md new file mode 100644 index 00000000..5b485a69 --- /dev/null +++ b/node_modules/@babel/preset-env/CONTRIBUTING.md @@ -0,0 +1,93 @@ +# Contributing + +## Adding a new plugin to support (when approved in the next ECMAScript version) + +### Update [`plugin-features.js`](https://github.com/babel/babel/blob/master/packages/babel-preset-env/data/plugin-features.js) + +*Example:* + +If you were going to add `**` which is in ES2016: + +Find the relevant entries on [compat-table](https://kangax.github.io/compat-table/es2016plus/#test-exponentiation_(**)_operator): + +`exponentiation (**) operator` + +Find the corresponding babel plugin: + +`@babel/plugin-transform-exponentiation-operator` + +And add them in this structure: + +```js +// es2016 +"@babel/plugin-transform-exponentiation-operator": { + features: [ + "exponentiation (**) operator", + ], +}, +``` + +### Update [`built-in-features.js`](https://github.com/babel/babel/blob/master/packages/babel-preset-env/data/built-in-features.js) + +*Example:* + +In case you want to add `Object.values` which is in ES2017: + +Find the relevant feature and subfeature on [compat-table](https://kangax.github.io/compat-table/es2016plus/#test-Object_static_methods_Object.values) +and split it with `/`: + +`Object static methods / Object.values` + +Find the corresponding module on [core-js](https://github.com/zloirock/core-js/tree/master/modules): + +`es7.object.values.js` + +Find required ES version in [`built-in-features.js`](https://github.com/babel/babel/blob/master/packages/babel-preset-env/data/built-in-features.js) and add the new feature: + +```js +const es2017 = { + //... + "es7.object.values": "Object static methods / Object.values" +} +``` + +### Update [`plugins.json`](https://github.com/babel/babel/blob/master/packages/babel-preset-env/data/plugins.json) + +Until `compat-table` is a standalone npm module for data we are using the git url + +`"compat-table": "kangax/compat-table#[latest-commit-hash]"`, + +So we update and then run `npm run build-data`. If there are no changes, then `plugins.json` will be the same. + +## Tests + +### Running tests locally + +```bash +npm test +``` + +### Checking code coverage locally + +```bash +npm run coverage +``` + +### Writing tests + +#### General + +All the tests for `@babel/preset-env` exist in the `test/fixtures` folder. The +test setup and conventions are exactly the same as testing a Babel plugin, so +please read our [documentation on writing tests](https://github.com/babel/babel/blob/master/CONTRIBUTING.md#babel-plugin-x). + +#### Testing the `debug` option + +Testing debug output to `stdout` is similar. Under the `test/debug-fixtures`, +create a folder with a descriptive name of your test, and add the following: + +* Add a `options.json` file (just as the other tests, this is essentially a +`.babelrc`) with the desired test configuration (required) +* Add a `stdout.txt` file with the expected debug output. For added +convenience, if there is no `stdout.txt` present, the test runner will +generate one for you. diff --git a/node_modules/@babel/preset-env/README.md b/node_modules/@babel/preset-env/README.md new file mode 100644 index 00000000..372b5a0c --- /dev/null +++ b/node_modules/@babel/preset-env/README.md @@ -0,0 +1,598 @@ +# @babel/preset-env [](https://www.npmjs.com/package/babel-preset-env) [](https://travis-ci.org/babel/babel-preset-env) [](https://www.npmjs.com/package/babel-preset-env) [](https://codecov.io/github/babel/babel-preset-env) + +> A Babel preset that compiles [ES2015+](https://github.com/tc39/proposals/blob/master/finished-proposals.md) down to ES5 by automatically determining the Babel plugins and polyfills you need based on your targeted browser or runtime environments. + +```sh +npm install @babel/preset-env --save-dev +``` + +Without any configuration options, `@babel/preset-env` behaves exactly the same as [`@babel/preset-es2015`](https://github.com/babel/babel/tree/master/packages/babel-preset-es2015), [`@babel/preset-es2016`](https://github.com/babel/babel/tree/master/packages/babel-preset-es2016) and [`@babel/preset-es2017`](https://github.com/babel/babel/tree/master/packages/babel-preset-es2017) together (or the deprecated `babel-preset-latest`). + +> We don't recommend using `preset-env` this way because it doesn't take advantage of its ability to target specific browsers. + +```json +{ + "presets": ["@babel/preset-env"] +} +``` + +You can also configure it to only include the polyfills and transforms needed for the browsers you support. Compiling only what's needed can make your bundles smaller and your life easier. + +If you want to specify target browsers, we recommend using a [`.browserslistrc`](https://github.com/browserslist/browserslist) config, which is also used by many tools including Autoprefixer. + +For example, to only include polyfills and code transforms needed for users whose browsers have >0.25% market share (ignoring browsers without security updates like IE 10 and BlackBerry): + +``` +> 0.25% +not dead +``` + +The full list of queries could be found in [Browserslist docs](https://github.com/browserslist/browserslist#queries). + +If you need to use different browsers for Babel, you can also specify Browserslist queries in the [targets.browsers option](https://github.com/babel/babel/tree/master/packages/babel-preset-env#targetsbrowsers) in your Babel config. + +You may also target browsers supporting ES Modules (https://www.ecma-international.org/ecma-262/6.0/#sec-modules). When specifying this option, the browsers field will be ignored. You can use this approach in combination with `<script type="module"></script>` to conditionally serve smaller scripts to users (https://jakearchibald.com/2017/es-modules-in-browsers/#nomodule-for-backwards-compatibility). + +*Please note*: when specifying the esmodules target, browsers targets will be ignored. + +```json +{ + "presets": [ + ["@babel/preset-env", { + "targets": { + "esmodules": true + } + }] + ] +} +``` + +Similarly, if you're targeting Node.js instead of the browser, you can configure `@babel/preset-env` to only include the polyfills and transforms necessary for a particular version: + +```json +{ + "presets": [ + ["@babel/preset-env", { + "targets": { + "node": "6.10" + } + }] + ] +} +``` + +For convenience, you can use `"node": "current"` to only include the necessary polyfills and transforms for the Node.js version that you use to run Babel: + +```json +{ + "presets": [ + ["@babel/preset-env", { + "targets": { + "node": "current" + } + }] + ] +} +``` + +- [How it Works](#how-it-works) +- [Install](#install) +- [Usage](#usage) +- [Options](#options) +- [Examples](#examples) +- [Issues](#issues) + +## How it Works + +### Determine environment support for ECMAScript features + +Use external data such as [`compat-table`](https://github.com/kangax/compat-table) to determine browser support. (We should create PRs there when necessary) + + + +We can periodically run [build-data.js](https://github.com/babel/babel/blob/master/packages/babel-preset-env/scripts/build-data.js) which generates [plugins.json](https://github.com/babel/babel/blob/master/packages/babel-preset-env/data/plugins.json). + +Ref: [#7](https://github.com/babel/babel-preset-env/issues/7) + +### Maintain a mapping between JavaScript features and Babel plugins + +> Currently located at [plugin-features.js](https://github.com/babel/babel/blob/master/packages/babel-preset-env/data/plugin-features.js). + +This should be straightforward to do in most cases. There might be cases where plugins should be split up more or certain plugins aren't standalone enough (or impossible to do). + +### Support all plugins in Babel that are considered `latest` + +> Default behavior without options is the same as `@babel/preset-latest`. + +It won't include `stage-x` plugins. env will support all plugins in what we consider the latest version of JavaScript (by matching what we do in [`@babel/preset-latest`](http://babeljs.io/docs/plugins/preset-latest/)). + +Ref: [#14](https://github.com/babel/babel-preset-env/issues/14) + +### Determine the lowest common denominator of plugins to be included in the preset + +If you are targeting IE 8 and Chrome 55 it will include all plugins required by IE 8 since you would need to support both still. + +### Support a target option `"node": "current"` to compile for the currently running node version. + +For example, if you are building on Node 6, arrow functions won't be converted, but they will if you build on Node 0.12. + +### Support a `browsers` option like autoprefixer. + +Use [browserslist](https://github.com/ai/browserslist) to declare supported environments by performing queries like `> 1%, last 2 versions`. + +Ref: [#19](https://github.com/babel/babel-preset-env/pull/19) + +### Browserslist support. + +[Browserslist](https://github.com/ai/browserslist) is a library used to share a supported list of browsers between different front-end tools like [autoprefixer](https://github.com/postcss/autoprefixer), [stylelint](https://stylelint.io/), [eslint-plugin-compat](https://github.com/amilajack/eslint-plugin-compat) and many others. + +By default, @babel/preset-env will use [browserslist config sources](https://github.com/ai/browserslist#queries). + +For example, to enable only the polyfills and plugins needed for a project targeting *last 2 versions* and *IE10*: + +**.babelrc** +```json +{ + "presets": [ + ["@babel/preset-env", { + "useBuiltIns": "entry" + }] + ] +} +``` + +**browserslist** +``` +Last 2 versions +IE 10 +``` + +or + +**package.json** +``` +"browserslist": "last 2 versions, ie 10" +``` + +Browserslist config will be ignored if: 1) `targets.browsers` was specified 2) or with `ignoreBrowserslistConfig: true` option ([see more](#ignoreBrowserslistConfig)): + +#### Targets merging. + +1. If [targets.browsers](#targetsbrowsers) is defined - the browserslist config will be ignored. The browsers specified in `targets` will be merged with [any other explicitly defined targets](#targets). If merged, targets defined explicitly will override the same targets received from `targets.browsers`. + +2. If [targets.browsers](#targetsbrowsers) is _not_ defined - the program will search browserslist file or `package.json` with `browserslist` field. The search will start from the working directory of the process or from the path specified by the `configPath` option, and go up to the system root. If both a browserslist file and configuration inside a `package.json` are found, an exception will be thrown. + +3. If a browserslist config was found and other targets are defined (but not [targets.browsers](#targetsbrowsers)), the targets will be merged in the same way as `targets` defined explicitly with `targets.browsers`. + +## Install + +With [npm](https://www.npmjs.com): + +```sh +npm install --save-dev @babel/preset-env +``` + +Or [yarn](https://yarnpkg.com): + +```sh +yarn add @babel/preset-env --dev +``` + +## Usage + +The default behavior without options runs all transforms (behaves the same as [@babel/preset-latest](https://babeljs.io/docs/plugins/preset-latest/)). + +```json +{ + "presets": ["@babel/preset-env"] +} +``` + +## Options + +For more information on setting options for a preset, refer to the [plugin/preset options](http://babeljs.io/docs/plugins/#plugin-preset-options) documentation. + +### `targets` + +`{ [string]: number | string }`, defaults to `{}`. + +Takes an object of environment versions to support. + +Each target environment takes a number or a string (we recommend using a string when specifying minor versions like `node: "6.10"`). You can also specify `tp` (technology preview) version for Safari. + +Example environments: `chrome`, `opera`, `edge`, `firefox`, `safari`, `ie`, `ios`, `android`, `node`, `electron`. + +The [data](https://github.com/babel/babel/blob/master/packages/babel-preset-env/data/plugins.json) for this is generated by running the [build-data script](https://github.com/babel/babel/blob/master/packages/babel-preset-env/scripts/build-data.js) which pulls in data from [compat-table](https://kangax.github.io/compat-table). + +### `targets.node` + +`number | string | "current" | true` + +If you want to compile against the current node version, you can specify `"node": true` or `"node": "current"`, which would be the same as `"node": process.versions.node`. + +### `targets.browsers` + +`Array<string> | string` + +A query to select browsers (ex: last 2 versions, > 5%, safari tp) using [browserslist](https://github.com/ai/browserslist). + +Note, browsers' results are overridden by explicit items from `targets`. + +### `spec` + +`boolean`, defaults to `false`. + +Enable more spec compliant, but potentially slower, transformations for any plugins in this preset that support them. + +### `loose` + +`boolean`, defaults to `false`. + +Enable ["loose" transformations](http://2ality.com/2015/12/babel6-loose-mode.html) for any plugins in this preset that allow them. + +### `modules` + +`"amd" | "umd" | "systemjs" | "commonjs" | "cjs" | false`, defaults to `"commonjs"`. + +Enable transformation of ES6 module syntax to another module type. + +Setting this to `false` will not transform modules. + +### `debug` + +`boolean`, defaults to `false`. + +Outputs the targets/plugins used and the version specified in [plugin data version](https://github.com/babel/babel/blob/master/packages/babel-preset-env/data/plugins.json) to `console.log`. + +### `include` + +`Array<string|RegExp>`, defaults to `[]`. + +An array of plugins to always include. + +Valid options include any: + +- [Babel plugins](https://github.com/babel/babel/blob/master/packages/babel-preset-env/data/plugin-features.js) - both with (`@babel/plugin-transform-spread`) and without prefix (`plugin-transform-spread`) are supported. + +- [Built-ins](https://github.com/babel/babel/blob/master/packages/babel-preset-env/data/built-in-features.js), such as `es6.map`, `es6.set`, or `es6.object.assign`. + +Plugin names can be fully or partially specified (or using `RegExp`). + +Acceptable inputs: + +- Full name (`string`): `"es6.math.sign"` +- Partial name (`string`): `"es6.math.*"` (resolves to all plugins with `es6.math` prefix) +- `RegExp` Object: `/^transform-.*$/` or `new RegExp("^transform-modules-.*")` + +Note that the above `.` is the `RegExp` equivalent to match any character, and not the actual `'.'` character. Also note that to match any character `.*` is used in `RegExp` as opposed to `*` in `glob` format. + +This option is useful if there is a bug in a native implementation, or a combination of a non-supported feature + a supported one doesn't work. + +For example, Node 4 supports native classes but not spread. If `super` is used with a spread argument, then the `@babel/plugin-transform-classes` transform needs to be `include`d, as it is not possible to transpile a spread with `super` otherwise. + +> NOTE: The `include` and `exclude` options _only_ work with the [plugins included with this preset](https://github.com/babel/babel/blob/master/packages/babel-preset-env/data/plugin-features.js); so, for example, including `@babel/plugin-proposal-do-expressions` or excluding `@babel/plugin-proposal-function-bind` will throw errors. To use a plugin _not_ included with this preset, add them to your [config](https://babeljs.io/docs/usage/babelrc/) directly. + +### `exclude` + +`Array<string|RegExp>`, defaults to `[]`. + +An array of plugins to always exclude/remove. + +The possible options are the same as the `include` option. + +This option is useful for "blacklisting" a transform like `@babel/plugin-transform-regenerator` if you don't use generators and don't want to include `regeneratorRuntime` (when using `useBuiltIns`) or for using another plugin like [fast-async](https://github.com/MatAtBread/fast-async) instead of [Babel's async-to-gen](http://babeljs.io/docs/plugins/proposal-async-generator-functions/). + +### `useBuiltIns` + +`"usage"` | `"entry"` | `false`, defaults to `false`. + +A way to apply `@babel/preset-env` for polyfills (via `@babel/polyfill`). + +```sh +npm install @babel/polyfill --save +``` + +#### `useBuiltIns: 'usage'` + +Adds specific imports for polyfills when they are used in each file. We take advantage of the fact that a bundler will load the same polyfill only once. + +**In** + +a.js + +```js +var a = new Promise(); +``` + +b.js + +```js +var b = new Map(); +``` + +**Out (if environment doesn't support it)** + +```js +import "core-js/modules/es6.promise"; +var a = new Promise(); +``` + +```js +import "core-js/modules/es6.map"; +var b = new Map(); +``` + +**Out (if environment supports it)** + +```js +var a = new Promise(); +``` + +```js +var b = new Map(); +``` + +#### `useBuiltIns: 'entry'` + +> NOTE: Only use `require("@babel/polyfill");` once in your whole app. +> Multiple imports or requires of `@babel/polyfill` will throw an error since it can cause global collisions and other issues that are hard to trace. +> We recommend creating a single entry file that only contains the `require` statement. + +This option enables a new plugin that replaces the statement `import "@babel/polyfill"` or `require("@babel/polyfill")` with individual requires for `@babel/polyfill` based on environment. + +**In** + +```js +import "@babel/polyfill"; +``` + +**Out (different based on environment)** + +```js +import "core-js/modules/es7.string.pad-start"; +import "core-js/modules/es7.string.pad-end"; +``` + +This will also work for `core-js` directly (`import "core-js";` or `require('core-js');`) + +#### `useBuiltIns: false` + +Don't add polyfills automatically per file, or transform `import "@babel/polyfill"` to individual polyfills. + +### `forceAllTransforms` + +`boolean`, defaults to `false`. + +<p><details> + <summary><b>Example</b></summary> + + With Babel 7's .babelrc.js support, you can force all transforms to be run if env is set to `production`. + + ```js + module.exports = { + presets: [ + ["@babel/preset-env", { + targets: { + chrome: 59, + edge: 13, + firefox: 50, + }, + // for uglifyjs... + forceAllTransforms: process.env === "production" + }], + ], + }; + ``` +</details></p> + + +> NOTE: `targets.uglify` is deprecated and will be removed in the next major in +favor of this. + +By default, this preset will run all the transforms needed for the targeted +environment(s). Enable this option if you want to force running _all_ +transforms, which is useful if the output will be run through UglifyJS or an +environment that only supports ES5. + +> NOTE: Uglify has a work-in-progress "Harmony" branch to address the lack of +ES6 support, but it is not yet stable. You can follow its progress in +[UglifyJS2 issue #448](https://github.com/mishoo/UglifyJS2/issues/448). If you +require an alternative minifier which _does_ support ES6 syntax, we recommend +using [babel-minify](https://github.com/babel/minify). + +### `configPath` + +`string`, defaults to `process.cwd()` + +The starting point where the config search for browserslist will start, and ascend to the system root until found. + +### `ignoreBrowserslistConfig` + +`boolean`, defaults to `false` + +Toggles whether or not [browserslist config sources](https://github.com/ai/browserslist#queries) are used, which includes searching for any browserslist files or referencing the browserslist key inside package.json. This is useful for projects that use a browserslist config for files that won't be compiled with Babel. + +### `shippedProposals` + +`boolean`, defaults to `false` + +Toggles enabling support for builtin/feature proposals that have shipped in browsers. If your target environments have native support for a feature proposal, its matching parser syntax plugin is enabled instead of performing any transform. Note that this _does not_ enable the same transformations as [`@babel/preset-stage-3`](https://babeljs.io/docs/plugins/preset-stage-3/), since proposals can continue to change before landing in browsers. + +The following are currently supported: + +**Builtins** + +- None + +**Features** + +- [Optional catch binding](https://github.com/tc39/proposal-optional-catch-binding) + +--- + +## Examples + +### Export with various targets + +```js +export class A {} +``` + +#### Target only Chrome 52 + +**.babelrc** + +```json +{ + "presets": [ + ["@babel/preset-env", { + "targets": { + "chrome": 52 + } + }] + ] +} +``` + +**Out** + +```js +class A {} +exports.A = A; +``` + +#### Target Chrome 52 with webpack 2/rollup and loose mode + +**.babelrc** + +```json +{ + "presets": [ + ["@babel/preset-env", { + "targets": { + "chrome": 52 + }, + "modules": false, + "loose": true + }] + ] +} +``` + +**Out** + +```js +export class A {} +``` + +#### Target specific browsers via browserslist + +**.babelrc** + +```json +{ + "presets": [ + ["@babel/preset-env", { + "targets": { + "chrome": 52, + "browsers": ["last 2 versions", "safari 7"] + } + }] + ] +} +``` + +**Out** + +```js +export var A = function A() { + _classCallCheck(this, A); +}; +``` + +#### Target latest node via `node: true` or `node: "current"` + +**.babelrc** + +```json +{ + "presets": [ + ["@babel/preset-env", { + "targets": { + "node": "current" + } + }] + ] +} +``` + +**Out** + +```js +class A {} +exports.A = A; +``` + +### Show debug output + +**.babelrc** + +```json +{ + "presets": [ + ["@babel/preset-env", { + "targets": { + "safari": 10 + }, + "modules": false, + "useBuiltIns": "entry", + "debug": true + }] + ] +} +``` + +**stdout** + +```sh +Using targets: +{ + "safari": 10 +} + +Modules transform: false + +Using plugins: + @babel/plugin-transform-exponentiation-operator {} + @babel/plugin-transform-async-to-generator {} + +Using polyfills: + es7.object.values {} + es7.object.entries {} + es7.object.get-own-property-descriptors {} + web.timers {} + web.immediate {} + web.dom.iterable {} +``` + +### Include and exclude specific plugins/built-ins + +> always include arrow functions, explicitly exclude generators + +```json +{ + "presets": [ + ["@babel/preset-env", { + "targets": { + "browsers": ["last 2 versions", "safari >= 7"] + }, + "include": ["@babel/plugin-transform-arrow-functions", "es6.map"], + "exclude": ["@babel/plugin-transform-regenerator", "es6.set"] + }] + ] +} +``` + +## Issues + +If you get a `SyntaxError: Unexpected token ...` error when using the [object-rest-spread](https://github.com/babel/babel/tree/master/packages/babel-plugin-proposal-object-rest-spread) transform then make sure the plugin has been updated to, at least, `v6.19.0`. diff --git a/node_modules/@babel/preset-env/data/built-in-features.js b/node_modules/@babel/preset-env/data/built-in-features.js new file mode 100644 index 00000000..89d4474d --- /dev/null +++ b/node_modules/@babel/preset-env/data/built-in-features.js @@ -0,0 +1,331 @@ +const typedArrayMethods = [ + "typed arrays / %TypedArray%.from", + "typed arrays / %TypedArray%.of", + "typed arrays / %TypedArray%.prototype.subarray", + "typed arrays / %TypedArray%.prototype.join", + "typed arrays / %TypedArray%.prototype.indexOf", + "typed arrays / %TypedArray%.prototype.lastIndexOf", + "typed arrays / %TypedArray%.prototype.slice", + "typed arrays / %TypedArray%.prototype.every", + "typed arrays / %TypedArray%.prototype.filter", + "typed arrays / %TypedArray%.prototype.forEach", + "typed arrays / %TypedArray%.prototype.map", + "typed arrays / %TypedArray%.prototype.reduce", + "typed arrays / %TypedArray%.prototype.reduceRight", + "typed arrays / %TypedArray%.prototype.reverse", + "typed arrays / %TypedArray%.prototype.some", + "typed arrays / %TypedArray%.prototype.sort", + "typed arrays / %TypedArray%.prototype.copyWithin", + "typed arrays / %TypedArray%.prototype.find", + "typed arrays / %TypedArray%.prototype.findIndex", + "typed arrays / %TypedArray%.prototype.fill", + "typed arrays / %TypedArray%.prototype.keys", + "typed arrays / %TypedArray%.prototype.values", + "typed arrays / %TypedArray%.prototype.entries", + "typed arrays / %TypedArray%.prototype[Symbol.iterator]", + "typed arrays / %TypedArray%[Symbol.species]", +]; + +const es = { + // compat-table missing babel6 mapping + // "es6.array.concat": { + // features: [ + // "well-known symbols / Symbol.isConcatSpreadable", + // "well-known symbols / Symbol.species, Array.prototype.concat", + // ] + // }, + "es6.array.copy-within": "Array.prototype methods / Array.prototype.copyWithin", + "es6.array.every": "Array methods / Array.prototype.every", + "es6.array.fill": "Array.prototype methods / Array.prototype.fill", + "es6.array.filter": { + features: [ + "Array methods / Array.prototype.filter", + // compat-table missing babel6 mapping + // "well-known symbols / Symbol.species, Array.prototype.filter", + ], + }, + "es6.array.find": "Array.prototype methods / Array.prototype.find", + "es6.array.find-index": "Array.prototype methods / Array.prototype.findIndex", + "es6.array.for-each": "Array methods / Array.prototype.forEach", + "es6.array.from": "Array static methods / Array.from", + "es7.array.includes": "Array.prototype.includes", + "es6.array.index-of": "Array methods / Array.prototype.indexOf", + "es6.array.is-array": "Array methods / Array.isArray", + // "es.array.join": "", required tests for that + "es6.array.iterator": { + features: [ + "Array.prototype methods / Array.prototype.keys", + // can use Symbol.iterator, not implemented in many environments + // "Array.prototype methods / Array.prototype.values", + "Array.prototype methods / Array.prototype.entries", + ], + }, + "es6.array.last-index-of": "Array methods / Array.prototype.lastIndexOf", + "es6.array.map": { + features: [ + "Array methods / Array.prototype.map", + // compat-table missing babel6 mapping + // "well-known symbols / Symbol.species, Array.prototype.map", + ], + }, + "es6.array.of": "Array static methods / Array.of", + "es6.array.reduce": "Array methods / Array.prototype.reduce", + "es6.array.reduce-right": "Array methods / Array.prototype.reduceRight", + // compat-table missing babel6 mapping + // "es6.array.slice": "well-known symbols / Symbol.species, Array.prototype.slice", + "es6.array.some": "Array methods / Array.prototype.some", + "es6.array.sort": "Array methods / Array.prototype.sort", + "es6.array.species": "Array static methods / Array[Symbol.species]", + // compat-table missing babel6 mapping + //"es6.array.splice": "well-known symbols / Symbol.species, Array.prototype.splice", + + "es6.date.now": "Date methods / Date.now", + "es6.date.to-iso-string": "Date methods / Date.prototype.toISOString", + "es6.date.to-json": "Date methods / Date.prototype.toJSON", + "es6.date.to-primitive": "Date.prototype[Symbol.toPrimitive]", + "es6.date.to-string": "miscellaneous / Invalid Date", + + "es6.function.bind": "Function.prototype.bind", + "es6.function.has-instance": "well-known symbols / Symbol.hasInstance", + "es6.function.name": { + features: [ + "function \"name\" property / function statements", + "function \"name\" property / function expressions", + ], + }, + + "es6.map": "Map", + + "es6.math.acosh": "Math methods / Math.acosh", + "es6.math.asinh": "Math methods / Math.asinh", + "es6.math.atanh": "Math methods / Math.atanh", + "es6.math.cbrt": "Math methods / Math.cbrt", + "es6.math.clz32": "Math methods / Math.clz32", + "es6.math.cosh": "Math methods / Math.cosh", + "es6.math.expm1": "Math methods / Math.expm1", + "es6.math.fround": "Math methods / Math.fround", + "es6.math.hypot": "Math methods / Math.hypot", + "es6.math.imul": "Math methods / Math.imul", + "es6.math.log1p": "Math methods / Math.log1p", + "es6.math.log10": "Math methods / Math.log10", + "es6.math.log2": "Math methods / Math.log2", + "es6.math.sign": "Math methods / Math.sign", + "es6.math.sinh": "Math methods / Math.sinh", + "es6.math.tanh": "Math methods / Math.tanh", + "es6.math.trunc": "Math methods / Math.trunc", + + "es6.number.constructor": { + features: [ + "octal and binary literals / octal supported by Number()", + "octal and binary literals / binary supported by Number()", + ], + }, + "es6.number.epsilon": "Number properties / Number.EPSILON", + "es6.number.is-finite": "Number properties / Number.isFinite", + "es6.number.is-integer": "Number properties / Number.isInteger", + "es6.number.is-nan": "Number properties / Number.isNaN", + "es6.number.is-safe-integer": "Number properties / Number.isSafeInteger", + "es6.number.max-safe-integer": "Number properties / Number.MAX_SAFE_INTEGER", + "es6.number.min-safe-integer": "Number properties / Number.MIN_SAFE_INTEGER", + "es6.number.parse-float": "Number properties / Number.parseFloat", + "es6.number.parse-int": "Number properties / Number.parseInt", + + "es6.object.assign": { + features: ["Object static methods / Object.assign", "Symbol"], + }, + "es6.object.create": "Object static methods / Object.create", + "es7.object.define-getter": { + features: [ + "Object.prototype getter/setter methods / __defineGetter__", + "Object.prototype getter/setter methods / __defineGetter__, symbols", + "Object.prototype getter/setter methods / __defineGetter__, ToObject(this)", + ], + }, + "es7.object.define-setter": { + features: [ + "Object.prototype getter/setter methods / __defineSetter__", + "Object.prototype getter/setter methods / __defineSetter__, symbols", + "Object.prototype getter/setter methods / __defineSetter__, ToObject(this)", + ], + }, + "es6.object.define-property": "Object static methods / Object.defineProperty", + "es6.object.define-properties": "Object static methods / Object.defineProperties", + "es7.object.entries": "Object static methods / Object.entries", + "es6.object.freeze": "Object static methods accept primitives / Object.freeze", + "es6.object.get-own-property-descriptor": "Object static methods accept primitives / Object.getOwnPropertyDescriptor", + "es7.object.get-own-property-descriptors": "Object static methods / Object.getOwnPropertyDescriptors", + "es6.object.get-own-property-names": "Object static methods accept primitives / Object.getOwnPropertyNames", + "es6.object.get-prototype-of": "Object static methods accept primitives / Object.getPrototypeOf", + "es7.object.lookup-getter": { + features: [ + "Object.prototype getter/setter methods / __lookupGetter__", + "Object.prototype getter/setter methods / __lookupGetter__, prototype chain", + "Object.prototype getter/setter methods / __lookupGetter__, symbols", + "Object.prototype getter/setter methods / __lookupGetter__, ToObject(this)", + "Object.prototype getter/setter methods / __lookupGetter__, data properties can shadow accessors", + ], + }, + "es7.object.lookup-setter": { + features: [ + "Object.prototype getter/setter methods / __lookupSetter__", + "Object.prototype getter/setter methods / __lookupSetter__, prototype chain", + "Object.prototype getter/setter methods / __lookupSetter__, symbols", + "Object.prototype getter/setter methods / __lookupSetter__, ToObject(this)", + "Object.prototype getter/setter methods / __lookupSetter__, data properties can shadow accessors", + ], + }, + "es6.object.prevent-extensions": "Object static methods accept primitives / Object.preventExtensions", + "es6.object.is": "Object static methods / Object.is", + "es6.object.is-frozen": "Object static methods accept primitives / Object.isFrozen", + "es6.object.is-sealed": "Object static methods accept primitives / Object.isSealed", + "es6.object.is-extensible": "Object static methods accept primitives / Object.isExtensible", + "es6.object.keys": "Object static methods accept primitives / Object.keys", + "es6.object.seal": "Object static methods accept primitives / Object.seal", + "es6.object.set-prototype-of": "Object static methods / Object.setPrototypeOf", + "es7.object.values": "Object static methods / Object.values", + + "es6.promise": { + features: [ + // required unhandled rejection tracking tests + "Promise", + "well-known symbols / Symbol.species, Promise.prototype.then", + ], + }, + "es7.promise.finally": "Promise.prototype.finally", + + "es6.reflect.apply": "Reflect / Reflect.apply", + "es6.reflect.construct": "Reflect / Reflect.construct", + "es6.reflect.define-property": "Reflect / Reflect.defineProperty", + "es6.reflect.delete-property": "Reflect / Reflect.deleteProperty", + "es6.reflect.get": "Reflect / Reflect.get", + "es6.reflect.get-own-property-descriptor": "Reflect / Reflect.getOwnPropertyDescriptor", + "es6.reflect.get-prototype-of": "Reflect / Reflect.getPrototypeOf", + "es6.reflect.has": "Reflect / Reflect.has", + "es6.reflect.is-extensible": "Reflect / Reflect.isExtensible", + "es6.reflect.own-keys": "Reflect / Reflect.ownKeys", + "es6.reflect.prevent-extensions": "Reflect / Reflect.preventExtensions", + "es6.reflect.set": "Reflect / Reflect.set", + "es6.reflect.set-prototype-of": "Reflect / Reflect.setPrototypeOf", + + "es6.regexp.constructor": { + features: [ + "miscellaneous / RegExp constructor can alter flags", + "well-known symbols / Symbol.match, RegExp constructor", + ], + }, + "es6.regexp.flags": "RegExp.prototype properties / RegExp.prototype.flags", + "es6.regexp.match": "RegExp.prototype properties / RegExp.prototype[Symbol.match]", + "es6.regexp.replace": "RegExp.prototype properties / RegExp.prototype[Symbol.replace]", + "es6.regexp.split": "RegExp.prototype properties / RegExp.prototype[Symbol.split]", + "es6.regexp.search": "RegExp.prototype properties / RegExp.prototype[Symbol.search]", + "es6.regexp.to-string": "miscellaneous / RegExp.prototype.toString generic and uses \"flags\" property", + + // This is explicit due to prevent the stage-1 Set proposals under the + // category "Set methods" from being included. + "es6.set": { + features: [ + "Set / basic functionality", + "Set / constructor arguments", + "Set / constructor requires new", + "Set / constructor accepts null", + "Set / constructor invokes add", + "Set / iterator closing", + "Set / Set.prototype.add returns this", + "Set / -0 key converts to +0", + "Set / Set.prototype.size", + "Set / Set.prototype.delete", + "Set / Set.prototype.clear", + "Set / Set.prototype.forEach", + "Set / Set.prototype.keys", + "Set / Set.prototype.values", + "Set / Set.prototype.entries", + "Set / Set.prototype[Symbol.iterator]", + "Set / Set.prototype isn't an instance", + "Set / Set iterator prototype chain", + "Set / Set[Symbol.species]", + ], + }, + + "es6.symbol": { + features: [ + "Symbol", + "Object static methods / Object.getOwnPropertySymbols", + "well-known symbols / Symbol.hasInstance", + "well-known symbols / Symbol.isConcatSpreadable", + "well-known symbols / Symbol.iterator", + "well-known symbols / Symbol.match", + "well-known symbols / Symbol.replace", + "well-known symbols / Symbol.search", + "well-known symbols / Symbol.species", + "well-known symbols / Symbol.split", + "well-known symbols / Symbol.toPrimitive", + "well-known symbols / Symbol.toStringTag", + "well-known symbols / Symbol.unscopables", + ], + }, + "es7.symbol.async-iterator": "Asynchronous Iterators", + + "es6.string.anchor": "String.prototype HTML methods", + "es6.string.big": "String.prototype HTML methods", + "es6.string.blink": "String.prototype HTML methods", + "es6.string.bold": "String.prototype HTML methods", + "es6.string.code-point-at": "String.prototype methods / String.prototype.codePointAt", + "es6.string.ends-with": "String.prototype methods / String.prototype.endsWith", + "es6.string.fixed": "String.prototype HTML methods", + "es6.string.fontcolor": "String.prototype HTML methods", + "es6.string.fontsize": "String.prototype HTML methods", + "es6.string.from-code-point": "String static methods / String.fromCodePoint", + "es6.string.includes": "String.prototype methods / String.prototype.includes", + "es6.string.italics": "String.prototype HTML methods", + "es6.string.iterator": "String properties and methods / Property access on strings", + "es6.string.link": "String.prototype HTML methods", + // "String.prototype methods / String.prototype.normalize" not implemented + "es7.string.pad-start": "String padding / String.prototype.padStart", + "es7.string.pad-end": "String padding / String.prototype.padEnd", + "es6.string.raw": "String static methods / String.raw", + "es6.string.repeat": "String.prototype methods / String.prototype.repeat", + "es6.string.small": "String.prototype HTML methods", + "es6.string.starts-with": "String.prototype methods / String.prototype.startsWith", + "es6.string.strike": "String.prototype HTML methods", + "es6.string.sub": "String.prototype HTML methods", + "es6.string.sup": "String.prototype HTML methods", + "es6.string.trim": "String properties and methods / String.prototype.trim", + + "es6.typed.array-buffer": "typed arrays / ArrayBuffer[Symbol.species]", + "es6.typed.data-view": "typed arrays / DataView", + "es6.typed.int8-array": { + features: ["typed arrays / Int8Array"].concat(typedArrayMethods), + }, + "es6.typed.uint8-array": { + features: ["typed arrays / Uint8Array"].concat(typedArrayMethods), + }, + "es6.typed.uint8-clamped-array": { + features: ["typed arrays / Uint8ClampedArray"].concat(typedArrayMethods), + }, + "es6.typed.int16-array": { + features: ["typed arrays / Int16Array"].concat(typedArrayMethods), + }, + "es6.typed.uint16-array": { + features: ["typed arrays / Uint16Array"].concat(typedArrayMethods), + }, + "es6.typed.int32-array": { + features: ["typed arrays / Int32Array"].concat(typedArrayMethods), + }, + "es6.typed.uint32-array": { + features: ["typed arrays / Uint32Array"].concat(typedArrayMethods), + }, + "es6.typed.float32-array": { + features: ["typed arrays / Float32Array"].concat(typedArrayMethods), + }, + "es6.typed.float64-array": { + features: ["typed arrays / Float64Array"].concat(typedArrayMethods), + }, + + "es6.weak-map": "WeakMap", + + "es6.weak-set": "WeakSet", +}; + +const proposals = require("./shipped-proposals").builtIns; + +module.exports = Object.assign({}, es, proposals); diff --git a/node_modules/@babel/preset-env/data/built-in-modules.json b/node_modules/@babel/preset-env/data/built-in-modules.json new file mode 100644 index 00000000..c2d05dbd --- /dev/null +++ b/node_modules/@babel/preset-env/data/built-in-modules.json @@ -0,0 +1,9 @@ +{ + "es6.module": { + "edge": "16", + "firefox": "60", + "chrome": "61", + "safari": "10.1", + "ios_saf": "10.3" + } +} diff --git a/node_modules/@babel/preset-env/data/built-ins.json b/node_modules/@babel/preset-env/data/built-ins.json new file mode 100644 index 00000000..91877c45 --- /dev/null +++ b/node_modules/@babel/preset-env/data/built-ins.json @@ -0,0 +1,1434 @@ +{ + "es6.array.copy-within": { + "chrome": "45", + "edge": "12", + "firefox": "32", + "safari": "9", + "node": "4", + "ios": "9", + "opera": "32", + "electron": "0.35" + }, + "es6.array.every": { + "chrome": "5", + "opera": "10.10", + "edge": "12", + "firefox": "2", + "safari": "3.1", + "node": "0.10", + "ie": "9", + "android": "4.0", + "ios": "6", + "electron": "1.1" + }, + "es6.array.fill": { + "chrome": "45", + "edge": "12", + "firefox": "31", + "safari": "7.1", + "node": "4", + "ios": "8", + "opera": "32", + "electron": "0.35" + }, + "es6.array.filter": { + "chrome": "5", + "opera": "10.10", + "edge": "12", + "firefox": "2", + "safari": "3.1", + "node": "0.10", + "ie": "9", + "android": "4.0", + "ios": "6", + "electron": "1.1" + }, + "es6.array.find": { + "chrome": "45", + "edge": "12", + "firefox": "25", + "safari": "7.1", + "node": "4", + "ios": "8", + "opera": "32", + "electron": "0.35" + }, + "es6.array.find-index": { + "chrome": "45", + "edge": "12", + "firefox": "25", + "safari": "7.1", + "node": "4", + "ios": "8", + "opera": "32", + "electron": "0.35" + }, + "es6.array.for-each": { + "chrome": "5", + "opera": "10.10", + "edge": "12", + "firefox": "2", + "safari": "3.1", + "node": "0.10", + "ie": "9", + "android": "4.0", + "ios": "6", + "electron": "1.1" + }, + "es6.array.from": { + "chrome": "51", + "edge": "15", + "firefox": "36", + "safari": "10", + "node": "6.5", + "ios": "10", + "opera": "38", + "electron": "1.2" + }, + "es7.array.includes": { + "chrome": "47", + "edge": "14", + "firefox": "43", + "safari": "10", + "node": "6", + "ios": "10", + "opera": "34", + "electron": "0.36" + }, + "es6.array.index-of": { + "chrome": "5", + "opera": "10.10", + "edge": "12", + "firefox": "2", + "safari": "3.1", + "node": "0.10", + "ie": "9", + "android": "4.0", + "ios": "6", + "electron": "1.1" + }, + "es6.array.is-array": { + "chrome": "5", + "opera": "10.50", + "edge": "12", + "firefox": "4", + "safari": "4", + "node": "0.10", + "ie": "9", + "android": "4.0", + "ios": "6", + "electron": "1.1" + }, + "es6.array.iterator": { + "chrome": "38", + "edge": "12", + "firefox": "28", + "safari": "7.1", + "node": "0.12", + "ios": "8", + "opera": "25", + "electron": "0.2" + }, + "es6.array.last-index-of": { + "chrome": "5", + "opera": "10.10", + "edge": "12", + "firefox": "2", + "safari": "3.1", + "node": "0.10", + "ie": "9", + "android": "4.0", + "ios": "6", + "electron": "1.1" + }, + "es6.array.map": { + "chrome": "5", + "opera": "10.10", + "edge": "12", + "firefox": "2", + "safari": "3.1", + "node": "0.10", + "ie": "9", + "android": "4.0", + "ios": "6", + "electron": "1.1" + }, + "es6.array.of": { + "chrome": "45", + "edge": "12", + "firefox": "25", + "safari": "9", + "node": "4", + "ios": "9", + "opera": "32", + "electron": "0.35" + }, + "es6.array.reduce": { + "chrome": "5", + "opera": "10.50", + "edge": "12", + "firefox": "3", + "safari": "4", + "node": "0.10", + "ie": "9", + "android": "4.0", + "ios": "6", + "electron": "1.1" + }, + "es6.array.reduce-right": { + "chrome": "5", + "opera": "10.50", + "edge": "12", + "firefox": "3", + "safari": "4", + "node": "0.10", + "ie": "9", + "android": "4.0", + "ios": "6", + "electron": "1.1" + }, + "es6.array.some": { + "chrome": "5", + "opera": "10.10", + "edge": "12", + "firefox": "2", + "safari": "3.1", + "node": "0.10", + "ie": "9", + "android": "4.0", + "ios": "6", + "electron": "1.1" + }, + "es6.array.sort": { + "chrome": "63", + "opera": "50", + "edge": "12", + "firefox": "5", + "safari": "10.1", + "ie": "9", + "ios": "10.3" + }, + "es6.array.species": { + "chrome": "51", + "edge": "13", + "firefox": "48", + "safari": "10", + "node": "6.5", + "ios": "10", + "opera": "38", + "electron": "1.2" + }, + "es6.date.now": { + "chrome": "5", + "opera": "10.50", + "edge": "12", + "firefox": "2", + "safari": "4", + "node": "0.10", + "ie": "9", + "android": "4.0", + "ios": "6", + "electron": "1.1" + }, + "es6.date.to-iso-string": { + "chrome": "5", + "opera": "10.50", + "edge": "12", + "firefox": "3.5", + "safari": "4", + "node": "0.10", + "ie": "9", + "android": "4.0", + "ios": "6", + "electron": "1.1" + }, + "es6.date.to-json": { + "chrome": "5", + "opera": "12.10", + "edge": "12", + "firefox": "4", + "safari": "10", + "node": "0.10", + "ie": "9", + "android": "4.0", + "ios": "10", + "electron": "1.1" + }, + "es6.date.to-primitive": { + "chrome": "47", + "edge": "15", + "firefox": "44", + "safari": "10", + "node": "6", + "ios": "10", + "opera": "34", + "electron": "0.36" + }, + "es6.date.to-string": { + "chrome": "5", + "opera": "10.50", + "edge": "12", + "firefox": "2", + "safari": "3.1", + "node": "0.12", + "ie": "10", + "android": "4.0", + "ios": "6", + "electron": "1.1" + }, + "es6.function.bind": { + "chrome": "7", + "opera": "12", + "edge": "12", + "firefox": "4", + "safari": "5.1", + "node": "0.10", + "ie": "9", + "android": "4.0", + "ios": "7" + }, + "es6.function.has-instance": { + "chrome": "51", + "edge": "15", + "firefox": "50", + "safari": "10", + "node": "6.5", + "ios": "10", + "opera": "38", + "electron": "1.2" + }, + "es6.function.name": { + "chrome": "5", + "opera": "10.50", + "edge": "12", + "firefox": "2", + "safari": "4", + "node": "0.12", + "android": "4.0", + "ios": "6", + "electron": "1.1" + }, + "es6.map": { + "chrome": "51", + "edge": "15", + "firefox": "53", + "safari": "10", + "node": "6.5", + "ios": "10", + "opera": "38", + "electron": "1.2" + }, + "es6.math.acosh": { + "chrome": "38", + "edge": "12", + "firefox": "25", + "safari": "7.1", + "node": "0.12", + "ios": "8", + "opera": "25", + "electron": "0.2" + }, + "es6.math.asinh": { + "chrome": "38", + "edge": "12", + "firefox": "25", + "safari": "7.1", + "node": "0.12", + "ios": "8", + "opera": "25", + "electron": "0.2" + }, + "es6.math.atanh": { + "chrome": "38", + "edge": "12", + "firefox": "25", + "safari": "7.1", + "node": "0.12", + "ios": "8", + "opera": "25", + "electron": "0.2" + }, + "es6.math.cbrt": { + "chrome": "38", + "edge": "12", + "firefox": "25", + "safari": "7.1", + "node": "0.12", + "ios": "8", + "opera": "25", + "electron": "0.2" + }, + "es6.math.clz32": { + "chrome": "38", + "edge": "12", + "firefox": "31", + "safari": "9", + "node": "0.12", + "ios": "9", + "opera": "25", + "electron": "0.2" + }, + "es6.math.cosh": { + "chrome": "38", + "edge": "12", + "firefox": "25", + "safari": "7.1", + "node": "0.12", + "ios": "8", + "opera": "25", + "electron": "0.2" + }, + "es6.math.expm1": { + "chrome": "38", + "edge": "12", + "firefox": "25", + "safari": "7.1", + "node": "0.12", + "ios": "8", + "opera": "25", + "electron": "0.2" + }, + "es6.math.fround": { + "chrome": "38", + "edge": "12", + "firefox": "26", + "safari": "7.1", + "node": "0.12", + "ios": "8", + "opera": "25", + "electron": "0.2" + }, + "es6.math.hypot": { + "chrome": "38", + "edge": "12", + "firefox": "27", + "safari": "7.1", + "node": "0.12", + "ios": "8", + "opera": "25", + "electron": "0.2" + }, + "es6.math.imul": { + "chrome": "30", + "edge": "12", + "firefox": "23", + "safari": "7", + "node": "0.12", + "android": "4.4", + "ios": "7", + "opera": "17", + "electron": "0.2" + }, + "es6.math.log1p": { + "chrome": "38", + "edge": "12", + "firefox": "25", + "safari": "7.1", + "node": "0.12", + "ios": "8", + "opera": "25", + "electron": "0.2" + }, + "es6.math.log10": { + "chrome": "38", + "edge": "12", + "firefox": "25", + "safari": "7.1", + "node": "0.12", + "ios": "8", + "opera": "25", + "electron": "0.2" + }, + "es6.math.log2": { + "chrome": "38", + "edge": "12", + "firefox": "25", + "safari": "7.1", + "node": "0.12", + "ios": "8", + "opera": "25", + "electron": "0.2" + }, + "es6.math.sign": { + "chrome": "38", + "edge": "12", + "firefox": "25", + "safari": "9", + "node": "0.12", + "ios": "9", + "opera": "25", + "electron": "0.2" + }, + "es6.math.sinh": { + "chrome": "38", + "edge": "12", + "firefox": "25", + "safari": "7.1", + "node": "0.12", + "ios": "8", + "opera": "25", + "electron": "0.2" + }, + "es6.math.tanh": { + "chrome": "38", + "edge": "12", + "firefox": "25", + "safari": "7.1", + "node": "0.12", + "ios": "8", + "opera": "25", + "electron": "0.2" + }, + "es6.math.trunc": { + "chrome": "38", + "edge": "12", + "firefox": "25", + "safari": "7.1", + "node": "0.12", + "ios": "8", + "opera": "25", + "electron": "0.2" + }, + "es6.number.constructor": { + "chrome": "41", + "edge": "12", + "firefox": "36", + "safari": "9", + "node": "4", + "ios": "9", + "opera": "28", + "electron": "0.24" + }, + "es6.number.epsilon": { + "chrome": "34", + "edge": "12", + "firefox": "25", + "safari": "9", + "node": "0.12", + "ios": "9", + "opera": "21", + "electron": "0.2" + }, + "es6.number.is-finite": { + "chrome": "19", + "edge": "12", + "firefox": "16", + "safari": "9", + "node": "0.12", + "android": "4.1", + "ios": "9", + "electron": "0.2" + }, + "es6.number.is-integer": { + "chrome": "34", + "edge": "12", + "firefox": "16", + "safari": "9", + "node": "0.12", + "ios": "9", + "opera": "21", + "electron": "0.2" + }, + "es6.number.is-nan": { + "chrome": "19", + "edge": "12", + "firefox": "15", + "safari": "9", + "node": "0.12", + "android": "4.1", + "ios": "9", + "electron": "0.2" + }, + "es6.number.is-safe-integer": { + "chrome": "34", + "edge": "12", + "firefox": "32", + "safari": "9", + "node": "0.12", + "ios": "9", + "opera": "21", + "electron": "0.2" + }, + "es6.number.max-safe-integer": { + "chrome": "34", + "edge": "12", + "firefox": "31", + "safari": "9", + "node": "0.12", + "ios": "9", + "opera": "21", + "electron": "0.2" + }, + "es6.number.min-safe-integer": { + "chrome": "34", + "edge": "12", + "firefox": "31", + "safari": "9", + "node": "0.12", + "ios": "9", + "opera": "21", + "electron": "0.2" + }, + "es6.number.parse-float": { + "chrome": "34", + "edge": "12", + "firefox": "25", + "safari": "9", + "node": "0.12", + "ios": "9", + "opera": "21", + "electron": "0.2" + }, + "es6.number.parse-int": { + "chrome": "34", + "edge": "12", + "firefox": "25", + "safari": "9", + "node": "0.12", + "ios": "9", + "opera": "21", + "electron": "0.2" + }, + "es6.object.assign": { + "chrome": "49", + "edge": "13", + "firefox": "36", + "safari": "10", + "node": "6", + "ios": "10", + "opera": "36", + "electron": "1" + }, + "es6.object.create": { + "chrome": "5", + "opera": "12", + "edge": "12", + "firefox": "4", + "safari": "4", + "node": "0.10", + "ie": "9", + "android": "4.0", + "ios": "6", + "electron": "1.1" + }, + "es7.object.define-getter": { + "chrome": "62", + "edge": "16", + "firefox": "48", + "safari": "9", + "node": "8.10", + "ios": "9", + "opera": "49" + }, + "es7.object.define-setter": { + "chrome": "62", + "edge": "16", + "firefox": "48", + "safari": "9", + "node": "8.10", + "ios": "9", + "opera": "49" + }, + "es6.object.define-property": { + "chrome": "5", + "opera": "12", + "edge": "12", + "firefox": "4", + "safari": "5.1", + "node": "0.10", + "ie": "9", + "android": "4.0", + "ios": "6", + "electron": "1.1" + }, + "es6.object.define-properties": { + "chrome": "5", + "opera": "12", + "edge": "12", + "firefox": "4", + "safari": "4", + "node": "0.10", + "ie": "9", + "android": "4.0", + "ios": "6", + "electron": "1.1" + }, + "es7.object.entries": { + "chrome": "54", + "edge": "14", + "firefox": "47", + "safari": "10.1", + "node": "7", + "ios": "10.3", + "opera": "41", + "electron": "1.5" + }, + "es6.object.freeze": { + "chrome": "44", + "edge": "12", + "firefox": "35", + "safari": "9", + "node": "4", + "ios": "9", + "opera": "31", + "electron": "0.31" + }, + "es6.object.get-own-property-descriptor": { + "chrome": "44", + "edge": "12", + "firefox": "35", + "safari": "9", + "node": "4", + "ios": "9", + "opera": "31", + "electron": "0.31" + }, + "es7.object.get-own-property-descriptors": { + "chrome": "54", + "edge": "15", + "firefox": "50", + "safari": "10.1", + "node": "7", + "ios": "10.3", + "opera": "41", + "electron": "1.5" + }, + "es6.object.get-own-property-names": { + "chrome": "40", + "edge": "12", + "firefox": "33", + "safari": "9", + "node": "4", + "ios": "9", + "opera": "27", + "electron": "0.21" + }, + "es6.object.get-prototype-of": { + "chrome": "44", + "edge": "12", + "firefox": "3.5", + "safari": "9", + "node": "4", + "ios": "9", + "opera": "31", + "electron": "0.31" + }, + "es7.object.lookup-getter": { + "chrome": "62", + "firefox": "36", + "safari": "9", + "node": "8.10", + "ios": "9", + "opera": "49" + }, + "es7.object.lookup-setter": { + "chrome": "62", + "firefox": "36", + "safari": "9", + "node": "8.10", + "ios": "9", + "opera": "49" + }, + "es6.object.prevent-extensions": { + "chrome": "44", + "edge": "12", + "firefox": "35", + "safari": "9", + "node": "4", + "ios": "9", + "opera": "31", + "electron": "0.31" + }, + "es6.object.is": { + "chrome": "19", + "edge": "12", + "firefox": "22", + "safari": "9", + "node": "0.12", + "android": "4.1", + "ios": "9", + "electron": "0.2" + }, + "es6.object.is-frozen": { + "chrome": "44", + "edge": "12", + "firefox": "35", + "safari": "9", + "node": "4", + "ios": "9", + "opera": "31", + "electron": "0.31" + }, + "es6.object.is-sealed": { + "chrome": "44", + "edge": "12", + "firefox": "35", + "safari": "9", + "node": "4", + "ios": "9", + "opera": "31", + "electron": "0.31" + }, + "es6.object.is-extensible": { + "chrome": "44", + "edge": "12", + "firefox": "35", + "safari": "9", + "node": "4", + "ios": "9", + "opera": "31", + "electron": "0.31" + }, + "es6.object.keys": { + "chrome": "40", + "edge": "12", + "firefox": "35", + "safari": "9", + "node": "4", + "ios": "9", + "opera": "27", + "electron": "0.21" + }, + "es6.object.seal": { + "chrome": "44", + "edge": "12", + "firefox": "35", + "safari": "9", + "node": "4", + "ios": "9", + "opera": "31", + "electron": "0.31" + }, + "es6.object.set-prototype-of": { + "chrome": "34", + "edge": "12", + "firefox": "31", + "safari": "9", + "node": "0.12", + "ie": "11", + "ios": "9", + "opera": "21", + "electron": "0.2" + }, + "es7.object.values": { + "chrome": "54", + "edge": "14", + "firefox": "47", + "safari": "10.1", + "node": "7", + "ios": "10.3", + "opera": "41", + "electron": "1.5" + }, + "es6.promise": { + "chrome": "51", + "edge": "14", + "firefox": "45", + "safari": "10", + "node": "6.5", + "ios": "10", + "opera": "38", + "electron": "1.2" + }, + "es7.promise.finally": { + "chrome": "63", + "firefox": "58", + "safari": "11.1", + "ios": "11.3", + "opera": "50" + }, + "es6.reflect.apply": { + "chrome": "49", + "edge": "12", + "firefox": "42", + "safari": "10", + "node": "6", + "ios": "10", + "opera": "36", + "electron": "1" + }, + "es6.reflect.construct": { + "chrome": "49", + "edge": "13", + "firefox": "44", + "safari": "10", + "node": "6", + "ios": "10", + "opera": "36", + "electron": "1" + }, + "es6.reflect.define-property": { + "chrome": "49", + "edge": "13", + "firefox": "42", + "safari": "10", + "node": "6", + "ios": "10", + "opera": "36", + "electron": "1" + }, + "es6.reflect.delete-property": { + "chrome": "49", + "edge": "12", + "firefox": "42", + "safari": "10", + "node": "6", + "ios": "10", + "opera": "36", + "electron": "1" + }, + "es6.reflect.get": { + "chrome": "49", + "edge": "12", + "firefox": "42", + "safari": "10", + "node": "6", + "ios": "10", + "opera": "36", + "electron": "1" + }, + "es6.reflect.get-own-property-descriptor": { + "chrome": "49", + "edge": "12", + "firefox": "42", + "safari": "10", + "node": "6", + "ios": "10", + "opera": "36", + "electron": "1" + }, + "es6.reflect.get-prototype-of": { + "chrome": "49", + "edge": "12", + "firefox": "42", + "safari": "10", + "node": "6", + "ios": "10", + "opera": "36", + "electron": "1" + }, + "es6.reflect.has": { + "chrome": "49", + "edge": "12", + "firefox": "42", + "safari": "10", + "node": "6", + "ios": "10", + "opera": "36", + "electron": "1" + }, + "es6.reflect.is-extensible": { + "chrome": "49", + "edge": "12", + "firefox": "42", + "safari": "10", + "node": "6", + "ios": "10", + "opera": "36", + "electron": "1" + }, + "es6.reflect.own-keys": { + "chrome": "49", + "edge": "12", + "firefox": "42", + "safari": "10", + "node": "6", + "ios": "10", + "opera": "36", + "electron": "1" + }, + "es6.reflect.prevent-extensions": { + "chrome": "49", + "edge": "12", + "firefox": "42", + "safari": "10", + "node": "6", + "ios": "10", + "opera": "36", + "electron": "1" + }, + "es6.reflect.set": { + "chrome": "49", + "edge": "12", + "firefox": "42", + "safari": "10", + "node": "6", + "ios": "10", + "opera": "36", + "electron": "1" + }, + "es6.reflect.set-prototype-of": { + "chrome": "49", + "edge": "12", + "firefox": "42", + "safari": "10", + "node": "6", + "ios": "10", + "opera": "36", + "electron": "1" + }, + "es6.regexp.constructor": { + "chrome": "50", + "firefox": "40", + "safari": "10", + "node": "6", + "ios": "10", + "opera": "37", + "electron": "1.1" + }, + "es6.regexp.flags": { + "chrome": "49", + "firefox": "37", + "safari": "9", + "node": "6", + "ios": "9", + "opera": "36", + "electron": "1" + }, + "es6.regexp.match": { + "chrome": "50", + "firefox": "49", + "safari": "10", + "node": "6", + "ios": "10", + "opera": "37", + "electron": "1.1" + }, + "es6.regexp.replace": { + "chrome": "50", + "firefox": "49", + "safari": "10", + "node": "6", + "ios": "10", + "opera": "37", + "electron": "1.1" + }, + "es6.regexp.split": { + "chrome": "50", + "firefox": "49", + "safari": "10", + "node": "6", + "ios": "10", + "opera": "37", + "electron": "1.1" + }, + "es6.regexp.search": { + "chrome": "50", + "firefox": "49", + "safari": "10", + "node": "6", + "ios": "10", + "opera": "37", + "electron": "1.1" + }, + "es6.regexp.to-string": { + "chrome": "50", + "firefox": "39", + "safari": "10", + "node": "6", + "ios": "10", + "opera": "37", + "electron": "1.1" + }, + "es6.set": { + "chrome": "51", + "edge": "15", + "firefox": "53", + "safari": "10", + "node": "6.5", + "ios": "10", + "opera": "38", + "electron": "1.2" + }, + "es6.symbol": { + "chrome": "51", + "firefox": "51", + "safari": "10", + "node": "6.5", + "ios": "10", + "opera": "38", + "electron": "1.2" + }, + "es7.symbol.async-iterator": { + "chrome": "63", + "firefox": "57", + "safari": "tp", + "opera": "50" + }, + "es6.string.anchor": { + "chrome": "5", + "edge": "12", + "firefox": "17", + "safari": "6", + "node": "0.12", + "android": "4.0", + "ios": "7", + "electron": "1.1" + }, + "es6.string.big": { + "chrome": "5", + "edge": "12", + "firefox": "17", + "safari": "6", + "node": "0.12", + "android": "4.0", + "ios": "7", + "electron": "1.1" + }, + "es6.string.blink": { + "chrome": "5", + "edge": "12", + "firefox": "17", + "safari": "6", + "node": "0.12", + "android": "4.0", + "ios": "7", + "electron": "1.1" + }, + "es6.string.bold": { + "chrome": "5", + "edge": "12", + "firefox": "17", + "safari": "6", + "node": "0.12", + "android": "4.0", + "ios": "7", + "electron": "1.1" + }, + "es6.string.code-point-at": { + "chrome": "41", + "edge": "12", + "firefox": "29", + "safari": "9", + "node": "4", + "ios": "9", + "opera": "28", + "electron": "0.24" + }, + "es6.string.ends-with": { + "chrome": "41", + "edge": "12", + "firefox": "29", + "safari": "9", + "node": "4", + "ios": "9", + "opera": "28", + "electron": "0.24" + }, + "es6.string.fixed": { + "chrome": "5", + "edge": "12", + "firefox": "17", + "safari": "6", + "node": "0.12", + "android": "4.0", + "ios": "7", + "electron": "1.1" + }, + "es6.string.fontcolor": { + "chrome": "5", + "edge": "12", + "firefox": "17", + "safari": "6", + "node": "0.12", + "android": "4.0", + "ios": "7", + "electron": "1.1" + }, + "es6.string.fontsize": { + "chrome": "5", + "edge": "12", + "firefox": "17", + "safari": "6", + "node": "0.12", + "android": "4.0", + "ios": "7", + "electron": "1.1" + }, + "es6.string.from-code-point": { + "chrome": "41", + "edge": "12", + "firefox": "29", + "safari": "9", + "node": "4", + "ios": "9", + "opera": "28", + "electron": "0.24" + }, + "es6.string.includes": { + "chrome": "41", + "edge": "12", + "firefox": "40", + "safari": "9", + "node": "4", + "ios": "9", + "opera": "28", + "electron": "0.24" + }, + "es6.string.italics": { + "chrome": "5", + "edge": "12", + "firefox": "17", + "safari": "6", + "node": "0.12", + "android": "4.0", + "ios": "7", + "electron": "1.1" + }, + "es6.string.iterator": { + "chrome": "5", + "opera": "10.10", + "edge": "12", + "firefox": "2", + "safari": "3.1", + "node": "0.10", + "ie": "8", + "android": "4.0", + "ios": "6", + "electron": "1.1" + }, + "es6.string.link": { + "chrome": "5", + "edge": "12", + "firefox": "17", + "safari": "6", + "node": "0.12", + "android": "4.0", + "ios": "7", + "electron": "1.1" + }, + "es7.string.pad-start": { + "chrome": "57", + "edge": "15", + "firefox": "48", + "safari": "10", + "node": "8", + "ios": "10", + "opera": "44", + "electron": "1.7" + }, + "es7.string.pad-end": { + "chrome": "57", + "edge": "15", + "firefox": "48", + "safari": "10", + "node": "8", + "ios": "10", + "opera": "44", + "electron": "1.7" + }, + "es6.string.raw": { + "chrome": "41", + "edge": "12", + "firefox": "34", + "safari": "9", + "node": "4", + "ios": "9", + "opera": "28", + "electron": "0.24" + }, + "es6.string.repeat": { + "chrome": "41", + "edge": "12", + "firefox": "24", + "safari": "9", + "node": "4", + "ios": "9", + "opera": "28", + "electron": "0.24" + }, + "es6.string.small": { + "chrome": "5", + "edge": "12", + "firefox": "17", + "safari": "6", + "node": "0.12", + "android": "4.0", + "ios": "7", + "electron": "1.1" + }, + "es6.string.starts-with": { + "chrome": "41", + "edge": "12", + "firefox": "29", + "safari": "9", + "node": "4", + "ios": "9", + "opera": "28", + "electron": "0.24" + }, + "es6.string.strike": { + "chrome": "5", + "edge": "12", + "firefox": "17", + "safari": "6", + "node": "0.12", + "android": "4.0", + "ios": "7", + "electron": "1.1" + }, + "es6.string.sub": { + "chrome": "5", + "edge": "12", + "firefox": "17", + "safari": "6", + "node": "0.12", + "android": "4.0", + "ios": "7", + "electron": "1.1" + }, + "es6.string.sup": { + "chrome": "5", + "edge": "12", + "firefox": "17", + "safari": "6", + "node": "0.12", + "android": "4.0", + "ios": "7", + "electron": "1.1" + }, + "es6.string.trim": { + "chrome": "5", + "opera": "10.50", + "edge": "12", + "firefox": "3.5", + "safari": "4", + "node": "0.10", + "ie": "9", + "android": "4.0", + "ios": "6", + "electron": "1.1" + }, + "es6.typed.array-buffer": { + "chrome": "51", + "edge": "13", + "firefox": "48", + "safari": "10", + "node": "6.5", + "ios": "10", + "opera": "38", + "electron": "1.2" + }, + "es6.typed.data-view": { + "chrome": "5", + "opera": "12", + "edge": "12", + "firefox": "15", + "safari": "5.1", + "node": "0.12", + "ie": "10", + "android": "4.0", + "ios": "6", + "electron": "1.1" + }, + "es6.typed.int8-array": { + "chrome": "51", + "edge": "13", + "firefox": "48", + "safari": "10", + "node": "6.5", + "ios": "10", + "opera": "38", + "electron": "1.2" + }, + "es6.typed.uint8-array": { + "chrome": "51", + "edge": "13", + "firefox": "48", + "safari": "10", + "node": "6.5", + "ios": "10", + "opera": "38", + "electron": "1.2" + }, + "es6.typed.uint8-clamped-array": { + "chrome": "51", + "edge": "13", + "firefox": "48", + "safari": "10", + "node": "6.5", + "ios": "10", + "opera": "38", + "electron": "1.2" + }, + "es6.typed.int16-array": { + "chrome": "51", + "edge": "13", + "firefox": "48", + "safari": "10", + "node": "6.5", + "ios": "10", + "opera": "38", + "electron": "1.2" + }, + "es6.typed.uint16-array": { + "chrome": "51", + "edge": "13", + "firefox": "48", + "safari": "10", + "node": "6.5", + "ios": "10", + "opera": "38", + "electron": "1.2" + }, + "es6.typed.int32-array": { + "chrome": "51", + "edge": "13", + "firefox": "48", + "safari": "10", + "node": "6.5", + "ios": "10", + "opera": "38", + "electron": "1.2" + }, + "es6.typed.uint32-array": { + "chrome": "51", + "edge": "13", + "firefox": "48", + "safari": "10", + "node": "6.5", + "ios": "10", + "opera": "38", + "electron": "1.2" + }, + "es6.typed.float32-array": { + "chrome": "51", + "edge": "13", + "firefox": "48", + "safari": "10", + "node": "6.5", + "ios": "10", + "opera": "38", + "electron": "1.2" + }, + "es6.typed.float64-array": { + "chrome": "51", + "edge": "13", + "firefox": "48", + "safari": "10", + "node": "6.5", + "ios": "10", + "opera": "38", + "electron": "1.2" + }, + "es6.weak-map": { + "chrome": "51", + "edge": "15", + "firefox": "53", + "safari": "9", + "node": "6.5", + "ios": "9", + "opera": "38", + "electron": "1.2" + }, + "es6.weak-set": { + "chrome": "51", + "edge": "15", + "firefox": "53", + "safari": "9", + "node": "6.5", + "ios": "9", + "opera": "38", + "electron": "1.2" + } +} diff --git a/node_modules/@babel/preset-env/data/plugin-features.js b/node_modules/@babel/preset-env/data/plugin-features.js new file mode 100644 index 00000000..eb417db7 --- /dev/null +++ b/node_modules/@babel/preset-env/data/plugin-features.js @@ -0,0 +1,96 @@ +const es2015 = { + "transform-template-literals": { + features: ["template literals"], + }, + "transform-literals": { + features: ["Unicode code point escapes"], + }, + "transform-function-name": { + features: ['function "name" property'], + }, + "transform-arrow-functions": { + features: ["arrow functions"], + }, + "transform-block-scoped-functions": { + features: ["block-level function declaration"], + }, + "transform-classes": { + features: ["class", "super"], + }, + "transform-object-super": { + features: ["super"], + }, + "transform-shorthand-properties": { + features: ["object literal extensions / shorthand properties"], + }, + "transform-duplicate-keys": { + features: ["miscellaneous / duplicate property names in strict mode"], + }, + "transform-computed-properties": { + features: ["object literal extensions / computed properties"], + }, + "transform-for-of": { + features: ["for..of loops"], + }, + "transform-sticky-regex": { + features: [ + 'RegExp "y" and "u" flags / "y" flag, lastIndex', + 'RegExp "y" and "u" flags / "y" flag', + ], + }, + "transform-unicode-regex": { + features: [ + 'RegExp "y" and "u" flags / "u" flag, case folding', + 'RegExp "y" and "u" flags / "u" flag, Unicode code point escapes', + 'RegExp "y" and "u" flags / "u" flag', + ], + }, + "transform-spread": { + features: ["spread (...) operator"], + }, + "transform-parameters": { + features: ["default function parameters", "rest parameters"], + }, + "transform-destructuring": { + features: [ + "destructuring, assignment", + "destructuring, declarations", + "destructuring, parameters", + ], + }, + "transform-block-scoping": { + features: ["const", "let"], + }, + "transform-typeof-symbol": { + features: ["Symbol / typeof support"], + }, + "transform-new-target": { + features: ["new.target"], + }, + "transform-regenerator": { + features: ["generators"], + }, +}; + +const es2016 = { + "transform-exponentiation-operator": { + features: ["exponentiation (**) operator"], + }, +}; + +const es2017 = { + "transform-async-to-generator": { + features: ["async functions"], + }, +}; + +const es2018 = { + "proposal-async-generator-functions": "Asynchronous Iterators", + "proposal-object-rest-spread": "object rest/spread properties", + "proposal-unicode-property-regex": "RegExp Unicode Property Escapes", + "transform-dotall-regex": "s (dotAll) flag for regular expressions", +}; + +const proposals = require("./shipped-proposals").features; + +module.exports = Object.assign({}, es2015, es2016, es2017, es2018, proposals); diff --git a/node_modules/@babel/preset-env/data/plugins.json b/node_modules/@babel/preset-env/data/plugins.json new file mode 100644 index 00000000..204b3a79 --- /dev/null +++ b/node_modules/@babel/preset-env/data/plugins.json @@ -0,0 +1,256 @@ +{ + "transform-template-literals": { + "chrome": "41", + "edge": "13", + "firefox": "34", + "safari": "9", + "node": "4", + "ios": "9", + "opera": "28", + "electron": "0.24" + }, + "transform-literals": { + "chrome": "44", + "edge": "12", + "firefox": "53", + "safari": "9", + "node": "4", + "ios": "9", + "opera": "31", + "electron": "0.31" + }, + "transform-function-name": { + "chrome": "51", + "firefox": "53", + "safari": "10", + "node": "6.5", + "ios": "10", + "opera": "38", + "electron": "1.2" + }, + "transform-arrow-functions": { + "chrome": "47", + "edge": "13", + "firefox": "45", + "safari": "10", + "node": "6", + "ios": "10", + "opera": "34", + "electron": "0.36" + }, + "transform-block-scoped-functions": { + "chrome": "41", + "edge": "12", + "firefox": "46", + "safari": "10", + "node": "4", + "ie": "11", + "ios": "10", + "opera": "28", + "electron": "0.24" + }, + "transform-classes": { + "chrome": "46", + "edge": "13", + "firefox": "45", + "safari": "10", + "node": "5", + "ios": "10", + "opera": "33", + "electron": "0.36" + }, + "transform-object-super": { + "chrome": "46", + "edge": "13", + "firefox": "45", + "safari": "10", + "node": "5", + "ios": "10", + "opera": "33", + "electron": "0.36" + }, + "transform-shorthand-properties": { + "chrome": "43", + "edge": "12", + "firefox": "33", + "safari": "9", + "node": "4", + "ios": "9", + "opera": "30", + "electron": "0.29" + }, + "transform-duplicate-keys": { + "chrome": "42", + "edge": "12", + "firefox": "34", + "safari": "9", + "node": "4", + "ios": "9", + "opera": "29", + "electron": "0.27" + }, + "transform-computed-properties": { + "chrome": "44", + "edge": "12", + "firefox": "34", + "safari": "7.1", + "node": "4", + "ios": "8", + "opera": "31", + "electron": "0.31" + }, + "transform-for-of": { + "chrome": "51", + "edge": "15", + "firefox": "53", + "safari": "10", + "node": "6.5", + "ios": "10", + "opera": "38", + "electron": "1.2" + }, + "transform-sticky-regex": { + "chrome": "49", + "edge": "13", + "firefox": "3", + "safari": "10", + "node": "6", + "ios": "10", + "opera": "36", + "electron": "1" + }, + "transform-unicode-regex": { + "chrome": "50", + "edge": "13", + "firefox": "46", + "safari": "10", + "node": "6", + "ios": "10", + "opera": "37", + "electron": "1.1" + }, + "transform-spread": { + "chrome": "46", + "edge": "13", + "firefox": "36", + "safari": "10", + "node": "5", + "ios": "10", + "opera": "33", + "electron": "0.36" + }, + "transform-parameters": { + "chrome": "49", + "edge": "14", + "firefox": "53", + "safari": "10", + "node": "6", + "ios": "10", + "opera": "36", + "electron": "1" + }, + "transform-destructuring": { + "chrome": "51", + "firefox": "53", + "safari": "10", + "node": "6.5", + "ios": "10", + "opera": "38", + "electron": "1.2" + }, + "transform-block-scoping": { + "chrome": "49", + "edge": "14", + "firefox": "51", + "safari": "10", + "node": "6", + "ios": "10", + "opera": "36", + "electron": "1" + }, + "transform-typeof-symbol": { + "chrome": "38", + "edge": "12", + "firefox": "36", + "safari": "9", + "node": "0.12", + "ios": "9", + "opera": "25", + "electron": "0.2" + }, + "transform-new-target": { + "chrome": "46", + "edge": "14", + "firefox": "41", + "safari": "10", + "node": "5", + "ios": "10", + "opera": "33", + "electron": "0.36" + }, + "transform-regenerator": { + "chrome": "50", + "edge": "13", + "firefox": "53", + "safari": "10", + "node": "6", + "ios": "10", + "opera": "37", + "electron": "1.1" + }, + "transform-exponentiation-operator": { + "chrome": "52", + "edge": "14", + "firefox": "52", + "safari": "10.1", + "node": "7", + "ios": "10.3", + "opera": "39", + "electron": "1.3" + }, + "transform-async-to-generator": { + "chrome": "55", + "edge": "15", + "firefox": "52", + "safari": "10.1", + "node": "7.6", + "ios": "10.3", + "opera": "42", + "electron": "1.6" + }, + "proposal-async-generator-functions": { + "chrome": "63", + "firefox": "57", + "safari": "tp", + "opera": "50" + }, + "proposal-object-rest-spread": { + "chrome": "60", + "firefox": "55", + "safari": "11.1", + "node": "8.3", + "ios": "11.3", + "opera": "47", + "electron": "2" + }, + "proposal-unicode-property-regex": { + "chrome": "64", + "safari": "11.1", + "ios": "11.3", + "opera": "51" + }, + "transform-dotall-regex": { + "chrome": "62", + "safari": "11.1", + "node": "8.10", + "ios": "11.3", + "opera": "49" + }, + "proposal-optional-catch-binding": { + "chrome": "66", + "firefox": "58", + "safari": "11.1", + "ios": "11.3", + "opera": "53" + } +} diff --git a/node_modules/@babel/preset-env/data/shipped-proposals.js b/node_modules/@babel/preset-env/data/shipped-proposals.js new file mode 100644 index 00000000..23b74501 --- /dev/null +++ b/node_modules/@babel/preset-env/data/shipped-proposals.js @@ -0,0 +1,17 @@ +// These mappings represent the builtin/feature proposals that have been +// shipped by browsers, and are enabled by the `shippedProposals` option. + +const builtIns = {}; + +const features = { + "proposal-optional-catch-binding": "optional catch binding", +}; + +const pluginSyntaxMap = new Map([ + ["proposal-async-generator-functions", "syntax-async-generators"], + ["proposal-object-rest-spread", "syntax-object-rest-spread"], + ["proposal-optional-catch-binding", "syntax-optional-catch-binding"], + ["proposal-unicode-property-regex", null], +]); + +module.exports = { builtIns, features, pluginSyntaxMap }; diff --git a/node_modules/@babel/preset-env/data/unreleased-labels.js b/node_modules/@babel/preset-env/data/unreleased-labels.js new file mode 100644 index 00000000..bc513056 --- /dev/null +++ b/node_modules/@babel/preset-env/data/unreleased-labels.js @@ -0,0 +1,3 @@ +module.exports = { + safari: "tp", +}; diff --git a/node_modules/@babel/preset-env/lib/available-plugins.js b/node_modules/@babel/preset-env/lib/available-plugins.js new file mode 100644 index 00000000..d57c0f29 --- /dev/null +++ b/node_modules/@babel/preset-env/lib/available-plugins.js @@ -0,0 +1,43 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; +var _default = { + "syntax-async-generators": require("@babel/plugin-syntax-async-generators"), + "syntax-object-rest-spread": require("@babel/plugin-syntax-object-rest-spread"), + "syntax-optional-catch-binding": require("@babel/plugin-syntax-optional-catch-binding"), + "transform-async-to-generator": require("@babel/plugin-transform-async-to-generator"), + "proposal-async-generator-functions": require("@babel/plugin-proposal-async-generator-functions"), + "transform-arrow-functions": require("@babel/plugin-transform-arrow-functions"), + "transform-block-scoped-functions": require("@babel/plugin-transform-block-scoped-functions"), + "transform-block-scoping": require("@babel/plugin-transform-block-scoping"), + "transform-classes": require("@babel/plugin-transform-classes"), + "transform-computed-properties": require("@babel/plugin-transform-computed-properties"), + "transform-destructuring": require("@babel/plugin-transform-destructuring"), + "transform-dotall-regex": require("@babel/plugin-transform-dotall-regex"), + "transform-duplicate-keys": require("@babel/plugin-transform-duplicate-keys"), + "transform-for-of": require("@babel/plugin-transform-for-of"), + "transform-function-name": require("@babel/plugin-transform-function-name"), + "transform-literals": require("@babel/plugin-transform-literals"), + "transform-modules-amd": require("@babel/plugin-transform-modules-amd"), + "transform-modules-commonjs": require("@babel/plugin-transform-modules-commonjs"), + "transform-modules-systemjs": require("@babel/plugin-transform-modules-systemjs"), + "transform-modules-umd": require("@babel/plugin-transform-modules-umd"), + "transform-object-super": require("@babel/plugin-transform-object-super"), + "transform-parameters": require("@babel/plugin-transform-parameters"), + "transform-shorthand-properties": require("@babel/plugin-transform-shorthand-properties"), + "transform-spread": require("@babel/plugin-transform-spread"), + "transform-sticky-regex": require("@babel/plugin-transform-sticky-regex"), + "transform-template-literals": require("@babel/plugin-transform-template-literals"), + "transform-typeof-symbol": require("@babel/plugin-transform-typeof-symbol"), + "transform-unicode-regex": require("@babel/plugin-transform-unicode-regex"), + "transform-exponentiation-operator": require("@babel/plugin-transform-exponentiation-operator"), + "transform-new-target": require("@babel/plugin-transform-new-target"), + "proposal-object-rest-spread": require("@babel/plugin-proposal-object-rest-spread"), + "proposal-optional-catch-binding": require("@babel/plugin-proposal-optional-catch-binding"), + "transform-regenerator": require("@babel/plugin-transform-regenerator"), + "proposal-unicode-property-regex": require("@babel/plugin-proposal-unicode-property-regex") +}; +exports.default = _default;
\ No newline at end of file diff --git a/node_modules/@babel/preset-env/lib/built-in-definitions.js b/node_modules/@babel/preset-env/lib/built-in-definitions.js new file mode 100644 index 00000000..57e700b0 --- /dev/null +++ b/node_modules/@babel/preset-env/lib/built-in-definitions.js @@ -0,0 +1,168 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.definitions = void 0; +const ArrayNatureIterators = ["es6.object.to-string", "es6.array.iterator", "web.dom.iterable"]; +const CommonIterators = ["es6.string.iterator"].concat(ArrayNatureIterators); +const definitions = { + builtins: { + DataView: "es6.typed.data-view", + Float32Array: "es6.typed.float32-array", + Float64Array: "es6.typed.float64-array", + Int8Array: "es6.typed.int8-array", + Int16Array: "es6.typed.int16-array", + Int32Array: "es6.typed.int32-array", + Map: ["es6.map"].concat(CommonIterators), + Number: "es6.number.constructor", + Promise: ["es6.object.to-string", "es6.promise"], + RegExp: ["es6.regexp.constructor"], + Set: ["es6.set"].concat(CommonIterators), + Symbol: ["es6.symbol", "es7.symbol.async-iterator"], + Uint8Array: "es6.typed.uint8-array", + Uint8ClampedArray: "es6.typed.uint8-clamped-array", + Uint16Array: "es6.typed.uint16-array", + Uint32Array: "es6.typed.uint32-array", + WeakMap: ["es6.weak-map"].concat(CommonIterators), + WeakSet: ["es6.weak-set"].concat(CommonIterators) + }, + instanceMethods: { + __defineGetter__: ["es7.object.define-getter"], + __defineSetter__: ["es7.object.define-setter"], + __lookupGetter__: ["es7.object.lookup-getter"], + __lookupSetter__: ["es7.object.lookup-setter"], + anchor: ["es6.string.anchor"], + big: ["es6.string.big"], + bind: ["es6.function.bind"], + blink: ["es6.string.blink"], + bold: ["es6.string.bold"], + codePointAt: ["es6.string.code-point-at"], + copyWithin: ["es6.array.copy-within"], + endsWith: ["es6.string.ends-with"], + entries: ArrayNatureIterators, + every: ["es6.array.is-array"], + fill: ["es6.array.fill"], + filter: ["es6.array.filter"], + find: ["es6.array.find"], + findIndex: ["es6.array.find-index"], + fixed: ["es6.string.fixed"], + flags: ["es6.regexp.flags"], + fontcolor: ["es6.string.fontcolor"], + fontsize: ["es6.string.fontsize"], + forEach: ["es6.array.for-each", "web.dom.iterable"], + includes: ["es6.string.includes", "es7.array.includes"], + indexOf: ["es6.array.index-of"], + italics: ["es6.string.italics"], + keys: ArrayNatureIterators, + lastIndexOf: ["es6.array.last-index-of"], + link: ["es6.string.link"], + map: ["es6.array.map"], + match: ["es6.regexp.match"], + name: ["es6.function.name"], + padStart: ["es7.string.pad-start"], + padEnd: ["es7.string.pad-end"], + reduce: ["es6.array.reduce"], + reduceRight: ["es6.array.reduce-right"], + repeat: ["es6.string.repeat"], + replace: ["es6.regexp.replace"], + search: ["es6.regexp.search"], + slice: ["es6.array.slice"], + small: ["es6.string.small"], + some: ["es6.array.some"], + sort: ["es6.array.sort"], + split: ["es6.regexp.split"], + startsWith: ["es6.string.starts-with"], + strike: ["es6.string.strike"], + sub: ["es6.string.sub"], + sup: ["es6.string.sup"], + toISOString: ["es6.date.to-iso-string"], + toJSON: ["es6.date.to-json"], + toString: ["es6.object.to-string", "es6.date.to-string", "es6.regexp.to-string"], + trim: ["es6.string.trim"], + values: ArrayNatureIterators + }, + staticMethods: { + Array: { + from: ["es6.array.from", "es6.string.iterator"], + isArray: "es6.array.is-array", + of: "es6.array.of" + }, + Date: { + now: "es6.date.now" + }, + Object: { + assign: "es6.object.assign", + create: "es6.object.create", + defineProperty: "es6.object.define-property", + defineProperties: "es6.object.define-properties", + entries: "es7.object.entries", + freeze: "es6.object.freeze", + getOwnPropertyDescriptors: "es7.object.get-own-property-descriptors", + getOwnPropertySymbols: "es6.object.get-own-property-symbols", + is: "es6.object.is", + isExtensible: "es6.object.is-extensible", + isFrozen: "es6.object.is-frozen", + isSealed: "es6.object.is-sealed", + keys: "es6.object.keys", + preventExtensions: "es6.object.prevent-extensions", + seal: "es6.object.seal", + setPrototypeOf: "es6.object.set-prototype-of", + values: "es7.object.values" + }, + Math: { + acosh: "es6.math.acosh", + asinh: "es6.math.asinh", + atanh: "es6.math.atanh", + cbrt: "es6.math.cbrt", + clz32: "es6.math.clz32", + cosh: "es6.math.cosh", + expm1: "es6.math.expm1", + fround: "es6.math.fround", + hypot: "es6.math.hypot", + imul: "es6.math.imul", + log1p: "es6.math.log1p", + log10: "es6.math.log10", + log2: "es6.math.log2", + sign: "es6.math.sign", + sinh: "es6.math.sinh", + tanh: "es6.math.tanh", + trunc: "es6.math.trunc" + }, + String: { + fromCodePoint: "es6.string.from-code-point", + raw: "es6.string.raw" + }, + Number: { + EPSILON: "es6.number.epsilon", + MIN_SAFE_INTEGER: "es6.number.min-safe-integer", + MAX_SAFE_INTEGER: "es6.number.max-safe-integer", + isFinite: "es6.number.is-finite", + isInteger: "es6.number.is-integer", + isSafeInteger: "es6.number.is-safe-integer", + isNaN: "es6.number.is-nan", + parseFloat: "es6.number.parse-float", + parseInt: "es6.number.parse-int" + }, + Promise: { + all: CommonIterators, + race: CommonIterators + }, + Reflect: { + apply: "es6.reflect.apply", + construct: "es6.reflect.construct", + defineProperty: "es6.reflect.define-property", + deleteProperty: "es6.reflect.delete-property", + get: "es6.reflect.get", + getOwnPropertyDescriptor: "es6.reflect.get-own-property-descriptor", + getPrototypeOf: "es6.reflect.get-prototype-of", + has: "es6.reflect.has", + isExtensible: "es6.reflect.is-extensible", + ownKeys: "es6.reflect.own-keys", + preventExtensions: "es6.reflect.prevent-extensions", + set: "es6.reflect.set", + setPrototypeOf: "es6.reflect.set-prototype-of" + } + } +}; +exports.definitions = definitions;
\ No newline at end of file diff --git a/node_modules/@babel/preset-env/lib/debug.js b/node_modules/@babel/preset-env/lib/debug.js new file mode 100644 index 00000000..57bd263d --- /dev/null +++ b/node_modules/@babel/preset-env/lib/debug.js @@ -0,0 +1,91 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.logUsagePolyfills = exports.logEntryPolyfills = exports.logPlugin = exports.logMessage = void 0; + +function _semver() { + const data = _interopRequireDefault(require("semver")); + + _semver = function _semver() { + return data; + }; + + return data; +} + +var _utils = require("./utils"); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +const wordEnds = size => { + return size > 1 ? "s" : ""; +}; + +const logMessage = (message, context) => { + const pre = context ? `[${context}] ` : ""; + const logStr = ` ${pre}${message}`; + console.log(logStr); +}; + +exports.logMessage = logMessage; + +const logPlugin = (item, targetVersions, list, context) => { + const minVersions = list[item] || {}; + const filteredList = Object.keys(targetVersions).reduce((result, env) => { + const minVersion = minVersions[env]; + const targetVersion = targetVersions[env]; + + if (!minVersion) { + result[env] = (0, _utils.prettifyVersion)(targetVersion); + } else { + const minIsUnreleased = (0, _utils.isUnreleasedVersion)(minVersion, env); + const targetIsUnreleased = (0, _utils.isUnreleasedVersion)(targetVersion, env); + + if (!targetIsUnreleased && (minIsUnreleased || _semver().default.lt(targetVersion, (0, _utils.semverify)(minVersion)))) { + result[env] = (0, _utils.prettifyVersion)(targetVersion); + } + } + + return result; + }, {}); + const formattedTargets = JSON.stringify(filteredList).replace(/,/g, ", ").replace(/^\{"/, '{ "').replace(/"\}$/, '" }'); + logMessage(`${item} ${formattedTargets}`, context); +}; + +exports.logPlugin = logPlugin; + +const logEntryPolyfills = (importPolyfillIncluded, polyfills, filename, onDebug) => { + if (!importPolyfillIncluded) { + console.log(` +[${filename}] \`import '@babel/polyfill'\` was not found.`); + return; + } + + if (!polyfills.size) { + console.log(` +[${filename}] Based on your targets, none were added.`); + return; + } + + console.log(` +[${filename}] Replaced \`@babel/polyfill\` with the following polyfill${wordEnds(polyfills.size)}:`); + onDebug(polyfills); +}; + +exports.logEntryPolyfills = logEntryPolyfills; + +const logUsagePolyfills = (polyfills, filename, onDebug) => { + if (!polyfills.size) { + console.log(` +[${filename}] Based on your code and targets, none were added.`); + return; + } + + console.log(` +[${filename}] Added following polyfill${wordEnds(polyfills.size)}:`); + onDebug(polyfills); +}; + +exports.logUsagePolyfills = logUsagePolyfills;
\ No newline at end of file diff --git a/node_modules/@babel/preset-env/lib/default-includes.js b/node_modules/@babel/preset-env/lib/default-includes.js new file mode 100644 index 00000000..0579abfb --- /dev/null +++ b/node_modules/@babel/preset-env/lib/default-includes.js @@ -0,0 +1,8 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.defaultWebIncludes = void 0; +const defaultWebIncludes = ["web.timers", "web.immediate", "web.dom.iterable"]; +exports.defaultWebIncludes = defaultWebIncludes;
\ No newline at end of file diff --git a/node_modules/@babel/preset-env/lib/defaults.js b/node_modules/@babel/preset-env/lib/defaults.js new file mode 100644 index 00000000..e1d714b7 --- /dev/null +++ b/node_modules/@babel/preset-env/lib/defaults.js @@ -0,0 +1,29 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.getOptionSpecificExcludesFor = exports.getPlatformSpecificDefaultFor = void 0; +const defaultWebIncludes = ["web.timers", "web.immediate", "web.dom.iterable"]; +const defaultExcludesForLooseMode = ["transform-typeof-symbol"]; + +const getPlatformSpecificDefaultFor = targets => { + const targetNames = Object.keys(targets); + const isAnyTarget = !targetNames.length; + const isWebTarget = targetNames.some(name => name !== "node"); + return isAnyTarget || isWebTarget ? defaultWebIncludes : null; +}; + +exports.getPlatformSpecificDefaultFor = getPlatformSpecificDefaultFor; + +const getOptionSpecificExcludesFor = ({ + loose +}) => { + if (loose) { + return defaultExcludesForLooseMode; + } + + return null; +}; + +exports.getOptionSpecificExcludesFor = getOptionSpecificExcludesFor;
\ No newline at end of file diff --git a/node_modules/@babel/preset-env/lib/index.js b/node_modules/@babel/preset-env/lib/index.js new file mode 100644 index 00000000..cbf730f1 --- /dev/null +++ b/node_modules/@babel/preset-env/lib/index.js @@ -0,0 +1,253 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = exports.transformIncludesAndExcludes = exports.isPluginRequired = void 0; + +function _semver() { + const data = _interopRequireDefault(require("semver")); + + _semver = function _semver() { + return data; + }; + + return data; +} + +var _builtIns = _interopRequireDefault(require("../data/built-ins.json")); + +var _debug = require("./debug"); + +var _defaults = require("./defaults"); + +var _moduleTransformations = _interopRequireDefault(require("./module-transformations")); + +var _normalizeOptions2 = _interopRequireDefault(require("./normalize-options.js")); + +var _plugins = _interopRequireDefault(require("../data/plugins.json")); + +var _shippedProposals = require("../data/shipped-proposals.js"); + +var _useBuiltInsEntryPlugin = _interopRequireDefault(require("./use-built-ins-entry-plugin")); + +var _useBuiltInsPlugin = _interopRequireDefault(require("./use-built-ins-plugin")); + +var _targetsParser = _interopRequireDefault(require("./targets-parser")); + +var _availablePlugins = _interopRequireDefault(require("./available-plugins")); + +var _utils = require("./utils"); + +function _helperPluginUtils() { + const data = require("@babel/helper-plugin-utils"); + + _helperPluginUtils = function _helperPluginUtils() { + return data; + }; + + return data; +} + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +const getPlugin = pluginName => { + const plugin = _availablePlugins.default[pluginName]; + + if (!plugin) { + throw new Error(`Could not find plugin "${pluginName}". Ensure there is an entry in ./available-plugins.js for it.`); + } + + return plugin; +}; + +const builtInsListWithoutProposals = (0, _utils.filterStageFromList)(_builtIns.default, _shippedProposals.builtIns); +const pluginListWithoutProposals = (0, _utils.filterStageFromList)(_plugins.default, _shippedProposals.features); + +const isPluginRequired = (supportedEnvironments, plugin) => { + const targetEnvironments = Object.keys(supportedEnvironments); + + if (targetEnvironments.length === 0) { + return true; + } + + const isRequiredForEnvironments = targetEnvironments.filter(environment => { + if (!plugin[environment]) { + return true; + } + + const lowestImplementedVersion = plugin[environment]; + const lowestTargetedVersion = supportedEnvironments[environment]; + + if ((0, _utils.isUnreleasedVersion)(lowestTargetedVersion, environment)) { + return false; + } else if ((0, _utils.isUnreleasedVersion)(lowestImplementedVersion, environment)) { + return true; + } + + if (!_semver().default.valid(lowestTargetedVersion)) { + throw new Error(`Invalid version passed for target "${environment}": "${lowestTargetedVersion}". ` + "Versions must be in semver format (major.minor.patch)"); + } + + return _semver().default.gt((0, _utils.semverify)(lowestImplementedVersion), lowestTargetedVersion); + }); + return isRequiredForEnvironments.length > 0; +}; + +exports.isPluginRequired = isPluginRequired; + +const getBuiltInTargets = targets => { + const builtInTargets = Object.assign({}, targets); + + if (builtInTargets.uglify != null) { + delete builtInTargets.uglify; + } + + return builtInTargets; +}; + +const transformIncludesAndExcludes = opts => { + return opts.reduce((result, opt) => { + const target = opt.match(/^(es\d+|web)\./) ? "builtIns" : "plugins"; + result[target].add(opt); + return result; + }, { + all: opts, + plugins: new Set(), + builtIns: new Set() + }); +}; + +exports.transformIncludesAndExcludes = transformIncludesAndExcludes; + +const filterItems = (list, includes, excludes, targets, defaultIncludes, defaultExcludes) => { + const result = new Set(); + + for (const item in list) { + if (!excludes.has(item) && (isPluginRequired(targets, list[item]) || includes.has(item))) { + result.add(item); + } else { + const shippedProposalsSyntax = _shippedProposals.pluginSyntaxMap.get(item); + + if (shippedProposalsSyntax) { + result.add(shippedProposalsSyntax); + } + } + } + + if (defaultIncludes) { + defaultIncludes.forEach(item => !excludes.has(item) && result.add(item)); + } + + if (defaultExcludes) { + defaultExcludes.forEach(item => !includes.has(item) && result.delete(item)); + } + + return result; +}; + +var _default = (0, _helperPluginUtils().declare)((api, opts) => { + api.assertVersion(7); + + const _normalizeOptions = (0, _normalizeOptions2.default)(opts), + configPath = _normalizeOptions.configPath, + debug = _normalizeOptions.debug, + optionsExclude = _normalizeOptions.exclude, + forceAllTransforms = _normalizeOptions.forceAllTransforms, + ignoreBrowserslistConfig = _normalizeOptions.ignoreBrowserslistConfig, + optionsInclude = _normalizeOptions.include, + loose = _normalizeOptions.loose, + modules = _normalizeOptions.modules, + shippedProposals = _normalizeOptions.shippedProposals, + spec = _normalizeOptions.spec, + optionsTargets = _normalizeOptions.targets, + useBuiltIns = _normalizeOptions.useBuiltIns; + + let hasUglifyTarget = false; + + if (optionsTargets && optionsTargets.uglify) { + hasUglifyTarget = true; + delete optionsTargets.uglify; + console.log(""); + console.log("The uglify target has been deprecated. Set the top level"); + console.log("option `forceAllTransforms: true` instead."); + console.log(""); + } + + if (optionsTargets && optionsTargets.esmodules && optionsTargets.browsers) { + console.log(""); + console.log("@babel/preset-env: esmodules and browsers targets have been specified together."); + console.log(`\`browsers\` target, \`${optionsTargets.browsers}\` will be ignored.`); + console.log(""); + } + + const targets = (0, _targetsParser.default)(optionsTargets, { + ignoreBrowserslistConfig, + configPath + }); + const include = transformIncludesAndExcludes(optionsInclude); + const exclude = transformIncludesAndExcludes(optionsExclude); + const transformTargets = forceAllTransforms || hasUglifyTarget ? {} : targets; + const transformations = filterItems(shippedProposals ? _plugins.default : pluginListWithoutProposals, include.plugins, exclude.plugins, transformTargets, null, (0, _defaults.getOptionSpecificExcludesFor)({ + loose + })); + let polyfills; + let polyfillTargets; + + if (useBuiltIns) { + polyfillTargets = getBuiltInTargets(targets); + polyfills = filterItems(shippedProposals ? _builtIns.default : builtInsListWithoutProposals, include.builtIns, exclude.builtIns, polyfillTargets, (0, _defaults.getPlatformSpecificDefaultFor)(polyfillTargets)); + } + + const plugins = []; + const pluginUseBuiltIns = useBuiltIns !== false; + + if (modules !== false && _moduleTransformations.default[modules]) { + plugins.push([getPlugin(_moduleTransformations.default[modules]), { + loose + }]); + } + + transformations.forEach(pluginName => plugins.push([getPlugin(pluginName), { + spec, + loose, + useBuiltIns: pluginUseBuiltIns + }])); + const regenerator = transformations.has("transform-regenerator"); + + if (debug) { + console.log("@babel/preset-env: `DEBUG` option"); + console.log("\nUsing targets:"); + console.log(JSON.stringify((0, _utils.prettifyTargets)(targets), null, 2)); + console.log(`\nUsing modules transform: ${modules.toString()}`); + console.log("\nUsing plugins:"); + transformations.forEach(transform => { + (0, _debug.logPlugin)(transform, targets, _plugins.default); + }); + + if (!useBuiltIns) { + console.log("\nUsing polyfills: No polyfills were added, since the `useBuiltIns` option was not set."); + } else { + console.log(` +Using polyfills with \`${useBuiltIns}\` option:`); + } + } + + if (useBuiltIns === "usage" || useBuiltIns === "entry") { + const pluginOptions = { + debug, + polyfills, + regenerator, + onDebug: (polyfills, context) => { + polyfills.forEach(polyfill => (0, _debug.logPlugin)(polyfill, polyfillTargets, _builtIns.default, context)); + } + }; + plugins.push([useBuiltIns === "usage" ? _useBuiltInsPlugin.default : _useBuiltInsEntryPlugin.default, pluginOptions]); + } + + return { + plugins + }; +}); + +exports.default = _default;
\ No newline at end of file diff --git a/node_modules/@babel/preset-env/lib/module-transformations.js b/node_modules/@babel/preset-env/lib/module-transformations.js new file mode 100644 index 00000000..f565785a --- /dev/null +++ b/node_modules/@babel/preset-env/lib/module-transformations.js @@ -0,0 +1,14 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; +var _default = { + amd: "transform-modules-amd", + commonjs: "transform-modules-commonjs", + cjs: "transform-modules-commonjs", + systemjs: "transform-modules-systemjs", + umd: "transform-modules-umd" +}; +exports.default = _default;
\ No newline at end of file diff --git a/node_modules/@babel/preset-env/lib/normalize-options.js b/node_modules/@babel/preset-env/lib/normalize-options.js new file mode 100644 index 00000000..178795a3 --- /dev/null +++ b/node_modules/@babel/preset-env/lib/normalize-options.js @@ -0,0 +1,152 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = normalizeOptions; +exports.validateUseBuiltInsOption = exports.objectToBrowserslist = exports.validateModulesOption = exports.validateIgnoreBrowserslistConfig = exports.validateBoolOption = exports.validateConfigPathOption = exports.checkDuplicateIncludeExcludes = exports.normalizePluginName = void 0; + +function _invariant() { + const data = _interopRequireDefault(require("invariant")); + + _invariant = function _invariant() { + return data; + }; + + return data; +} + +function _browserslist() { + const data = _interopRequireDefault(require("browserslist")); + + _browserslist = function _browserslist() { + return data; + }; + + return data; +} + +var _builtIns = _interopRequireDefault(require("../data/built-ins.json")); + +var _defaultIncludes = require("./default-includes"); + +var _moduleTransformations = _interopRequireDefault(require("./module-transformations")); + +var _plugins = _interopRequireDefault(require("../data/plugins.json")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +const validIncludesAndExcludes = new Set([...Object.keys(_plugins.default), ...Object.keys(_moduleTransformations.default).map(m => _moduleTransformations.default[m]), ...Object.keys(_builtIns.default), ..._defaultIncludes.defaultWebIncludes]); + +const pluginToRegExp = plugin => { + if (plugin instanceof RegExp) return plugin; + + try { + return new RegExp(`^${normalizePluginName(plugin)}$`); + } catch (e) { + return null; + } +}; + +const selectPlugins = regexp => Array.from(validIncludesAndExcludes).filter(item => regexp instanceof RegExp && regexp.test(item)); + +const flatten = array => [].concat(...array); + +const expandIncludesAndExcludes = (plugins = [], type) => { + if (plugins.length === 0) return []; + const selectedPlugins = plugins.map(plugin => selectPlugins(pluginToRegExp(plugin))); + const invalidRegExpList = plugins.filter((p, i) => selectedPlugins[i].length === 0); + (0, _invariant().default)(invalidRegExpList.length === 0, `Invalid Option: The plugins/built-ins '${invalidRegExpList.join(", ")}' passed to the '${type}' option are not + valid. Please check data/[plugin-features|built-in-features].js in babel-preset-env`); + return flatten(selectedPlugins); +}; + +const validBrowserslistTargets = [...Object.keys(_browserslist().default.data), ...Object.keys(_browserslist().default.aliases)]; + +const normalizePluginName = plugin => plugin.replace(/^babel-plugin-/, ""); + +exports.normalizePluginName = normalizePluginName; + +const checkDuplicateIncludeExcludes = (include = [], exclude = []) => { + const duplicates = include.filter(opt => exclude.indexOf(opt) >= 0); + (0, _invariant().default)(duplicates.length === 0, `Invalid Option: The plugins/built-ins '${duplicates.join(", ")}' were found in both the "include" and + "exclude" options.`); +}; + +exports.checkDuplicateIncludeExcludes = checkDuplicateIncludeExcludes; + +const validateConfigPathOption = (configPath = process.cwd()) => { + (0, _invariant().default)(typeof configPath === "string", `Invalid Option: The configPath option '${configPath}' is invalid, only strings are allowed.`); + return configPath; +}; + +exports.validateConfigPathOption = validateConfigPathOption; + +const validateBoolOption = (name, value, defaultValue) => { + if (typeof value === "undefined") { + value = defaultValue; + } + + if (typeof value !== "boolean") { + throw new Error(`Preset env: '${name}' option must be a boolean.`); + } + + return value; +}; + +exports.validateBoolOption = validateBoolOption; + +const validateIgnoreBrowserslistConfig = ignoreBrowserslistConfig => validateBoolOption("ignoreBrowserslistConfig", ignoreBrowserslistConfig, false); + +exports.validateIgnoreBrowserslistConfig = validateIgnoreBrowserslistConfig; + +const validateModulesOption = (modulesOpt = "commonjs") => { + (0, _invariant().default)(modulesOpt === false || Object.keys(_moduleTransformations.default).indexOf(modulesOpt) > -1, `Invalid Option: The 'modules' option must be either 'false' to indicate no modules, or a + module type which can be be one of: 'commonjs' (default), 'amd', 'umd', 'systemjs'.`); + return modulesOpt; +}; + +exports.validateModulesOption = validateModulesOption; + +const objectToBrowserslist = object => { + return Object.keys(object).reduce((list, targetName) => { + if (validBrowserslistTargets.indexOf(targetName) >= 0) { + const targetVersion = object[targetName]; + return list.concat(`${targetName} ${targetVersion}`); + } + + return list; + }, []); +}; + +exports.objectToBrowserslist = objectToBrowserslist; + +const validateUseBuiltInsOption = (builtInsOpt = false) => { + (0, _invariant().default)(builtInsOpt === "usage" || builtInsOpt === false || builtInsOpt === "entry", `Invalid Option: The 'useBuiltIns' option must be either + 'false' (default) to indicate no polyfill, + '"entry"' to indicate replacing the entry polyfill, or + '"usage"' to import only used polyfills per file`); + return builtInsOpt; +}; + +exports.validateUseBuiltInsOption = validateUseBuiltInsOption; + +function normalizeOptions(opts) { + const include = expandIncludesAndExcludes(opts.include, "include"); + const exclude = expandIncludesAndExcludes(opts.exclude, "exclude"); + checkDuplicateIncludeExcludes(include, exclude); + return { + configPath: validateConfigPathOption(opts.configPath), + debug: opts.debug, + include, + exclude, + forceAllTransforms: validateBoolOption("forceAllTransforms", opts.forceAllTransforms, false), + ignoreBrowserslistConfig: validateIgnoreBrowserslistConfig(opts.ignoreBrowserslistConfig), + loose: validateBoolOption("loose", opts.loose, false), + modules: validateModulesOption(opts.modules), + shippedProposals: validateBoolOption("shippedProposals", opts.shippedProposals, false), + spec: validateBoolOption("loose", opts.spec, false), + targets: Object.assign({}, opts.targets), + useBuiltIns: validateUseBuiltInsOption(opts.useBuiltIns) + }; +}
\ No newline at end of file diff --git a/node_modules/@babel/preset-env/lib/targets-parser.js b/node_modules/@babel/preset-env/lib/targets-parser.js new file mode 100644 index 00000000..5202a4a4 --- /dev/null +++ b/node_modules/@babel/preset-env/lib/targets-parser.js @@ -0,0 +1,172 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = exports.semverMin = void 0; + +function _browserslist() { + const data = _interopRequireDefault(require("browserslist")); + + _browserslist = function _browserslist() { + return data; + }; + + return data; +} + +function _semver() { + const data = _interopRequireDefault(require("semver")); + + _semver = function _semver() { + return data; + }; + + return data; +} + +var _utils = require("./utils"); + +var _normalizeOptions = require("./normalize-options"); + +var _builtInModules = _interopRequireDefault(require("../data/built-in-modules.json")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +const browserNameMap = { + android: "android", + chrome: "chrome", + and_chr: "chrome", + edge: "edge", + firefox: "firefox", + ie: "ie", + ios_saf: "ios", + safari: "safari" +}; + +const isBrowsersQueryValid = browsers => typeof browsers === "string" || Array.isArray(browsers); + +const semverMin = (first, second) => { + return first && _semver().default.lt(first, second) ? first : second; +}; + +exports.semverMin = semverMin; + +const mergeBrowsers = (fromQuery, fromTarget) => { + return Object.keys(fromTarget).reduce((queryObj, targKey) => { + if (targKey !== "browsers") { + queryObj[targKey] = fromTarget[targKey]; + } + + return queryObj; + }, fromQuery); +}; + +const getLowestVersions = browsers => { + return browsers.reduce((all, browser) => { + const _browser$split = browser.split(" "), + browserName = _browser$split[0], + browserVersion = _browser$split[1]; + + const normalizedBrowserName = browserNameMap[browserName]; + + if (!normalizedBrowserName) { + return all; + } + + try { + const splitVersion = browserVersion.split("-")[0].toLowerCase(); + + if ((0, _utils.isUnreleasedVersion)(splitVersion, browserName)) { + all[normalizedBrowserName] = (0, _utils.getLowestUnreleased)(all[normalizedBrowserName], splitVersion, browserName); + } + + const parsedBrowserVersion = (0, _utils.semverify)(splitVersion); + all[normalizedBrowserName] = semverMin(all[normalizedBrowserName], parsedBrowserVersion); + } catch (e) {} + + return all; + }, {}); +}; + +const outputDecimalWarning = decimalTargets => { + if (!decimalTargets || !decimalTargets.length) { + return; + } + + console.log("Warning, the following targets are using a decimal version:"); + console.log(""); + decimalTargets.forEach(({ + target, + value + }) => console.log(` ${target}: ${value}`)); + console.log(""); + console.log("We recommend using a string for minor/patch versions to avoid numbers like 6.10"); + console.log("getting parsed as 6.1, which can lead to unexpected behavior."); + console.log(""); +}; + +const targetParserMap = { + __default: (target, value) => { + const version = (0, _utils.isUnreleasedVersion)(value, target) ? value.toLowerCase() : (0, _utils.semverify)(value); + return [target, version]; + }, + node: (target, value) => { + const parsed = value === true || value === "current" ? process.versions.node : (0, _utils.semverify)(value); + return [target, parsed]; + } +}; + +const getTargets = (targets = {}, options = {}) => { + const targetOpts = {}; + + if (targets.esmodules) { + const supportsESModules = _builtInModules.default["es6.module"]; + targets.browsers = Object.keys(supportsESModules).map(browser => `${browser} ${supportsESModules[browser]}`).join(", "); + } + + const queryIsValid = isBrowsersQueryValid(targets.browsers); + const browsersquery = queryIsValid ? targets.browsers : null; + + if (queryIsValid || !options.ignoreBrowserslistConfig) { + _browserslist().default.defaults = (0, _normalizeOptions.objectToBrowserslist)(targets); + const browsers = (0, _browserslist().default)(browsersquery, { + path: options.configPath + }); + const queryBrowsers = getLowestVersions(browsers); + targets = mergeBrowsers(queryBrowsers, targets); + } + + const parsed = Object.keys(targets).filter(value => value !== "esmodules").sort().reduce((results, target) => { + if (target !== "browsers") { + const value = targets[target]; + + if (typeof value === "number" && value % 1 !== 0) { + results.decimalWarnings.push({ + target, + value + }); + } + + const parser = targetParserMap[target] || targetParserMap.__default; + + const _parser = parser(target, value), + parsedTarget = _parser[0], + parsedValue = _parser[1]; + + if (parsedValue) { + results.targets[parsedTarget] = parsedValue; + } + } + + return results; + }, { + targets: targetOpts, + decimalWarnings: [] + }); + outputDecimalWarning(parsed.decimalWarnings); + return parsed.targets; +}; + +var _default = getTargets; +exports.default = _default;
\ No newline at end of file diff --git a/node_modules/@babel/preset-env/lib/use-built-ins-entry-plugin.js b/node_modules/@babel/preset-env/lib/use-built-ins-entry-plugin.js new file mode 100644 index 00000000..27cbe952 --- /dev/null +++ b/node_modules/@babel/preset-env/lib/use-built-ins-entry-plugin.js @@ -0,0 +1,79 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _default; + +var _debug = require("./debug"); + +var _utils = require("./utils"); + +function _default({ + types: t +}) { + function replaceWithPolyfillImports(path, polyfills, regenerator) { + if (regenerator) { + (0, _utils.createImport)(path, "regenerator-runtime"); + } + + const items = Array.isArray(polyfills) ? new Set(polyfills) : polyfills; + + for (var _iterator = Array.from(items).reverse(), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref = _i.value; + } + + const p = _ref; + (0, _utils.createImport)(path, p); + } + + path.remove(); + } + + const isPolyfillImport = { + ImportDeclaration(path, state) { + if (path.node.specifiers.length === 0 && (0, _utils.isPolyfillSource)(path.node.source.value)) { + this.importPolyfillIncluded = true; + replaceWithPolyfillImports(path, state.opts.polyfills, state.opts.regenerator); + } + }, + + Program(path, state) { + path.get("body").forEach(bodyPath => { + if ((0, _utils.isRequire)(t, bodyPath)) { + replaceWithPolyfillImports(bodyPath, state.opts.polyfills, state.opts.regenerator); + } + }); + } + + }; + return { + name: "transform-polyfill-require", + visitor: isPolyfillImport, + + pre() { + this.numPolyfillImports = 0; + this.importPolyfillIncluded = false; + }, + + post() { + const _this$opts = this.opts, + debug = _this$opts.debug, + onDebug = _this$opts.onDebug, + polyfills = _this$opts.polyfills; + + if (debug) { + (0, _debug.logEntryPolyfills)(this.importPolyfillIncluded, polyfills, this.file.opts.filename, onDebug); + } + } + + }; +}
\ No newline at end of file diff --git a/node_modules/@babel/preset-env/lib/use-built-ins-plugin.js b/node_modules/@babel/preset-env/lib/use-built-ins-plugin.js new file mode 100644 index 00000000..cf00b794 --- /dev/null +++ b/node_modules/@babel/preset-env/lib/use-built-ins-plugin.js @@ -0,0 +1,245 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _default; + +var _builtInDefinitions = require("./built-in-definitions"); + +var _debug = require("./debug"); + +var _utils = require("./utils"); + +function has(obj, key) { + return Object.prototype.hasOwnProperty.call(obj, key); +} + +function getType(target) { + if (Array.isArray(target)) return "array"; + return typeof target; +} + +function _default({ + types: t +}) { + function addImport(path, builtIn, builtIns) { + if (builtIn && !builtIns.has(builtIn)) { + builtIns.add(builtIn); + (0, _utils.createImport)(path, builtIn); + } + } + + function addUnsupported(path, polyfills, builtIn, builtIns) { + if (Array.isArray(builtIn)) { + for (var _iterator = builtIn, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref = _i.value; + } + + const i = _ref; + + if (polyfills.has(i)) { + addImport(path, i, builtIns); + } + } + } else { + if (polyfills.has(builtIn)) { + addImport(path, builtIn, builtIns); + } + } + } + + const addAndRemovePolyfillImports = { + ImportDeclaration(path) { + if (path.node.specifiers.length === 0 && (0, _utils.isPolyfillSource)(path.node.source.value)) { + console.warn(` + When setting \`useBuiltIns: 'usage'\`, polyfills are automatically imported when needed. + Please remove the \`import '@babel/polyfill'\` call or use \`useBuiltIns: 'entry'\` instead.`); + path.remove(); + } + }, + + Program: { + enter(path) { + path.get("body").forEach(bodyPath => { + if ((0, _utils.isRequire)(t, bodyPath)) { + console.warn(` + When setting \`useBuiltIns: 'usage'\`, polyfills are automatically imported when needed. + Please remove the \`require('@babel/polyfill')\` call or use \`useBuiltIns: 'entry'\` instead.`); + bodyPath.remove(); + } + }); + } + + }, + + ReferencedIdentifier(path, state) { + const node = path.node, + parent = path.parent, + scope = path.scope; + if (t.isMemberExpression(parent)) return; + if (!has(_builtInDefinitions.definitions.builtins, node.name)) return; + if (scope.getBindingIdentifier(node.name)) return; + const builtIn = _builtInDefinitions.definitions.builtins[node.name]; + addUnsupported(path, state.opts.polyfills, builtIn, this.builtIns); + }, + + CallExpression(path) { + if (path.node.arguments.length) return; + const callee = path.node.callee; + if (!t.isMemberExpression(callee)) return; + if (!callee.computed) return; + + if (!path.get("callee.property").matchesPattern("Symbol.iterator")) { + return; + } + + addImport(path, "web.dom.iterable", this.builtIns); + }, + + BinaryExpression(path) { + if (path.node.operator !== "in") return; + if (!path.get("left").matchesPattern("Symbol.iterator")) return; + addImport(path, "web.dom.iterable", this.builtIns); + }, + + YieldExpression(path) { + if (!path.node.delegate) return; + addImport(path, "web.dom.iterable", this.builtIns); + }, + + MemberExpression: { + enter(path, state) { + if (!path.isReferenced()) return; + const node = path.node; + const obj = node.object; + const prop = node.property; + if (!t.isReferenced(obj, node)) return; + let instanceType; + let evaluatedPropType = obj.name; + let propName = prop.name; + + if (node.computed) { + if (t.isStringLiteral(prop)) { + propName = prop.value; + } else { + const res = path.get("property").evaluate(); + + if (res.confident && res.value) { + propName = res.value; + } + } + } + + if (path.scope.getBindingIdentifier(obj.name)) { + const result = path.get("object").evaluate(); + + if (result.value) { + instanceType = getType(result.value); + } else if (result.deopt && result.deopt.isIdentifier()) { + evaluatedPropType = result.deopt.node.name; + } + } + + if (has(_builtInDefinitions.definitions.staticMethods, evaluatedPropType)) { + const staticMethods = _builtInDefinitions.definitions.staticMethods[evaluatedPropType]; + + if (has(staticMethods, propName)) { + const builtIn = staticMethods[propName]; + addUnsupported(path, state.opts.polyfills, builtIn, this.builtIns); + } + } + + if (has(_builtInDefinitions.definitions.instanceMethods, propName)) { + let builtIn = _builtInDefinitions.definitions.instanceMethods[propName]; + + if (instanceType) { + builtIn = builtIn.filter(item => item.includes(instanceType)); + } + + addUnsupported(path, state.opts.polyfills, builtIn, this.builtIns); + } + }, + + exit(path, state) { + if (!path.isReferenced()) return; + const node = path.node; + const obj = node.object; + if (!has(_builtInDefinitions.definitions.builtins, obj.name)) return; + if (path.scope.getBindingIdentifier(obj.name)) return; + const builtIn = _builtInDefinitions.definitions.builtins[obj.name]; + addUnsupported(path, state.opts.polyfills, builtIn, this.builtIns); + } + + }, + + VariableDeclarator(path, state) { + if (!path.isReferenced()) return; + const node = path.node; + const obj = node.init; + if (!t.isObjectPattern(node.id)) return; + if (!t.isReferenced(obj, node)) return; + if (obj && path.scope.getBindingIdentifier(obj.name)) return; + + for (var _iterator2 = node.id.properties, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) { + var _ref2; + + if (_isArray2) { + if (_i2 >= _iterator2.length) break; + _ref2 = _iterator2[_i2++]; + } else { + _i2 = _iterator2.next(); + if (_i2.done) break; + _ref2 = _i2.value; + } + + let prop = _ref2; + prop = prop.key; + + if (!node.computed && t.isIdentifier(prop) && has(_builtInDefinitions.definitions.instanceMethods, prop.name)) { + const builtIn = _builtInDefinitions.definitions.instanceMethods[prop.name]; + addUnsupported(path, state.opts.polyfills, builtIn, this.builtIns); + } + } + }, + + Function(path, state) { + if (!this.usesRegenerator && (path.node.generator || path.node.async)) { + this.usesRegenerator = true; + + if (state.opts.regenerator) { + addImport(path, "regenerator-runtime", this.builtIns); + } + } + } + + }; + return { + name: "use-built-ins", + + pre() { + this.builtIns = new Set(); + this.usesRegenerator = false; + }, + + post() { + const _this$opts = this.opts, + debug = _this$opts.debug, + onDebug = _this$opts.onDebug; + + if (debug) { + (0, _debug.logUsagePolyfills)(this.builtIns, this.file.opts.filename, onDebug); + } + }, + + visitor: addAndRemovePolyfillImports + }; +}
\ No newline at end of file diff --git a/node_modules/@babel/preset-env/lib/utils.js b/node_modules/@babel/preset-env/lib/utils.js new file mode 100644 index 00000000..f09c4da5 --- /dev/null +++ b/node_modules/@babel/preset-env/lib/utils.js @@ -0,0 +1,139 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.isRequire = exports.createImport = exports.getModulePath = exports.isPolyfillSource = exports.filterStageFromList = exports.getLowestUnreleased = exports.isUnreleasedVersion = exports.prettifyTargets = exports.prettifyVersion = exports.semverify = void 0; + +function _semver() { + const data = _interopRequireDefault(require("semver")); + + _semver = function _semver() { + return data; + }; + + return data; +} + +function _helperModuleImports() { + const data = require("@babel/helper-module-imports"); + + _helperModuleImports = function _helperModuleImports() { + return data; + }; + + return data; +} + +var _unreleasedLabels = _interopRequireDefault(require("../data/unreleased-labels")); + +var _targetsParser = require("./targets-parser"); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +const semverify = version => { + if (typeof version === "string" && _semver().default.valid(version)) { + return version; + } + + const split = version.toString().split("."); + + while (split.length < 3) { + split.push("0"); + } + + return split.join("."); +}; + +exports.semverify = semverify; + +const prettifyVersion = version => { + if (typeof version !== "string") { + return version; + } + + const parts = [_semver().default.major(version)]; + + const minor = _semver().default.minor(version); + + const patch = _semver().default.patch(version); + + if (minor || patch) { + parts.push(minor); + } + + if (patch) { + parts.push(patch); + } + + return parts.join("."); +}; + +exports.prettifyVersion = prettifyVersion; + +const prettifyTargets = targets => { + return Object.keys(targets).reduce((results, target) => { + let value = targets[target]; + const unreleasedLabel = _unreleasedLabels.default[target]; + + if (typeof value === "string" && unreleasedLabel !== value) { + value = prettifyVersion(value); + } + + results[target] = value; + return results; + }, {}); +}; + +exports.prettifyTargets = prettifyTargets; + +const isUnreleasedVersion = (version, env) => { + const unreleasedLabel = _unreleasedLabels.default[env]; + return !!unreleasedLabel && unreleasedLabel === version.toString().toLowerCase(); +}; + +exports.isUnreleasedVersion = isUnreleasedVersion; + +const getLowestUnreleased = (a, b, env) => { + const unreleasedLabel = _unreleasedLabels.default[env]; + const hasUnreleased = [a, b].some(item => item === unreleasedLabel); + + if (hasUnreleased) { + return a === hasUnreleased ? b : a || b; + } + + return (0, _targetsParser.semverMin)(a, b); +}; + +exports.getLowestUnreleased = getLowestUnreleased; + +const filterStageFromList = (list, stageList) => { + return Object.keys(list).reduce((result, item) => { + if (!stageList[item]) { + result[item] = list[item]; + } + + return result; + }, {}); +}; + +exports.filterStageFromList = filterStageFromList; + +const isPolyfillSource = source => source === "@babel/polyfill" || source === "core-js"; + +exports.isPolyfillSource = isPolyfillSource; +const modulePathMap = { + "regenerator-runtime": "regenerator-runtime/runtime" +}; + +const getModulePath = mod => modulePathMap[mod] || `core-js/modules/${mod}`; + +exports.getModulePath = getModulePath; + +const createImport = (path, mod) => (0, _helperModuleImports().addSideEffect)(path, getModulePath(mod)); + +exports.createImport = createImport; + +const isRequire = (t, path) => t.isExpressionStatement(path.node) && t.isCallExpression(path.node.expression) && t.isIdentifier(path.node.expression.callee) && path.node.expression.callee.name === "require" && path.node.expression.arguments.length === 1 && t.isStringLiteral(path.node.expression.arguments[0]) && isPolyfillSource(path.node.expression.arguments[0].value); + +exports.isRequire = isRequire;
\ No newline at end of file diff --git a/node_modules/@babel/preset-env/node_modules/.bin/browserslist b/node_modules/@babel/preset-env/node_modules/.bin/browserslist new file mode 120000 index 00000000..3cd991b2 --- /dev/null +++ b/node_modules/@babel/preset-env/node_modules/.bin/browserslist @@ -0,0 +1 @@ +../browserslist/cli.js
\ No newline at end of file diff --git a/node_modules/@babel/preset-env/node_modules/.bin/semver b/node_modules/@babel/preset-env/node_modules/.bin/semver new file mode 120000 index 00000000..7a17f06e --- /dev/null +++ b/node_modules/@babel/preset-env/node_modules/.bin/semver @@ -0,0 +1 @@ +../../../../semver/bin/semver
\ No newline at end of file diff --git a/node_modules/@babel/preset-env/node_modules/browserslist/.bin/browserslist b/node_modules/@babel/preset-env/node_modules/browserslist/.bin/browserslist new file mode 120000 index 00000000..9fbea327 --- /dev/null +++ b/node_modules/@babel/preset-env/node_modules/browserslist/.bin/browserslist @@ -0,0 +1 @@ +../cli.js
\ No newline at end of file diff --git a/node_modules/@babel/preset-env/node_modules/browserslist/CHANGELOG.md b/node_modules/@babel/preset-env/node_modules/browserslist/CHANGELOG.md new file mode 100644 index 00000000..5d67c0f8 --- /dev/null +++ b/node_modules/@babel/preset-env/node_modules/browserslist/CHANGELOG.md @@ -0,0 +1,288 @@ +# Change Log +This project adheres to [Semantic Versioning](http://semver.org/). + +## 3.2.8 +* Add IE 9-5.5 to dead browsers. +* Remove development configs from npm package. + +## 3.2.7 +* Add Firefox 60 as Firefox ESR. + +## 3.2.6 +* Add Opera Mini 12 to dead browsers. +* Update docs (by Jamie Kyle). + +## 3.2.5 +* Fix excluding Opera Mini and other browsers with `all` version. + +## 3.2.4 +* Resolve shareable config from current working directory. + +## 3.2.3 +* Fix `package.json` config validation for single string case. +* Fix CLI error reporting. + +## 3.2.2 +* Add `package.json` config validation. +* Move project to `browserlist` GitHub organization. + +## 3.2.1 +* Fix error text (by Steve Schrab). + +## 3.2 +* Add `cover 99%` query (by Vasily Fedoseyev). +* Add `cover 99% in US` query (by Vasily Fedoseyev). +* Add `cover 99% in my stats` query (by Vasily Fedoseyev). +* Add `"my stats"` support to `browserlist.coverage()` (by Vasily Fedoseyev). + +## 3.1.2 +* Add more clear error on missed browser version. + +## 3.1.1 +* Fix JSDoc (by Sylvain Pollet-Villard). + +## 3.1 +* Add `ignoreUnknownVersions` option. +* Fix docs (by Pascal Duez). + +## 3.0 +* Remove country statistics from client-side build of Browserslist. +* Change `> 1%` to `> 0.5%` in default query. +* Add `not dead` to default query. +* Change default environment to `production` (by Marco Fugaro). +* Add `dead` query support with IE 10 and BlackBerry browser. +* Add multiple environments in one section support (by Evilebot Tnawi). +* Add custom statistics support to `browserlist.coverage()`. +* Fix `path` option check. + +## 2.11.3 +* Fix for `path: undefined` option. + +## 2.11.2 +* Remove Node.js specific code from webpack build. + +## 2.11.1 +* Fix using Browserslist in browser with `path` but without `fs`. + +## 2.11 +* Add `last 2 years` query support (by James Harris). + +## 2.10.2 +* Fix Browserify support. + +## 2.10.1 +* Fix using Browserslist without `process` (by Andrew Patton). + +## 2.10 +* Add `< 1%` and `<= 1%` queries support (by August Kaiser). + +## 2.9.1 +* Fix unknown query on trailing spaces in query. + +## 2.9 +* Add `last Electron versions` and `last Electron major versions` queries + (by Louis Mouhat). + +## 2.8 +* Add `since 2016-03` and `since 2016-03-20` queries support (by Andrew Blick). + +## 2.7 +* Add `since 2016` queries support (by Igor Deryabin). + +## 2.6.1 +* Fix `Path must be a string` error. + +## 2.6 +* By default load config from current directory in CLI tool. + +## 2.5.1 +* Allow `@scope/browserlist-config` config name (by Jamie Connolly). + +## 2.5 +* Add `extends` query (by YellowKirby). + +## 2.4.1 +* Throw error if `package.json` contain `browserlist` instead of `browserslist`. + +## 2.4 +* Add `last n major versions` query (by John Sanders). + +## 2.3.3 +* Fix browsers support. + +## 2.3.2 +* Fix `> 0` query for browsers with one version (by Nikolay Solovyov). + +## 2.3.1 +* Reduce library size. + +## 2.3 +* Add `unreleased versions` and `unreleased Chrome versions` queries. + +## 2.2.2 +* Fix `Path must be a string` error (by Pieter Beulque). + +## 2.2.1 +* Fix security issue with regions dynamic `require`. + +## 2.2 +* Add region usage statistics support (by Clément P). + +## 2.1.5 +* Remove Firefox 45 from Firefox ESR. + +## 2.1.4 +* Use both ESR versions when they actual. + +## 2.1.3 +* Add warning on first exclude query. + +## 2.1.2 +* Fix non-Node.js environments support. + +## 2.1.1 +* Fix CLI arguments parsing. + +## 2.1 +* Add `>= 5%`, `>= 5% in US` and `>= 5% in my stats` queries. + +## 2.0 +* `last n versions` returns versions for all browsers, not only main browsers. +* Cache file system operations (by Aarni Koskela). +* Use `caniuse-lite` 1 MB instead of `caniuse-db` 7 MB (by Ben Briggs). +* Add `.browserslistrc` config support. +* Add QQ Browser for Android support. +* Add tests for CLI (by Zhulduz Zhankenova). + +## 1.7.7 +* Update Firefox ESR. + +## 1.7.6 +* Fix Android Chrome selection. + +## 1.7.5 +* Fix combining `not` query with country based statistics. +* Fix `--env` argument in CLI (by Tuure Savuoja). + +## 1.7.4 +* Speed up browser sorting (by Aarni Koskela). + +## 1.7.3 +* Fix config finding when directory was passed to `path` (by Aarni Koskela). + +## 1.7.2 +* Fix config finding algorithm (by Aarni Koskela). + +## 1.7.1 +* Fix unreleased browsers version detection. + +## 1.7 +* Add `--config` and `--env` arguments to CLI (by Jarek Rencz). + +## 1.6 +* Convert Electron version to Chrome (by Kilian Valkhof). +* Fix `0` version mistake in Can I Use data. + +## 1.5.2 +* Fix browser versions ordering (by Marco Massarotto). + +## 1.5.1 +* Fix error on `package.json` and `browserslist` in same directory. + +## 1.5 +* Add `package.json` support (by Stepan Kuzmin). +* Add environments support (by Maksim Semenov and openlibser). +* Add `browserslist-stats.json` file support (by Oleh Aloshkin). +* Add `config` option to CLI (by Evilebot Tnawi). +* Add JSDoc. +* Fix tests on Windows (by Anna Stoliar). +* Don’t set custom usage statistics globally. + +## 1.4 +* Add `defaults` keyword. + +## 1.3.6 +* Add `UCAndroid` alias to `and_uc` (by Evilebot Tnawi). + +## 1.3.5 +* Fix Opera Mini support. Use `op_mini all`. + +## 1.3.4 +* Add space-less `>1%` and `>.5%` syntax support (by Andreas Lind). + +## 1.3.3 +* Clean `0` versions in some country-based requests. + +## 1.3.2 +* Update Firefox ESR. + +## 1.3.1 +* Add Safari TP support. + +## 1.3 +* Add coverage for specific country (by Joshua Wise). + +## 1.2 +* Add `browserslist.coverage()` method. +* Add `--coverage` and `-c` argument to CLI. +* Add `-v` argument support to CLI. +* Better error handling in CLI. + +## 1.1.3 +* Fix jspm support (by Sean Anderson). + +## 1.1.2 +* Fix jspm support (by Sean Anderson). + +## 1.1.1 +* Fix space-less `>10%` and `>10% in my stats` queries. +* Normalize error messages. +* Remove development files from npm package. + +## 1.1 +* Added query against custom browser usage data (by Daniel Rey). + +## 1.0.1 +* Update Firefox ESR (by Rouven Weßling). + +## 1.0 +* Remove Opera 12.1 from default query. +* Add `not` keyword and exclude browsers by query. +* Add Microsoft Edge support (by Andrey Polischuk). +* Add CLI for debug and non-JS usage (by Luke Horvat). +* Use own class in Browserslist errors. + +## 0.5 +* Add version ranges `IE 6-9` (by Ben Briggs). + +## 0.4 +* Add `config` option and `BROWSERSLIST_CONFIG` environment variable support. +* Add symlink config support. + +## 0.3.3 +* Fix DynJS compatibility (by Nick Howes). + +## 0.3.2 +* Fix joined versions on versions query (by Vincent De Oliveira). + +## 0.3.1 +* Fix global variable leak (by Peter Müller). + +## 0.3 +* Takes queries from `BROWSERSLIST` environment variable. + +## 0.2 +* Return Can I Use joined versions as `ios_saf 7.0-7.1`. + +## 0.1.3 +* Better work with Can I Use joined versions like `ios_saf 7.0-7.1`. +* Browserslist now understands `ios_saf 7.0` or `ios_saf 7`. + +## 0.1.2 +* Do not create global `browserslist` var (by Maxime Thirouin). + +## 0.1.1 +* Sort browsers by name and version. + +## 0.1 +* Initial release. diff --git a/node_modules/@babel/preset-env/node_modules/browserslist/LICENSE b/node_modules/@babel/preset-env/node_modules/browserslist/LICENSE new file mode 100644 index 00000000..1ae47a20 --- /dev/null +++ b/node_modules/@babel/preset-env/node_modules/browserslist/LICENSE @@ -0,0 +1,20 @@ +The MIT License (MIT) + +Copyright 2014 Andrey Sitnik <andrey@sitnik.ru> + +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. diff --git a/node_modules/@babel/preset-env/node_modules/browserslist/README.md b/node_modules/@babel/preset-env/node_modules/browserslist/README.md new file mode 100644 index 00000000..da204c1b --- /dev/null +++ b/node_modules/@babel/preset-env/node_modules/browserslist/README.md @@ -0,0 +1,516 @@ +# Browserslist [![Cult Of Martians][cult-img]][cult] + +<img align="right" width="120" height="120" + src="./logo.svg" alt="Browserslist logo by Anton Lovchikov"> + +Library to share target browsers between different front-end tools. +It is used in: + +* [Autoprefixer] +* [Babel] + (external config in `package.json` or `browserslist` will be supported in 7.0) +* [postcss-preset-env] +* [eslint-plugin-compat] +* [stylelint-no-unsupported-browser-features] +* [postcss-normalize] + +[Browserslist Example] shows how every tool uses Browserslist. +All tools will find target browsers automatically, +when you add the following to `package.json`: + +```json +{ + "browserslist": [ + "> 1%", + "IE 10" + ] +} +``` + +Or in `.browserslistrc` config: + +```yaml +# Browsers that we support + +> 1% +IE 10 # sorry +``` + +Developers set browsers list in queries like `last 2 version` +to be free from updating browser versions manually. +Browserslist will use [Can I Use] data for this queries. + +Browserslist will take browsers queries from tool option, +`browserslist` config, `.browserslistrc` config, +`browserslist` section in `package.json` or environment variables. + +You can test Browserslist queries in [online demo]. + +[cult-img]: http://cultofmartians.com/assets/badges/badge.svg +[cult]: http://cultofmartians.com/done.html + +<a href="https://evilmartians.com/?utm_source=browserslist"> + <img src="https://evilmartians.com/badges/sponsored-by-evil-martians.svg" + alt="Sponsored by Evil Martians" width="236" height="54"> +</a> + +[stylelint-no-unsupported-browser-features]: https://github.com/ismay/stylelint-no-unsupported-browser-features +[eslint-plugin-compat]: https://github.com/amilajack/eslint-plugin-compat +[Browserslist Example]: https://github.com/browserslist/browserslist-example +[postcss-preset-env]: https://github.com/jonathantneal/postcss-preset-env +[postcss-normalize]: https://github.com/jonathantneal/postcss-normalize +[Autoprefixer]: https://github.com/postcss/autoprefixer +[online demo]: http://browserl.ist/ +[Can I Use]: http://caniuse.com/ +[Babel]: https://github.com/babel/babel/tree/master/packages/babel-preset-env + +## Tools + +* [`browserslist-ga`] downloads your website browsers statistics + to use it in `> 0.5% in my stats` query. +* [`browserslist-useragent`] checks browser by user agent string + to match Browserslist target browsers query. +* [`browserslist-useragent-ruby`] is a Ruby library to checks browser + by user agent string to match Browserslist. +* [`caniuse-api`] returns browsers which support some specific feature. +* Run `npx browserslist` in your project directory to see project’s + target browsers. This CLI tool is built-in and available in any project + with Autoprefixer. + +[`browserslist-useragent-ruby`]: https://github.com/browserslist/browserslist-useragent-ruby +[`browserslist-useragent`]: https://github.com/pastelsky/browserslist-useragent +[`browserslist-ga`]: https://github.com/browserslist/browserslist-ga +[`caniuse-api`]: https://github.com/Nyalab/caniuse-api + + +## Queries + +Browserslist will use browsers query from one of this sources: + +1. Tool options. For example `browsers` option in Autoprefixer. +2. `BROWSERSLIST` environment variable. +3. `browserslist` config file in current or parent directories. +3. `.browserslistrc` config file in current or parent directories. +4. `browserslist` key in `package.json` file in current or parent directories. + **We recommend this way.** +5. If the above methods did not produce a valid result + Browserslist will use defaults: + `> 0.5%, last 2 versions, Firefox ESR, not dead`. + + +### Best Practices + +* Select browsers directly (`last 2 Chrome versions`) only if you are making + web app for kiosk with one browser. There are a lot browsers on the market. + If you are making general web app you should respect browsers diversity. +* If you want to change the default set of browsers we recommend to combine + `last 1 version`, `not dead` with `> 0.2%` (or `> 1% in US`, + `> 1% in my stats`). Just `last n versions` adds to many dead browsers + and do not add popular old versions. Just `> 0.2%` make popular browsers even + more popular, so we will have a monopoly and stagnation, as we had + with Internet Explorer 6. +* Don’t remove browsers just because you don’t know them. Opera Mini has + 100 million users in Africa and it is more popular in global market, + than Microsoft Edge. Chinese QQ Browsers has more market share than Firefox + and desktop Safari altogether. + + +### Full List + +You can specify the versions by queries (case insensitive): + +* `> 5%`: versions selected by global usage statistics. + `>=`, `<` and `<=` work too. +* `> 5% in US`: uses USA usage statistics. It accepts [two-letter country code]. +* `> 5% in alt-AS`: uses Asia region usage statistics. List of all region codes + can be found at [`caniuse-lite/data/regions`]. +* `> 5% in my stats`: uses [custom usage data]. +* `cover 99.5%`: most popular browsers that provide coverage. +* `cover 99.5% in US`: same as above, with [two-letter country code]. +* `cover 99.5% in my stats`: uses [custom usage data]. +* `extends browserslist-config-mycompany`: take queries from + `browserslist-config-mycompany` npm package. +* `ie 6-8`: selects an inclusive range of versions. +* `Firefox > 20`: versions of Firefox newer than 20. + `>=`, `<` and `<=` work too. +* `iOS 7`: the iOS browser version 7 directly. +* `Firefox ESR`: the latest [Firefox ESR] version. +* `unreleased versions` or `unreleased Chrome versions`: + alpha and beta versions. +* `last 2 major versions` or `last 2 iOS major versions`: + all minor/patch releases of last 2 major versions. +* `since 2015` or `last 2 years`: all versions released since year 2015 + (also `since 2015-03` and `since 2015-03-10`). +* `dead`: browsers from `last 2 version` query, but with less than 0.5% + in global usage statistics and without official support or updates + for 24 months. Right now it is `IE 10`, `IE_Mob 10`, `BlackBerry 10`, + `BlackBerry 7`, and `OperaMobile 12.1`. +* `last 2 versions`: the last 2 versions for *each* browser. +* `last 2 Chrome versions`: the last 2 versions of Chrome browser. +* `defaults`: Browserslist’s default browsers + (`> 0.5%, last 2 versions, Firefox ESR, not dead`). +* `not ie <= 8`: exclude browsers selected by previous queries. + +You can add `not ` to any query. + + +### Debug + +Run `npx browserslist` in project directory to see what browsers was selected +by your queries. + +```sh +$ npx browserslist +and_chr 61 +and_ff 56 +and_qq 1.2 +and_uc 11.4 +android 56 +baidu 7.12 +bb 10 +chrome 62 +edge 16 +firefox 56 +ios_saf 11 +opera 48 +safari 11 +samsung 5 +``` + + +### Notes + +Browserslist works with separated versions of browsers. +You should avoid queries like `Firefox > 0`. + +Multiple criteria are combined as a boolean `OR`. A browser version must match +at least one of the criteria to be selected. + +All queries are based on the [Can I Use] support table, +e.g. `last 3 iOS versions` might select `8.4, 9.2, 9.3` (mixed major and minor), +whereas `last 3 Chrome versions` might select `50, 49, 48` (major only). + +[`caniuse-lite/data/regions`]: https://github.com/ben-eb/caniuse-lite/tree/master/data/regions +[two-letter country code]: http://en.wikipedia.org/wiki/ISO_3166-1_alpha-2#Officially_assigned_code_elements +[custom usage data]: #custom-usage-data +[Can I Use]: http://caniuse.com/ + + +### Browsers + +Names are case insensitive: + +* `Android` for Android WebView. +* `Baidu` for Baidu Browser. +* `BlackBerry` or `bb` for Blackberry browser. +* `Chrome` for Google Chrome. +* `ChromeAndroid` or `and_chr` for Chrome for Android +* `Edge` for Microsoft Edge. +* `Electron` for Electron framework. It will be converted to Chrome version. +* `Explorer` or `ie` for Internet Explorer. +* `ExplorerMobile` or `ie_mob` for Internet Explorer Mobile. +* `Firefox` or `ff` for Mozilla Firefox. +* `FirefoxAndroid` or `and_ff` for Firefox for Android. +* `iOS` or `ios_saf` for iOS Safari. +* `Opera` for Opera. +* `OperaMini` or `op_mini` for Opera Mini. +* `OperaMobile` or `op_mob` for Opera Mobile. +* `QQAndroid` or `and_qq` for QQ Browser for Android. +* `Safari` for desktop Safari. +* `Samsung` for Samsung Internet. +* `UCAndroid` or `and_uc` for UC Browser for Android. + + +## `package.json` + +If you want to reduce config files in project root, you can specify +browsers in `package.json` with `browserslist` key: + +```json +{ + "private": true, + "dependencies": { + "autoprefixer": "^6.5.4" + }, + "browserslist": [ + "> 1%", + "IE 10" + ] +} +``` + + +## Config File + +Browserslist config should be named `.browserslistrc` or `browserslist` +and have browsers queries split by a new line. Comments starts with `#` symbol: + +```yaml +# Browsers that we support + +> 1% +IE 10 # sorry +``` + +Browserslist will check config in every directory in `path`. +So, if tool process `app/styles/main.css`, you can put config to root, +`app/` or `app/styles`. + +You can specify direct path in `BROWSERSLIST_CONFIG` environment variables. + + +## Shareable Configs + +You can use the following query to reference an exported Browserslist config +from another package: + +```json + "browserslist": [ + "extends browserslist-config-mycompany" + ] +``` + +For security reasons, external configuration only supports packages that have +the `browserslist-config-` prefix. npm scoped packages are also supported, by +naming or prefixing the module with `@scope/browserslist-config`, such as +`@scope/browserslist-config` or `@scope/browserslist-config-mycompany`. + +If you don’t accept Browserslist queries from users, you can disable the +validation by using the `dangerousExtend` option: + +```js +browserslist(queries, { path, dangerousExtend: true }) +``` + +Because this uses `npm`'s resolution, you can also reference specific files +in a package: + +```json + "browserslist": [ + "extends browserslist-config-mycompany/desktop", + "extends browserslist-config-mycompany/mobile" + ] +``` + +When writing a shared Browserslist package, just export an array. +`browserslist-config-mycompany/index.js`: + +```js +module.exports = [ + '> 1%', + 'ie 10' +] +``` + + +## Environment Variables + +If some tool use Browserslist inside, you can change browsers settings +by [environment variables]: + +* `BROWSERSLIST` with browsers queries. + + ```sh + BROWSERSLIST="> 5%" gulp css + ``` + +* `BROWSERSLIST_CONFIG` with path to config file. + + ```sh + BROWSERSLIST_CONFIG=./config/browserslist gulp css + ``` + +* `BROWSERSLIST_ENV` with environments string. + + ```sh + BROWSERSLIST_ENV="development" gulp css + ``` + +* `BROWSERSLIST_STATS` with path to the custom usage data + for `> 1% in my stats` query. + + ```sh + BROWSERSLIST_STATS=./config/usage_data.json gulp css + ``` + +* `BROWSERSLIST_DISABLE_CACHE` if you want to disable config reading cache. + + ```sh + BROWSERSLIST_DISABLE_CACHE=1 gulp css + ``` + +[environment variables]: https://en.wikipedia.org/wiki/Environment_variable + + +## Environments + +You can also specify different browser queries for various environments. +Browserslist will choose query according to `BROWSERSLIST_ENV` or `NODE_ENV` +variables. If none of them is declared, Browserslist will firstly look +for `production` queries and then use defaults. + +In `package.json`: + +```js + "browserslist": { + "production": [ + "> 1%", + "ie 10" + ], + "development": [ + "last 1 chrome version", + "last 1 firefox version" + ] + } +``` + +In `.browserslistrc` config: + +```ini +[production staging] +> 1% +ie 10 + +[development] +last 1 chrome version +last 1 firefox version +``` + + +## Custom Usage Data + +If you have a website, you can query against the usage statistics of your site. +[`browserslist-ga`] will ask access to Google Analytics and then generate +`browserslist-stats.json`: + +``` +npx browserslist-ga +``` + +Of course, you can generate usage statistics file by any other method. +File format should be like: + +```js +{ + "ie": { + "6": 0.01, + "7": 0.4, + "8": 1.5 + }, + "chrome": { + … + }, + … +} +``` + +Note that you can query against your custom usage data +while also querying against global or regional data. +For example, the query `> 1% in my stats, > 5% in US, 10%` is permitted. + +[`browserslist-ga`]: https://github.com/browserslist/browserslist-ga +[Can I Use]: http://caniuse.com/ + + +## JS API + +```js +var browserslist = require('browserslist'); + +// Your CSS/JS build tool code +var process = function (source, opts) { + var browsers = browserslist(opts.browsers, { + stats: opts.stats, + path: opts.file, + env: opts.env + }); + // Your code to add features for selected browsers +} +``` + +Queries can be a string `"> 1%, IE 10"` +or an array `['> 1%', 'IE 10']`. + +If a query is missing, Browserslist will look for a config file. +You can provide a `path` option (that can be a file) to find the config file +relatively to it. + +Options: + +* `path`: file or a directory path to look for config file. Default is `.`. +* `env`: what environment section use from config. Default is `production`. +* `stats`: custom usage statistics data. +* `config`: path to config if you want to set it manually. +* `ignoreUnknownVersions`: do not throw on direct query (like `ie 12`). + Default is `false.` +* `dangerousExtend`: Disable security checks for `extend` query. + Default is `false.` + +For non-JS environment and debug purpose you can use CLI tool: + +```sh +browserslist "> 1%, IE 10" +``` + + +## Coverage + +You can get total users coverage for selected browsers by JS API: + +```js +browserslist.coverage(browserslist('> 1%')) +//=> 81.4 +``` + +```js +browserslist.coverage(browserslist('> 1% in US'), 'US') +//=> 83.1 +``` + +```js +browserslist.coverage(browserslist('> 1% in my stats'), 'my stats') +//=> 83.1 +``` + +```js +browserslist.coverage(browserslist('> 1% in my stats', { stats }), stats) +//=> 82.2 +``` + +Or by CLI: + +```sh +$ browserslist --coverage "> 1%" +These browsers account for 81.4% of all users globally +``` + +```sh +$ browserslist --coverage=US "> 1% in US" +These browsers account for 83.1% of all users in the US +``` + +```sh +$ browserslist --coverage "> 1% in my stats" +These browsers account for 83.1% of all users in custom statistics +``` + +```sh +$ browserslist --coverage "> 1% in my stats" --stats=./stats.json +These browsers account for 83.1% of all users in custom statistics +``` + + +## Cache + +Browserslist caches the configuration it reads from `package.json` and +`browserslist` files, as well as knowledge about the existence of files, +for the duration of the hosting process. + +To clear these caches, use: + +```js +browserslist.clearCaches(); +``` + +To disable the caching altogether, set the `BROWSERSLIST_DISABLE_CACHE` +environment variable. diff --git a/node_modules/@babel/preset-env/node_modules/browserslist/browser.js b/node_modules/@babel/preset-env/node_modules/browserslist/browser.js new file mode 100644 index 00000000..75657e59 --- /dev/null +++ b/node_modules/@babel/preset-env/node_modules/browserslist/browser.js @@ -0,0 +1,35 @@ +var BrowserslistError = require('./error') + +function noop () { } + +module.exports = { + loadQueries: function loadQueries () { + throw new BrowserslistError( + 'Sharable configs are not supported in client-side build of Browserslist') + }, + + getStat: function getStat (opts) { + return opts.stats + }, + + loadConfig: function loadConfig (opts) { + if (opts.config) { + throw new BrowserslistError( + 'Browserslist config are not supported in client-side build') + } + }, + + loadCountry: function loadCountry () { + throw new BrowserslistError( + 'Country statistics is not supported ' + + 'in client-side build of Browserslist') + }, + + parseConfig: noop, + + readConfig: noop, + + findConfig: noop, + + clearCaches: noop +} diff --git a/node_modules/@babel/preset-env/node_modules/browserslist/cli.js b/node_modules/@babel/preset-env/node_modules/browserslist/cli.js new file mode 100755 index 00000000..fc6149d9 --- /dev/null +++ b/node_modules/@babel/preset-env/node_modules/browserslist/cli.js @@ -0,0 +1,112 @@ +#!/usr/bin/env node + +var fs = require('fs') + +var browserslist = require('./') +var pkg = require('./package.json') +var args = process.argv.slice(2) + +var USAGE = 'Usage:\n' + + ' ' + pkg.name + '\n' + + ' ' + pkg.name + ' "QUERIES"\n' + + ' ' + pkg.name + ' --config="path/to/browserlist/file"\n' + + ' ' + pkg.name + ' --coverage "QUERIES"\n' + + ' ' + pkg.name + ' --coverage=US "QUERIES"\n' + + ' ' + pkg.name + ' --env="environment name defined in config"\n' + + ' ' + pkg.name + ' --stats="path/to/browserlist/stats/file"' + +function isArg (arg) { + return args.some(function (str) { + return str === arg || str.indexOf(arg + '=') === 0 + }) +} + +function error (msg) { + process.stderr.write(pkg.name + ': ' + msg + '\n') + process.exit(1) +} + +if (isArg('--help') || isArg('-h')) { + process.stdout.write(pkg.description + '.\n\n' + USAGE + '\n') +} else if (isArg('--version') || isArg('-v')) { + process.stdout.write(pkg.name + ' ' + pkg.version + '\n') +} else { + var mode = 'browsers' + var opts = { } + var queries + var country + + for (var i = 0; i < args.length; i++) { + if (args[i][0] !== '-') { + queries = args[i].replace(/^["']|["']$/g, '') + continue + } + + var arg = args[i].split('=') + var name = arg[0] + var value = arg[1] + + if (value) value = value.replace(/^["']|["']$/g, '') + + if (name === '--config' || name === '-b') { + opts.config = value + } else if (name === '--env' || name === '-e') { + opts.env = value + } else if (name === '--stats' || name === '-s') { + opts.stats = value + } else if (name === '--coverage' || name === '-c') { + mode = 'coverage' + if (value) country = value + } else { + error('Unknown arguments ' + args[i] + '.\n\n' + USAGE) + } + } + + var browsers + try { + if (!queries && !opts.config) { + if (browserslist.findConfig(process.cwd())) { + opts.path = process.cwd() + } else { + error( + 'Browserslist config was not found. ' + + 'Define queries or config path.' + + '\n\n' + USAGE + ) + } + } + browsers = browserslist(queries, opts) + } catch (e) { + if (e.name === 'BrowserslistError') { + error(e.message) + } else { + throw e + } + } + + if (mode === 'browsers') { + browsers.forEach(function (browser) { + process.stdout.write(browser + '\n') + }) + } else { + var stats + if (country) { + stats = country + } else if (opts.stats) { + stats = JSON.parse(fs.readFileSync(opts.stats)) + } + var result = browserslist.coverage(browsers, stats) + var round = Math.round(result * 100) / 100.0 + + var end = 'globally' + if (country && country !== 'global') { + end = 'in the ' + country.toUpperCase() + } else if (opts.stats) { + end = 'in custom statistics' + } + + process.stdout.write( + 'These browsers account for ' + round + '% of all users ' + + end + '\n') + } +} diff --git a/node_modules/@babel/preset-env/node_modules/browserslist/error.js b/node_modules/@babel/preset-env/node_modules/browserslist/error.js new file mode 100644 index 00000000..b3bc0fe9 --- /dev/null +++ b/node_modules/@babel/preset-env/node_modules/browserslist/error.js @@ -0,0 +1,12 @@ +function BrowserslistError (message) { + this.name = 'BrowserslistError' + this.message = message + this.browserslist = true + if (Error.captureStackTrace) { + Error.captureStackTrace(this, BrowserslistError) + } +} + +BrowserslistError.prototype = Error.prototype + +module.exports = BrowserslistError diff --git a/node_modules/@babel/preset-env/node_modules/browserslist/index.js b/node_modules/@babel/preset-env/node_modules/browserslist/index.js new file mode 100644 index 00000000..67692907 --- /dev/null +++ b/node_modules/@babel/preset-env/node_modules/browserslist/index.js @@ -0,0 +1,758 @@ +var path = require('path') +var e2c = require('electron-to-chromium/versions') + +var agents = require('caniuse-lite/dist/unpacker/agents').agents + +var BrowserslistError = require('./error') +var env = require('./node') // Will load browser.js in webpack + +var FLOAT_RANGE = /^\d+(\.\d+)?(-\d+(\.\d+)?)*$/ + +function normalize (versions) { + return versions.filter(function (version) { + return typeof version === 'string' + }) +} + +function nameMapper (name) { + return function mapName (version) { + return name + ' ' + version + } +} + +function getMajor (version) { + return parseInt(version.split('.')[0]) +} + +function getMajorVersions (released, number) { + if (released.length === 0) return [] + var minimum = getMajor(released[released.length - 1]) - parseInt(number) + 1 + var selected = [] + for (var i = released.length - 1; i >= 0; i--) { + if (minimum > getMajor(released[i])) break + selected.unshift(released[i]) + } + return selected +} + +function uniq (array) { + var filtered = [] + for (var i = 0; i < array.length; i++) { + if (filtered.indexOf(array[i]) === -1) filtered.push(array[i]) + } + return filtered +} + +// Helpers + +function fillUsage (result, name, data) { + for (var i in data) { + result[name + ' ' + i] = data[i] + } +} + +function generateFilter (sign, version) { + version = parseFloat(version) + if (sign === '>') { + return function (v) { + return parseFloat(v) > version + } + } else if (sign === '>=') { + return function (v) { + return parseFloat(v) >= version + } + } else if (sign === '<') { + return function (v) { + return parseFloat(v) < version + } + } else { + return function (v) { + return parseFloat(v) <= version + } + } +} + +function compareStrings (a, b) { + if (a < b) return -1 + if (a > b) return +1 + return 0 +} + +function normalizeVersion (data, version) { + if (data.versions.indexOf(version) !== -1) { + return version + } else if (browserslist.versionAliases[data.name][version]) { + return browserslist.versionAliases[data.name][version] + } else if (data.versions.length === 1) { + return data.versions[0] + } else { + return false + } +} + +function filterByYear (since) { + return Object.keys(agents).reduce(function (selected, name) { + var data = byName(name) + if (!data) return selected + var versions = Object.keys(data.releaseDate).filter(function (v) { + return data.releaseDate[v] >= since + }) + return selected.concat(versions.map(nameMapper(data.name))) + }, []) +} + +function byName (name) { + name = name.toLowerCase() + name = browserslist.aliases[name] || name + return browserslist.data[name] +} + +function checkName (name) { + var data = byName(name) + if (!data) throw new BrowserslistError('Unknown browser ' + name) + return data +} + +function unknownQuery (query) { + return new BrowserslistError('Unknown browser query `' + query + '`') +} + +function resolve (queries, context) { + return queries.reduce(function (result, selection, index) { + selection = selection.trim() + if (selection === '') return result + + var isExclude = selection.indexOf('not ') === 0 + if (isExclude) { + if (index === 0) { + throw new BrowserslistError( + 'Write any browsers query (for instance, `defaults`) ' + + 'before `' + selection + '`') + } + selection = selection.slice(4) + } + + for (var i = 0; i < QUERIES.length; i++) { + var type = QUERIES[i] + var match = selection.match(type.regexp) + if (match) { + var args = [context].concat(match.slice(1)) + var array = type.select.apply(browserslist, args) + if (isExclude) { + array = array.concat(array.map(function (j) { + return j.replace(/\s\S+/, ' 0') + })) + return result.filter(function (j) { + return array.indexOf(j) === -1 + }) + } + return result.concat(array) + } + } + + throw unknownQuery(selection) + }, []) +} + +/** + * Return array of browsers by selection queries. + * + * @param {(string|string[])} [queries=browserslist.defaults] Browser queries. + * @param {object} [opts] Options. + * @param {string} [opts.path="."] Path to processed file. + * It will be used to find config files. + * @param {string} [opts.env="production"] Processing environment. + * It will be used to take right + * queries from config file. + * @param {string} [opts.config] Path to config file with queries. + * @param {object} [opts.stats] Custom browser usage statistics + * for "> 1% in my stats" query. + * @param {boolean} [opts.ignoreUnknownVersions=false] Do not throw on unknown + * version in direct query. + * @param {boolean} [opts.dangerousExtend] Disable security checks + * for extend query. + * @return {string[]} Array with browser names in Can I Use. + * + * @example + * browserslist('IE >= 10, IE 8') //=> ['ie 11', 'ie 10', 'ie 8'] + */ +function browserslist (queries, opts) { + if (typeof opts === 'undefined') opts = { } + + if (typeof opts.path === 'undefined') { + opts.path = path.resolve ? path.resolve('.') : '.' + } + + if (typeof queries === 'undefined' || queries === null) { + var config = browserslist.loadConfig(opts) + if (config) { + queries = config + } else { + queries = browserslist.defaults + } + } + + if (typeof queries === 'string') { + queries = queries.split(/,\s*/) + } + + if (!Array.isArray(queries)) { + throw new BrowserslistError( + 'Browser queries must be an array. Got ' + typeof queries + '.') + } + + var context = { + ignoreUnknownVersions: opts.ignoreUnknownVersions, + dangerousExtend: opts.dangerousExtend + } + + var stats = env.getStat(opts) + if (stats) { + context.customUsage = { } + for (var browser in stats) { + fillUsage(context.customUsage, browser, stats[browser]) + } + } + + var result = resolve(queries, context).map(function (i) { + var parts = i.split(' ') + var name = parts[0] + var version = parts[1] + if (version === '0') { + return name + ' ' + byName(name).versions[0] + } else { + return i + } + }).sort(function (name1, name2) { + name1 = name1.split(' ') + name2 = name2.split(' ') + if (name1[0] === name2[0]) { + if (FLOAT_RANGE.test(name1[1]) && FLOAT_RANGE.test(name2[1])) { + return parseFloat(name2[1]) - parseFloat(name1[1]) + } else { + return compareStrings(name2[1], name1[1]) + } + } else { + return compareStrings(name1[0], name2[0]) + } + }) + + return uniq(result) +} + +// Will be filled by Can I Use data below +browserslist.data = { } +browserslist.usage = { + global: { }, + custom: null +} + +// Default browsers query +browserslist.defaults = [ + '> 0.5%', + 'last 2 versions', + 'Firefox ESR', + 'not dead' +] + +// Browser names aliases +browserslist.aliases = { + fx: 'firefox', + ff: 'firefox', + ios: 'ios_saf', + explorer: 'ie', + blackberry: 'bb', + explorermobile: 'ie_mob', + operamini: 'op_mini', + operamobile: 'op_mob', + chromeandroid: 'and_chr', + firefoxandroid: 'and_ff', + ucandroid: 'and_uc', + qqandroid: 'and_qq' +} + +// Aliases to work with joined versions like `ios_saf 7.0-7.1` +browserslist.versionAliases = { } + +browserslist.clearCaches = env.clearCaches +browserslist.parseConfig = env.parseConfig +browserslist.readConfig = env.readConfig +browserslist.findConfig = env.findConfig +browserslist.loadConfig = env.loadConfig + +/** + * Return browsers market coverage. + * + * @param {string[]} browsers Browsers names in Can I Use. + * @param {string|object} [stats="global"] Which statistics should be used. + * Country code or custom statistics. + * Pass `"my stats"` to load statistics + * from Browserslist files. + * + * @return {number} Total market coverage for all selected browsers. + * + * @example + * browserslist.coverage(browserslist('> 1% in US'), 'US') //=> 83.1 + */ +browserslist.coverage = function (browsers, stats) { + var data + if (typeof stats === 'undefined') { + data = browserslist.usage.global + } else if (stats === 'my stats') { + var opts = {} + opts.path = path.resolve ? path.resolve('.') : '.' + var customStats = env.getStat(opts) + if (!customStats) { + throw new BrowserslistError('Custom usage statistics was not provided') + } + data = {} + for (var browser in customStats) { + fillUsage(data, browser, customStats[browser]) + } + } else if (typeof stats === 'string') { + if (stats.length > 2) { + stats = stats.toLowerCase() + } else { + stats = stats.toUpperCase() + } + env.loadCountry(browserslist.usage, stats) + data = browserslist.usage[stats] + } else { + if ('dataByBrowser' in stats) { + stats = stats.dataByBrowser + } + data = { } + for (var name in stats) { + for (var version in stats[name]) { + data[name + ' ' + version] = stats[name][version] + } + } + } + + return browsers.reduce(function (all, i) { + var usage = data[i] + if (usage === undefined) { + usage = data[i.replace(/ \S+$/, ' 0')] + } + return all + (usage || 0) + }, 0) +} + +var QUERIES = [ + { + regexp: /^last\s+(\d+)\s+major versions?$/i, + select: function (context, versions) { + return Object.keys(agents).reduce(function (selected, name) { + var data = byName(name) + if (!data) return selected + var array = getMajorVersions(data.released, versions) + + array = array.map(nameMapper(data.name)) + return selected.concat(array) + }, []) + } + }, + { + regexp: /^last\s+(\d+)\s+versions?$/i, + select: function (context, versions) { + return Object.keys(agents).reduce(function (selected, name) { + var data = byName(name) + if (!data) return selected + var array = data.released.slice(-versions) + + array = array.map(nameMapper(data.name)) + return selected.concat(array) + }, []) + } + }, + { + regexp: /^last\s+(\d+)\s+electron\s+major versions?$/i, + select: function (context, versions) { + var validVersions = getMajorVersions(Object.keys(e2c).reverse(), versions) + return validVersions.map(function (i) { + return 'chrome ' + e2c[i] + }) + } + }, + { + regexp: /^last\s+(\d+)\s+(\w+)\s+major versions?$/i, + select: function (context, versions, name) { + var data = checkName(name) + var validVersions = getMajorVersions(data.released, versions) + return validVersions.map(nameMapper(data.name)) + } + }, + { + regexp: /^last\s+(\d+)\s+electron\s+versions?$/i, + select: function (context, versions) { + return Object.keys(e2c).reverse().slice(-versions).map(function (i) { + return 'chrome ' + e2c[i] + }) + } + }, + { + regexp: /^last\s+(\d+)\s+(\w+)\s+versions?$/i, + select: function (context, versions, name) { + var data = checkName(name) + return data.released.slice(-versions).map(nameMapper(data.name)) + } + }, + { + regexp: /^unreleased\s+versions$/i, + select: function () { + return Object.keys(agents).reduce(function (selected, name) { + var data = byName(name) + if (!data) return selected + var array = data.versions.filter(function (v) { + return data.released.indexOf(v) === -1 + }) + + array = array.map(nameMapper(data.name)) + return selected.concat(array) + }, []) + } + }, + { + regexp: /^unreleased\s+electron\s+versions?$/i, + select: function () { + return [] + } + }, + { + regexp: /^unreleased\s+(\w+)\s+versions?$/i, + select: function (context, name) { + var data = checkName(name) + return data.versions.filter(function (v) { + return data.released.indexOf(v) === -1 + }).map(nameMapper(data.name)) + } + }, + { + regexp: /^last\s+(\d+)\s+years?$/i, + select: function (context, years) { + var date = new Date() + var since = date.setFullYear(date.getFullYear() - years) / 1000 + + return filterByYear(since) + } + }, + { + regexp: /^since (\d+)(?:-(\d+))?(?:-(\d+))?$/i, + select: function (context, year, month, date) { + year = parseInt(year) + month = parseInt(month || '01') - 1 + date = parseInt(date || '01') + var since = Date.UTC(year, month, date, 0, 0, 0) / 1000 + + return filterByYear(since) + } + }, + { + regexp: /^(>=?|<=?)\s*(\d*\.?\d+)%$/, + select: function (context, sign, popularity) { + popularity = parseFloat(popularity) + var usage = browserslist.usage.global + + return Object.keys(usage).reduce(function (result, version) { + if (sign === '>') { + if (usage[version] > popularity) { + result.push(version) + } + } else if (sign === '<') { + if (usage[version] < popularity) { + result.push(version) + } + } else if (sign === '<=') { + if (usage[version] <= popularity) { + result.push(version) + } + } else if (usage[version] >= popularity) { + result.push(version) + } + return result + }, []) + } + }, + { + regexp: /^(>=?|<=?)\s*(\d*\.?\d+)%\s+in\s+my\s+stats$/, + select: function (context, sign, popularity) { + popularity = parseFloat(popularity) + + if (!context.customUsage) { + throw new BrowserslistError('Custom usage statistics was not provided') + } + + var usage = context.customUsage + + return Object.keys(usage).reduce(function (result, version) { + if (sign === '>') { + if (usage[version] > popularity) { + result.push(version) + } + } else if (sign === '<') { + if (usage[version] < popularity) { + result.push(version) + } + } else if (sign === '<=') { + if (usage[version] <= popularity) { + result.push(version) + } + } else if (usage[version] >= popularity) { + result.push(version) + } + return result + }, []) + } + }, + { + regexp: /^(>=?|<=?)\s*(\d*\.?\d+)%\s+in\s+((alt-)?\w\w)$/, + select: function (context, sign, popularity, place) { + popularity = parseFloat(popularity) + + if (place.length === 2) { + place = place.toUpperCase() + } else { + place = place.toLowerCase() + } + + env.loadCountry(browserslist.usage, place) + var usage = browserslist.usage[place] + + return Object.keys(usage).reduce(function (result, version) { + if (sign === '>') { + if (usage[version] > popularity) { + result.push(version) + } + } else if (sign === '<') { + if (usage[version] < popularity) { + result.push(version) + } + } else if (sign === '<=') { + if (usage[version] <= popularity) { + result.push(version) + } + } else if (usage[version] >= popularity) { + result.push(version) + } + return result + }, []) + } + }, + { + regexp: /^cover\s+(\d*\.?\d+)%(\s+in\s+(my\s+stats|(alt-)?\w\w))?$/, + select: function (context, coverage, statMode) { + coverage = parseFloat(coverage) + + var usage = browserslist.usage.global + if (statMode) { + if (statMode.match(/^\s+in\s+my\s+stats$/)) { + if (!context.customUsage) { + throw new BrowserslistError( + 'Custom usage statistics was not provided' + ) + } + usage = context.customUsage + } else { + var match = statMode.match(/\s+in\s+((alt-)?\w\w)/) + var place = match[1] + if (place.length === 2) { + place = place.toUpperCase() + } else { + place = place.toLowerCase() + } + env.loadCountry(browserslist.usage, place) + usage = browserslist.usage[place] + } + } + + var versions = Object.keys(usage).sort(function (a, b) { + return usage[b] - usage[a] + }) + + var coveraged = 0 + var result = [] + var version + for (var i = 0; i <= versions.length; i++) { + version = versions[i] + if (usage[version] === 0) break + + coveraged += usage[version] + result.push(version) + if (coveraged >= coverage) break + } + + return result + } + }, + { + regexp: /^electron\s+([\d.]+)\s*-\s*([\d.]+)$/i, + select: function (context, from, to) { + if (!e2c[from]) { + throw new BrowserslistError('Unknown version ' + from + ' of electron') + } + if (!e2c[to]) { + throw new BrowserslistError('Unknown version ' + to + ' of electron') + } + + from = parseFloat(from) + to = parseFloat(to) + + return Object.keys(e2c).filter(function (i) { + var parsed = parseFloat(i) + return parsed >= from && parsed <= to + }).map(function (i) { + return 'chrome ' + e2c[i] + }) + } + }, + { + regexp: /^(\w+)\s+([\d.]+)\s*-\s*([\d.]+)$/i, + select: function (context, name, from, to) { + var data = checkName(name) + from = parseFloat(normalizeVersion(data, from) || from) + to = parseFloat(normalizeVersion(data, to) || to) + + function filter (v) { + var parsed = parseFloat(v) + return parsed >= from && parsed <= to + } + + return data.released.filter(filter).map(nameMapper(data.name)) + } + }, + { + regexp: /^electron\s*(>=?|<=?)\s*([\d.]+)$/i, + select: function (context, sign, version) { + return Object.keys(e2c) + .filter(generateFilter(sign, version)) + .map(function (i) { + return 'chrome ' + e2c[i] + }) + } + }, + { + regexp: /^(\w+)\s*(>=?|<=?)\s*([\d.]+)$/, + select: function (context, name, sign, version) { + var data = checkName(name) + var alias = browserslist.versionAliases[data.name][version] + if (alias) { + version = alias + } + return data.released + .filter(generateFilter(sign, version)) + .map(function (v) { + return data.name + ' ' + v + }) + } + }, + { + regexp: /^(firefox|ff|fx)\s+esr$/i, + select: function () { + return ['firefox 52', 'firefox 60'] + } + }, + { + regexp: /(operamini|op_mini)\s+all/i, + select: function () { + return ['op_mini all'] + } + }, + { + regexp: /^electron\s+([\d.]+)$/i, + select: function (context, version) { + var chrome = e2c[version] + if (!chrome) { + throw new BrowserslistError( + 'Unknown version ' + version + ' of electron') + } + return ['chrome ' + chrome] + } + }, + { + regexp: /^(\w+)\s+(tp|[\d.]+)$/i, + select: function (context, name, version) { + if (/^tp$/i.test(version)) version = 'TP' + var data = checkName(name) + var alias = normalizeVersion(data, version) + if (alias) { + version = alias + } else { + if (version.indexOf('.') === -1) { + alias = version + '.0' + } else { + alias = version.replace(/\.0$/, '') + } + alias = normalizeVersion(data, alias) + if (alias) { + version = alias + } else if (context.ignoreUnknownVersions) { + return [] + } else { + throw new BrowserslistError( + 'Unknown version ' + version + ' of ' + name) + } + } + return [data.name + ' ' + version] + } + }, + { + regexp: /^extends (.+)$/i, + select: function (context, name) { + return resolve(env.loadQueries(context, name), context) + } + }, + { + regexp: /^defaults$/i, + select: function () { + return browserslist(browserslist.defaults) + } + }, + { + regexp: /^dead$/i, + select: function (context) { + var dead = ['ie <= 10', 'ie_mob <= 10', 'bb <= 10', 'op_mob <= 12.1'] + return resolve(dead, context) + } + }, + { + regexp: /^(\w+)$/i, + select: function (context, name) { + if (byName(name)) { + throw new BrowserslistError( + 'Specify versions in Browserslist query for browser ' + name) + } else { + throw unknownQuery(name) + } + } + } +]; + +// Get and convert Can I Use data + +(function () { + for (var name in agents) { + var browser = agents[name] + browserslist.data[name] = { + name: name, + versions: normalize(agents[name].versions), + released: normalize(agents[name].versions.slice(0, -3)), + releaseDate: agents[name].release_date + } + fillUsage(browserslist.usage.global, name, browser.usage_global) + + browserslist.versionAliases[name] = { } + for (var i = 0; i < browser.versions.length; i++) { + var full = browser.versions[i] + if (!full) continue + + if (full.indexOf('-') !== -1) { + var interval = full.split('-') + for (var j = 0; j < interval.length; j++) { + browserslist.versionAliases[name][interval[j]] = full + } + } + } + } +}()) + +module.exports = browserslist diff --git a/node_modules/@babel/preset-env/node_modules/browserslist/node.js b/node_modules/@babel/preset-env/node_modules/browserslist/node.js new file mode 100644 index 00000000..b46da136 --- /dev/null +++ b/node_modules/@babel/preset-env/node_modules/browserslist/node.js @@ -0,0 +1,262 @@ +var region = require('caniuse-lite/dist/unpacker/region').default +var path = require('path') +var fs = require('fs') + +var BrowserslistError = require('./error') + +var IS_SECTION = /^\s*\[(.+)\]\s*$/ +var CONFIG_PATTERN = /^browserslist-config-/ +var SCOPED_CONFIG__PATTERN = /@[^./]+\/browserslist-config(-|$)/ +var FORMAT = 'Browserslist config should be a string or an array ' + + 'of strings with browser queries' + +var filenessCache = { } +var configCache = { } + +function checkExtend (name) { + var use = ' Use `dangerousExtend` option to disable.' + if (!CONFIG_PATTERN.test(name) && !SCOPED_CONFIG__PATTERN.test(name)) { + throw new BrowserslistError( + 'Browserslist config needs `browserslist-config-` prefix. ' + use) + } + if (name.indexOf('.') !== -1) { + throw new BrowserslistError( + '`.` not allowed in Browserslist config name. ' + use) + } + if (name.indexOf('node_modules') !== -1) { + throw new BrowserslistError( + '`node_modules` not allowed in Browserslist config.' + use) + } +} + +function isFile (file) { + if (file in filenessCache) { + return filenessCache[file] + } + var result = fs.existsSync(file) && fs.statSync(file).isFile() + if (!process.env.BROWSERSLIST_DISABLE_CACHE) { + filenessCache[file] = result + } + return result +} + +function eachParent (file, callback) { + var loc = path.resolve(file) + do { + var result = callback(loc) + if (typeof result !== 'undefined') return result + } while (loc !== (loc = path.dirname(loc))) + return undefined +} + +function check (section) { + if (Array.isArray(section)) { + for (var i = 0; i < section.length; i++) { + if (typeof section[i] !== 'string') { + throw new BrowserslistError(FORMAT) + } + } + } else if (typeof section !== 'string') { + throw new BrowserslistError(FORMAT) + } +} + +function pickEnv (config, opts) { + if (typeof config !== 'object') return config + + var name + if (typeof opts.env === 'string') { + name = opts.env + } else if (process.env.BROWSERSLIST_ENV) { + name = process.env.BROWSERSLIST_ENV + } else if (process.env.NODE_ENV) { + name = process.env.NODE_ENV + } else { + name = 'production' + } + + return config[name] || config.defaults +} + +function parsePackage (file) { + var config = JSON.parse(fs.readFileSync(file)) + if (config.browserlist && !config.browserslist) { + throw new BrowserslistError( + '`browserlist` key instead of `browserslist` in ' + file) + } + var list = config.browserslist + if (Array.isArray(list)) { + list = { defaults: list } + } + + for (var i in list) { + check(list[i]) + } + + return list +} + +module.exports = { + loadQueries: function loadQueries (context, name) { + if (!context.dangerousExtend) checkExtend(name) + // eslint-disable-next-line security/detect-non-literal-require + var queries = require(require.resolve(name, { paths: ['.'] })) + if (!Array.isArray(queries)) { + throw new BrowserslistError( + '`' + name + '` config exports not an array of queries') + } + return queries + }, + + getStat: function getStat (opts) { + var stats + if (opts.stats) { + stats = opts.stats + } else if (process.env.BROWSERSLIST_STATS) { + stats = process.env.BROWSERSLIST_STATS + } else if (opts.path && path.resolve && fs.existsSync) { + stats = eachParent(opts.path, function (dir) { + var file = path.join(dir, 'browserslist-stats.json') + return isFile(file) ? file : undefined + }) + } + + if (typeof stats === 'string') { + try { + stats = JSON.parse(fs.readFileSync(stats)) + } catch (e) { + throw new BrowserslistError('Can\'t read ' + stats) + } + } + + if (stats && 'dataByBrowser' in stats) { + stats = stats.dataByBrowser + } + + return stats + }, + + loadConfig: function loadConfig (opts) { + if (process.env.BROWSERSLIST) { + return process.env.BROWSERSLIST + } else if (opts.config || process.env.BROWSERSLIST_CONFIG) { + var file = opts.config || process.env.BROWSERSLIST_CONFIG + if (path.basename(file) === 'package.json') { + return pickEnv(parsePackage(file), opts) + } else { + return pickEnv(module.exports.readConfig(file), opts) + } + } else if (opts.path) { + return pickEnv(module.exports.findConfig(opts.path), opts) + } else { + return undefined + } + }, + + loadCountry: function loadCountry (usage, country) { + var code = country.replace(/[^\w-]/g, '') + if (!usage[code]) { + // eslint-disable-next-line security/detect-non-literal-require + var compressed = require('caniuse-lite/data/regions/' + code + '.js') + var data = region(compressed) + usage[country] = { } + for (var i in data) { + for (var j in data[i]) { + usage[country][i + ' ' + j] = data[i][j] + } + } + } + }, + + parseConfig: function parseConfig (string) { + var result = { defaults: [] } + var sections = ['defaults'] + + string.toString() + .replace(/#[^\n]*/g, '') + .split(/\n/) + .map(function (line) { + return line.trim() + }) + .filter(function (line) { + return line !== '' + }) + .forEach(function (line) { + if (IS_SECTION.test(line)) { + sections = line.match(IS_SECTION)[1].trim().split(' ') + sections.forEach(function (section) { + if (result[section]) { + throw new BrowserslistError( + 'Dublicate section ' + section + ' in Browserslist config') + } + result[section] = [] + }) + } else { + sections.forEach(function (section) { + result[section].push(line) + }) + } + }) + + return result + }, + + readConfig: function readConfig (file) { + if (!isFile(file)) { + throw new BrowserslistError('Can\'t read ' + file + ' config') + } + return module.exports.parseConfig(fs.readFileSync(file)) + }, + + findConfig: function findConfig (from) { + from = path.resolve(from) + + var cacheKey = isFile(from) ? path.dirname(from) : from + if (cacheKey in configCache) { + return configCache[cacheKey] + } + + var resolved = eachParent(from, function (dir) { + var config = path.join(dir, 'browserslist') + var pkg = path.join(dir, 'package.json') + var rc = path.join(dir, '.browserslistrc') + + var pkgBrowserslist + if (isFile(pkg)) { + try { + pkgBrowserslist = parsePackage(pkg) + } catch (e) { + if (e.name === 'BrowserslistError') throw e + console.warn( + '[Browserslist] Could not parse ' + pkg + '. Ignoring it.') + } + } + + if (isFile(config) && pkgBrowserslist) { + throw new BrowserslistError( + dir + ' contains both browserslist and package.json with browsers') + } else if (isFile(rc) && pkgBrowserslist) { + throw new BrowserslistError( + dir + ' contains both .browserslistrc and package.json with browsers') + } else if (isFile(config) && isFile(rc)) { + throw new BrowserslistError( + dir + ' contains both .browserslistrc and browserslist') + } else if (isFile(config)) { + return module.exports.readConfig(config) + } else if (isFile(rc)) { + return module.exports.readConfig(rc) + } else { + return pkgBrowserslist + } + }) + if (!process.env.BROWSERSLIST_DISABLE_CACHE) { + configCache[cacheKey] = resolved + } + return resolved + }, + + clearCaches: function clearCaches () { + filenessCache = { } + configCache = { } + } +} diff --git a/node_modules/@babel/preset-env/node_modules/browserslist/package.json b/node_modules/@babel/preset-env/node_modules/browserslist/package.json new file mode 100644 index 00000000..f4ea934a --- /dev/null +++ b/node_modules/@babel/preset-env/node_modules/browserslist/package.json @@ -0,0 +1,62 @@ +{ + "name": "browserslist", + "version": "3.2.8", + "description": "Share target browsers between different front-end tools, like Autoprefixer, Stylelint and babel-env-preset", + "keywords": [ + "caniuse", + "browsers", + "target" + ], + "author": "Andrey Sitnik <andrey@sitnik.ru>", + "license": "MIT", + "repository": "browserslist/browserslist", + "dependencies": { + "caniuse-lite": "^1.0.30000844", + "electron-to-chromium": "^1.3.47" + }, + "bin": "./cli.js", + "devDependencies": { + "cross-spawn": "^6.0.5", + "eslint": "^4.19.1", + "eslint-ci": "^0.1.1", + "eslint-config-logux": "^22.1.0", + "eslint-config-standard": "^11.0.0", + "eslint-plugin-es5": "^1.3.1", + "eslint-plugin-import": "^2.12.0", + "eslint-plugin-jest": "^21.15.1", + "eslint-plugin-node": "^6.0.1", + "eslint-plugin-promise": "^3.7.0", + "eslint-plugin-security": "^1.4.0", + "eslint-plugin-standard": "^3.1.0", + "fs-extra": "^5.0.0", + "jest": "^22.4.4", + "lint-staged": "^7.1.2", + "pre-commit": "^1.1.3", + "size-limit": "^0.18.0", + "yaspeller-ci": "^1.0.0" + }, + "jest": { + "testEnvironment": "node", + "coverageThreshold": { + "global": { + "statements": 100 + } + }, + "modulePathIgnorePatterns": [ + "<rootDir>/test/fixtures" + ] + }, + "scripts": { + "lint-staged": "lint-staged", + "spellcheck": "yaspeller-ci README.md CHANGELOG.md", + "lint": "eslint-ci *.js test/*.js benchmark/*.js", + "test": "jest --coverage && yarn lint && yarn spellcheck && size-limit" + }, + "browser": { + "./node.js": "./browser.js", + "path": false + }, + "pre-commit": [ + "lint-staged" + ] +} diff --git a/node_modules/@babel/preset-env/package.json b/node_modules/@babel/preset-env/package.json new file mode 100644 index 00000000..775e3af0 --- /dev/null +++ b/node_modules/@babel/preset-env/package.json @@ -0,0 +1,66 @@ +{ + "name": "@babel/preset-env", + "version": "7.0.0-beta.47", + "description": "A Babel preset for each environment.", + "author": "Henry Zhu <hi@henryzoo.com>", + "homepage": "https://babeljs.io/", + "license": "MIT", + "repository": "https://github.com/babel/babel/tree/master/packages/babel-preset-env", + "main": "lib/index.js", + "scripts": { + "build-data": "node ./scripts/build-data.js; node ./scripts/build-modules-support.js" + }, + "dependencies": { + "@babel/helper-module-imports": "7.0.0-beta.47", + "@babel/helper-plugin-utils": "7.0.0-beta.47", + "@babel/plugin-proposal-async-generator-functions": "7.0.0-beta.47", + "@babel/plugin-proposal-object-rest-spread": "7.0.0-beta.47", + "@babel/plugin-proposal-optional-catch-binding": "7.0.0-beta.47", + "@babel/plugin-proposal-unicode-property-regex": "7.0.0-beta.47", + "@babel/plugin-syntax-async-generators": "7.0.0-beta.47", + "@babel/plugin-syntax-object-rest-spread": "7.0.0-beta.47", + "@babel/plugin-syntax-optional-catch-binding": "7.0.0-beta.47", + "@babel/plugin-transform-arrow-functions": "7.0.0-beta.47", + "@babel/plugin-transform-async-to-generator": "7.0.0-beta.47", + "@babel/plugin-transform-block-scoped-functions": "7.0.0-beta.47", + "@babel/plugin-transform-block-scoping": "7.0.0-beta.47", + "@babel/plugin-transform-classes": "7.0.0-beta.47", + "@babel/plugin-transform-computed-properties": "7.0.0-beta.47", + "@babel/plugin-transform-destructuring": "7.0.0-beta.47", + "@babel/plugin-transform-dotall-regex": "7.0.0-beta.47", + "@babel/plugin-transform-duplicate-keys": "7.0.0-beta.47", + "@babel/plugin-transform-exponentiation-operator": "7.0.0-beta.47", + "@babel/plugin-transform-for-of": "7.0.0-beta.47", + "@babel/plugin-transform-function-name": "7.0.0-beta.47", + "@babel/plugin-transform-literals": "7.0.0-beta.47", + "@babel/plugin-transform-modules-amd": "7.0.0-beta.47", + "@babel/plugin-transform-modules-commonjs": "7.0.0-beta.47", + "@babel/plugin-transform-modules-systemjs": "7.0.0-beta.47", + "@babel/plugin-transform-modules-umd": "7.0.0-beta.47", + "@babel/plugin-transform-new-target": "7.0.0-beta.47", + "@babel/plugin-transform-object-super": "7.0.0-beta.47", + "@babel/plugin-transform-parameters": "7.0.0-beta.47", + "@babel/plugin-transform-regenerator": "7.0.0-beta.47", + "@babel/plugin-transform-shorthand-properties": "7.0.0-beta.47", + "@babel/plugin-transform-spread": "7.0.0-beta.47", + "@babel/plugin-transform-sticky-regex": "7.0.0-beta.47", + "@babel/plugin-transform-template-literals": "7.0.0-beta.47", + "@babel/plugin-transform-typeof-symbol": "7.0.0-beta.47", + "@babel/plugin-transform-unicode-regex": "7.0.0-beta.47", + "browserslist": "^3.0.0", + "invariant": "^2.2.2", + "semver": "^5.3.0" + }, + "peerDependencies": { + "@babel/core": "7.0.0-beta.47" + }, + "devDependencies": { + "@babel/cli": "7.0.0-beta.47", + "@babel/core": "7.0.0-beta.47", + "@babel/helper-fixtures": "7.0.0-beta.47", + "@babel/helper-plugin-test-runner": "7.0.0-beta.47", + "compat-table": "kangax/compat-table#90d02e486227d179d2ce9b850dbb3f9846443cab", + "electron-to-chromium": "^1.3.27", + "request": "^2.83.0" + } +} |