pax_global_header00006660000000000000000000000064144632321220014511gustar00rootroot0000000000000052 comment=bad29905af2a4c4324f712ded6db96d6c12e5f91 regenerator-regenerator-transform-0.15.2/000077500000000000000000000000001446323212200204375ustar00rootroot00000000000000regenerator-regenerator-transform-0.15.2/.github/000077500000000000000000000000001446323212200217775ustar00rootroot00000000000000regenerator-regenerator-transform-0.15.2/.github/dependabot.yml000066400000000000000000000005321446323212200246270ustar00rootroot00000000000000# Please see the documentation for all configuration options: # https://help.github.com/github/administering-a-repository/configuration-options-for-dependency-updates version: 2 updates: - package-ecosystem: "npm" # See documentation for possible values directory: "/" # Location of package manifests schedule: interval: "daily" regenerator-regenerator-transform-0.15.2/.github/workflows/000077500000000000000000000000001446323212200240345ustar00rootroot00000000000000regenerator-regenerator-transform-0.15.2/.github/workflows/node.js.yml000066400000000000000000000015651446323212200261260ustar00rootroot00000000000000# This workflow will do a clean install of node dependencies, build the source code and run tests across different versions of node # For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions name: Node.js CI on: push: branches: [ main ] pull_request: branches: [ main ] jobs: build: runs-on: ubuntu-latest strategy: matrix: node-version: [12.x, 14.x, 16.x, 18.x] # See supported Node.js release schedule at https://nodejs.org/en/about/releases/ steps: - uses: actions/checkout@v2 - name: Use Node.js ${{ matrix.node-version }} uses: actions/setup-node@v1 with: node-version: ${{ matrix.node-version }} - name: Use npm v8 run: npm install --global npm@8 - run: npm ci - run: npm run build --if-present - run: npm test regenerator-regenerator-transform-0.15.2/.gitignore000066400000000000000000000001731446323212200224300ustar00rootroot00000000000000npm-debug.log node_modules test/mocha.js test/mocha.css test/*.es5.js test/*.regenerator.js test/tests.browser.js .idea regenerator-regenerator-transform-0.15.2/.npmignore000066400000000000000000000002401446323212200224320ustar00rootroot00000000000000/node_modules /test # Don't publish the helper packages as part of the parent package. /packages # Don't publish docs directory to npm (it's very large). /docs regenerator-regenerator-transform-0.15.2/CODE_OF_CONDUCT.md000066400000000000000000000003711446323212200232370ustar00rootroot00000000000000# Code of Conduct Facebook has adopted a Code of Conduct that we expect project participants to adhere to. Please [read the full text](https://code.facebook.com/codeofconduct) so that you can understand what actions will and will not be tolerated. regenerator-regenerator-transform-0.15.2/CONTRIBUTING.md000066400000000000000000000060131446323212200226700ustar00rootroot00000000000000# Contributing to Regenerator Regenerator uses GitHub as its sole source of truth. Everything happens here. Facebook employees who contribute to Regenerator are expected to do so in the same way as everyone else. In other words, this document applies equally to all contributors. ### Code of Conduct The code of conduct is described in [`CODE_OF_CONDUCT.md`](CODE_OF_CONDUCT.md) ### `master` is unsafe We will do our best to keep `master` in good shape, with tests passing at all times. But in order to move fast, we will make API changes that your application might not be compatible with. We will do our best to communicate these changes and always version appropriately so you can lock into a specific version if need be. ### Pull Requests In case you've never submitted a pull request (PR) via GitHub before, please read [this short tutorial](https://help.github.com/articles/creating-a-pull-request). If you've submitted a PR before, there should be nothing surprising about our procedures for Regenerator. *Before* submitting a pull request, please make sure the following is doneā€¦ 1. Fork the repo and create your branch from `master`. 2. If you've added code that should be tested, add tests! 3. Ensure the test suite passes (`npm test`). 4. If you haven't already, complete the CLA. 5. Submit a pull request via GitHub. 6. Check that Travis CI tests pass (pull request turns green). ### Contributor License Agreement ("CLA") In order to accept your pull request, we need you to submit a CLA. You only need to do this once, so if you've done this for another Facebook open source project, you're good to go. If you are submitting a pull request for the first time, just let us know that you have completed the CLA and we can cross-check with your GitHub username. Complete your CLA here: ## Bugs ### Where to Find Known Issues We will be using GitHub Issues for all bugs. Before filing a new issue, please try to make sure your problem doesn't already exist. If you think your issue is more general than one that already exists, our preference is still to modify the original issue to reflect the underlying problem more faithfully. ### Reporting New Issues The best way to get a bug fixed is to provide a reduced test case, and the easiest way to reduce a testcase is to edit it in [the sandbox](http://facebook.github.io/regenerator/) until you're satisfied and then click the "report a bug" link (the new issue will be populated automatically with your code). ### Security Bugs Facebook has a [bounty program](https://www.facebook.com/whitehat/) for the safe disclosure of security bugs. With that in mind, please do not file public issues and go through the process outlined on that page. ## Coding Style * Use semicolons; * Commas last, * 2 spaces for indentation (no tabs). * Prefer `"` over `'` * 80 character line length * Match surrounding coding style. * Less code is better code. ## License By contributing to Regenerator, you agree that your contributions will be licensed under the [MIT License](LICENSE). regenerator-regenerator-transform-0.15.2/LICENSE000066400000000000000000000020701446323212200214430ustar00rootroot00000000000000MIT License Copyright (c) 2014-present, Facebook, Inc. 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. regenerator-regenerator-transform-0.15.2/README.md000066400000000000000000000044361446323212200217250ustar00rootroot00000000000000regenerator [![Build Status](https://travis-ci.org/facebook/regenerator.svg?branch=master)](https://travis-ci.org/facebook/regenerator) === This package implements a fully-functional source transformation that takes the syntax for generators/`yield` from [ECMAScript 2015 or ES2015](http://www.ecma-international.org/ecma-262/6.0/) and [Asynchronous Iteration](https://github.com/tc39/proposal-async-iteration) proposal and spits out efficient JS-of-today (ES5) that behaves the same way. A small runtime library (less than 1KB compressed) is required to provide the `wrapGenerator` function. You can install it either as a CommonJS module or as a standalone .js file, whichever you prefer. Installation --- From npm: ```sh npm install -g regenerator ``` From GitHub: ```sh cd path/to/node_modules git clone git://github.com/facebook/regenerator.git cd regenerator npm install . npm test ``` Usage --- You have several options for using this module. Simplest usage: ```sh regenerator es6.js > es5.js # Just the transform. regenerator --include-runtime es6.js > es5.js # Add the runtime too. regenerator src lib # Transform every .js file in src and output to lib. ``` Programmatic usage: ```js var es5Source = require("regenerator").compile(es6Source).code; var es5SourceWithRuntime = require("regenerator").compile(es6Source, { includeRuntime: true }).code; ``` AST transformation: ```js var recast = require("recast"); var ast = recast.parse(es6Source); ast = require("regenerator").transform(ast); var es5Source = recast.print(ast); ``` How can you get involved? --- The easiest way to get involved is to look for buggy examples using [the sandbox](http://facebook.github.io/regenerator/), and when you find something strange just click the "report a bug" link (the new issue form will be populated automatically with the problematic code). Alternatively, you can [fork](https://github.com/facebook/regenerator/fork) the repository, create some failing tests cases in [test/tests.es6.js](test/tests.es6.js), and send pull requests for me to fix. If you're feeling especially brave, you are more than welcome to dive into the transformer code and fix the bug(s) yourself, but I must warn you that the code could really benefit from [better implementation comments](https://github.com/facebook/regenerator/issues/7). regenerator-regenerator-transform-0.15.2/bin/000077500000000000000000000000001446323212200212075ustar00rootroot00000000000000regenerator-regenerator-transform-0.15.2/bin/regenerator000077500000000000000000000010211446323212200234440ustar00rootroot00000000000000#!/usr/bin/env node // -*- mode: js -*- var compile = require("../main").compile; require("commoner").version( require("../package.json").version ).resolve(function(id) { return this.readModuleP(id); }).option( "-r, --include-runtime", "Prepend the runtime to the output." ).option( "--disable-async", "Disable transformation of async functions." ).process(function(id, source) { return compile(source, { includeRuntime: this.options.includeRuntime, disableAsync: this.options.disableAsync }).code; }); regenerator-regenerator-transform-0.15.2/docs/000077500000000000000000000000001446323212200213675ustar00rootroot00000000000000regenerator-regenerator-transform-0.15.2/docs/.gitignore000066400000000000000000000001421446323212200233540ustar00rootroot00000000000000npm-debug.log node_modules test/mocha.js test/mocha.css test/tests.es5.js test/tests.browser.js regenerator-regenerator-transform-0.15.2/docs/.nojekyll000066400000000000000000000000001446323212200232050ustar00rootroot00000000000000regenerator-regenerator-transform-0.15.2/docs/bundle.js000066400000000000000000160412551446323212200232140ustar00rootroot00000000000000(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.regenerator = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i { return highlighted ? chalkFn(string) : string; }; const lines = rawLines.split(NEWLINE); const { start, end, markerLines } = getMarkerLines(loc, lines, opts); const hasColumns = loc.start && typeof loc.start.column === "number"; const numberMaxWidth = String(end).length; const highlightedLines = highlighted ? (0, _highlight.default)(rawLines, opts) : rawLines; let frame = highlightedLines.split(NEWLINE, end).slice(start, end).map((line, index) => { const number = start + 1 + index; const paddedNumber = ` ${number}`.slice(-numberMaxWidth); const gutter = ` ${paddedNumber} |`; const hasMarker = markerLines[number]; const lastMarkerLine = !markerLines[number + 1]; if (hasMarker) { let markerLine = ""; if (Array.isArray(hasMarker)) { const markerSpacing = line.slice(0, Math.max(hasMarker[0] - 1, 0)).replace(/[^\t]/g, " "); const numberOfMarkers = hasMarker[1] || 1; markerLine = ["\n ", maybeHighlight(defs.gutter, gutter.replace(/\d/g, " ")), " ", markerSpacing, maybeHighlight(defs.marker, "^").repeat(numberOfMarkers)].join(""); if (lastMarkerLine && opts.message) { markerLine += " " + maybeHighlight(defs.message, opts.message); } } return [maybeHighlight(defs.marker, ">"), maybeHighlight(defs.gutter, gutter), line.length > 0 ? ` ${line}` : "", markerLine].join(""); } else { return ` ${maybeHighlight(defs.gutter, gutter)}${line.length > 0 ? ` ${line}` : ""}`; } }).join("\n"); if (opts.message && !hasColumns) { frame = `${" ".repeat(numberMaxWidth + 1)}${opts.message}\n${frame}`; } if (highlighted) { return chalk.reset(frame); } else { return frame; } } function _default(rawLines, lineNumber, colNumber, opts = {}) { if (!deprecationWarningShown) { deprecationWarningShown = true; const message = "Passing lineNumber and colNumber is deprecated to @babel/code-frame. Please use `codeFrameColumns`."; if (process.emitWarning) { process.emitWarning(message, "DeprecationWarning"); } else { const deprecationError = new Error(message); deprecationError.name = "DeprecationWarning"; console.warn(new Error(message)); } } colNumber = Math.max(colNumber, 0); const location = { start: { column: colNumber, line: lineNumber } }; return codeFrameColumns(rawLines, location, opts); } }).call(this)}).call(this,require('_process')) },{"@babel/highlight":265,"_process":460}],5:[function(require,module,exports){ module.exports={ "es6.module": { "chrome": "61", "and_chr": "61", "edge": "16", "firefox": "60", "and_ff": "60", "node": "13.2.0", "opera": "48", "op_mob": "48", "safari": "10.1", "ios": "10.3", "samsung": "8.2", "android": "61", "electron": "2.0", "ios_saf": "10.3" } } },{}],6:[function(require,module,exports){ module.exports={ "transform-class-static-block": { "chrome": "94", "opera": "80", "edge": "94", "firefox": "93", "node": "16.11", "electron": "15.0" }, "proposal-class-static-block": { "chrome": "94", "opera": "80", "edge": "94", "firefox": "93", "node": "16.11", "electron": "15.0" }, "transform-private-property-in-object": { "chrome": "91", "opera": "77", "edge": "91", "firefox": "90", "safari": "15", "node": "16.9", "ios": "15", "electron": "13.0" }, "proposal-private-property-in-object": { "chrome": "91", "opera": "77", "edge": "91", "firefox": "90", "safari": "15", "node": "16.9", "ios": "15", "electron": "13.0" }, "transform-class-properties": { "chrome": "74", "opera": "62", "edge": "79", "firefox": "90", "safari": "14.1", "node": "12", "ios": "15", "samsung": "11", "electron": "6.0" }, "proposal-class-properties": { "chrome": "74", "opera": "62", "edge": "79", "firefox": "90", "safari": "14.1", "node": "12", "ios": "15", "samsung": "11", "electron": "6.0" }, "transform-private-methods": { "chrome": "84", "opera": "70", "edge": "84", "firefox": "90", "safari": "15", "node": "14.6", "ios": "15", "samsung": "14", "electron": "10.0" }, "proposal-private-methods": { "chrome": "84", "opera": "70", "edge": "84", "firefox": "90", "safari": "15", "node": "14.6", "ios": "15", "samsung": "14", "electron": "10.0" }, "transform-numeric-separator": { "chrome": "75", "opera": "62", "edge": "79", "firefox": "70", "safari": "13", "node": "12.5", "ios": "13", "samsung": "11", "rhino": "1.7.14", "electron": "6.0" }, "proposal-numeric-separator": { "chrome": "75", "opera": "62", "edge": "79", "firefox": "70", "safari": "13", "node": "12.5", "ios": "13", "samsung": "11", "rhino": "1.7.14", "electron": "6.0" }, "transform-logical-assignment-operators": { "chrome": "85", "opera": "71", "edge": "85", "firefox": "79", "safari": "14", "node": "15", "ios": "14", "samsung": "14", "electron": "10.0" }, "proposal-logical-assignment-operators": { "chrome": "85", "opera": "71", "edge": "85", "firefox": "79", "safari": "14", "node": "15", "ios": "14", "samsung": "14", "electron": "10.0" }, "transform-nullish-coalescing-operator": { "chrome": "80", "opera": "67", "edge": "80", "firefox": "72", "safari": "13.1", "node": "14", "ios": "13.4", "samsung": "13", "electron": "8.0" }, "proposal-nullish-coalescing-operator": { "chrome": "80", "opera": "67", "edge": "80", "firefox": "72", "safari": "13.1", "node": "14", "ios": "13.4", "samsung": "13", "electron": "8.0" }, "transform-optional-chaining": { "chrome": "91", "opera": "77", "edge": "91", "firefox": "74", "safari": "13.1", "node": "16.9", "ios": "13.4", "electron": "13.0" }, "proposal-optional-chaining": { "chrome": "91", "opera": "77", "edge": "91", "firefox": "74", "safari": "13.1", "node": "16.9", "ios": "13.4", "electron": "13.0" }, "transform-json-strings": { "chrome": "66", "opera": "53", "edge": "79", "firefox": "62", "safari": "12", "node": "10", "ios": "12", "samsung": "9", "rhino": "1.7.14", "electron": "3.0" }, "proposal-json-strings": { "chrome": "66", "opera": "53", "edge": "79", "firefox": "62", "safari": "12", "node": "10", "ios": "12", "samsung": "9", "rhino": "1.7.14", "electron": "3.0" }, "transform-optional-catch-binding": { "chrome": "66", "opera": "53", "edge": "79", "firefox": "58", "safari": "11.1", "node": "10", "ios": "11.3", "samsung": "9", "electron": "3.0" }, "proposal-optional-catch-binding": { "chrome": "66", "opera": "53", "edge": "79", "firefox": "58", "safari": "11.1", "node": "10", "ios": "11.3", "samsung": "9", "electron": "3.0" }, "transform-parameters": { "chrome": "49", "opera": "36", "edge": "18", "firefox": "53", "node": "6", "samsung": "5", "electron": "0.37" }, "transform-async-generator-functions": { "chrome": "63", "opera": "50", "edge": "79", "firefox": "57", "safari": "12", "node": "10", "ios": "12", "samsung": "8", "electron": "3.0" }, "proposal-async-generator-functions": { "chrome": "63", "opera": "50", "edge": "79", "firefox": "57", "safari": "12", "node": "10", "ios": "12", "samsung": "8", "electron": "3.0" }, "transform-object-rest-spread": { "chrome": "60", "opera": "47", "edge": "79", "firefox": "55", "safari": "11.1", "node": "8.3", "ios": "11.3", "samsung": "8", "electron": "2.0" }, "proposal-object-rest-spread": { "chrome": "60", "opera": "47", "edge": "79", "firefox": "55", "safari": "11.1", "node": "8.3", "ios": "11.3", "samsung": "8", "electron": "2.0" }, "transform-dotall-regex": { "chrome": "62", "opera": "49", "edge": "79", "firefox": "78", "safari": "11.1", "node": "8.10", "ios": "11.3", "samsung": "8", "electron": "3.0" }, "transform-unicode-property-regex": { "chrome": "64", "opera": "51", "edge": "79", "firefox": "78", "safari": "11.1", "node": "10", "ios": "11.3", "samsung": "9", "electron": "3.0" }, "proposal-unicode-property-regex": { "chrome": "64", "opera": "51", "edge": "79", "firefox": "78", "safari": "11.1", "node": "10", "ios": "11.3", "samsung": "9", "electron": "3.0" }, "transform-named-capturing-groups-regex": { "chrome": "64", "opera": "51", "edge": "79", "firefox": "78", "safari": "11.1", "node": "10", "ios": "11.3", "samsung": "9", "electron": "3.0" }, "transform-async-to-generator": { "chrome": "55", "opera": "42", "edge": "15", "firefox": "52", "safari": "11", "node": "7.6", "ios": "11", "samsung": "6", "electron": "1.6" }, "transform-exponentiation-operator": { "chrome": "52", "opera": "39", "edge": "14", "firefox": "52", "safari": "10.1", "node": "7", "ios": "10.3", "samsung": "6", "rhino": "1.7.14", "electron": "1.3" }, "transform-template-literals": { "chrome": "41", "opera": "28", "edge": "13", "firefox": "34", "safari": "13", "node": "4", "ios": "13", "samsung": "3.4", "electron": "0.21" }, "transform-literals": { "chrome": "44", "opera": "31", "edge": "12", "firefox": "53", "safari": "9", "node": "4", "ios": "9", "samsung": "4", "electron": "0.30" }, "transform-function-name": { "chrome": "51", "opera": "38", "edge": "79", "firefox": "53", "safari": "10", "node": "6.5", "ios": "10", "samsung": "5", "electron": "1.2" }, "transform-arrow-functions": { "chrome": "47", "opera": "34", "edge": "13", "firefox": "43", "safari": "10", "node": "6", "ios": "10", "samsung": "5", "rhino": "1.7.13", "electron": "0.36" }, "transform-block-scoped-functions": { "chrome": "41", "opera": "28", "edge": "12", "firefox": "46", "safari": "10", "node": "4", "ie": "11", "ios": "10", "samsung": "3.4", "electron": "0.21" }, "transform-classes": { "chrome": "46", "opera": "33", "edge": "13", "firefox": "45", "safari": "10", "node": "5", "ios": "10", "samsung": "5", "electron": "0.36" }, "transform-object-super": { "chrome": "46", "opera": "33", "edge": "13", "firefox": "45", "safari": "10", "node": "5", "ios": "10", "samsung": "5", "electron": "0.36" }, "transform-shorthand-properties": { "chrome": "43", "opera": "30", "edge": "12", "firefox": "33", "safari": "9", "node": "4", "ios": "9", "samsung": "4", "rhino": "1.7.14", "electron": "0.27" }, "transform-duplicate-keys": { "chrome": "42", "opera": "29", "edge": "12", "firefox": "34", "safari": "9", "node": "4", "ios": "9", "samsung": "3.4", "electron": "0.25" }, "transform-computed-properties": { "chrome": "44", "opera": "31", "edge": "12", "firefox": "34", "safari": "7.1", "node": "4", "ios": "8", "samsung": "4", "electron": "0.30" }, "transform-for-of": { "chrome": "51", "opera": "38", "edge": "15", "firefox": "53", "safari": "10", "node": "6.5", "ios": "10", "samsung": "5", "electron": "1.2" }, "transform-sticky-regex": { "chrome": "49", "opera": "36", "edge": "13", "firefox": "3", "safari": "10", "node": "6", "ios": "10", "samsung": "5", "electron": "0.37" }, "transform-unicode-escapes": { "chrome": "44", "opera": "31", "edge": "12", "firefox": "53", "safari": "9", "node": "4", "ios": "9", "samsung": "4", "electron": "0.30" }, "transform-unicode-regex": { "chrome": "50", "opera": "37", "edge": "13", "firefox": "46", "safari": "12", "node": "6", "ios": "12", "samsung": "5", "electron": "1.1" }, "transform-spread": { "chrome": "46", "opera": "33", "edge": "13", "firefox": "45", "safari": "10", "node": "5", "ios": "10", "samsung": "5", "electron": "0.36" }, "transform-destructuring": { "chrome": "51", "opera": "38", "edge": "15", "firefox": "53", "safari": "10", "node": "6.5", "ios": "10", "samsung": "5", "electron": "1.2" }, "transform-block-scoping": { "chrome": "49", "opera": "36", "edge": "14", "firefox": "51", "safari": "11", "node": "6", "ios": "11", "samsung": "5", "electron": "0.37" }, "transform-typeof-symbol": { "chrome": "38", "opera": "25", "edge": "12", "firefox": "36", "safari": "9", "node": "0.12", "ios": "9", "samsung": "3", "rhino": "1.7.13", "electron": "0.20" }, "transform-new-target": { "chrome": "46", "opera": "33", "edge": "14", "firefox": "41", "safari": "10", "node": "5", "ios": "10", "samsung": "5", "electron": "0.36" }, "transform-regenerator": { "chrome": "50", "opera": "37", "edge": "13", "firefox": "53", "safari": "10", "node": "6", "ios": "10", "samsung": "5", "electron": "1.1" }, "transform-member-expression-literals": { "chrome": "7", "opera": "12", "edge": "12", "firefox": "2", "safari": "5.1", "node": "0.4", "ie": "9", "android": "4", "ios": "6", "phantom": "1.9", "samsung": "1", "rhino": "1.7.13", "electron": "0.20" }, "transform-property-literals": { "chrome": "7", "opera": "12", "edge": "12", "firefox": "2", "safari": "5.1", "node": "0.4", "ie": "9", "android": "4", "ios": "6", "phantom": "1.9", "samsung": "1", "rhino": "1.7.13", "electron": "0.20" }, "transform-reserved-words": { "chrome": "13", "opera": "10.50", "edge": "12", "firefox": "2", "safari": "3.1", "node": "0.6", "ie": "9", "android": "4.4", "ios": "6", "phantom": "1.9", "samsung": "1", "rhino": "1.7.13", "electron": "0.20" }, "transform-export-namespace-from": { "chrome": "72", "and_chr": "72", "edge": "79", "firefox": "80", "and_ff": "80", "node": "13.2", "opera": "60", "op_mob": "51", "samsung": "11.0", "android": "72", "electron": "5.0" }, "proposal-export-namespace-from": { "chrome": "72", "and_chr": "72", "edge": "79", "firefox": "80", "and_ff": "80", "node": "13.2", "opera": "60", "op_mob": "51", "samsung": "11.0", "android": "72", "electron": "5.0" } } },{}],7:[function(require,module,exports){ module.exports = require("./data/native-modules.json"); },{"./data/native-modules.json":5}],8:[function(require,module,exports){ module.exports = require("./data/plugins.json"); },{"./data/plugins.json":6}],9:[function(require,module,exports){ },{}],10:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.makeWeakCache = makeWeakCache; exports.makeWeakCacheSync = makeWeakCacheSync; exports.makeStrongCache = makeStrongCache; exports.makeStrongCacheSync = makeStrongCacheSync; exports.assertSimpleType = assertSimpleType; function _gensync() { const data = require("gensync"); _gensync = function () { return data; }; return data; } var _async = require("../gensync-utils/async"); var _util = require("./util"); const synchronize = gen => { return _gensync()(gen).sync; }; function* genTrue() { return true; } function makeWeakCache(handler) { return makeCachedFunction(WeakMap, handler); } function makeWeakCacheSync(handler) { return synchronize(makeWeakCache(handler)); } function makeStrongCache(handler) { return makeCachedFunction(Map, handler); } function makeStrongCacheSync(handler) { return synchronize(makeStrongCache(handler)); } function makeCachedFunction(CallCache, handler) { const callCacheSync = new CallCache(); const callCacheAsync = new CallCache(); const futureCache = new CallCache(); return function* cachedFunction(arg, data) { const asyncContext = yield* (0, _async.isAsync)(); const callCache = asyncContext ? callCacheAsync : callCacheSync; const cached = yield* getCachedValueOrWait(asyncContext, callCache, futureCache, arg, data); if (cached.valid) return cached.value; const cache = new CacheConfigurator(data); const handlerResult = handler(arg, cache); let finishLock; let value; if ((0, _util.isIterableIterator)(handlerResult)) { const gen = handlerResult; value = yield* (0, _async.onFirstPause)(gen, () => { finishLock = setupAsyncLocks(cache, futureCache, arg); }); } else { value = handlerResult; } updateFunctionCache(callCache, cache, arg, value); if (finishLock) { futureCache.delete(arg); finishLock.release(value); } return value; }; } function* getCachedValue(cache, arg, data) { const cachedValue = cache.get(arg); if (cachedValue) { for (const { value, valid } of cachedValue) { if (yield* valid(data)) return { valid: true, value }; } } return { valid: false, value: null }; } function* getCachedValueOrWait(asyncContext, callCache, futureCache, arg, data) { const cached = yield* getCachedValue(callCache, arg, data); if (cached.valid) { return cached; } if (asyncContext) { const cached = yield* getCachedValue(futureCache, arg, data); if (cached.valid) { const value = yield* (0, _async.waitFor)(cached.value.promise); return { valid: true, value }; } } return { valid: false, value: null }; } function setupAsyncLocks(config, futureCache, arg) { const finishLock = new Lock(); updateFunctionCache(futureCache, config, arg, finishLock); return finishLock; } function updateFunctionCache(cache, config, arg, value) { if (!config.configured()) config.forever(); let cachedValue = cache.get(arg); config.deactivate(); switch (config.mode()) { case "forever": cachedValue = [{ value, valid: genTrue }]; cache.set(arg, cachedValue); break; case "invalidate": cachedValue = [{ value, valid: config.validator() }]; cache.set(arg, cachedValue); break; case "valid": if (cachedValue) { cachedValue.push({ value, valid: config.validator() }); } else { cachedValue = [{ value, valid: config.validator() }]; cache.set(arg, cachedValue); } } } class CacheConfigurator { constructor(data) { this._active = true; this._never = false; this._forever = false; this._invalidate = false; this._configured = false; this._pairs = []; this._data = void 0; this._data = data; } simple() { return makeSimpleConfigurator(this); } mode() { if (this._never) return "never"; if (this._forever) return "forever"; if (this._invalidate) return "invalidate"; return "valid"; } forever() { if (!this._active) { throw new Error("Cannot change caching after evaluation has completed."); } if (this._never) { throw new Error("Caching has already been configured with .never()"); } this._forever = true; this._configured = true; } never() { if (!this._active) { throw new Error("Cannot change caching after evaluation has completed."); } if (this._forever) { throw new Error("Caching has already been configured with .forever()"); } this._never = true; this._configured = true; } using(handler) { if (!this._active) { throw new Error("Cannot change caching after evaluation has completed."); } if (this._never || this._forever) { throw new Error("Caching has already been configured with .never or .forever()"); } this._configured = true; const key = handler(this._data); const fn = (0, _async.maybeAsync)(handler, `You appear to be using an async cache handler, but Babel has been called synchronously`); if ((0, _async.isThenable)(key)) { return key.then(key => { this._pairs.push([key, fn]); return key; }); } this._pairs.push([key, fn]); return key; } invalidate(handler) { this._invalidate = true; return this.using(handler); } validator() { const pairs = this._pairs; return function* (data) { for (const [key, fn] of pairs) { if (key !== (yield* fn(data))) return false; } return true; }; } deactivate() { this._active = false; } configured() { return this._configured; } } function makeSimpleConfigurator(cache) { function cacheFn(val) { if (typeof val === "boolean") { if (val) cache.forever();else cache.never(); return; } return cache.using(() => assertSimpleType(val())); } cacheFn.forever = () => cache.forever(); cacheFn.never = () => cache.never(); cacheFn.using = cb => cache.using(() => assertSimpleType(cb())); cacheFn.invalidate = cb => cache.invalidate(() => assertSimpleType(cb())); return cacheFn; } function assertSimpleType(value) { if ((0, _async.isThenable)(value)) { throw new Error(`You appear to be using an async cache handler, ` + `which your current version of Babel does not support. ` + `We may add support for this in the future, ` + `but if you're on the most recent version of @babel/core and still ` + `seeing this error, then you'll need to synchronously handle your caching logic.`); } if (value != null && typeof value !== "string" && typeof value !== "boolean" && typeof value !== "number") { throw new Error("Cache keys must be either string, boolean, number, null, or undefined."); } return value; } class Lock { constructor() { this.released = false; this.promise = void 0; this._resolve = void 0; this.promise = new Promise(resolve => { this._resolve = resolve; }); } release(value) { this.released = true; this._resolve(value); } } },{"../gensync-utils/async":29,"./util":24,"gensync":439}],11:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.buildPresetChain = buildPresetChain; exports.buildRootChain = buildRootChain; exports.buildPresetChainWalker = void 0; function _path() { const data = require("path"); _path = function () { return data; }; return data; } function _debug() { const data = require("debug"); _debug = function () { return data; }; return data; } var _options = require("./validation/options"); var _patternToRegex = require("./pattern-to-regex"); var _printer = require("./printer"); var _files = require("./files"); var _caching = require("./caching"); var _configDescriptors = require("./config-descriptors"); const debug = _debug()("babel:config:config-chain"); function* buildPresetChain(arg, context) { const chain = yield* buildPresetChainWalker(arg, context); if (!chain) return null; return { plugins: dedupDescriptors(chain.plugins), presets: dedupDescriptors(chain.presets), options: chain.options.map(o => normalizeOptions(o)), files: new Set() }; } const buildPresetChainWalker = makeChainWalker({ root: preset => loadPresetDescriptors(preset), env: (preset, envName) => loadPresetEnvDescriptors(preset)(envName), overrides: (preset, index) => loadPresetOverridesDescriptors(preset)(index), overridesEnv: (preset, index, envName) => loadPresetOverridesEnvDescriptors(preset)(index)(envName), createLogger: () => () => {} }); exports.buildPresetChainWalker = buildPresetChainWalker; const loadPresetDescriptors = (0, _caching.makeWeakCacheSync)(preset => buildRootDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors)); const loadPresetEnvDescriptors = (0, _caching.makeWeakCacheSync)(preset => (0, _caching.makeStrongCacheSync)(envName => buildEnvDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, envName))); const loadPresetOverridesDescriptors = (0, _caching.makeWeakCacheSync)(preset => (0, _caching.makeStrongCacheSync)(index => buildOverrideDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, index))); const loadPresetOverridesEnvDescriptors = (0, _caching.makeWeakCacheSync)(preset => (0, _caching.makeStrongCacheSync)(index => (0, _caching.makeStrongCacheSync)(envName => buildOverrideEnvDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, index, envName)))); function* buildRootChain(opts, context) { let configReport, babelRcReport; const programmaticLogger = new _printer.ConfigPrinter(); const programmaticChain = yield* loadProgrammaticChain({ options: opts, dirname: context.cwd }, context, undefined, programmaticLogger); if (!programmaticChain) return null; const programmaticReport = yield* programmaticLogger.output(); let configFile; if (typeof opts.configFile === "string") { configFile = yield* (0, _files.loadConfig)(opts.configFile, context.cwd, context.envName, context.caller); } else if (opts.configFile !== false) { configFile = yield* (0, _files.findRootConfig)(context.root, context.envName, context.caller); } let { babelrc, babelrcRoots } = opts; let babelrcRootsDirectory = context.cwd; const configFileChain = emptyChain(); const configFileLogger = new _printer.ConfigPrinter(); if (configFile) { const validatedFile = validateConfigFile(configFile); const result = yield* loadFileChain(validatedFile, context, undefined, configFileLogger); if (!result) return null; configReport = yield* configFileLogger.output(); if (babelrc === undefined) { babelrc = validatedFile.options.babelrc; } if (babelrcRoots === undefined) { babelrcRootsDirectory = validatedFile.dirname; babelrcRoots = validatedFile.options.babelrcRoots; } mergeChain(configFileChain, result); } let ignoreFile, babelrcFile; let isIgnored = false; const fileChain = emptyChain(); if ((babelrc === true || babelrc === undefined) && typeof context.filename === "string") { const pkgData = yield* (0, _files.findPackageData)(context.filename); if (pkgData && babelrcLoadEnabled(context, pkgData, babelrcRoots, babelrcRootsDirectory)) { ({ ignore: ignoreFile, config: babelrcFile } = yield* (0, _files.findRelativeConfig)(pkgData, context.envName, context.caller)); if (ignoreFile) { fileChain.files.add(ignoreFile.filepath); } if (ignoreFile && shouldIgnore(context, ignoreFile.ignore, null, ignoreFile.dirname)) { isIgnored = true; } if (babelrcFile && !isIgnored) { const validatedFile = validateBabelrcFile(babelrcFile); const babelrcLogger = new _printer.ConfigPrinter(); const result = yield* loadFileChain(validatedFile, context, undefined, babelrcLogger); if (!result) { isIgnored = true; } else { babelRcReport = yield* babelrcLogger.output(); mergeChain(fileChain, result); } } if (babelrcFile && isIgnored) { fileChain.files.add(babelrcFile.filepath); } } } if (context.showConfig) { console.log(`Babel configs on "${context.filename}" (ascending priority):\n` + [configReport, babelRcReport, programmaticReport].filter(x => !!x).join("\n\n") + "\n-----End Babel configs-----"); } const chain = mergeChain(mergeChain(mergeChain(emptyChain(), configFileChain), fileChain), programmaticChain); return { plugins: isIgnored ? [] : dedupDescriptors(chain.plugins), presets: isIgnored ? [] : dedupDescriptors(chain.presets), options: isIgnored ? [] : chain.options.map(o => normalizeOptions(o)), fileHandling: isIgnored ? "ignored" : "transpile", ignore: ignoreFile || undefined, babelrc: babelrcFile || undefined, config: configFile || undefined, files: chain.files }; } function babelrcLoadEnabled(context, pkgData, babelrcRoots, babelrcRootsDirectory) { if (typeof babelrcRoots === "boolean") return babelrcRoots; const absoluteRoot = context.root; if (babelrcRoots === undefined) { return pkgData.directories.indexOf(absoluteRoot) !== -1; } let babelrcPatterns = babelrcRoots; if (!Array.isArray(babelrcPatterns)) { babelrcPatterns = [babelrcPatterns]; } babelrcPatterns = babelrcPatterns.map(pat => { return typeof pat === "string" ? _path().resolve(babelrcRootsDirectory, pat) : pat; }); if (babelrcPatterns.length === 1 && babelrcPatterns[0] === absoluteRoot) { return pkgData.directories.indexOf(absoluteRoot) !== -1; } return babelrcPatterns.some(pat => { if (typeof pat === "string") { pat = (0, _patternToRegex.default)(pat, babelrcRootsDirectory); } return pkgData.directories.some(directory => { return matchPattern(pat, babelrcRootsDirectory, directory, context); }); }); } const validateConfigFile = (0, _caching.makeWeakCacheSync)(file => ({ filepath: file.filepath, dirname: file.dirname, options: (0, _options.validate)("configfile", file.options) })); const validateBabelrcFile = (0, _caching.makeWeakCacheSync)(file => ({ filepath: file.filepath, dirname: file.dirname, options: (0, _options.validate)("babelrcfile", file.options) })); const validateExtendFile = (0, _caching.makeWeakCacheSync)(file => ({ filepath: file.filepath, dirname: file.dirname, options: (0, _options.validate)("extendsfile", file.options) })); const loadProgrammaticChain = makeChainWalker({ root: input => buildRootDescriptors(input, "base", _configDescriptors.createCachedDescriptors), env: (input, envName) => buildEnvDescriptors(input, "base", _configDescriptors.createCachedDescriptors, envName), overrides: (input, index) => buildOverrideDescriptors(input, "base", _configDescriptors.createCachedDescriptors, index), overridesEnv: (input, index, envName) => buildOverrideEnvDescriptors(input, "base", _configDescriptors.createCachedDescriptors, index, envName), createLogger: (input, context, baseLogger) => buildProgrammaticLogger(input, context, baseLogger) }); const loadFileChainWalker = makeChainWalker({ root: file => loadFileDescriptors(file), env: (file, envName) => loadFileEnvDescriptors(file)(envName), overrides: (file, index) => loadFileOverridesDescriptors(file)(index), overridesEnv: (file, index, envName) => loadFileOverridesEnvDescriptors(file)(index)(envName), createLogger: (file, context, baseLogger) => buildFileLogger(file.filepath, context, baseLogger) }); function* loadFileChain(input, context, files, baseLogger) { const chain = yield* loadFileChainWalker(input, context, files, baseLogger); if (chain) { chain.files.add(input.filepath); } return chain; } const loadFileDescriptors = (0, _caching.makeWeakCacheSync)(file => buildRootDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors)); const loadFileEnvDescriptors = (0, _caching.makeWeakCacheSync)(file => (0, _caching.makeStrongCacheSync)(envName => buildEnvDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, envName))); const loadFileOverridesDescriptors = (0, _caching.makeWeakCacheSync)(file => (0, _caching.makeStrongCacheSync)(index => buildOverrideDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, index))); const loadFileOverridesEnvDescriptors = (0, _caching.makeWeakCacheSync)(file => (0, _caching.makeStrongCacheSync)(index => (0, _caching.makeStrongCacheSync)(envName => buildOverrideEnvDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, index, envName)))); function buildFileLogger(filepath, context, baseLogger) { if (!baseLogger) { return () => {}; } return baseLogger.configure(context.showConfig, _printer.ChainFormatter.Config, { filepath }); } function buildRootDescriptors({ dirname, options }, alias, descriptors) { return descriptors(dirname, options, alias); } function buildProgrammaticLogger(_, context, baseLogger) { var _context$caller; if (!baseLogger) { return () => {}; } return baseLogger.configure(context.showConfig, _printer.ChainFormatter.Programmatic, { callerName: (_context$caller = context.caller) == null ? void 0 : _context$caller.name }); } function buildEnvDescriptors({ dirname, options }, alias, descriptors, envName) { const opts = options.env && options.env[envName]; return opts ? descriptors(dirname, opts, `${alias}.env["${envName}"]`) : null; } function buildOverrideDescriptors({ dirname, options }, alias, descriptors, index) { const opts = options.overrides && options.overrides[index]; if (!opts) throw new Error("Assertion failure - missing override"); return descriptors(dirname, opts, `${alias}.overrides[${index}]`); } function buildOverrideEnvDescriptors({ dirname, options }, alias, descriptors, index, envName) { const override = options.overrides && options.overrides[index]; if (!override) throw new Error("Assertion failure - missing override"); const opts = override.env && override.env[envName]; return opts ? descriptors(dirname, opts, `${alias}.overrides[${index}].env["${envName}"]`) : null; } function makeChainWalker({ root, env, overrides, overridesEnv, createLogger }) { return function* (input, context, files = new Set(), baseLogger) { const { dirname } = input; const flattenedConfigs = []; const rootOpts = root(input); if (configIsApplicable(rootOpts, dirname, context)) { flattenedConfigs.push({ config: rootOpts, envName: undefined, index: undefined }); const envOpts = env(input, context.envName); if (envOpts && configIsApplicable(envOpts, dirname, context)) { flattenedConfigs.push({ config: envOpts, envName: context.envName, index: undefined }); } (rootOpts.options.overrides || []).forEach((_, index) => { const overrideOps = overrides(input, index); if (configIsApplicable(overrideOps, dirname, context)) { flattenedConfigs.push({ config: overrideOps, index, envName: undefined }); const overrideEnvOpts = overridesEnv(input, index, context.envName); if (overrideEnvOpts && configIsApplicable(overrideEnvOpts, dirname, context)) { flattenedConfigs.push({ config: overrideEnvOpts, index, envName: context.envName }); } } }); } if (flattenedConfigs.some(({ config: { options: { ignore, only } } }) => shouldIgnore(context, ignore, only, dirname))) { return null; } const chain = emptyChain(); const logger = createLogger(input, context, baseLogger); for (const { config, index, envName } of flattenedConfigs) { if (!(yield* mergeExtendsChain(chain, config.options, dirname, context, files, baseLogger))) { return null; } logger(config, index, envName); yield* mergeChainOpts(chain, config); } return chain; }; } function* mergeExtendsChain(chain, opts, dirname, context, files, baseLogger) { if (opts.extends === undefined) return true; const file = yield* (0, _files.loadConfig)(opts.extends, dirname, context.envName, context.caller); if (files.has(file)) { throw new Error(`Configuration cycle detected loading ${file.filepath}.\n` + `File already loaded following the config chain:\n` + Array.from(files, file => ` - ${file.filepath}`).join("\n")); } files.add(file); const fileChain = yield* loadFileChain(validateExtendFile(file), context, files, baseLogger); files.delete(file); if (!fileChain) return false; mergeChain(chain, fileChain); return true; } function mergeChain(target, source) { target.options.push(...source.options); target.plugins.push(...source.plugins); target.presets.push(...source.presets); for (const file of source.files) { target.files.add(file); } return target; } function* mergeChainOpts(target, { options, plugins, presets }) { target.options.push(options); target.plugins.push(...(yield* plugins())); target.presets.push(...(yield* presets())); return target; } function emptyChain() { return { options: [], presets: [], plugins: [], files: new Set() }; } function normalizeOptions(opts) { const options = Object.assign({}, opts); delete options.extends; delete options.env; delete options.overrides; delete options.plugins; delete options.presets; delete options.passPerPreset; delete options.ignore; delete options.only; delete options.test; delete options.include; delete options.exclude; if (Object.prototype.hasOwnProperty.call(options, "sourceMap")) { options.sourceMaps = options.sourceMap; delete options.sourceMap; } return options; } function dedupDescriptors(items) { const map = new Map(); const descriptors = []; for (const item of items) { if (typeof item.value === "function") { const fnKey = item.value; let nameMap = map.get(fnKey); if (!nameMap) { nameMap = new Map(); map.set(fnKey, nameMap); } let desc = nameMap.get(item.name); if (!desc) { desc = { value: item }; descriptors.push(desc); if (!item.ownPass) nameMap.set(item.name, desc); } else { desc.value = item; } } else { descriptors.push({ value: item }); } } return descriptors.reduce((acc, desc) => { acc.push(desc.value); return acc; }, []); } function configIsApplicable({ options }, dirname, context) { return (options.test === undefined || configFieldIsApplicable(context, options.test, dirname)) && (options.include === undefined || configFieldIsApplicable(context, options.include, dirname)) && (options.exclude === undefined || !configFieldIsApplicable(context, options.exclude, dirname)); } function configFieldIsApplicable(context, test, dirname) { const patterns = Array.isArray(test) ? test : [test]; return matchesPatterns(context, patterns, dirname); } function shouldIgnore(context, ignore, only, dirname) { if (ignore && matchesPatterns(context, ignore, dirname)) { var _context$filename; const message = `No config is applied to "${(_context$filename = context.filename) != null ? _context$filename : "(unknown)"}" because it matches one of \`ignore: ${JSON.stringify(ignore)}\` from "${dirname}"`; debug(message); if (context.showConfig) { console.log(message); } return true; } if (only && !matchesPatterns(context, only, dirname)) { var _context$filename2; const message = `No config is applied to "${(_context$filename2 = context.filename) != null ? _context$filename2 : "(unknown)"}" because it fails to match one of \`only: ${JSON.stringify(only)}\` from "${dirname}"`; debug(message); if (context.showConfig) { console.log(message); } return true; } return false; } function matchesPatterns(context, patterns, dirname) { return patterns.some(pattern => matchPattern(pattern, dirname, context.filename, context)); } function matchPattern(pattern, dirname, pathToTest, context) { if (typeof pattern === "function") { return !!pattern(pathToTest, { dirname, envName: context.envName, caller: context.caller }); } if (typeof pathToTest !== "string") { throw new Error(`Configuration contains string/RegExp pattern, but no filename was passed to Babel`); } if (typeof pattern === "string") { pattern = (0, _patternToRegex.default)(pattern, dirname); } return pattern.test(pathToTest); } },{"./caching":10,"./config-descriptors":12,"./files":13,"./pattern-to-regex":20,"./printer":22,"./validation/options":26,"debug":430,"path":459}],12:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.createCachedDescriptors = createCachedDescriptors; exports.createUncachedDescriptors = createUncachedDescriptors; exports.createDescriptor = createDescriptor; function _gensync() { const data = require("gensync"); _gensync = function () { return data; }; return data; } var _files = require("./files"); var _item = require("./item"); var _caching = require("./caching"); var _resolveTargets = require("./resolve-targets"); function isEqualDescriptor(a, b) { return a.name === b.name && a.value === b.value && a.options === b.options && a.dirname === b.dirname && a.alias === b.alias && a.ownPass === b.ownPass && (a.file && a.file.request) === (b.file && b.file.request) && (a.file && a.file.resolved) === (b.file && b.file.resolved); } function* handlerOf(value) { return value; } function optionsWithResolvedBrowserslistConfigFile(options, dirname) { if (typeof options.browserslistConfigFile === "string") { options.browserslistConfigFile = (0, _resolveTargets.resolveBrowserslistConfigFile)(options.browserslistConfigFile, dirname); } return options; } function createCachedDescriptors(dirname, options, alias) { const { plugins, presets, passPerPreset } = options; return { options: optionsWithResolvedBrowserslistConfigFile(options, dirname), plugins: plugins ? () => createCachedPluginDescriptors(plugins, dirname)(alias) : () => handlerOf([]), presets: presets ? () => createCachedPresetDescriptors(presets, dirname)(alias)(!!passPerPreset) : () => handlerOf([]) }; } function createUncachedDescriptors(dirname, options, alias) { let plugins; let presets; return { options: optionsWithResolvedBrowserslistConfigFile(options, dirname), *plugins() { if (!plugins) { plugins = yield* createPluginDescriptors(options.plugins || [], dirname, alias); } return plugins; }, *presets() { if (!presets) { presets = yield* createPresetDescriptors(options.presets || [], dirname, alias, !!options.passPerPreset); } return presets; } }; } const PRESET_DESCRIPTOR_CACHE = new WeakMap(); const createCachedPresetDescriptors = (0, _caching.makeWeakCacheSync)((items, cache) => { const dirname = cache.using(dir => dir); return (0, _caching.makeStrongCacheSync)(alias => (0, _caching.makeStrongCache)(function* (passPerPreset) { const descriptors = yield* createPresetDescriptors(items, dirname, alias, passPerPreset); return descriptors.map(desc => loadCachedDescriptor(PRESET_DESCRIPTOR_CACHE, desc)); })); }); const PLUGIN_DESCRIPTOR_CACHE = new WeakMap(); const createCachedPluginDescriptors = (0, _caching.makeWeakCacheSync)((items, cache) => { const dirname = cache.using(dir => dir); return (0, _caching.makeStrongCache)(function* (alias) { const descriptors = yield* createPluginDescriptors(items, dirname, alias); return descriptors.map(desc => loadCachedDescriptor(PLUGIN_DESCRIPTOR_CACHE, desc)); }); }); const DEFAULT_OPTIONS = {}; function loadCachedDescriptor(cache, desc) { const { value, options = DEFAULT_OPTIONS } = desc; if (options === false) return desc; let cacheByOptions = cache.get(value); if (!cacheByOptions) { cacheByOptions = new WeakMap(); cache.set(value, cacheByOptions); } let possibilities = cacheByOptions.get(options); if (!possibilities) { possibilities = []; cacheByOptions.set(options, possibilities); } if (possibilities.indexOf(desc) === -1) { const matches = possibilities.filter(possibility => isEqualDescriptor(possibility, desc)); if (matches.length > 0) { return matches[0]; } possibilities.push(desc); } return desc; } function* createPresetDescriptors(items, dirname, alias, passPerPreset) { return yield* createDescriptors("preset", items, dirname, alias, passPerPreset); } function* createPluginDescriptors(items, dirname, alias) { return yield* createDescriptors("plugin", items, dirname, alias); } function* createDescriptors(type, items, dirname, alias, ownPass) { const descriptors = yield* _gensync().all(items.map((item, index) => createDescriptor(item, dirname, { type, alias: `${alias}$${index}`, ownPass: !!ownPass }))); assertNoDuplicates(descriptors); return descriptors; } function* createDescriptor(pair, dirname, { type, alias, ownPass }) { const desc = (0, _item.getItemDescriptor)(pair); if (desc) { return desc; } let name; let options; let value = pair; if (Array.isArray(value)) { if (value.length === 3) { [value, options, name] = value; } else { [value, options] = value; } } let file = undefined; let filepath = null; if (typeof value === "string") { if (typeof type !== "string") { throw new Error("To resolve a string-based item, the type of item must be given"); } const resolver = type === "plugin" ? _files.loadPlugin : _files.loadPreset; const request = value; ({ filepath, value } = yield* resolver(value, dirname)); file = { request, resolved: filepath }; } if (!value) { throw new Error(`Unexpected falsy value: ${String(value)}`); } if (typeof value === "object" && value.__esModule) { if (value.default) { value = value.default; } else { throw new Error("Must export a default export when using ES6 modules."); } } if (typeof value !== "object" && typeof value !== "function") { throw new Error(`Unsupported format: ${typeof value}. Expected an object or a function.`); } if (filepath !== null && typeof value === "object" && value) { throw new Error(`Plugin/Preset files are not allowed to export objects, only functions. In ${filepath}`); } return { name, alias: filepath || alias, value, options, dirname, ownPass, file }; } function assertNoDuplicates(items) { const map = new Map(); for (const item of items) { if (typeof item.value !== "function") continue; let nameMap = map.get(item.value); if (!nameMap) { nameMap = new Set(); map.set(item.value, nameMap); } if (nameMap.has(item.name)) { const conflicts = items.filter(i => i.value === item.value); throw new Error([`Duplicate plugin/preset detected.`, `If you'd like to use two separate instances of a plugin,`, `they need separate names, e.g.`, ``, ` plugins: [`, ` ['some-plugin', {}],`, ` ['some-plugin', {}, 'some unique name'],`, ` ]`, ``, `Duplicates detected are:`, `${JSON.stringify(conflicts, null, 2)}`].join("\n")); } nameMap.add(item.name); } } },{"./caching":10,"./files":13,"./item":18,"./resolve-targets":23,"gensync":439}],13:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.findConfigUpwards = findConfigUpwards; exports.findPackageData = findPackageData; exports.findRelativeConfig = findRelativeConfig; exports.findRootConfig = findRootConfig; exports.loadConfig = loadConfig; exports.resolveShowConfigPath = resolveShowConfigPath; exports.resolvePlugin = resolvePlugin; exports.resolvePreset = resolvePreset; exports.loadPlugin = loadPlugin; exports.loadPreset = loadPreset; exports.ROOT_CONFIG_FILENAMES = void 0; function findConfigUpwards(rootDir) { return null; } function* findPackageData(filepath) { return { filepath, directories: [], pkg: null, isPackage: false }; } function* findRelativeConfig(pkgData, envName, caller) { return { config: null, ignore: null }; } function* findRootConfig(dirname, envName, caller) { return null; } function* loadConfig(name, dirname, envName, caller) { throw new Error(`Cannot load ${name} relative to ${dirname} in a browser`); } function* resolveShowConfigPath(dirname) { return null; } const ROOT_CONFIG_FILENAMES = []; exports.ROOT_CONFIG_FILENAMES = ROOT_CONFIG_FILENAMES; function resolvePlugin(name, dirname) { return null; } function resolvePreset(name, dirname) { return null; } function loadPlugin(name, dirname) { throw new Error(`Cannot load plugin ${name} relative to ${dirname} in a browser`); } function loadPreset(name, dirname) { throw new Error(`Cannot load preset ${name} relative to ${dirname} in a browser`); } },{}],14:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = void 0; function _gensync() { const data = require("gensync"); _gensync = function () { return data; }; return data; } var _async = require("../gensync-utils/async"); var _util = require("./util"); var context = require("../index"); var _plugin = require("./plugin"); var _item = require("./item"); var _configChain = require("./config-chain"); function _traverse() { const data = require("@babel/traverse"); _traverse = function () { return data; }; return data; } var _caching = require("./caching"); var _options = require("./validation/options"); var _plugins = require("./validation/plugins"); var _configApi = require("./helpers/config-api"); var _partial = require("./partial"); var Context = require("./cache-contexts"); var _default = _gensync()(function* loadFullConfig(inputOpts) { var _opts$assumptions; const result = yield* (0, _partial.default)(inputOpts); if (!result) { return null; } const { options, context, fileHandling } = result; if (fileHandling === "ignored") { return null; } const optionDefaults = {}; const { plugins, presets } = options; if (!plugins || !presets) { throw new Error("Assertion failure - plugins and presets exist"); } const presetContext = Object.assign({}, context, { targets: options.targets }); const toDescriptor = item => { const desc = (0, _item.getItemDescriptor)(item); if (!desc) { throw new Error("Assertion failure - must be config item"); } return desc; }; const presetsDescriptors = presets.map(toDescriptor); const initialPluginsDescriptors = plugins.map(toDescriptor); const pluginDescriptorsByPass = [[]]; const passes = []; const ignored = yield* enhanceError(context, function* recursePresetDescriptors(rawPresets, pluginDescriptorsPass) { const presets = []; for (let i = 0; i < rawPresets.length; i++) { const descriptor = rawPresets[i]; if (descriptor.options !== false) { try { if (descriptor.ownPass) { presets.push({ preset: yield* loadPresetDescriptor(descriptor, presetContext), pass: [] }); } else { presets.unshift({ preset: yield* loadPresetDescriptor(descriptor, presetContext), pass: pluginDescriptorsPass }); } } catch (e) { if (e.code === "BABEL_UNKNOWN_OPTION") { (0, _options.checkNoUnwrappedItemOptionPairs)(rawPresets, i, "preset", e); } throw e; } } } if (presets.length > 0) { pluginDescriptorsByPass.splice(1, 0, ...presets.map(o => o.pass).filter(p => p !== pluginDescriptorsPass)); for (const { preset, pass } of presets) { if (!preset) return true; pass.push(...preset.plugins); const ignored = yield* recursePresetDescriptors(preset.presets, pass); if (ignored) return true; preset.options.forEach(opts => { (0, _util.mergeOptions)(optionDefaults, opts); }); } } })(presetsDescriptors, pluginDescriptorsByPass[0]); if (ignored) return null; const opts = optionDefaults; (0, _util.mergeOptions)(opts, options); const pluginContext = Object.assign({}, presetContext, { assumptions: (_opts$assumptions = opts.assumptions) != null ? _opts$assumptions : {} }); yield* enhanceError(context, function* loadPluginDescriptors() { pluginDescriptorsByPass[0].unshift(...initialPluginsDescriptors); for (const descs of pluginDescriptorsByPass) { const pass = []; passes.push(pass); for (let i = 0; i < descs.length; i++) { const descriptor = descs[i]; if (descriptor.options !== false) { try { pass.push(yield* loadPluginDescriptor(descriptor, pluginContext)); } catch (e) { if (e.code === "BABEL_UNKNOWN_PLUGIN_PROPERTY") { (0, _options.checkNoUnwrappedItemOptionPairs)(descs, i, "plugin", e); } throw e; } } } } })(); opts.plugins = passes[0]; opts.presets = passes.slice(1).filter(plugins => plugins.length > 0).map(plugins => ({ plugins })); opts.passPerPreset = opts.presets.length > 0; return { options: opts, passes: passes }; }); exports.default = _default; function enhanceError(context, fn) { return function* (arg1, arg2) { try { return yield* fn(arg1, arg2); } catch (e) { if (!/^\[BABEL\]/.test(e.message)) { e.message = `[BABEL] ${context.filename || "unknown"}: ${e.message}`; } throw e; } }; } const makeDescriptorLoader = apiFactory => (0, _caching.makeWeakCache)(function* ({ value, options, dirname, alias }, cache) { if (options === false) throw new Error("Assertion failure"); options = options || {}; let item = value; if (typeof value === "function") { const factory = (0, _async.maybeAsync)(value, `You appear to be using an async plugin/preset, but Babel has been called synchronously`); const api = Object.assign({}, context, apiFactory(cache)); try { item = yield* factory(api, options, dirname); } catch (e) { if (alias) { e.message += ` (While processing: ${JSON.stringify(alias)})`; } throw e; } } if (!item || typeof item !== "object") { throw new Error("Plugin/Preset did not return an object."); } if ((0, _async.isThenable)(item)) { yield* []; throw new Error(`You appear to be using a promise as a plugin, ` + `which your current version of Babel does not support. ` + `If you're using a published plugin, ` + `you may need to upgrade your @babel/core version. ` + `As an alternative, you can prefix the promise with "await". ` + `(While processing: ${JSON.stringify(alias)})`); } return { value: item, options, dirname, alias }; }); const pluginDescriptorLoader = makeDescriptorLoader(_configApi.makePluginAPI); const presetDescriptorLoader = makeDescriptorLoader(_configApi.makePresetAPI); function* loadPluginDescriptor(descriptor, context) { if (descriptor.value instanceof _plugin.default) { if (descriptor.options) { throw new Error("Passed options to an existing Plugin instance will not work."); } return descriptor.value; } return yield* instantiatePlugin(yield* pluginDescriptorLoader(descriptor, context), context); } const instantiatePlugin = (0, _caching.makeWeakCache)(function* ({ value, options, dirname, alias }, cache) { const pluginObj = (0, _plugins.validatePluginObject)(value); const plugin = Object.assign({}, pluginObj); if (plugin.visitor) { plugin.visitor = _traverse().default.explode(Object.assign({}, plugin.visitor)); } if (plugin.inherits) { const inheritsDescriptor = { name: undefined, alias: `${alias}$inherits`, value: plugin.inherits, options, dirname }; const inherits = yield* (0, _async.forwardAsync)(loadPluginDescriptor, run => { return cache.invalidate(data => run(inheritsDescriptor, data)); }); plugin.pre = chain(inherits.pre, plugin.pre); plugin.post = chain(inherits.post, plugin.post); plugin.manipulateOptions = chain(inherits.manipulateOptions, plugin.manipulateOptions); plugin.visitor = _traverse().default.visitors.merge([inherits.visitor || {}, plugin.visitor || {}]); } return new _plugin.default(plugin, options, alias); }); const validateIfOptionNeedsFilename = (options, descriptor) => { if (options.test || options.include || options.exclude) { const formattedPresetName = descriptor.name ? `"${descriptor.name}"` : "/* your preset */"; throw new Error([`Preset ${formattedPresetName} requires a filename to be set when babel is called directly,`, `\`\`\``, `babel.transform(code, { filename: 'file.ts', presets: [${formattedPresetName}] });`, `\`\`\``, `See https://babeljs.io/docs/en/options#filename for more information.`].join("\n")); } }; const validatePreset = (preset, context, descriptor) => { if (!context.filename) { const { options } = preset; validateIfOptionNeedsFilename(options, descriptor); if (options.overrides) { options.overrides.forEach(overrideOptions => validateIfOptionNeedsFilename(overrideOptions, descriptor)); } } }; function* loadPresetDescriptor(descriptor, context) { const preset = instantiatePreset(yield* presetDescriptorLoader(descriptor, context)); validatePreset(preset, context, descriptor); return yield* (0, _configChain.buildPresetChain)(preset, context); } const instantiatePreset = (0, _caching.makeWeakCacheSync)(({ value, dirname, alias }) => { return { options: (0, _options.validate)("preset", value), alias, dirname }; }); function chain(a, b) { const fns = [a, b].filter(Boolean); if (fns.length <= 1) return fns[0]; return function (...args) { for (const fn of fns) { fn.apply(this, args); } }; } },{"../gensync-utils/async":29,"../index":30,"./cache-contexts":9,"./caching":10,"./config-chain":11,"./helpers/config-api":15,"./item":18,"./partial":19,"./plugin":21,"./util":24,"./validation/options":26,"./validation/plugins":27,"@babel/traverse":290,"gensync":439}],15:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.makeConfigAPI = makeConfigAPI; exports.makePresetAPI = makePresetAPI; exports.makePluginAPI = makePluginAPI; function _semver() { const data = require("semver"); _semver = function () { return data; }; return data; } var _ = require("../../"); var _caching = require("../caching"); var Context = require("../cache-contexts"); function makeConfigAPI(cache) { const env = value => cache.using(data => { if (typeof value === "undefined") return data.envName; if (typeof value === "function") { return (0, _caching.assertSimpleType)(value(data.envName)); } if (!Array.isArray(value)) value = [value]; return value.some(entry => { if (typeof entry !== "string") { throw new Error("Unexpected non-string value"); } return entry === data.envName; }); }); const caller = cb => cache.using(data => (0, _caching.assertSimpleType)(cb(data.caller))); return { version: _.version, cache: cache.simple(), env, async: () => false, caller, assertVersion }; } function makePresetAPI(cache) { const targets = () => JSON.parse(cache.using(data => JSON.stringify(data.targets))); return Object.assign({}, makeConfigAPI(cache), { targets }); } function makePluginAPI(cache) { const assumption = name => cache.using(data => data.assumptions[name]); return Object.assign({}, makePresetAPI(cache), { assumption }); } function assertVersion(range) { if (typeof range === "number") { if (!Number.isInteger(range)) { throw new Error("Expected string or integer value."); } range = `^${range}.0.0-0`; } if (typeof range !== "string") { throw new Error("Expected string or integer value."); } if (_semver().satisfies(_.version, range)) return; const limit = Error.stackTraceLimit; if (typeof limit === "number" && limit < 25) { Error.stackTraceLimit = 25; } const err = new Error(`Requires Babel "${range}", but was loaded with "${_.version}". ` + `If you are sure you have a compatible version of @babel/core, ` + `it is likely that something in your build process is loading the ` + `wrong version. Inspect the stack trace of this error to look for ` + `the first entry that doesn't mention "@babel/core" or "babel-core" ` + `to see what is calling Babel.`); if (typeof limit === "number") { Error.stackTraceLimit = limit; } throw Object.assign(err, { code: "BABEL_VERSION_UNSUPPORTED", version: _.version, range }); } },{"../../":30,"../cache-contexts":9,"../caching":10,"semver":47}],16:[function(require,module,exports){ (function (process){(function (){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.getEnv = getEnv; function getEnv(defaultValue = "development") { return process.env.BABEL_ENV || process.env.NODE_ENV || defaultValue; } }).call(this)}).call(this,require('_process')) },{"_process":460}],17:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.createConfigItem = createConfigItem; Object.defineProperty(exports, "default", { enumerable: true, get: function () { return _full.default; } }); exports.createConfigItemAsync = exports.createConfigItemSync = exports.loadOptionsAsync = exports.loadOptionsSync = exports.loadOptions = exports.loadPartialConfigAsync = exports.loadPartialConfigSync = exports.loadPartialConfig = void 0; function _gensync() { const data = require("gensync"); _gensync = function () { return data; }; return data; } var _full = require("./full"); var _partial = require("./partial"); var _item = require("./item"); const loadOptionsRunner = _gensync()(function* (opts) { var _config$options; const config = yield* (0, _full.default)(opts); return (_config$options = config == null ? void 0 : config.options) != null ? _config$options : null; }); const createConfigItemRunner = _gensync()(_item.createConfigItem); const maybeErrback = runner => (opts, callback) => { if (callback === undefined && typeof opts === "function") { callback = opts; opts = undefined; } return callback ? runner.errback(opts, callback) : runner.sync(opts); }; const loadPartialConfig = maybeErrback(_partial.loadPartialConfig); exports.loadPartialConfig = loadPartialConfig; const loadPartialConfigSync = _partial.loadPartialConfig.sync; exports.loadPartialConfigSync = loadPartialConfigSync; const loadPartialConfigAsync = _partial.loadPartialConfig.async; exports.loadPartialConfigAsync = loadPartialConfigAsync; const loadOptions = maybeErrback(loadOptionsRunner); exports.loadOptions = loadOptions; const loadOptionsSync = loadOptionsRunner.sync; exports.loadOptionsSync = loadOptionsSync; const loadOptionsAsync = loadOptionsRunner.async; exports.loadOptionsAsync = loadOptionsAsync; const createConfigItemSync = createConfigItemRunner.sync; exports.createConfigItemSync = createConfigItemSync; const createConfigItemAsync = createConfigItemRunner.async; exports.createConfigItemAsync = createConfigItemAsync; function createConfigItem(target, options, callback) { if (callback !== undefined) { return createConfigItemRunner.errback(target, options, callback); } else if (typeof options === "function") { return createConfigItemRunner.errback(target, undefined, callback); } else { return createConfigItemRunner.sync(target, options); } } },{"./full":14,"./item":18,"./partial":19,"gensync":439}],18:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.createItemFromDescriptor = createItemFromDescriptor; exports.createConfigItem = createConfigItem; exports.getItemDescriptor = getItemDescriptor; function _path() { const data = require("path"); _path = function () { return data; }; return data; } var _configDescriptors = require("./config-descriptors"); function createItemFromDescriptor(desc) { return new ConfigItem(desc); } function* createConfigItem(value, { dirname = ".", type } = {}) { const descriptor = yield* (0, _configDescriptors.createDescriptor)(value, _path().resolve(dirname), { type, alias: "programmatic item" }); return createItemFromDescriptor(descriptor); } function getItemDescriptor(item) { if (item != null && item[CONFIG_ITEM_BRAND]) { return item._descriptor; } return undefined; } const CONFIG_ITEM_BRAND = Symbol.for("@babel/core@7 - ConfigItem"); class ConfigItem { constructor(descriptor) { this._descriptor = void 0; this[CONFIG_ITEM_BRAND] = true; this.value = void 0; this.options = void 0; this.dirname = void 0; this.name = void 0; this.file = void 0; this._descriptor = descriptor; Object.defineProperty(this, "_descriptor", { enumerable: false }); Object.defineProperty(this, CONFIG_ITEM_BRAND, { enumerable: false }); this.value = this._descriptor.value; this.options = this._descriptor.options; this.dirname = this._descriptor.dirname; this.name = this._descriptor.name; this.file = this._descriptor.file ? { request: this._descriptor.file.request, resolved: this._descriptor.file.resolved } : undefined; Object.freeze(this); } } Object.freeze(ConfigItem.prototype); },{"./config-descriptors":12,"path":459}],19:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = loadPrivatePartialConfig; exports.loadPartialConfig = void 0; function _path() { const data = require("path"); _path = function () { return data; }; return data; } function _gensync() { const data = require("gensync"); _gensync = function () { return data; }; return data; } var _plugin = require("./plugin"); var _util = require("./util"); var _item = require("./item"); var _configChain = require("./config-chain"); var _environment = require("./helpers/environment"); var _options = require("./validation/options"); var _files = require("./files"); var _resolveTargets = require("./resolve-targets"); const _excluded = ["showIgnoredFiles"]; function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } function resolveRootMode(rootDir, rootMode) { switch (rootMode) { case "root": return rootDir; case "upward-optional": { const upwardRootDir = (0, _files.findConfigUpwards)(rootDir); return upwardRootDir === null ? rootDir : upwardRootDir; } case "upward": { const upwardRootDir = (0, _files.findConfigUpwards)(rootDir); if (upwardRootDir !== null) return upwardRootDir; throw Object.assign(new Error(`Babel was run with rootMode:"upward" but a root could not ` + `be found when searching upward from "${rootDir}".\n` + `One of the following config files must be in the directory tree: ` + `"${_files.ROOT_CONFIG_FILENAMES.join(", ")}".`), { code: "BABEL_ROOT_NOT_FOUND", dirname: rootDir }); } default: throw new Error(`Assertion failure - unknown rootMode value.`); } } function* loadPrivatePartialConfig(inputOpts) { if (inputOpts != null && (typeof inputOpts !== "object" || Array.isArray(inputOpts))) { throw new Error("Babel options must be an object, null, or undefined"); } const args = inputOpts ? (0, _options.validate)("arguments", inputOpts) : {}; const { envName = (0, _environment.getEnv)(), cwd = ".", root: rootDir = ".", rootMode = "root", caller, cloneInputAst = true } = args; const absoluteCwd = _path().resolve(cwd); const absoluteRootDir = resolveRootMode(_path().resolve(absoluteCwd, rootDir), rootMode); const filename = typeof args.filename === "string" ? _path().resolve(cwd, args.filename) : undefined; const showConfigPath = yield* (0, _files.resolveShowConfigPath)(absoluteCwd); const context = { filename, cwd: absoluteCwd, root: absoluteRootDir, envName, caller, showConfig: showConfigPath === filename }; const configChain = yield* (0, _configChain.buildRootChain)(args, context); if (!configChain) return null; const merged = { assumptions: {} }; configChain.options.forEach(opts => { (0, _util.mergeOptions)(merged, opts); }); const options = Object.assign({}, merged, { targets: (0, _resolveTargets.resolveTargets)(merged, absoluteRootDir), cloneInputAst, babelrc: false, configFile: false, browserslistConfigFile: false, passPerPreset: false, envName: context.envName, cwd: context.cwd, root: context.root, rootMode: "root", filename: typeof context.filename === "string" ? context.filename : undefined, plugins: configChain.plugins.map(descriptor => (0, _item.createItemFromDescriptor)(descriptor)), presets: configChain.presets.map(descriptor => (0, _item.createItemFromDescriptor)(descriptor)) }); return { options, context, fileHandling: configChain.fileHandling, ignore: configChain.ignore, babelrc: configChain.babelrc, config: configChain.config, files: configChain.files }; } const loadPartialConfig = _gensync()(function* (opts) { let showIgnoredFiles = false; if (typeof opts === "object" && opts !== null && !Array.isArray(opts)) { var _opts = opts; ({ showIgnoredFiles } = _opts); opts = _objectWithoutPropertiesLoose(_opts, _excluded); _opts; } const result = yield* loadPrivatePartialConfig(opts); if (!result) return null; const { options, babelrc, ignore, config, fileHandling, files } = result; if (fileHandling === "ignored" && !showIgnoredFiles) { return null; } (options.plugins || []).forEach(item => { if (item.value instanceof _plugin.default) { throw new Error("Passing cached plugin instances is not supported in " + "babel.loadPartialConfig()"); } }); return new PartialConfig(options, babelrc ? babelrc.filepath : undefined, ignore ? ignore.filepath : undefined, config ? config.filepath : undefined, fileHandling, files); }); exports.loadPartialConfig = loadPartialConfig; class PartialConfig { constructor(options, babelrc, ignore, config, fileHandling, files) { this.options = void 0; this.babelrc = void 0; this.babelignore = void 0; this.config = void 0; this.fileHandling = void 0; this.files = void 0; this.options = options; this.babelignore = ignore; this.babelrc = babelrc; this.config = config; this.fileHandling = fileHandling; this.files = files; Object.freeze(this); } hasFilesystemConfig() { return this.babelrc !== undefined || this.config !== undefined; } } Object.freeze(PartialConfig.prototype); },{"./config-chain":11,"./files":13,"./helpers/environment":16,"./item":18,"./plugin":21,"./resolve-targets":23,"./util":24,"./validation/options":26,"gensync":439,"path":459}],20:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = pathToPattern; function _path() { const data = require("path"); _path = function () { return data; }; return data; } const sep = `\\${_path().sep}`; const endSep = `(?:${sep}|$)`; const substitution = `[^${sep}]+`; const starPat = `(?:${substitution}${sep})`; const starPatLast = `(?:${substitution}${endSep})`; const starStarPat = `${starPat}*?`; const starStarPatLast = `${starPat}*?${starPatLast}?`; function escapeRegExp(string) { return string.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&"); } function pathToPattern(pattern, dirname) { const parts = _path().resolve(dirname, pattern).split(_path().sep); return new RegExp(["^", ...parts.map((part, i) => { const last = i === parts.length - 1; if (part === "**") return last ? starStarPatLast : starStarPat; if (part === "*") return last ? starPatLast : starPat; if (part.indexOf("*.") === 0) { return substitution + escapeRegExp(part.slice(1)) + (last ? endSep : sep); } return escapeRegExp(part) + (last ? endSep : sep); })].join("")); } },{"path":459}],21:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = void 0; class Plugin { constructor(plugin, options, key) { this.key = void 0; this.manipulateOptions = void 0; this.post = void 0; this.pre = void 0; this.visitor = void 0; this.parserOverride = void 0; this.generatorOverride = void 0; this.options = void 0; this.key = plugin.name || key; this.manipulateOptions = plugin.manipulateOptions; this.post = plugin.post; this.pre = plugin.pre; this.visitor = plugin.visitor || {}; this.parserOverride = plugin.parserOverride; this.generatorOverride = plugin.generatorOverride; this.options = options; } } exports.default = Plugin; },{}],22:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.ConfigPrinter = exports.ChainFormatter = void 0; function _gensync() { const data = require("gensync"); _gensync = function () { return data; }; return data; } const ChainFormatter = { Programmatic: 0, Config: 1 }; exports.ChainFormatter = ChainFormatter; const Formatter = { title(type, callerName, filepath) { let title = ""; if (type === ChainFormatter.Programmatic) { title = "programmatic options"; if (callerName) { title += " from " + callerName; } } else { title = "config " + filepath; } return title; }, loc(index, envName) { let loc = ""; if (index != null) { loc += `.overrides[${index}]`; } if (envName != null) { loc += `.env["${envName}"]`; } return loc; }, *optionsAndDescriptors(opt) { const content = Object.assign({}, opt.options); delete content.overrides; delete content.env; const pluginDescriptors = [...(yield* opt.plugins())]; if (pluginDescriptors.length) { content.plugins = pluginDescriptors.map(d => descriptorToConfig(d)); } const presetDescriptors = [...(yield* opt.presets())]; if (presetDescriptors.length) { content.presets = [...presetDescriptors].map(d => descriptorToConfig(d)); } return JSON.stringify(content, undefined, 2); } }; function descriptorToConfig(d) { var _d$file; let name = (_d$file = d.file) == null ? void 0 : _d$file.request; if (name == null) { if (typeof d.value === "object") { name = d.value; } else if (typeof d.value === "function") { name = `[Function: ${d.value.toString().substr(0, 50)} ... ]`; } } if (name == null) { name = "[Unknown]"; } if (d.options === undefined) { return name; } else if (d.name == null) { return [name, d.options]; } else { return [name, d.options, d.name]; } } class ConfigPrinter { constructor() { this._stack = []; } configure(enabled, type, { callerName, filepath }) { if (!enabled) return () => {}; return (content, index, envName) => { this._stack.push({ type, callerName, filepath, content, index, envName }); }; } static *format(config) { let title = Formatter.title(config.type, config.callerName, config.filepath); const loc = Formatter.loc(config.index, config.envName); if (loc) title += ` ${loc}`; const content = yield* Formatter.optionsAndDescriptors(config.content); return `${title}\n${content}`; } *output() { if (this._stack.length === 0) return ""; const configs = yield* _gensync().all(this._stack.map(s => ConfigPrinter.format(s))); return configs.join("\n\n"); } } exports.ConfigPrinter = ConfigPrinter; },{"gensync":439}],23:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.resolveBrowserslistConfigFile = resolveBrowserslistConfigFile; exports.resolveTargets = resolveTargets; function _helperCompilationTargets() { const data = require("@babel/helper-compilation-targets"); _helperCompilationTargets = function () { return data; }; return data; } function resolveBrowserslistConfigFile(browserslistConfigFile, configFilePath) { return undefined; } function resolveTargets(options, root) { let targets = options.targets; if (typeof targets === "string" || Array.isArray(targets)) { targets = { browsers: targets }; } if (targets && targets.esmodules) { targets = Object.assign({}, targets, { esmodules: "intersect" }); } return (0, _helperCompilationTargets().default)(targets, { ignoreBrowserslistConfig: true, browserslistEnv: options.browserslistEnv }); } },{"@babel/helper-compilation-targets":70}],24:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.mergeOptions = mergeOptions; exports.isIterableIterator = isIterableIterator; function mergeOptions(target, source) { for (const k of Object.keys(source)) { if ((k === "parserOpts" || k === "generatorOpts" || k === "assumptions") && source[k]) { const parserOpts = source[k]; const targetObj = target[k] || (target[k] = {}); mergeDefaultFields(targetObj, parserOpts); } else { const val = source[k]; if (val !== undefined) target[k] = val; } } } function mergeDefaultFields(target, source) { for (const k of Object.keys(source)) { const val = source[k]; if (val !== undefined) target[k] = val; } } function isIterableIterator(value) { return !!value && typeof value.next === "function" && typeof value[Symbol.iterator] === "function"; } },{}],25:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.msg = msg; exports.access = access; exports.assertRootMode = assertRootMode; exports.assertSourceMaps = assertSourceMaps; exports.assertCompact = assertCompact; exports.assertSourceType = assertSourceType; exports.assertCallerMetadata = assertCallerMetadata; exports.assertInputSourceMap = assertInputSourceMap; exports.assertString = assertString; exports.assertFunction = assertFunction; exports.assertBoolean = assertBoolean; exports.assertObject = assertObject; exports.assertArray = assertArray; exports.assertIgnoreList = assertIgnoreList; exports.assertConfigApplicableTest = assertConfigApplicableTest; exports.assertConfigFileSearch = assertConfigFileSearch; exports.assertBabelrcSearch = assertBabelrcSearch; exports.assertPluginList = assertPluginList; exports.assertTargets = assertTargets; exports.assertAssumptions = assertAssumptions; function _helperCompilationTargets() { const data = require("@babel/helper-compilation-targets"); _helperCompilationTargets = function () { return data; }; return data; } var _options = require("./options"); function msg(loc) { switch (loc.type) { case "root": return ``; case "env": return `${msg(loc.parent)}.env["${loc.name}"]`; case "overrides": return `${msg(loc.parent)}.overrides[${loc.index}]`; case "option": return `${msg(loc.parent)}.${loc.name}`; case "access": return `${msg(loc.parent)}[${JSON.stringify(loc.name)}]`; default: throw new Error(`Assertion failure: Unknown type ${loc.type}`); } } function access(loc, name) { return { type: "access", name, parent: loc }; } function assertRootMode(loc, value) { if (value !== undefined && value !== "root" && value !== "upward" && value !== "upward-optional") { throw new Error(`${msg(loc)} must be a "root", "upward", "upward-optional" or undefined`); } return value; } function assertSourceMaps(loc, value) { if (value !== undefined && typeof value !== "boolean" && value !== "inline" && value !== "both") { throw new Error(`${msg(loc)} must be a boolean, "inline", "both", or undefined`); } return value; } function assertCompact(loc, value) { if (value !== undefined && typeof value !== "boolean" && value !== "auto") { throw new Error(`${msg(loc)} must be a boolean, "auto", or undefined`); } return value; } function assertSourceType(loc, value) { if (value !== undefined && value !== "module" && value !== "script" && value !== "unambiguous") { throw new Error(`${msg(loc)} must be "module", "script", "unambiguous", or undefined`); } return value; } function assertCallerMetadata(loc, value) { const obj = assertObject(loc, value); if (obj) { if (typeof obj.name !== "string") { throw new Error(`${msg(loc)} set but does not contain "name" property string`); } for (const prop of Object.keys(obj)) { const propLoc = access(loc, prop); const value = obj[prop]; if (value != null && typeof value !== "boolean" && typeof value !== "string" && typeof value !== "number") { throw new Error(`${msg(propLoc)} must be null, undefined, a boolean, a string, or a number.`); } } } return value; } function assertInputSourceMap(loc, value) { if (value !== undefined && typeof value !== "boolean" && (typeof value !== "object" || !value)) { throw new Error(`${msg(loc)} must be a boolean, object, or undefined`); } return value; } function assertString(loc, value) { if (value !== undefined && typeof value !== "string") { throw new Error(`${msg(loc)} must be a string, or undefined`); } return value; } function assertFunction(loc, value) { if (value !== undefined && typeof value !== "function") { throw new Error(`${msg(loc)} must be a function, or undefined`); } return value; } function assertBoolean(loc, value) { if (value !== undefined && typeof value !== "boolean") { throw new Error(`${msg(loc)} must be a boolean, or undefined`); } return value; } function assertObject(loc, value) { if (value !== undefined && (typeof value !== "object" || Array.isArray(value) || !value)) { throw new Error(`${msg(loc)} must be an object, or undefined`); } return value; } function assertArray(loc, value) { if (value != null && !Array.isArray(value)) { throw new Error(`${msg(loc)} must be an array, or undefined`); } return value; } function assertIgnoreList(loc, value) { const arr = assertArray(loc, value); if (arr) { arr.forEach((item, i) => assertIgnoreItem(access(loc, i), item)); } return arr; } function assertIgnoreItem(loc, value) { if (typeof value !== "string" && typeof value !== "function" && !(value instanceof RegExp)) { throw new Error(`${msg(loc)} must be an array of string/Function/RegExp values, or undefined`); } return value; } function assertConfigApplicableTest(loc, value) { if (value === undefined) return value; if (Array.isArray(value)) { value.forEach((item, i) => { if (!checkValidTest(item)) { throw new Error(`${msg(access(loc, i))} must be a string/Function/RegExp.`); } }); } else if (!checkValidTest(value)) { throw new Error(`${msg(loc)} must be a string/Function/RegExp, or an array of those`); } return value; } function checkValidTest(value) { return typeof value === "string" || typeof value === "function" || value instanceof RegExp; } function assertConfigFileSearch(loc, value) { if (value !== undefined && typeof value !== "boolean" && typeof value !== "string") { throw new Error(`${msg(loc)} must be a undefined, a boolean, a string, ` + `got ${JSON.stringify(value)}`); } return value; } function assertBabelrcSearch(loc, value) { if (value === undefined || typeof value === "boolean") return value; if (Array.isArray(value)) { value.forEach((item, i) => { if (!checkValidTest(item)) { throw new Error(`${msg(access(loc, i))} must be a string/Function/RegExp.`); } }); } else if (!checkValidTest(value)) { throw new Error(`${msg(loc)} must be a undefined, a boolean, a string/Function/RegExp ` + `or an array of those, got ${JSON.stringify(value)}`); } return value; } function assertPluginList(loc, value) { const arr = assertArray(loc, value); if (arr) { arr.forEach((item, i) => assertPluginItem(access(loc, i), item)); } return arr; } function assertPluginItem(loc, value) { if (Array.isArray(value)) { if (value.length === 0) { throw new Error(`${msg(loc)} must include an object`); } if (value.length > 3) { throw new Error(`${msg(loc)} may only be a two-tuple or three-tuple`); } assertPluginTarget(access(loc, 0), value[0]); if (value.length > 1) { const opts = value[1]; if (opts !== undefined && opts !== false && (typeof opts !== "object" || Array.isArray(opts) || opts === null)) { throw new Error(`${msg(access(loc, 1))} must be an object, false, or undefined`); } } if (value.length === 3) { const name = value[2]; if (name !== undefined && typeof name !== "string") { throw new Error(`${msg(access(loc, 2))} must be a string, or undefined`); } } } else { assertPluginTarget(loc, value); } return value; } function assertPluginTarget(loc, value) { if ((typeof value !== "object" || !value) && typeof value !== "string" && typeof value !== "function") { throw new Error(`${msg(loc)} must be a string, object, function`); } return value; } function assertTargets(loc, value) { if ((0, _helperCompilationTargets().isBrowsersQueryValid)(value)) return value; if (typeof value !== "object" || !value || Array.isArray(value)) { throw new Error(`${msg(loc)} must be a string, an array of strings or an object`); } const browsersLoc = access(loc, "browsers"); const esmodulesLoc = access(loc, "esmodules"); assertBrowsersList(browsersLoc, value.browsers); assertBoolean(esmodulesLoc, value.esmodules); for (const key of Object.keys(value)) { const val = value[key]; const subLoc = access(loc, key); if (key === "esmodules") assertBoolean(subLoc, val);else if (key === "browsers") assertBrowsersList(subLoc, val);else if (!Object.hasOwnProperty.call(_helperCompilationTargets().TargetNames, key)) { const validTargets = Object.keys(_helperCompilationTargets().TargetNames).join(", "); throw new Error(`${msg(subLoc)} is not a valid target. Supported targets are ${validTargets}`); } else assertBrowserVersion(subLoc, val); } return value; } function assertBrowsersList(loc, value) { if (value !== undefined && !(0, _helperCompilationTargets().isBrowsersQueryValid)(value)) { throw new Error(`${msg(loc)} must be undefined, a string or an array of strings`); } } function assertBrowserVersion(loc, value) { if (typeof value === "number" && Math.round(value) === value) return; if (typeof value === "string") return; throw new Error(`${msg(loc)} must be a string or an integer number`); } function assertAssumptions(loc, value) { if (value === undefined) return; if (typeof value !== "object" || value === null) { throw new Error(`${msg(loc)} must be an object or undefined.`); } let root = loc; do { root = root.parent; } while (root.type !== "root"); const inPreset = root.source === "preset"; for (const name of Object.keys(value)) { const subLoc = access(loc, name); if (!_options.assumptionsNames.has(name)) { throw new Error(`${msg(subLoc)} is not a supported assumption.`); } if (typeof value[name] !== "boolean") { throw new Error(`${msg(subLoc)} must be a boolean.`); } if (inPreset && value[name] === false) { throw new Error(`${msg(subLoc)} cannot be set to 'false' inside presets.`); } } return value; } },{"./options":26,"@babel/helper-compilation-targets":70}],26:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.validate = validate; exports.checkNoUnwrappedItemOptionPairs = checkNoUnwrappedItemOptionPairs; exports.assumptionsNames = void 0; var _plugin = require("../plugin"); var _removed = require("./removed"); var _optionAssertions = require("./option-assertions"); const ROOT_VALIDATORS = { cwd: _optionAssertions.assertString, root: _optionAssertions.assertString, rootMode: _optionAssertions.assertRootMode, configFile: _optionAssertions.assertConfigFileSearch, caller: _optionAssertions.assertCallerMetadata, filename: _optionAssertions.assertString, filenameRelative: _optionAssertions.assertString, code: _optionAssertions.assertBoolean, ast: _optionAssertions.assertBoolean, cloneInputAst: _optionAssertions.assertBoolean, envName: _optionAssertions.assertString }; const BABELRC_VALIDATORS = { babelrc: _optionAssertions.assertBoolean, babelrcRoots: _optionAssertions.assertBabelrcSearch }; const NONPRESET_VALIDATORS = { extends: _optionAssertions.assertString, ignore: _optionAssertions.assertIgnoreList, only: _optionAssertions.assertIgnoreList, targets: _optionAssertions.assertTargets, browserslistConfigFile: _optionAssertions.assertConfigFileSearch, browserslistEnv: _optionAssertions.assertString }; const COMMON_VALIDATORS = { inputSourceMap: _optionAssertions.assertInputSourceMap, presets: _optionAssertions.assertPluginList, plugins: _optionAssertions.assertPluginList, passPerPreset: _optionAssertions.assertBoolean, assumptions: _optionAssertions.assertAssumptions, env: assertEnvSet, overrides: assertOverridesList, test: _optionAssertions.assertConfigApplicableTest, include: _optionAssertions.assertConfigApplicableTest, exclude: _optionAssertions.assertConfigApplicableTest, retainLines: _optionAssertions.assertBoolean, comments: _optionAssertions.assertBoolean, shouldPrintComment: _optionAssertions.assertFunction, compact: _optionAssertions.assertCompact, minified: _optionAssertions.assertBoolean, auxiliaryCommentBefore: _optionAssertions.assertString, auxiliaryCommentAfter: _optionAssertions.assertString, sourceType: _optionAssertions.assertSourceType, wrapPluginVisitorMethod: _optionAssertions.assertFunction, highlightCode: _optionAssertions.assertBoolean, sourceMaps: _optionAssertions.assertSourceMaps, sourceMap: _optionAssertions.assertSourceMaps, sourceFileName: _optionAssertions.assertString, sourceRoot: _optionAssertions.assertString, parserOpts: _optionAssertions.assertObject, generatorOpts: _optionAssertions.assertObject }; { Object.assign(COMMON_VALIDATORS, { getModuleId: _optionAssertions.assertFunction, moduleRoot: _optionAssertions.assertString, moduleIds: _optionAssertions.assertBoolean, moduleId: _optionAssertions.assertString }); } const assumptionsNames = new Set(["arrayLikeIsIterable", "constantReexports", "constantSuper", "enumerableModuleMeta", "ignoreFunctionLength", "ignoreToPrimitiveHint", "iterableIsArray", "mutableTemplateObject", "noClassCalls", "noDocumentAll", "noNewArrows", "objectRestNoSymbols", "privateFieldsAsProperties", "pureGetters", "setClassMethods", "setComputedProperties", "setPublicClassFields", "setSpreadProperties", "skipForOfIteratorClosing", "superIsCallableConstructor"]); exports.assumptionsNames = assumptionsNames; function getSource(loc) { return loc.type === "root" ? loc.source : getSource(loc.parent); } function validate(type, opts) { return validateNested({ type: "root", source: type }, opts); } function validateNested(loc, opts) { const type = getSource(loc); assertNoDuplicateSourcemap(opts); Object.keys(opts).forEach(key => { const optLoc = { type: "option", name: key, parent: loc }; if (type === "preset" && NONPRESET_VALIDATORS[key]) { throw new Error(`${(0, _optionAssertions.msg)(optLoc)} is not allowed in preset options`); } if (type !== "arguments" && ROOT_VALIDATORS[key]) { throw new Error(`${(0, _optionAssertions.msg)(optLoc)} is only allowed in root programmatic options`); } if (type !== "arguments" && type !== "configfile" && BABELRC_VALIDATORS[key]) { if (type === "babelrcfile" || type === "extendsfile") { throw new Error(`${(0, _optionAssertions.msg)(optLoc)} is not allowed in .babelrc or "extends"ed files, only in root programmatic options, ` + `or babel.config.js/config file options`); } throw new Error(`${(0, _optionAssertions.msg)(optLoc)} is only allowed in root programmatic options, or babel.config.js/config file options`); } const validator = COMMON_VALIDATORS[key] || NONPRESET_VALIDATORS[key] || BABELRC_VALIDATORS[key] || ROOT_VALIDATORS[key] || throwUnknownError; validator(optLoc, opts[key]); }); return opts; } function throwUnknownError(loc) { const key = loc.name; if (_removed.default[key]) { const { message, version = 5 } = _removed.default[key]; throw new Error(`Using removed Babel ${version} option: ${(0, _optionAssertions.msg)(loc)} - ${message}`); } else { const unknownOptErr = new Error(`Unknown option: ${(0, _optionAssertions.msg)(loc)}. Check out https://babeljs.io/docs/en/babel-core/#options for more information about options.`); unknownOptErr.code = "BABEL_UNKNOWN_OPTION"; throw unknownOptErr; } } function has(obj, key) { return Object.prototype.hasOwnProperty.call(obj, key); } function assertNoDuplicateSourcemap(opts) { if (has(opts, "sourceMap") && has(opts, "sourceMaps")) { throw new Error(".sourceMap is an alias for .sourceMaps, cannot use both"); } } function assertEnvSet(loc, value) { if (loc.parent.type === "env") { throw new Error(`${(0, _optionAssertions.msg)(loc)} is not allowed inside of another .env block`); } const parent = loc.parent; const obj = (0, _optionAssertions.assertObject)(loc, value); if (obj) { for (const envName of Object.keys(obj)) { const env = (0, _optionAssertions.assertObject)((0, _optionAssertions.access)(loc, envName), obj[envName]); if (!env) continue; const envLoc = { type: "env", name: envName, parent }; validateNested(envLoc, env); } } return obj; } function assertOverridesList(loc, value) { if (loc.parent.type === "env") { throw new Error(`${(0, _optionAssertions.msg)(loc)} is not allowed inside an .env block`); } if (loc.parent.type === "overrides") { throw new Error(`${(0, _optionAssertions.msg)(loc)} is not allowed inside an .overrides block`); } const parent = loc.parent; const arr = (0, _optionAssertions.assertArray)(loc, value); if (arr) { for (const [index, item] of arr.entries()) { const objLoc = (0, _optionAssertions.access)(loc, index); const env = (0, _optionAssertions.assertObject)(objLoc, item); if (!env) throw new Error(`${(0, _optionAssertions.msg)(objLoc)} must be an object`); const overridesLoc = { type: "overrides", index, parent }; validateNested(overridesLoc, env); } } return arr; } function checkNoUnwrappedItemOptionPairs(items, index, type, e) { if (index === 0) return; const lastItem = items[index - 1]; const thisItem = items[index]; if (lastItem.file && lastItem.options === undefined && typeof thisItem.value === "object") { e.message += `\n- Maybe you meant to use\n` + `"${type}s": [\n ["${lastItem.file.request}", ${JSON.stringify(thisItem.value, undefined, 2)}]\n]\n` + `To be a valid ${type}, its name and options should be wrapped in a pair of brackets`; } } },{"../plugin":21,"./option-assertions":25,"./removed":28}],27:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.validatePluginObject = validatePluginObject; var _optionAssertions = require("./option-assertions"); const VALIDATORS = { name: _optionAssertions.assertString, manipulateOptions: _optionAssertions.assertFunction, pre: _optionAssertions.assertFunction, post: _optionAssertions.assertFunction, inherits: _optionAssertions.assertFunction, visitor: assertVisitorMap, parserOverride: _optionAssertions.assertFunction, generatorOverride: _optionAssertions.assertFunction }; function assertVisitorMap(loc, value) { const obj = (0, _optionAssertions.assertObject)(loc, value); if (obj) { Object.keys(obj).forEach(prop => assertVisitorHandler(prop, obj[prop])); if (obj.enter || obj.exit) { throw new Error(`${(0, _optionAssertions.msg)(loc)} cannot contain catch-all "enter" or "exit" handlers. Please target individual nodes.`); } } return obj; } function assertVisitorHandler(key, value) { if (value && typeof value === "object") { Object.keys(value).forEach(handler => { if (handler !== "enter" && handler !== "exit") { throw new Error(`.visitor["${key}"] may only have .enter and/or .exit handlers.`); } }); } else if (typeof value !== "function") { throw new Error(`.visitor["${key}"] must be a function`); } return value; } function validatePluginObject(obj) { const rootPath = { type: "root", source: "plugin" }; Object.keys(obj).forEach(key => { const validator = VALIDATORS[key]; if (validator) { const optLoc = { type: "option", name: key, parent: rootPath }; validator(optLoc, obj[key]); } else { const invalidPluginPropertyError = new Error(`.${key} is not a valid Plugin property`); invalidPluginPropertyError.code = "BABEL_UNKNOWN_PLUGIN_PROPERTY"; throw invalidPluginPropertyError; } }); return obj; } },{"./option-assertions":25}],28:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = void 0; var _default = { auxiliaryComment: { message: "Use `auxiliaryCommentBefore` or `auxiliaryCommentAfter`" }, blacklist: { message: "Put the specific transforms you want in the `plugins` option" }, breakConfig: { message: "This is not a necessary option in Babel 6" }, experimental: { message: "Put the specific transforms you want in the `plugins` option" }, externalHelpers: { message: "Use the `external-helpers` plugin instead. " + "Check out http://babeljs.io/docs/plugins/external-helpers/" }, extra: { message: "" }, jsxPragma: { message: "use the `pragma` option in the `react-jsx` plugin. " + "Check out http://babeljs.io/docs/plugins/transform-react-jsx/" }, loose: { message: "Specify the `loose` option for the relevant plugin you are using " + "or use a preset that sets the option." }, metadataUsedHelpers: { message: "Not required anymore as this is enabled by default" }, modules: { message: "Use the corresponding module transform plugin in the `plugins` option. " + "Check out http://babeljs.io/docs/plugins/#modules" }, nonStandard: { message: "Use the `react-jsx` and `flow-strip-types` plugins to support JSX and Flow. " + "Also check out the react preset http://babeljs.io/docs/plugins/preset-react/" }, optional: { message: "Put the specific transforms you want in the `plugins` option" }, sourceMapName: { message: "The `sourceMapName` option has been removed because it makes more sense for the " + "tooling that calls Babel to assign `map.file` themselves." }, stage: { message: "Check out the corresponding stage-x presets http://babeljs.io/docs/plugins/#presets" }, whitelist: { message: "Put the specific transforms you want in the `plugins` option" }, resolveModuleSource: { version: 6, message: "Use `babel-plugin-module-resolver@3`'s 'resolvePath' options" }, metadata: { version: 6, message: "Generated plugin metadata is always included in the output result" }, sourceMapTarget: { version: 6, message: "The `sourceMapTarget` option has been removed because it makes more sense for the tooling " + "that calls Babel to assign `map.file` themselves." } }; exports.default = _default; },{}],29:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.maybeAsync = maybeAsync; exports.forwardAsync = forwardAsync; exports.isThenable = isThenable; exports.waitFor = exports.onFirstPause = exports.isAsync = void 0; function _gensync() { const data = require("gensync"); _gensync = function () { return data; }; return data; } const id = x => x; const runGenerator = _gensync()(function* (item) { return yield* item; }); const isAsync = _gensync()({ sync: () => false, errback: cb => cb(null, true) }); exports.isAsync = isAsync; function maybeAsync(fn, message) { return _gensync()({ sync(...args) { const result = fn.apply(this, args); if (isThenable(result)) throw new Error(message); return result; }, async(...args) { return Promise.resolve(fn.apply(this, args)); } }); } const withKind = _gensync()({ sync: cb => cb("sync"), async: cb => cb("async") }); function forwardAsync(action, cb) { const g = _gensync()(action); return withKind(kind => { const adapted = g[kind]; return cb(adapted); }); } const onFirstPause = _gensync()({ name: "onFirstPause", arity: 2, sync: function (item) { return runGenerator.sync(item); }, errback: function (item, firstPause, cb) { let completed = false; runGenerator.errback(item, (err, value) => { completed = true; cb(err, value); }); if (!completed) { firstPause(); } } }); exports.onFirstPause = onFirstPause; const waitFor = _gensync()({ sync: id, async: id }); exports.waitFor = waitFor; function isThenable(val) { return !!val && (typeof val === "object" || typeof val === "function") && !!val.then && typeof val.then === "function"; } },{"gensync":439}],30:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.Plugin = Plugin; Object.defineProperty(exports, "File", { enumerable: true, get: function () { return _file.default; } }); Object.defineProperty(exports, "buildExternalHelpers", { enumerable: true, get: function () { return _buildExternalHelpers.default; } }); Object.defineProperty(exports, "resolvePlugin", { enumerable: true, get: function () { return _files.resolvePlugin; } }); Object.defineProperty(exports, "resolvePreset", { enumerable: true, get: function () { return _files.resolvePreset; } }); Object.defineProperty(exports, "getEnv", { enumerable: true, get: function () { return _environment.getEnv; } }); Object.defineProperty(exports, "tokTypes", { enumerable: true, get: function () { return _parser().tokTypes; } }); Object.defineProperty(exports, "traverse", { enumerable: true, get: function () { return _traverse().default; } }); Object.defineProperty(exports, "template", { enumerable: true, get: function () { return _template().default; } }); Object.defineProperty(exports, "createConfigItem", { enumerable: true, get: function () { return _config.createConfigItem; } }); Object.defineProperty(exports, "createConfigItemSync", { enumerable: true, get: function () { return _config.createConfigItemSync; } }); Object.defineProperty(exports, "createConfigItemAsync", { enumerable: true, get: function () { return _config.createConfigItemAsync; } }); Object.defineProperty(exports, "loadPartialConfig", { enumerable: true, get: function () { return _config.loadPartialConfig; } }); Object.defineProperty(exports, "loadPartialConfigSync", { enumerable: true, get: function () { return _config.loadPartialConfigSync; } }); Object.defineProperty(exports, "loadPartialConfigAsync", { enumerable: true, get: function () { return _config.loadPartialConfigAsync; } }); Object.defineProperty(exports, "loadOptions", { enumerable: true, get: function () { return _config.loadOptions; } }); Object.defineProperty(exports, "loadOptionsSync", { enumerable: true, get: function () { return _config.loadOptionsSync; } }); Object.defineProperty(exports, "loadOptionsAsync", { enumerable: true, get: function () { return _config.loadOptionsAsync; } }); Object.defineProperty(exports, "transform", { enumerable: true, get: function () { return _transform.transform; } }); Object.defineProperty(exports, "transformSync", { enumerable: true, get: function () { return _transform.transformSync; } }); Object.defineProperty(exports, "transformAsync", { enumerable: true, get: function () { return _transform.transformAsync; } }); Object.defineProperty(exports, "transformFile", { enumerable: true, get: function () { return _transformFile.transformFile; } }); Object.defineProperty(exports, "transformFileSync", { enumerable: true, get: function () { return _transformFile.transformFileSync; } }); Object.defineProperty(exports, "transformFileAsync", { enumerable: true, get: function () { return _transformFile.transformFileAsync; } }); Object.defineProperty(exports, "transformFromAst", { enumerable: true, get: function () { return _transformAst.transformFromAst; } }); Object.defineProperty(exports, "transformFromAstSync", { enumerable: true, get: function () { return _transformAst.transformFromAstSync; } }); Object.defineProperty(exports, "transformFromAstAsync", { enumerable: true, get: function () { return _transformAst.transformFromAstAsync; } }); Object.defineProperty(exports, "parse", { enumerable: true, get: function () { return _parse.parse; } }); Object.defineProperty(exports, "parseSync", { enumerable: true, get: function () { return _parse.parseSync; } }); Object.defineProperty(exports, "parseAsync", { enumerable: true, get: function () { return _parse.parseAsync; } }); exports.types = exports.OptionManager = exports.DEFAULT_EXTENSIONS = exports.version = void 0; var _file = require("./transformation/file/file"); var _buildExternalHelpers = require("./tools/build-external-helpers"); var _files = require("./config/files"); var _environment = require("./config/helpers/environment"); function _types() { const data = require("@babel/types"); _types = function () { return data; }; return data; } Object.defineProperty(exports, "types", { enumerable: true, get: function () { return _types(); } }); function _parser() { const data = require("@babel/parser"); _parser = function () { return data; }; return data; } function _traverse() { const data = require("@babel/traverse"); _traverse = function () { return data; }; return data; } function _template() { const data = require("@babel/template"); _template = function () { return data; }; return data; } var _config = require("./config"); var _transform = require("./transform"); var _transformFile = require("./transform-file"); var _transformAst = require("./transform-ast"); var _parse = require("./parse"); const version = "7.14.8"; exports.version = version; const DEFAULT_EXTENSIONS = Object.freeze([".js", ".jsx", ".es6", ".es", ".mjs", ".cjs"]); exports.DEFAULT_EXTENSIONS = DEFAULT_EXTENSIONS; class OptionManager { init(opts) { return (0, _config.loadOptions)(opts); } } exports.OptionManager = OptionManager; function Plugin(alias) { throw new Error(`The (${alias}) Babel 5 plugin is being run with an unsupported Babel version.`); } },{"./config":17,"./config/files":13,"./config/helpers/environment":16,"./parse":31,"./tools/build-external-helpers":34,"./transform":37,"./transform-ast":35,"./transform-file":36,"./transformation/file/file":39,"@babel/parser":266,"@babel/template":281,"@babel/traverse":290,"@babel/types":359}],31:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.parseAsync = exports.parseSync = exports.parse = void 0; function _gensync() { const data = require("gensync"); _gensync = function () { return data; }; return data; } var _config = require("./config"); var _parser = require("./parser"); var _normalizeOpts = require("./transformation/normalize-opts"); const parseRunner = _gensync()(function* parse(code, opts) { const config = yield* (0, _config.default)(opts); if (config === null) { return null; } return yield* (0, _parser.default)(config.passes, (0, _normalizeOpts.default)(config), code); }); const parse = function parse(code, opts, callback) { if (typeof opts === "function") { callback = opts; opts = undefined; } if (callback === undefined) return parseRunner.sync(code, opts); parseRunner.errback(code, opts, callback); }; exports.parse = parse; const parseSync = parseRunner.sync; exports.parseSync = parseSync; const parseAsync = parseRunner.async; exports.parseAsync = parseAsync; },{"./config":17,"./parser":32,"./transformation/normalize-opts":44,"gensync":439}],32:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = parser; function _parser() { const data = require("@babel/parser"); _parser = function () { return data; }; return data; } function _codeFrame() { const data = require("@babel/code-frame"); _codeFrame = function () { return data; }; return data; } var _missingPluginHelper = require("./util/missing-plugin-helper"); function* parser(pluginPasses, { parserOpts, highlightCode = true, filename = "unknown" }, code) { try { const results = []; for (const plugins of pluginPasses) { for (const plugin of plugins) { const { parserOverride } = plugin; if (parserOverride) { const ast = parserOverride(code, parserOpts, _parser().parse); if (ast !== undefined) results.push(ast); } } } if (results.length === 0) { return (0, _parser().parse)(code, parserOpts); } else if (results.length === 1) { yield* []; if (typeof results[0].then === "function") { throw new Error(`You appear to be using an async parser plugin, ` + `which your current version of Babel does not support. ` + `If you're using a published plugin, you may need to upgrade ` + `your @babel/core version.`); } return results[0]; } throw new Error("More than one plugin attempted to override parsing."); } catch (err) { if (err.code === "BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED") { err.message += "\nConsider renaming the file to '.mjs', or setting sourceType:module " + "or sourceType:unambiguous in your Babel config for this file."; } const { loc, missingPlugin } = err; if (loc) { const codeFrame = (0, _codeFrame().codeFrameColumns)(code, { start: { line: loc.line, column: loc.column + 1 } }, { highlightCode }); if (missingPlugin) { err.message = `${filename}: ` + (0, _missingPluginHelper.default)(missingPlugin[0], loc, codeFrame); } else { err.message = `${filename}: ${err.message}\n\n` + codeFrame; } err.code = "BABEL_PARSE_ERROR"; } throw err; } } },{"./util/missing-plugin-helper":33,"@babel/code-frame":4,"@babel/parser":266}],33:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = generateMissingPluginMessage; const pluginNameMap = { asyncDoExpressions: { syntax: { name: "@babel/plugin-syntax-async-do-expressions", url: "https://git.io/JYer8" } }, classProperties: { syntax: { name: "@babel/plugin-syntax-class-properties", url: "https://git.io/vb4yQ" }, transform: { name: "@babel/plugin-proposal-class-properties", url: "https://git.io/vb4SL" } }, classPrivateProperties: { syntax: { name: "@babel/plugin-syntax-class-properties", url: "https://git.io/vb4yQ" }, transform: { name: "@babel/plugin-proposal-class-properties", url: "https://git.io/vb4SL" } }, classPrivateMethods: { syntax: { name: "@babel/plugin-syntax-class-properties", url: "https://git.io/vb4yQ" }, transform: { name: "@babel/plugin-proposal-private-methods", url: "https://git.io/JvpRG" } }, classStaticBlock: { syntax: { name: "@babel/plugin-syntax-class-static-block", url: "https://git.io/JTLB6" }, transform: { name: "@babel/plugin-proposal-class-static-block", url: "https://git.io/JTLBP" } }, decimal: { syntax: { name: "@babel/plugin-syntax-decimal", url: "https://git.io/JfKOH" } }, decorators: { syntax: { name: "@babel/plugin-syntax-decorators", url: "https://git.io/vb4y9" }, transform: { name: "@babel/plugin-proposal-decorators", url: "https://git.io/vb4ST" } }, doExpressions: { syntax: { name: "@babel/plugin-syntax-do-expressions", url: "https://git.io/vb4yh" }, transform: { name: "@babel/plugin-proposal-do-expressions", url: "https://git.io/vb4S3" } }, dynamicImport: { syntax: { name: "@babel/plugin-syntax-dynamic-import", url: "https://git.io/vb4Sv" } }, exportDefaultFrom: { syntax: { name: "@babel/plugin-syntax-export-default-from", url: "https://git.io/vb4SO" }, transform: { name: "@babel/plugin-proposal-export-default-from", url: "https://git.io/vb4yH" } }, exportNamespaceFrom: { syntax: { name: "@babel/plugin-syntax-export-namespace-from", url: "https://git.io/vb4Sf" }, transform: { name: "@babel/plugin-proposal-export-namespace-from", url: "https://git.io/vb4SG" } }, flow: { syntax: { name: "@babel/plugin-syntax-flow", url: "https://git.io/vb4yb" }, transform: { name: "@babel/preset-flow", url: "https://git.io/JfeDn" } }, functionBind: { syntax: { name: "@babel/plugin-syntax-function-bind", url: "https://git.io/vb4y7" }, transform: { name: "@babel/plugin-proposal-function-bind", url: "https://git.io/vb4St" } }, functionSent: { syntax: { name: "@babel/plugin-syntax-function-sent", url: "https://git.io/vb4yN" }, transform: { name: "@babel/plugin-proposal-function-sent", url: "https://git.io/vb4SZ" } }, importMeta: { syntax: { name: "@babel/plugin-syntax-import-meta", url: "https://git.io/vbKK6" } }, jsx: { syntax: { name: "@babel/plugin-syntax-jsx", url: "https://git.io/vb4yA" }, transform: { name: "@babel/preset-react", url: "https://git.io/JfeDR" } }, importAssertions: { syntax: { name: "@babel/plugin-syntax-import-assertions", url: "https://git.io/JUbkv" } }, moduleStringNames: { syntax: { name: "@babel/plugin-syntax-module-string-names", url: "https://git.io/JTL8G" } }, numericSeparator: { syntax: { name: "@babel/plugin-syntax-numeric-separator", url: "https://git.io/vb4Sq" }, transform: { name: "@babel/plugin-proposal-numeric-separator", url: "https://git.io/vb4yS" } }, optionalChaining: { syntax: { name: "@babel/plugin-syntax-optional-chaining", url: "https://git.io/vb4Sc" }, transform: { name: "@babel/plugin-proposal-optional-chaining", url: "https://git.io/vb4Sk" } }, pipelineOperator: { syntax: { name: "@babel/plugin-syntax-pipeline-operator", url: "https://git.io/vb4yj" }, transform: { name: "@babel/plugin-proposal-pipeline-operator", url: "https://git.io/vb4SU" } }, privateIn: { syntax: { name: "@babel/plugin-syntax-private-property-in-object", url: "https://git.io/JfK3q" }, transform: { name: "@babel/plugin-proposal-private-property-in-object", url: "https://git.io/JfK3O" } }, recordAndTuple: { syntax: { name: "@babel/plugin-syntax-record-and-tuple", url: "https://git.io/JvKp3" } }, throwExpressions: { syntax: { name: "@babel/plugin-syntax-throw-expressions", url: "https://git.io/vb4SJ" }, transform: { name: "@babel/plugin-proposal-throw-expressions", url: "https://git.io/vb4yF" } }, typescript: { syntax: { name: "@babel/plugin-syntax-typescript", url: "https://git.io/vb4SC" }, transform: { name: "@babel/preset-typescript", url: "https://git.io/JfeDz" } }, asyncGenerators: { syntax: { name: "@babel/plugin-syntax-async-generators", url: "https://git.io/vb4SY" }, transform: { name: "@babel/plugin-proposal-async-generator-functions", url: "https://git.io/vb4yp" } }, logicalAssignment: { syntax: { name: "@babel/plugin-syntax-logical-assignment-operators", url: "https://git.io/vAlBp" }, transform: { name: "@babel/plugin-proposal-logical-assignment-operators", url: "https://git.io/vAlRe" } }, nullishCoalescingOperator: { syntax: { name: "@babel/plugin-syntax-nullish-coalescing-operator", url: "https://git.io/vb4yx" }, transform: { name: "@babel/plugin-proposal-nullish-coalescing-operator", url: "https://git.io/vb4Se" } }, objectRestSpread: { syntax: { name: "@babel/plugin-syntax-object-rest-spread", url: "https://git.io/vb4y5" }, transform: { name: "@babel/plugin-proposal-object-rest-spread", url: "https://git.io/vb4Ss" } }, optionalCatchBinding: { syntax: { name: "@babel/plugin-syntax-optional-catch-binding", url: "https://git.io/vb4Sn" }, transform: { name: "@babel/plugin-proposal-optional-catch-binding", url: "https://git.io/vb4SI" } } }; pluginNameMap.privateIn.syntax = pluginNameMap.privateIn.transform; const getNameURLCombination = ({ name, url }) => `${name} (${url})`; function generateMissingPluginMessage(missingPluginName, loc, codeFrame) { let helpMessage = `Support for the experimental syntax '${missingPluginName}' isn't currently enabled ` + `(${loc.line}:${loc.column + 1}):\n\n` + codeFrame; const pluginInfo = pluginNameMap[missingPluginName]; if (pluginInfo) { const { syntax: syntaxPlugin, transform: transformPlugin } = pluginInfo; if (syntaxPlugin) { const syntaxPluginInfo = getNameURLCombination(syntaxPlugin); if (transformPlugin) { const transformPluginInfo = getNameURLCombination(transformPlugin); const sectionType = transformPlugin.name.startsWith("@babel/plugin") ? "plugins" : "presets"; helpMessage += `\n\nAdd ${transformPluginInfo} to the '${sectionType}' section of your Babel config to enable transformation. If you want to leave it as-is, add ${syntaxPluginInfo} to the 'plugins' section to enable parsing.`; } else { helpMessage += `\n\nAdd ${syntaxPluginInfo} to the 'plugins' section of your Babel config ` + `to enable parsing.`; } } } return helpMessage; } },{}],34:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = _default; function helpers() { const data = require("@babel/helpers"); helpers = function () { return data; }; return data; } function _generator() { const data = require("@babel/generator"); _generator = function () { return data; }; return data; } function _template() { const data = require("@babel/template"); _template = function () { return data; }; return data; } function t() { const data = require("@babel/types"); t = function () { return data; }; return data; } var _file = require("../transformation/file/file"); const buildUmdWrapper = replacements => (0, _template().default)` (function (root, factory) { if (typeof define === "function" && define.amd) { define(AMD_ARGUMENTS, factory); } else if (typeof exports === "object") { factory(COMMON_ARGUMENTS); } else { factory(BROWSER_ARGUMENTS); } })(UMD_ROOT, function (FACTORY_PARAMETERS) { FACTORY_BODY }); `(replacements); function buildGlobal(allowlist) { const namespace = t().identifier("babelHelpers"); const body = []; const container = t().functionExpression(null, [t().identifier("global")], t().blockStatement(body)); const tree = t().program([t().expressionStatement(t().callExpression(container, [t().conditionalExpression(t().binaryExpression("===", t().unaryExpression("typeof", t().identifier("global")), t().stringLiteral("undefined")), t().identifier("self"), t().identifier("global"))]))]); body.push(t().variableDeclaration("var", [t().variableDeclarator(namespace, t().assignmentExpression("=", t().memberExpression(t().identifier("global"), namespace), t().objectExpression([])))])); buildHelpers(body, namespace, allowlist); return tree; } function buildModule(allowlist) { const body = []; const refs = buildHelpers(body, null, allowlist); body.unshift(t().exportNamedDeclaration(null, Object.keys(refs).map(name => { return t().exportSpecifier(t().cloneNode(refs[name]), t().identifier(name)); }))); return t().program(body, [], "module"); } function buildUmd(allowlist) { const namespace = t().identifier("babelHelpers"); const body = []; body.push(t().variableDeclaration("var", [t().variableDeclarator(namespace, t().identifier("global"))])); buildHelpers(body, namespace, allowlist); return t().program([buildUmdWrapper({ FACTORY_PARAMETERS: t().identifier("global"), BROWSER_ARGUMENTS: t().assignmentExpression("=", t().memberExpression(t().identifier("root"), namespace), t().objectExpression([])), COMMON_ARGUMENTS: t().identifier("exports"), AMD_ARGUMENTS: t().arrayExpression([t().stringLiteral("exports")]), FACTORY_BODY: body, UMD_ROOT: t().identifier("this") })]); } function buildVar(allowlist) { const namespace = t().identifier("babelHelpers"); const body = []; body.push(t().variableDeclaration("var", [t().variableDeclarator(namespace, t().objectExpression([]))])); const tree = t().program(body); buildHelpers(body, namespace, allowlist); body.push(t().expressionStatement(namespace)); return tree; } function buildHelpers(body, namespace, allowlist) { const getHelperReference = name => { return namespace ? t().memberExpression(namespace, t().identifier(name)) : t().identifier(`_${name}`); }; const refs = {}; helpers().list.forEach(function (name) { if (allowlist && allowlist.indexOf(name) < 0) return; const ref = refs[name] = getHelperReference(name); helpers().ensure(name, _file.default); const { nodes } = helpers().get(name, getHelperReference, ref); body.push(...nodes); }); return refs; } function _default(allowlist, outputType = "global") { let tree; const build = { global: buildGlobal, module: buildModule, umd: buildUmd, var: buildVar }[outputType]; if (build) { tree = build(allowlist); } else { throw new Error(`Unsupported output type ${outputType}`); } return (0, _generator().default)(tree).code; } },{"../transformation/file/file":39,"@babel/generator":61,"@babel/helpers":264,"@babel/template":281,"@babel/types":359}],35:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.transformFromAstAsync = exports.transformFromAstSync = exports.transformFromAst = void 0; function _gensync() { const data = require("gensync"); _gensync = function () { return data; }; return data; } var _config = require("./config"); var _transformation = require("./transformation"); const transformFromAstRunner = _gensync()(function* (ast, code, opts) { const config = yield* (0, _config.default)(opts); if (config === null) return null; if (!ast) throw new Error("No AST given"); return yield* (0, _transformation.run)(config, code, ast); }); const transformFromAst = function transformFromAst(ast, code, opts, callback) { if (typeof opts === "function") { callback = opts; opts = undefined; } if (callback === undefined) { return transformFromAstRunner.sync(ast, code, opts); } transformFromAstRunner.errback(ast, code, opts, callback); }; exports.transformFromAst = transformFromAst; const transformFromAstSync = transformFromAstRunner.sync; exports.transformFromAstSync = transformFromAstSync; const transformFromAstAsync = transformFromAstRunner.async; exports.transformFromAstAsync = transformFromAstAsync; },{"./config":17,"./transformation":42,"gensync":439}],36:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.transformFileSync = transformFileSync; exports.transformFileAsync = transformFileAsync; exports.transformFile = void 0; const transformFile = function transformFile(filename, opts, callback) { if (typeof opts === "function") { callback = opts; } callback(new Error("Transforming files is not supported in browsers"), null); }; exports.transformFile = transformFile; function transformFileSync() { throw new Error("Transforming files is not supported in browsers"); } function transformFileAsync() { return Promise.reject(new Error("Transforming files is not supported in browsers")); } },{}],37:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.transformAsync = exports.transformSync = exports.transform = void 0; function _gensync() { const data = require("gensync"); _gensync = function () { return data; }; return data; } var _config = require("./config"); var _transformation = require("./transformation"); const transformRunner = _gensync()(function* transform(code, opts) { const config = yield* (0, _config.default)(opts); if (config === null) return null; return yield* (0, _transformation.run)(config, code); }); const transform = function transform(code, opts, callback) { if (typeof opts === "function") { callback = opts; opts = undefined; } if (callback === undefined) return transformRunner.sync(code, opts); transformRunner.errback(code, opts, callback); }; exports.transform = transform; const transformSync = transformRunner.sync; exports.transformSync = transformSync; const transformAsync = transformRunner.async; exports.transformAsync = transformAsync; },{"./config":17,"./transformation":42,"gensync":439}],38:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = loadBlockHoistPlugin; function _traverse() { const data = require("@babel/traverse"); _traverse = function () { return data; }; return data; } var _plugin = require("../config/plugin"); let LOADED_PLUGIN; function loadBlockHoistPlugin() { if (!LOADED_PLUGIN) { LOADED_PLUGIN = new _plugin.default(Object.assign({}, blockHoistPlugin, { visitor: _traverse().default.explode(blockHoistPlugin.visitor) }), {}); } return LOADED_PLUGIN; } function priority(bodyNode) { const priority = bodyNode == null ? void 0 : bodyNode._blockHoist; if (priority == null) return 1; if (priority === true) return 2; return priority; } function stableSort(body) { const buckets = Object.create(null); for (let i = 0; i < body.length; i++) { const n = body[i]; const p = priority(n); const bucket = buckets[p] || (buckets[p] = []); bucket.push(n); } const keys = Object.keys(buckets).map(k => +k).sort((a, b) => b - a); let index = 0; for (const key of keys) { const bucket = buckets[key]; for (const n of bucket) { body[index++] = n; } } return body; } const blockHoistPlugin = { name: "internal.blockHoist", visitor: { Block: { exit({ node }) { const { body } = node; let max = Math.pow(2, 30) - 1; let hasChange = false; for (let i = 0; i < body.length; i++) { const n = body[i]; const p = priority(n); if (p > max) { hasChange = true; break; } max = p; } if (!hasChange) return; node.body = stableSort(body.slice()); } } } }; },{"../config/plugin":21,"@babel/traverse":290}],39:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = void 0; function helpers() { const data = require("@babel/helpers"); helpers = function () { return data; }; return data; } function _traverse() { const data = require("@babel/traverse"); _traverse = function () { return data; }; return data; } function _codeFrame() { const data = require("@babel/code-frame"); _codeFrame = function () { return data; }; return data; } function t() { const data = require("@babel/types"); t = function () { return data; }; return data; } function _helperModuleTransforms() { const data = require("@babel/helper-module-transforms"); _helperModuleTransforms = function () { return data; }; return data; } function _semver() { const data = require("semver"); _semver = function () { return data; }; return data; } const errorVisitor = { enter(path, state) { const loc = path.node.loc; if (loc) { state.loc = loc; path.stop(); } } }; class File { constructor(options, { code, ast, inputMap }) { this._map = new Map(); this.opts = void 0; this.declarations = {}; this.path = null; this.ast = {}; this.scope = void 0; this.metadata = {}; this.code = ""; this.inputMap = null; this.hub = { file: this, getCode: () => this.code, getScope: () => this.scope, addHelper: this.addHelper.bind(this), buildError: this.buildCodeFrameError.bind(this) }; this.opts = options; this.code = code; this.ast = ast; this.inputMap = inputMap; this.path = _traverse().NodePath.get({ hub: this.hub, parentPath: null, parent: this.ast, container: this.ast, key: "program" }).setContext(); this.scope = this.path.scope; } get shebang() { const { interpreter } = this.path.node; return interpreter ? interpreter.value : ""; } set shebang(value) { if (value) { this.path.get("interpreter").replaceWith(t().interpreterDirective(value)); } else { this.path.get("interpreter").remove(); } } set(key, val) { if (key === "helpersNamespace") { throw new Error("Babel 7.0.0-beta.56 has dropped support for the 'helpersNamespace' utility." + "If you are using @babel/plugin-external-helpers you will need to use a newer " + "version than the one you currently have installed. " + "If you have your own implementation, you'll want to explore using 'helperGenerator' " + "alongside 'file.availableHelper()'."); } this._map.set(key, val); } get(key) { return this._map.get(key); } has(key) { return this._map.has(key); } getModuleName() { return (0, _helperModuleTransforms().getModuleName)(this.opts, this.opts); } addImport() { throw new Error("This API has been removed. If you're looking for this " + "functionality in Babel 7, you should import the " + "'@babel/helper-module-imports' module and use the functions exposed " + " from that module, such as 'addNamed' or 'addDefault'."); } availableHelper(name, versionRange) { let minVersion; try { minVersion = helpers().minVersion(name); } catch (err) { if (err.code !== "BABEL_HELPER_UNKNOWN") throw err; return false; } if (typeof versionRange !== "string") return true; if (_semver().valid(versionRange)) versionRange = `^${versionRange}`; return !_semver().intersects(`<${minVersion}`, versionRange) && !_semver().intersects(`>=8.0.0`, versionRange); } addHelper(name) { const declar = this.declarations[name]; if (declar) return t().cloneNode(declar); const generator = this.get("helperGenerator"); if (generator) { const res = generator(name); if (res) return res; } helpers().ensure(name, File); const uid = this.declarations[name] = this.scope.generateUidIdentifier(name); const dependencies = {}; for (const dep of helpers().getDependencies(name)) { dependencies[dep] = this.addHelper(dep); } const { nodes, globals } = helpers().get(name, dep => dependencies[dep], uid, Object.keys(this.scope.getAllBindings())); globals.forEach(name => { if (this.path.scope.hasBinding(name, true)) { this.path.scope.rename(name); } }); nodes.forEach(node => { node._compact = true; }); this.path.unshiftContainer("body", nodes); this.path.get("body").forEach(path => { if (nodes.indexOf(path.node) === -1) return; if (path.isVariableDeclaration()) this.scope.registerDeclaration(path); }); return uid; } addTemplateObject() { throw new Error("This function has been moved into the template literal transform itself."); } buildCodeFrameError(node, msg, _Error = SyntaxError) { let loc = node && (node.loc || node._loc); if (!loc && node) { const state = { loc: null }; (0, _traverse().default)(node, errorVisitor, this.scope, state); loc = state.loc; let txt = "This is an error on an internal node. Probably an internal error."; if (loc) txt += " Location has been estimated."; msg += ` (${txt})`; } if (loc) { const { highlightCode = true } = this.opts; msg += "\n" + (0, _codeFrame().codeFrameColumns)(this.code, { start: { line: loc.start.line, column: loc.start.column + 1 }, end: loc.end && loc.start.line === loc.end.line ? { line: loc.end.line, column: loc.end.column + 1 } : undefined }, { highlightCode }); } return new _Error(msg); } } exports.default = File; },{"@babel/code-frame":4,"@babel/helper-module-transforms":165,"@babel/helpers":264,"@babel/traverse":290,"@babel/types":359,"semver":47}],40:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = generateCode; function _convertSourceMap() { const data = require("convert-source-map"); _convertSourceMap = function () { return data; }; return data; } function _generator() { const data = require("@babel/generator"); _generator = function () { return data; }; return data; } var _mergeMap = require("./merge-map"); function generateCode(pluginPasses, file) { const { opts, ast, code, inputMap } = file; const results = []; for (const plugins of pluginPasses) { for (const plugin of plugins) { const { generatorOverride } = plugin; if (generatorOverride) { const result = generatorOverride(ast, opts.generatorOpts, code, _generator().default); if (result !== undefined) results.push(result); } } } let result; if (results.length === 0) { result = (0, _generator().default)(ast, opts.generatorOpts, code); } else if (results.length === 1) { result = results[0]; if (typeof result.then === "function") { throw new Error(`You appear to be using an async codegen plugin, ` + `which your current version of Babel does not support. ` + `If you're using a published plugin, ` + `you may need to upgrade your @babel/core version.`); } } else { throw new Error("More than one plugin attempted to override codegen."); } let { code: outputCode, map: outputMap } = result; if (outputMap && inputMap) { outputMap = (0, _mergeMap.default)(inputMap.toObject(), outputMap); } if (opts.sourceMaps === "inline" || opts.sourceMaps === "both") { outputCode += "\n" + _convertSourceMap().fromObject(outputMap).toComment(); } if (opts.sourceMaps === "inline") { outputMap = null; } return { outputCode, outputMap }; } },{"./merge-map":41,"@babel/generator":61,"convert-source-map":429}],41:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = mergeSourceMap; function _sourceMap() { const data = require("source-map"); _sourceMap = function () { return data; }; return data; } function mergeSourceMap(inputMap, map) { const input = buildMappingData(inputMap); const output = buildMappingData(map); const mergedGenerator = new (_sourceMap().SourceMapGenerator)(); for (const { source } of input.sources) { if (typeof source.content === "string") { mergedGenerator.setSourceContent(source.path, source.content); } } if (output.sources.length === 1) { const defaultSource = output.sources[0]; const insertedMappings = new Map(); eachInputGeneratedRange(input, (generated, original, source) => { eachOverlappingGeneratedOutputRange(defaultSource, generated, item => { const key = makeMappingKey(item); if (insertedMappings.has(key)) return; insertedMappings.set(key, item); mergedGenerator.addMapping({ source: source.path, original: { line: original.line, column: original.columnStart }, generated: { line: item.line, column: item.columnStart }, name: original.name }); }); }); for (const item of insertedMappings.values()) { if (item.columnEnd === Infinity) { continue; } const clearItem = { line: item.line, columnStart: item.columnEnd }; const key = makeMappingKey(clearItem); if (insertedMappings.has(key)) { continue; } mergedGenerator.addMapping({ generated: { line: clearItem.line, column: clearItem.columnStart } }); } } const result = mergedGenerator.toJSON(); if (typeof input.sourceRoot === "string") { result.sourceRoot = input.sourceRoot; } return result; } function makeMappingKey(item) { return `${item.line}/${item.columnStart}`; } function eachOverlappingGeneratedOutputRange(outputFile, inputGeneratedRange, callback) { const overlappingOriginal = filterApplicableOriginalRanges(outputFile, inputGeneratedRange); for (const { generated } of overlappingOriginal) { for (const item of generated) { callback(item); } } } function filterApplicableOriginalRanges({ mappings }, { line, columnStart, columnEnd }) { return filterSortedArray(mappings, ({ original: outOriginal }) => { if (line > outOriginal.line) return -1; if (line < outOriginal.line) return 1; if (columnStart >= outOriginal.columnEnd) return -1; if (columnEnd <= outOriginal.columnStart) return 1; return 0; }); } function eachInputGeneratedRange(map, callback) { for (const { source, mappings } of map.sources) { for (const { original, generated } of mappings) { for (const item of generated) { callback(item, original, source); } } } } function buildMappingData(map) { const consumer = new (_sourceMap().SourceMapConsumer)(Object.assign({}, map, { sourceRoot: null })); const sources = new Map(); const mappings = new Map(); let last = null; consumer.computeColumnSpans(); consumer.eachMapping(m => { if (m.originalLine === null) return; let source = sources.get(m.source); if (!source) { source = { path: m.source, content: consumer.sourceContentFor(m.source, true) }; sources.set(m.source, source); } let sourceData = mappings.get(source); if (!sourceData) { sourceData = { source, mappings: [] }; mappings.set(source, sourceData); } const obj = { line: m.originalLine, columnStart: m.originalColumn, columnEnd: Infinity, name: m.name }; if (last && last.source === source && last.mapping.line === m.originalLine) { last.mapping.columnEnd = m.originalColumn; } last = { source, mapping: obj }; sourceData.mappings.push({ original: obj, generated: consumer.allGeneratedPositionsFor({ source: m.source, line: m.originalLine, column: m.originalColumn }).map(item => ({ line: item.line, columnStart: item.column, columnEnd: item.lastColumn + 1 })) }); }, null, _sourceMap().SourceMapConsumer.ORIGINAL_ORDER); return { file: map.file, sourceRoot: map.sourceRoot, sources: Array.from(mappings.values()) }; } function findInsertionLocation(array, callback) { let left = 0; let right = array.length; while (left < right) { const mid = Math.floor((left + right) / 2); const item = array[mid]; const result = callback(item); if (result === 0) { left = mid; break; } if (result >= 0) { right = mid; } else { left = mid + 1; } } let i = left; if (i < array.length) { while (i >= 0 && callback(array[i]) >= 0) { i--; } return i + 1; } return i; } function filterSortedArray(array, callback) { const start = findInsertionLocation(array, callback); const results = []; for (let i = start; i < array.length && callback(array[i]) === 0; i++) { results.push(array[i]); } return results; } },{"source-map":521}],42:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.run = run; function _traverse() { const data = require("@babel/traverse"); _traverse = function () { return data; }; return data; } var _pluginPass = require("./plugin-pass"); var _blockHoistPlugin = require("./block-hoist-plugin"); var _normalizeOpts = require("./normalize-opts"); var _normalizeFile = require("./normalize-file"); var _generate = require("./file/generate"); function* run(config, code, ast) { const file = yield* (0, _normalizeFile.default)(config.passes, (0, _normalizeOpts.default)(config), code, ast); const opts = file.opts; try { yield* transformFile(file, config.passes); } catch (e) { var _opts$filename; e.message = `${(_opts$filename = opts.filename) != null ? _opts$filename : "unknown"}: ${e.message}`; if (!e.code) { e.code = "BABEL_TRANSFORM_ERROR"; } throw e; } let outputCode, outputMap; try { if (opts.code !== false) { ({ outputCode, outputMap } = (0, _generate.default)(config.passes, file)); } } catch (e) { var _opts$filename2; e.message = `${(_opts$filename2 = opts.filename) != null ? _opts$filename2 : "unknown"}: ${e.message}`; if (!e.code) { e.code = "BABEL_GENERATE_ERROR"; } throw e; } return { metadata: file.metadata, options: opts, ast: opts.ast === true ? file.ast : null, code: outputCode === undefined ? null : outputCode, map: outputMap === undefined ? null : outputMap, sourceType: file.ast.program.sourceType }; } function* transformFile(file, pluginPasses) { for (const pluginPairs of pluginPasses) { const passPairs = []; const passes = []; const visitors = []; for (const plugin of pluginPairs.concat([(0, _blockHoistPlugin.default)()])) { const pass = new _pluginPass.default(file, plugin.key, plugin.options); passPairs.push([plugin, pass]); passes.push(pass); visitors.push(plugin.visitor); } for (const [plugin, pass] of passPairs) { const fn = plugin.pre; if (fn) { const result = fn.call(pass, file); yield* []; if (isThenable(result)) { throw new Error(`You appear to be using an plugin with an async .pre, ` + `which your current version of Babel does not support. ` + `If you're using a published plugin, you may need to upgrade ` + `your @babel/core version.`); } } } const visitor = _traverse().default.visitors.merge(visitors, passes, file.opts.wrapPluginVisitorMethod); (0, _traverse().default)(file.ast, visitor, file.scope); for (const [plugin, pass] of passPairs) { const fn = plugin.post; if (fn) { const result = fn.call(pass, file); yield* []; if (isThenable(result)) { throw new Error(`You appear to be using an plugin with an async .post, ` + `which your current version of Babel does not support. ` + `If you're using a published plugin, you may need to upgrade ` + `your @babel/core version.`); } } } } } function isThenable(val) { return !!val && (typeof val === "object" || typeof val === "function") && !!val.then && typeof val.then === "function"; } },{"./block-hoist-plugin":38,"./file/generate":40,"./normalize-file":43,"./normalize-opts":44,"./plugin-pass":45,"@babel/traverse":290}],43:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = normalizeFile; function _fs() { const data = require("fs"); _fs = function () { return data; }; return data; } function _path() { const data = require("path"); _path = function () { return data; }; return data; } function _debug() { const data = require("debug"); _debug = function () { return data; }; return data; } function t() { const data = require("@babel/types"); t = function () { return data; }; return data; } function _convertSourceMap() { const data = require("convert-source-map"); _convertSourceMap = function () { return data; }; return data; } var _file = require("./file/file"); var _parser = require("../parser"); var _cloneDeep = require("./util/clone-deep"); const debug = _debug()("babel:transform:file"); const LARGE_INPUT_SOURCEMAP_THRESHOLD = 1000000; function* normalizeFile(pluginPasses, options, code, ast) { code = `${code || ""}`; if (ast) { if (ast.type === "Program") { ast = t().file(ast, [], []); } else if (ast.type !== "File") { throw new Error("AST root must be a Program or File node"); } if (options.cloneInputAst) { ast = (0, _cloneDeep.default)(ast); } } else { ast = yield* (0, _parser.default)(pluginPasses, options, code); } let inputMap = null; if (options.inputSourceMap !== false) { if (typeof options.inputSourceMap === "object") { inputMap = _convertSourceMap().fromObject(options.inputSourceMap); } if (!inputMap) { const lastComment = extractComments(INLINE_SOURCEMAP_REGEX, ast); if (lastComment) { try { inputMap = _convertSourceMap().fromComment(lastComment); } catch (err) { debug("discarding unknown inline input sourcemap", err); } } } if (!inputMap) { const lastComment = extractComments(EXTERNAL_SOURCEMAP_REGEX, ast); if (typeof options.filename === "string" && lastComment) { try { const match = EXTERNAL_SOURCEMAP_REGEX.exec(lastComment); const inputMapContent = _fs().readFileSync(_path().resolve(_path().dirname(options.filename), match[1])); if (inputMapContent.length > LARGE_INPUT_SOURCEMAP_THRESHOLD) { debug("skip merging input map > 1 MB"); } else { inputMap = _convertSourceMap().fromJSON(inputMapContent); } } catch (err) { debug("discarding unknown file input sourcemap", err); } } else if (lastComment) { debug("discarding un-loadable file input sourcemap"); } } } return new _file.default(options, { code, ast, inputMap }); } const INLINE_SOURCEMAP_REGEX = /^[@#]\s+sourceMappingURL=data:(?:application|text)\/json;(?:charset[:=]\S+?;)?base64,(?:.*)$/; const EXTERNAL_SOURCEMAP_REGEX = /^[@#][ \t]+sourceMappingURL=([^\s'"`]+)[ \t]*$/; function extractCommentsFromList(regex, comments, lastComment) { if (comments) { comments = comments.filter(({ value }) => { if (regex.test(value)) { lastComment = value; return false; } return true; }); } return [comments, lastComment]; } function extractComments(regex, ast) { let lastComment = null; t().traverseFast(ast, node => { [node.leadingComments, lastComment] = extractCommentsFromList(regex, node.leadingComments, lastComment); [node.innerComments, lastComment] = extractCommentsFromList(regex, node.innerComments, lastComment); [node.trailingComments, lastComment] = extractCommentsFromList(regex, node.trailingComments, lastComment); }); return lastComment; } },{"../parser":32,"./file/file":39,"./util/clone-deep":46,"@babel/types":359,"convert-source-map":429,"debug":430,"fs":409,"path":459}],44:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = normalizeOptions; function _path() { const data = require("path"); _path = function () { return data; }; return data; } function normalizeOptions(config) { const { filename, cwd, filenameRelative = typeof filename === "string" ? _path().relative(cwd, filename) : "unknown", sourceType = "module", inputSourceMap, sourceMaps = !!inputSourceMap, sourceRoot = config.options.moduleRoot, sourceFileName = _path().basename(filenameRelative), comments = true, compact = "auto" } = config.options; const opts = config.options; const options = Object.assign({}, opts, { parserOpts: Object.assign({ sourceType: _path().extname(filenameRelative) === ".mjs" ? "module" : sourceType, sourceFileName: filename, plugins: [] }, opts.parserOpts), generatorOpts: Object.assign({ filename, auxiliaryCommentBefore: opts.auxiliaryCommentBefore, auxiliaryCommentAfter: opts.auxiliaryCommentAfter, retainLines: opts.retainLines, comments, shouldPrintComment: opts.shouldPrintComment, compact, minified: opts.minified, sourceMaps, sourceRoot, sourceFileName }, opts.generatorOpts) }); for (const plugins of config.passes) { for (const plugin of plugins) { if (plugin.manipulateOptions) { plugin.manipulateOptions(options, options.parserOpts); } } } return options; } },{"path":459}],45:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = void 0; class PluginPass { constructor(file, key, options) { this._map = new Map(); this.key = void 0; this.file = void 0; this.opts = void 0; this.cwd = void 0; this.filename = void 0; this.key = key; this.file = file; this.opts = options || {}; this.cwd = file.opts.cwd; this.filename = file.opts.filename; } set(key, val) { this._map.set(key, val); } get(key) { return this._map.get(key); } availableHelper(name, versionRange) { return this.file.availableHelper(name, versionRange); } addHelper(name) { return this.file.addHelper(name); } addImport() { return this.file.addImport(); } buildCodeFrameError(node, msg, _Error) { return this.file.buildCodeFrameError(node, msg, _Error); } } exports.default = PluginPass; { PluginPass.prototype.getModuleName = function getModuleName() { return this.file.getModuleName(); }; } },{}],46:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = _default; const serialized = "$$ babel internal serialized type" + Math.random(); function serialize(key, value) { if (typeof value !== "bigint") return value; return { [serialized]: "BigInt", value: value.toString() }; } function revive(key, value) { if (!value || typeof value !== "object") return value; if (value[serialized] !== "BigInt") return value; return BigInt(value.value); } function _default(value) { return JSON.parse(JSON.stringify(value, serialize), revive); } },{}],47:[function(require,module,exports){ (function (process){(function (){ exports = module.exports = SemVer var debug /* istanbul ignore next */ if (typeof process === 'object' && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG)) { debug = function () { var args = Array.prototype.slice.call(arguments, 0) args.unshift('SEMVER') console.log.apply(console, args) } } else { debug = function () {} } // Note: this is the semver.org version of the spec that it implements // Not necessarily the package version of this code. exports.SEMVER_SPEC_VERSION = '2.0.0' var MAX_LENGTH = 256 var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */ 9007199254740991 // Max safe segment length for coercion. var MAX_SAFE_COMPONENT_LENGTH = 16 // The actual regexps go on exports.re var re = exports.re = [] var src = exports.src = [] var t = exports.tokens = {} var R = 0 function tok (n) { t[n] = R++ } // The following Regular Expressions can be used for tokenizing, // validating, and parsing SemVer version strings. // ## Numeric Identifier // A single `0`, or a non-zero digit followed by zero or more digits. tok('NUMERICIDENTIFIER') src[t.NUMERICIDENTIFIER] = '0|[1-9]\\d*' tok('NUMERICIDENTIFIERLOOSE') src[t.NUMERICIDENTIFIERLOOSE] = '[0-9]+' // ## Non-numeric Identifier // Zero or more digits, followed by a letter or hyphen, and then zero or // more letters, digits, or hyphens. tok('NONNUMERICIDENTIFIER') src[t.NONNUMERICIDENTIFIER] = '\\d*[a-zA-Z-][a-zA-Z0-9-]*' // ## Main Version // Three dot-separated numeric identifiers. tok('MAINVERSION') src[t.MAINVERSION] = '(' + src[t.NUMERICIDENTIFIER] + ')\\.' + '(' + src[t.NUMERICIDENTIFIER] + ')\\.' + '(' + src[t.NUMERICIDENTIFIER] + ')' tok('MAINVERSIONLOOSE') src[t.MAINVERSIONLOOSE] = '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')\\.' + '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')\\.' + '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')' // ## Pre-release Version Identifier // A numeric identifier, or a non-numeric identifier. tok('PRERELEASEIDENTIFIER') src[t.PRERELEASEIDENTIFIER] = '(?:' + src[t.NUMERICIDENTIFIER] + '|' + src[t.NONNUMERICIDENTIFIER] + ')' tok('PRERELEASEIDENTIFIERLOOSE') src[t.PRERELEASEIDENTIFIERLOOSE] = '(?:' + src[t.NUMERICIDENTIFIERLOOSE] + '|' + src[t.NONNUMERICIDENTIFIER] + ')' // ## Pre-release Version // Hyphen, followed by one or more dot-separated pre-release version // identifiers. tok('PRERELEASE') src[t.PRERELEASE] = '(?:-(' + src[t.PRERELEASEIDENTIFIER] + '(?:\\.' + src[t.PRERELEASEIDENTIFIER] + ')*))' tok('PRERELEASELOOSE') src[t.PRERELEASELOOSE] = '(?:-?(' + src[t.PRERELEASEIDENTIFIERLOOSE] + '(?:\\.' + src[t.PRERELEASEIDENTIFIERLOOSE] + ')*))' // ## Build Metadata Identifier // Any combination of digits, letters, or hyphens. tok('BUILDIDENTIFIER') src[t.BUILDIDENTIFIER] = '[0-9A-Za-z-]+' // ## Build Metadata // Plus sign, followed by one or more period-separated build metadata // identifiers. tok('BUILD') src[t.BUILD] = '(?:\\+(' + src[t.BUILDIDENTIFIER] + '(?:\\.' + src[t.BUILDIDENTIFIER] + ')*))' // ## Full Version String // A main version, followed optionally by a pre-release version and // build metadata. // Note that the only major, minor, patch, and pre-release sections of // the version string are capturing groups. The build metadata is not a // capturing group, because it should not ever be used in version // comparison. tok('FULL') tok('FULLPLAIN') src[t.FULLPLAIN] = 'v?' + src[t.MAINVERSION] + src[t.PRERELEASE] + '?' + src[t.BUILD] + '?' src[t.FULL] = '^' + src[t.FULLPLAIN] + '$' // like full, but allows v1.2.3 and =1.2.3, which people do sometimes. // also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty // common in the npm registry. tok('LOOSEPLAIN') src[t.LOOSEPLAIN] = '[v=\\s]*' + src[t.MAINVERSIONLOOSE] + src[t.PRERELEASELOOSE] + '?' + src[t.BUILD] + '?' tok('LOOSE') src[t.LOOSE] = '^' + src[t.LOOSEPLAIN] + '$' tok('GTLT') src[t.GTLT] = '((?:<|>)?=?)' // Something like "2.*" or "1.2.x". // Note that "x.x" is a valid xRange identifer, meaning "any version" // Only the first item is strictly required. tok('XRANGEIDENTIFIERLOOSE') src[t.XRANGEIDENTIFIERLOOSE] = src[t.NUMERICIDENTIFIERLOOSE] + '|x|X|\\*' tok('XRANGEIDENTIFIER') src[t.XRANGEIDENTIFIER] = src[t.NUMERICIDENTIFIER] + '|x|X|\\*' tok('XRANGEPLAIN') src[t.XRANGEPLAIN] = '[v=\\s]*(' + src[t.XRANGEIDENTIFIER] + ')' + '(?:\\.(' + src[t.XRANGEIDENTIFIER] + ')' + '(?:\\.(' + src[t.XRANGEIDENTIFIER] + ')' + '(?:' + src[t.PRERELEASE] + ')?' + src[t.BUILD] + '?' + ')?)?' tok('XRANGEPLAINLOOSE') src[t.XRANGEPLAINLOOSE] = '[v=\\s]*(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' + '(?:\\.(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' + '(?:\\.(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' + '(?:' + src[t.PRERELEASELOOSE] + ')?' + src[t.BUILD] + '?' + ')?)?' tok('XRANGE') src[t.XRANGE] = '^' + src[t.GTLT] + '\\s*' + src[t.XRANGEPLAIN] + '$' tok('XRANGELOOSE') src[t.XRANGELOOSE] = '^' + src[t.GTLT] + '\\s*' + src[t.XRANGEPLAINLOOSE] + '$' // Coercion. // Extract anything that could conceivably be a part of a valid semver tok('COERCE') src[t.COERCE] = '(^|[^\\d])' + '(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '})' + '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' + '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' + '(?:$|[^\\d])' tok('COERCERTL') re[t.COERCERTL] = new RegExp(src[t.COERCE], 'g') // Tilde ranges. // Meaning is "reasonably at or greater than" tok('LONETILDE') src[t.LONETILDE] = '(?:~>?)' tok('TILDETRIM') src[t.TILDETRIM] = '(\\s*)' + src[t.LONETILDE] + '\\s+' re[t.TILDETRIM] = new RegExp(src[t.TILDETRIM], 'g') var tildeTrimReplace = '$1~' tok('TILDE') src[t.TILDE] = '^' + src[t.LONETILDE] + src[t.XRANGEPLAIN] + '$' tok('TILDELOOSE') src[t.TILDELOOSE] = '^' + src[t.LONETILDE] + src[t.XRANGEPLAINLOOSE] + '$' // Caret ranges. // Meaning is "at least and backwards compatible with" tok('LONECARET') src[t.LONECARET] = '(?:\\^)' tok('CARETTRIM') src[t.CARETTRIM] = '(\\s*)' + src[t.LONECARET] + '\\s+' re[t.CARETTRIM] = new RegExp(src[t.CARETTRIM], 'g') var caretTrimReplace = '$1^' tok('CARET') src[t.CARET] = '^' + src[t.LONECARET] + src[t.XRANGEPLAIN] + '$' tok('CARETLOOSE') src[t.CARETLOOSE] = '^' + src[t.LONECARET] + src[t.XRANGEPLAINLOOSE] + '$' // A simple gt/lt/eq thing, or just "" to indicate "any version" tok('COMPARATORLOOSE') src[t.COMPARATORLOOSE] = '^' + src[t.GTLT] + '\\s*(' + src[t.LOOSEPLAIN] + ')$|^$' tok('COMPARATOR') src[t.COMPARATOR] = '^' + src[t.GTLT] + '\\s*(' + src[t.FULLPLAIN] + ')$|^$' // An expression to strip any whitespace between the gtlt and the thing // it modifies, so that `> 1.2.3` ==> `>1.2.3` tok('COMPARATORTRIM') src[t.COMPARATORTRIM] = '(\\s*)' + src[t.GTLT] + '\\s*(' + src[t.LOOSEPLAIN] + '|' + src[t.XRANGEPLAIN] + ')' // this one has to use the /g flag re[t.COMPARATORTRIM] = new RegExp(src[t.COMPARATORTRIM], 'g') var comparatorTrimReplace = '$1$2$3' // Something like `1.2.3 - 1.2.4` // Note that these all use the loose form, because they'll be // checked against either the strict or loose comparator form // later. tok('HYPHENRANGE') src[t.HYPHENRANGE] = '^\\s*(' + src[t.XRANGEPLAIN] + ')' + '\\s+-\\s+' + '(' + src[t.XRANGEPLAIN] + ')' + '\\s*$' tok('HYPHENRANGELOOSE') src[t.HYPHENRANGELOOSE] = '^\\s*(' + src[t.XRANGEPLAINLOOSE] + ')' + '\\s+-\\s+' + '(' + src[t.XRANGEPLAINLOOSE] + ')' + '\\s*$' // Star ranges basically just allow anything at all. tok('STAR') src[t.STAR] = '(<|>)?=?\\s*\\*' // Compile to actual regexp objects. // All are flag-free, unless they were created above with a flag. for (var i = 0; i < R; i++) { debug(i, src[i]) if (!re[i]) { re[i] = new RegExp(src[i]) } } exports.parse = parse function parse (version, options) { if (!options || typeof options !== 'object') { options = { loose: !!options, includePrerelease: false } } if (version instanceof SemVer) { return version } if (typeof version !== 'string') { return null } if (version.length > MAX_LENGTH) { return null } var r = options.loose ? re[t.LOOSE] : re[t.FULL] if (!r.test(version)) { return null } try { return new SemVer(version, options) } catch (er) { return null } } exports.valid = valid function valid (version, options) { var v = parse(version, options) return v ? v.version : null } exports.clean = clean function clean (version, options) { var s = parse(version.trim().replace(/^[=v]+/, ''), options) return s ? s.version : null } exports.SemVer = SemVer function SemVer (version, options) { if (!options || typeof options !== 'object') { options = { loose: !!options, includePrerelease: false } } if (version instanceof SemVer) { if (version.loose === options.loose) { return version } else { version = version.version } } else if (typeof version !== 'string') { throw new TypeError('Invalid Version: ' + version) } if (version.length > MAX_LENGTH) { throw new TypeError('version is longer than ' + MAX_LENGTH + ' characters') } if (!(this instanceof SemVer)) { return new SemVer(version, options) } debug('SemVer', version, options) this.options = options this.loose = !!options.loose var m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]) if (!m) { throw new TypeError('Invalid Version: ' + version) } this.raw = version // these are actually numbers this.major = +m[1] this.minor = +m[2] this.patch = +m[3] if (this.major > MAX_SAFE_INTEGER || this.major < 0) { throw new TypeError('Invalid major version') } if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) { throw new TypeError('Invalid minor version') } if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) { throw new TypeError('Invalid patch version') } // numberify any prerelease numeric ids if (!m[4]) { this.prerelease = [] } else { this.prerelease = m[4].split('.').map(function (id) { if (/^[0-9]+$/.test(id)) { var num = +id if (num >= 0 && num < MAX_SAFE_INTEGER) { return num } } return id }) } this.build = m[5] ? m[5].split('.') : [] this.format() } SemVer.prototype.format = function () { this.version = this.major + '.' + this.minor + '.' + this.patch if (this.prerelease.length) { this.version += '-' + this.prerelease.join('.') } return this.version } SemVer.prototype.toString = function () { return this.version } SemVer.prototype.compare = function (other) { debug('SemVer.compare', this.version, this.options, other) if (!(other instanceof SemVer)) { other = new SemVer(other, this.options) } return this.compareMain(other) || this.comparePre(other) } SemVer.prototype.compareMain = function (other) { if (!(other instanceof SemVer)) { other = new SemVer(other, this.options) } return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch) } SemVer.prototype.comparePre = function (other) { if (!(other instanceof SemVer)) { other = new SemVer(other, this.options) } // NOT having a prerelease is > having one if (this.prerelease.length && !other.prerelease.length) { return -1 } else if (!this.prerelease.length && other.prerelease.length) { return 1 } else if (!this.prerelease.length && !other.prerelease.length) { return 0 } var i = 0 do { var a = this.prerelease[i] var b = other.prerelease[i] debug('prerelease compare', i, a, b) if (a === undefined && b === undefined) { return 0 } else if (b === undefined) { return 1 } else if (a === undefined) { return -1 } else if (a === b) { continue } else { return compareIdentifiers(a, b) } } while (++i) } SemVer.prototype.compareBuild = function (other) { if (!(other instanceof SemVer)) { other = new SemVer(other, this.options) } var i = 0 do { var a = this.build[i] var b = other.build[i] debug('prerelease compare', i, a, b) if (a === undefined && b === undefined) { return 0 } else if (b === undefined) { return 1 } else if (a === undefined) { return -1 } else if (a === b) { continue } else { return compareIdentifiers(a, b) } } while (++i) } // preminor will bump the version up to the next minor release, and immediately // down to pre-release. premajor and prepatch work the same way. SemVer.prototype.inc = function (release, identifier) { switch (release) { case 'premajor': this.prerelease.length = 0 this.patch = 0 this.minor = 0 this.major++ this.inc('pre', identifier) break case 'preminor': this.prerelease.length = 0 this.patch = 0 this.minor++ this.inc('pre', identifier) break case 'prepatch': // If this is already a prerelease, it will bump to the next version // drop any prereleases that might already exist, since they are not // relevant at this point. this.prerelease.length = 0 this.inc('patch', identifier) this.inc('pre', identifier) break // If the input is a non-prerelease version, this acts the same as // prepatch. case 'prerelease': if (this.prerelease.length === 0) { this.inc('patch', identifier) } this.inc('pre', identifier) break case 'major': // If this is a pre-major version, bump up to the same major version. // Otherwise increment major. // 1.0.0-5 bumps to 1.0.0 // 1.1.0 bumps to 2.0.0 if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) { this.major++ } this.minor = 0 this.patch = 0 this.prerelease = [] break case 'minor': // If this is a pre-minor version, bump up to the same minor version. // Otherwise increment minor. // 1.2.0-5 bumps to 1.2.0 // 1.2.1 bumps to 1.3.0 if (this.patch !== 0 || this.prerelease.length === 0) { this.minor++ } this.patch = 0 this.prerelease = [] break case 'patch': // If this is not a pre-release version, it will increment the patch. // If it is a pre-release it will bump up to the same patch version. // 1.2.0-5 patches to 1.2.0 // 1.2.0 patches to 1.2.1 if (this.prerelease.length === 0) { this.patch++ } this.prerelease = [] break // This probably shouldn't be used publicly. // 1.0.0 "pre" would become 1.0.0-0 which is the wrong direction. case 'pre': if (this.prerelease.length === 0) { this.prerelease = [0] } else { var i = this.prerelease.length while (--i >= 0) { if (typeof this.prerelease[i] === 'number') { this.prerelease[i]++ i = -2 } } if (i === -1) { // didn't increment anything this.prerelease.push(0) } } if (identifier) { // 1.2.0-beta.1 bumps to 1.2.0-beta.2, // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0 if (this.prerelease[0] === identifier) { if (isNaN(this.prerelease[1])) { this.prerelease = [identifier, 0] } } else { this.prerelease = [identifier, 0] } } break default: throw new Error('invalid increment argument: ' + release) } this.format() this.raw = this.version return this } exports.inc = inc function inc (version, release, loose, identifier) { if (typeof (loose) === 'string') { identifier = loose loose = undefined } try { return new SemVer(version, loose).inc(release, identifier).version } catch (er) { return null } } exports.diff = diff function diff (version1, version2) { if (eq(version1, version2)) { return null } else { var v1 = parse(version1) var v2 = parse(version2) var prefix = '' if (v1.prerelease.length || v2.prerelease.length) { prefix = 'pre' var defaultResult = 'prerelease' } for (var key in v1) { if (key === 'major' || key === 'minor' || key === 'patch') { if (v1[key] !== v2[key]) { return prefix + key } } } return defaultResult // may be undefined } } exports.compareIdentifiers = compareIdentifiers var numeric = /^[0-9]+$/ function compareIdentifiers (a, b) { var anum = numeric.test(a) var bnum = numeric.test(b) if (anum && bnum) { a = +a b = +b } return a === b ? 0 : (anum && !bnum) ? -1 : (bnum && !anum) ? 1 : a < b ? -1 : 1 } exports.rcompareIdentifiers = rcompareIdentifiers function rcompareIdentifiers (a, b) { return compareIdentifiers(b, a) } exports.major = major function major (a, loose) { return new SemVer(a, loose).major } exports.minor = minor function minor (a, loose) { return new SemVer(a, loose).minor } exports.patch = patch function patch (a, loose) { return new SemVer(a, loose).patch } exports.compare = compare function compare (a, b, loose) { return new SemVer(a, loose).compare(new SemVer(b, loose)) } exports.compareLoose = compareLoose function compareLoose (a, b) { return compare(a, b, true) } exports.compareBuild = compareBuild function compareBuild (a, b, loose) { var versionA = new SemVer(a, loose) var versionB = new SemVer(b, loose) return versionA.compare(versionB) || versionA.compareBuild(versionB) } exports.rcompare = rcompare function rcompare (a, b, loose) { return compare(b, a, loose) } exports.sort = sort function sort (list, loose) { return list.sort(function (a, b) { return exports.compareBuild(a, b, loose) }) } exports.rsort = rsort function rsort (list, loose) { return list.sort(function (a, b) { return exports.compareBuild(b, a, loose) }) } exports.gt = gt function gt (a, b, loose) { return compare(a, b, loose) > 0 } exports.lt = lt function lt (a, b, loose) { return compare(a, b, loose) < 0 } exports.eq = eq function eq (a, b, loose) { return compare(a, b, loose) === 0 } exports.neq = neq function neq (a, b, loose) { return compare(a, b, loose) !== 0 } exports.gte = gte function gte (a, b, loose) { return compare(a, b, loose) >= 0 } exports.lte = lte function lte (a, b, loose) { return compare(a, b, loose) <= 0 } exports.cmp = cmp function cmp (a, op, b, loose) { switch (op) { case '===': if (typeof a === 'object') a = a.version if (typeof b === 'object') b = b.version return a === b case '!==': if (typeof a === 'object') a = a.version if (typeof b === 'object') b = b.version return a !== b case '': case '=': case '==': return eq(a, b, loose) case '!=': return neq(a, b, loose) case '>': return gt(a, b, loose) case '>=': return gte(a, b, loose) case '<': return lt(a, b, loose) case '<=': return lte(a, b, loose) default: throw new TypeError('Invalid operator: ' + op) } } exports.Comparator = Comparator function Comparator (comp, options) { if (!options || typeof options !== 'object') { options = { loose: !!options, includePrerelease: false } } if (comp instanceof Comparator) { if (comp.loose === !!options.loose) { return comp } else { comp = comp.value } } if (!(this instanceof Comparator)) { return new Comparator(comp, options) } debug('comparator', comp, options) this.options = options this.loose = !!options.loose this.parse(comp) if (this.semver === ANY) { this.value = '' } else { this.value = this.operator + this.semver.version } debug('comp', this) } var ANY = {} Comparator.prototype.parse = function (comp) { var r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR] var m = comp.match(r) if (!m) { throw new TypeError('Invalid comparator: ' + comp) } this.operator = m[1] !== undefined ? m[1] : '' if (this.operator === '=') { this.operator = '' } // if it literally is just '>' or '' then allow anything. if (!m[2]) { this.semver = ANY } else { this.semver = new SemVer(m[2], this.options.loose) } } Comparator.prototype.toString = function () { return this.value } Comparator.prototype.test = function (version) { debug('Comparator.test', version, this.options.loose) if (this.semver === ANY || version === ANY) { return true } if (typeof version === 'string') { try { version = new SemVer(version, this.options) } catch (er) { return false } } return cmp(version, this.operator, this.semver, this.options) } Comparator.prototype.intersects = function (comp, options) { if (!(comp instanceof Comparator)) { throw new TypeError('a Comparator is required') } if (!options || typeof options !== 'object') { options = { loose: !!options, includePrerelease: false } } var rangeTmp if (this.operator === '') { if (this.value === '') { return true } rangeTmp = new Range(comp.value, options) return satisfies(this.value, rangeTmp, options) } else if (comp.operator === '') { if (comp.value === '') { return true } rangeTmp = new Range(this.value, options) return satisfies(comp.semver, rangeTmp, options) } var sameDirectionIncreasing = (this.operator === '>=' || this.operator === '>') && (comp.operator === '>=' || comp.operator === '>') var sameDirectionDecreasing = (this.operator === '<=' || this.operator === '<') && (comp.operator === '<=' || comp.operator === '<') var sameSemVer = this.semver.version === comp.semver.version var differentDirectionsInclusive = (this.operator === '>=' || this.operator === '<=') && (comp.operator === '>=' || comp.operator === '<=') var oppositeDirectionsLessThan = cmp(this.semver, '<', comp.semver, options) && ((this.operator === '>=' || this.operator === '>') && (comp.operator === '<=' || comp.operator === '<')) var oppositeDirectionsGreaterThan = cmp(this.semver, '>', comp.semver, options) && ((this.operator === '<=' || this.operator === '<') && (comp.operator === '>=' || comp.operator === '>')) return sameDirectionIncreasing || sameDirectionDecreasing || (sameSemVer && differentDirectionsInclusive) || oppositeDirectionsLessThan || oppositeDirectionsGreaterThan } exports.Range = Range function Range (range, options) { if (!options || typeof options !== 'object') { options = { loose: !!options, includePrerelease: false } } if (range instanceof Range) { if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) { return range } else { return new Range(range.raw, options) } } if (range instanceof Comparator) { return new Range(range.value, options) } if (!(this instanceof Range)) { return new Range(range, options) } this.options = options this.loose = !!options.loose this.includePrerelease = !!options.includePrerelease // First, split based on boolean or || this.raw = range this.set = range.split(/\s*\|\|\s*/).map(function (range) { return this.parseRange(range.trim()) }, this).filter(function (c) { // throw out any that are not relevant for whatever reason return c.length }) if (!this.set.length) { throw new TypeError('Invalid SemVer Range: ' + range) } this.format() } Range.prototype.format = function () { this.range = this.set.map(function (comps) { return comps.join(' ').trim() }).join('||').trim() return this.range } Range.prototype.toString = function () { return this.range } Range.prototype.parseRange = function (range) { var loose = this.options.loose range = range.trim() // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4` var hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE] range = range.replace(hr, hyphenReplace) debug('hyphen replace', range) // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5` range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace) debug('comparator trim', range, re[t.COMPARATORTRIM]) // `~ 1.2.3` => `~1.2.3` range = range.replace(re[t.TILDETRIM], tildeTrimReplace) // `^ 1.2.3` => `^1.2.3` range = range.replace(re[t.CARETTRIM], caretTrimReplace) // normalize spaces range = range.split(/\s+/).join(' ') // At this point, the range is completely trimmed and // ready to be split into comparators. var compRe = loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR] var set = range.split(' ').map(function (comp) { return parseComparator(comp, this.options) }, this).join(' ').split(/\s+/) if (this.options.loose) { // in loose mode, throw out any that are not valid comparators set = set.filter(function (comp) { return !!comp.match(compRe) }) } set = set.map(function (comp) { return new Comparator(comp, this.options) }, this) return set } Range.prototype.intersects = function (range, options) { if (!(range instanceof Range)) { throw new TypeError('a Range is required') } return this.set.some(function (thisComparators) { return ( isSatisfiable(thisComparators, options) && range.set.some(function (rangeComparators) { return ( isSatisfiable(rangeComparators, options) && thisComparators.every(function (thisComparator) { return rangeComparators.every(function (rangeComparator) { return thisComparator.intersects(rangeComparator, options) }) }) ) }) ) }) } // take a set of comparators and determine whether there // exists a version which can satisfy it function isSatisfiable (comparators, options) { var result = true var remainingComparators = comparators.slice() var testComparator = remainingComparators.pop() while (result && remainingComparators.length) { result = remainingComparators.every(function (otherComparator) { return testComparator.intersects(otherComparator, options) }) testComparator = remainingComparators.pop() } return result } // Mostly just for testing and legacy API reasons exports.toComparators = toComparators function toComparators (range, options) { return new Range(range, options).set.map(function (comp) { return comp.map(function (c) { return c.value }).join(' ').trim().split(' ') }) } // comprised of xranges, tildes, stars, and gtlt's at this point. // already replaced the hyphen ranges // turn into a set of JUST comparators. function parseComparator (comp, options) { debug('comp', comp, options) comp = replaceCarets(comp, options) debug('caret', comp) comp = replaceTildes(comp, options) debug('tildes', comp) comp = replaceXRanges(comp, options) debug('xrange', comp) comp = replaceStars(comp, options) debug('stars', comp) return comp } function isX (id) { return !id || id.toLowerCase() === 'x' || id === '*' } // ~, ~> --> * (any, kinda silly) // ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0 // ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0 // ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0 // ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0 // ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0 function replaceTildes (comp, options) { return comp.trim().split(/\s+/).map(function (comp) { return replaceTilde(comp, options) }).join(' ') } function replaceTilde (comp, options) { var r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE] return comp.replace(r, function (_, M, m, p, pr) { debug('tilde', comp, _, M, m, p, pr) var ret if (isX(M)) { ret = '' } else if (isX(m)) { ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0' } else if (isX(p)) { // ~1.2 == >=1.2.0 <1.3.0 ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0' } else if (pr) { debug('replaceTilde pr', pr) ret = '>=' + M + '.' + m + '.' + p + '-' + pr + ' <' + M + '.' + (+m + 1) + '.0' } else { // ~1.2.3 == >=1.2.3 <1.3.0 ret = '>=' + M + '.' + m + '.' + p + ' <' + M + '.' + (+m + 1) + '.0' } debug('tilde return', ret) return ret }) } // ^ --> * (any, kinda silly) // ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0 // ^2.0, ^2.0.x --> >=2.0.0 <3.0.0 // ^1.2, ^1.2.x --> >=1.2.0 <2.0.0 // ^1.2.3 --> >=1.2.3 <2.0.0 // ^1.2.0 --> >=1.2.0 <2.0.0 function replaceCarets (comp, options) { return comp.trim().split(/\s+/).map(function (comp) { return replaceCaret(comp, options) }).join(' ') } function replaceCaret (comp, options) { debug('caret', comp, options) var r = options.loose ? re[t.CARETLOOSE] : re[t.CARET] return comp.replace(r, function (_, M, m, p, pr) { debug('caret', comp, _, M, m, p, pr) var ret if (isX(M)) { ret = '' } else if (isX(m)) { ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0' } else if (isX(p)) { if (M === '0') { ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0' } else { ret = '>=' + M + '.' + m + '.0 <' + (+M + 1) + '.0.0' } } else if (pr) { debug('replaceCaret pr', pr) if (M === '0') { if (m === '0') { ret = '>=' + M + '.' + m + '.' + p + '-' + pr + ' <' + M + '.' + m + '.' + (+p + 1) } else { ret = '>=' + M + '.' + m + '.' + p + '-' + pr + ' <' + M + '.' + (+m + 1) + '.0' } } else { ret = '>=' + M + '.' + m + '.' + p + '-' + pr + ' <' + (+M + 1) + '.0.0' } } else { debug('no pr') if (M === '0') { if (m === '0') { ret = '>=' + M + '.' + m + '.' + p + ' <' + M + '.' + m + '.' + (+p + 1) } else { ret = '>=' + M + '.' + m + '.' + p + ' <' + M + '.' + (+m + 1) + '.0' } } else { ret = '>=' + M + '.' + m + '.' + p + ' <' + (+M + 1) + '.0.0' } } debug('caret return', ret) return ret }) } function replaceXRanges (comp, options) { debug('replaceXRanges', comp, options) return comp.split(/\s+/).map(function (comp) { return replaceXRange(comp, options) }).join(' ') } function replaceXRange (comp, options) { comp = comp.trim() var r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE] return comp.replace(r, function (ret, gtlt, M, m, p, pr) { debug('xRange', comp, ret, gtlt, M, m, p, pr) var xM = isX(M) var xm = xM || isX(m) var xp = xm || isX(p) var anyX = xp if (gtlt === '=' && anyX) { gtlt = '' } // if we're including prereleases in the match, then we need // to fix this to -0, the lowest possible prerelease value pr = options.includePrerelease ? '-0' : '' if (xM) { if (gtlt === '>' || gtlt === '<') { // nothing is allowed ret = '<0.0.0-0' } else { // nothing is forbidden ret = '*' } } else if (gtlt && anyX) { // we know patch is an x, because we have any x at all. // replace X with 0 if (xm) { m = 0 } p = 0 if (gtlt === '>') { // >1 => >=2.0.0 // >1.2 => >=1.3.0 // >1.2.3 => >= 1.2.4 gtlt = '>=' if (xm) { M = +M + 1 m = 0 p = 0 } else { m = +m + 1 p = 0 } } else if (gtlt === '<=') { // <=0.7.x is actually <0.8.0, since any 0.7.x should // pass. Similarly, <=7.x is actually <8.0.0, etc. gtlt = '<' if (xm) { M = +M + 1 } else { m = +m + 1 } } ret = gtlt + M + '.' + m + '.' + p + pr } else if (xm) { ret = '>=' + M + '.0.0' + pr + ' <' + (+M + 1) + '.0.0' + pr } else if (xp) { ret = '>=' + M + '.' + m + '.0' + pr + ' <' + M + '.' + (+m + 1) + '.0' + pr } debug('xRange return', ret) return ret }) } // Because * is AND-ed with everything else in the comparator, // and '' means "any version", just remove the *s entirely. function replaceStars (comp, options) { debug('replaceStars', comp, options) // Looseness is ignored here. star is always as loose as it gets! return comp.trim().replace(re[t.STAR], '') } // This function is passed to string.replace(re[t.HYPHENRANGE]) // M, m, patch, prerelease, build // 1.2 - 3.4.5 => >=1.2.0 <=3.4.5 // 1.2.3 - 3.4 => >=1.2.0 <3.5.0 Any 3.4.x will do // 1.2 - 3.4 => >=1.2.0 <3.5.0 function hyphenReplace ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr, tb) { if (isX(fM)) { from = '' } else if (isX(fm)) { from = '>=' + fM + '.0.0' } else if (isX(fp)) { from = '>=' + fM + '.' + fm + '.0' } else { from = '>=' + from } if (isX(tM)) { to = '' } else if (isX(tm)) { to = '<' + (+tM + 1) + '.0.0' } else if (isX(tp)) { to = '<' + tM + '.' + (+tm + 1) + '.0' } else if (tpr) { to = '<=' + tM + '.' + tm + '.' + tp + '-' + tpr } else { to = '<=' + to } return (from + ' ' + to).trim() } // if ANY of the sets match ALL of its comparators, then pass Range.prototype.test = function (version) { if (!version) { return false } if (typeof version === 'string') { try { version = new SemVer(version, this.options) } catch (er) { return false } } for (var i = 0; i < this.set.length; i++) { if (testSet(this.set[i], version, this.options)) { return true } } return false } function testSet (set, version, options) { for (var i = 0; i < set.length; i++) { if (!set[i].test(version)) { return false } } if (version.prerelease.length && !options.includePrerelease) { // Find the set of versions that are allowed to have prereleases // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0 // That should allow `1.2.3-pr.2` to pass. // However, `1.2.4-alpha.notready` should NOT be allowed, // even though it's within the range set by the comparators. for (i = 0; i < set.length; i++) { debug(set[i].semver) if (set[i].semver === ANY) { continue } if (set[i].semver.prerelease.length > 0) { var allowed = set[i].semver if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) { return true } } } // Version has a -pre, but it's not one of the ones we like. return false } return true } exports.satisfies = satisfies function satisfies (version, range, options) { try { range = new Range(range, options) } catch (er) { return false } return range.test(version) } exports.maxSatisfying = maxSatisfying function maxSatisfying (versions, range, options) { var max = null var maxSV = null try { var rangeObj = new Range(range, options) } catch (er) { return null } versions.forEach(function (v) { if (rangeObj.test(v)) { // satisfies(v, range, options) if (!max || maxSV.compare(v) === -1) { // compare(max, v, true) max = v maxSV = new SemVer(max, options) } } }) return max } exports.minSatisfying = minSatisfying function minSatisfying (versions, range, options) { var min = null var minSV = null try { var rangeObj = new Range(range, options) } catch (er) { return null } versions.forEach(function (v) { if (rangeObj.test(v)) { // satisfies(v, range, options) if (!min || minSV.compare(v) === 1) { // compare(min, v, true) min = v minSV = new SemVer(min, options) } } }) return min } exports.minVersion = minVersion function minVersion (range, loose) { range = new Range(range, loose) var minver = new SemVer('0.0.0') if (range.test(minver)) { return minver } minver = new SemVer('0.0.0-0') if (range.test(minver)) { return minver } minver = null for (var i = 0; i < range.set.length; ++i) { var comparators = range.set[i] comparators.forEach(function (comparator) { // Clone to avoid manipulating the comparator's semver object. var compver = new SemVer(comparator.semver.version) switch (comparator.operator) { case '>': if (compver.prerelease.length === 0) { compver.patch++ } else { compver.prerelease.push(0) } compver.raw = compver.format() /* fallthrough */ case '': case '>=': if (!minver || gt(minver, compver)) { minver = compver } break case '<': case '<=': /* Ignore maximum versions */ break /* istanbul ignore next */ default: throw new Error('Unexpected operation: ' + comparator.operator) } }) } if (minver && range.test(minver)) { return minver } return null } exports.validRange = validRange function validRange (range, options) { try { // Return '*' instead of '' so that truthiness works. // This will throw if it's invalid anyway return new Range(range, options).range || '*' } catch (er) { return null } } // Determine if version is less than all the versions possible in the range exports.ltr = ltr function ltr (version, range, options) { return outside(version, range, '<', options) } // Determine if version is greater than all the versions possible in the range. exports.gtr = gtr function gtr (version, range, options) { return outside(version, range, '>', options) } exports.outside = outside function outside (version, range, hilo, options) { version = new SemVer(version, options) range = new Range(range, options) var gtfn, ltefn, ltfn, comp, ecomp switch (hilo) { case '>': gtfn = gt ltefn = lte ltfn = lt comp = '>' ecomp = '>=' break case '<': gtfn = lt ltefn = gte ltfn = gt comp = '<' ecomp = '<=' break default: throw new TypeError('Must provide a hilo val of "<" or ">"') } // If it satisifes the range it is not outside if (satisfies(version, range, options)) { return false } // From now on, variable terms are as if we're in "gtr" mode. // but note that everything is flipped for the "ltr" function. for (var i = 0; i < range.set.length; ++i) { var comparators = range.set[i] var high = null var low = null comparators.forEach(function (comparator) { if (comparator.semver === ANY) { comparator = new Comparator('>=0.0.0') } high = high || comparator low = low || comparator if (gtfn(comparator.semver, high.semver, options)) { high = comparator } else if (ltfn(comparator.semver, low.semver, options)) { low = comparator } }) // If the edge version comparator has a operator then our version // isn't outside it if (high.operator === comp || high.operator === ecomp) { return false } // If the lowest version comparator has an operator and our version // is less than it then it isn't higher than the range if ((!low.operator || low.operator === comp) && ltefn(version, low.semver)) { return false } else if (low.operator === ecomp && ltfn(version, low.semver)) { return false } } return true } exports.prerelease = prerelease function prerelease (version, options) { var parsed = parse(version, options) return (parsed && parsed.prerelease.length) ? parsed.prerelease : null } exports.intersects = intersects function intersects (r1, r2, options) { r1 = new Range(r1, options) r2 = new Range(r2, options) return r1.intersects(r2) } exports.coerce = coerce function coerce (version, options) { if (version instanceof SemVer) { return version } if (typeof version === 'number') { version = String(version) } if (typeof version !== 'string') { return null } options = options || {} var match = null if (!options.rtl) { match = version.match(re[t.COERCE]) } else { // Find the right-most coercible string that does not share // a terminus with a more left-ward coercible string. // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4' // // Walk through the string checking with a /g regexp // Manually set the index so as to pick up overlapping matches. // Stop when we get a match that ends at the string end, since no // coercible string can be more right-ward without the same terminus. var next while ((next = re[t.COERCERTL].exec(version)) && (!match || match.index + match[0].length !== version.length) ) { if (!match || next.index + next[0].length !== match.index + match[0].length) { match = next } re[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length } // leave it in a clean state re[t.COERCERTL].lastIndex = -1 } if (match === null) { return null } return parse(match[2] + '.' + (match[3] || '0') + '.' + (match[4] || '0'), options) } }).call(this)}).call(this,require('_process')) },{"_process":460}],48:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = void 0; class Buffer { constructor(map) { this._map = null; this._buf = ""; this._str = ""; this._appendCount = 0; this._last = 0; this._queue = []; this._queueCursor = 0; this._position = { line: 1, column: 0 }; this._sourcePosition = { identifierName: undefined, line: undefined, column: undefined, filename: undefined }; this._map = map; this._allocQueue(); } _allocQueue() { const queue = this._queue; for (let i = 0; i < 16; i++) { queue.push({ char: 0, repeat: 1, line: undefined, column: undefined, identifierName: undefined, filename: "" }); } } _pushQueue(char, repeat, line, column, identifierName, filename) { const cursor = this._queueCursor; if (cursor === this._queue.length) { this._allocQueue(); } const item = this._queue[cursor]; item.char = char; item.repeat = repeat; item.line = line; item.column = column; item.identifierName = identifierName; item.filename = filename; this._queueCursor++; } _popQueue() { if (this._queueCursor === 0) { throw new Error("Cannot pop from empty queue"); } return this._queue[--this._queueCursor]; } get() { this._flush(); const map = this._map; const result = { code: (this._buf + this._str).trimRight(), decodedMap: map == null ? void 0 : map.getDecoded(), get map() { const resultMap = map ? map.get() : null; result.map = resultMap; return resultMap; }, set map(value) { Object.defineProperty(result, "map", { value, writable: true }); }, get rawMappings() { const mappings = map == null ? void 0 : map.getRawMappings(); result.rawMappings = mappings; return mappings; }, set rawMappings(value) { Object.defineProperty(result, "rawMappings", { value, writable: true }); } }; return result; } append(str, maybeNewline) { this._flush(); this._append(str, this._sourcePosition, maybeNewline); } appendChar(char) { this._flush(); this._appendChar(char, 1, this._sourcePosition); } queue(char) { if (char === 10) { while (this._queueCursor !== 0) { const char = this._queue[this._queueCursor - 1].char; if (char !== 32 && char !== 9) { break; } this._queueCursor--; } } const sourcePosition = this._sourcePosition; this._pushQueue(char, 1, sourcePosition.line, sourcePosition.column, sourcePosition.identifierName, sourcePosition.filename); } queueIndentation(char, repeat) { this._pushQueue(char, repeat, undefined, undefined, undefined, undefined); } _flush() { const queueCursor = this._queueCursor; const queue = this._queue; for (let i = 0; i < queueCursor; i++) { const item = queue[i]; this._appendChar(item.char, item.repeat, item); } this._queueCursor = 0; } _appendChar(char, repeat, sourcePos) { this._last = char; this._str += repeat > 1 ? String.fromCharCode(char).repeat(repeat) : String.fromCharCode(char); if (char !== 10) { this._mark(sourcePos.line, sourcePos.column, sourcePos.identifierName, sourcePos.filename); this._position.column += repeat; } else { this._position.line++; this._position.column = 0; } } _append(str, sourcePos, maybeNewline) { const len = str.length; const position = this._position; this._last = str.charCodeAt(len - 1); if (++this._appendCount > 4096) { +this._str; this._buf += this._str; this._str = str; this._appendCount = 0; } else { this._str += str; } if (!maybeNewline && !this._map) { position.column += len; return; } const { column, identifierName, filename } = sourcePos; let line = sourcePos.line; let i = str.indexOf("\n"); let last = 0; if (i !== 0) { this._mark(line, column, identifierName, filename); } while (i !== -1) { position.line++; position.column = 0; last = i + 1; if (last < len) { this._mark(++line, 0, identifierName, filename); } i = str.indexOf("\n", last); } position.column += len - last; } _mark(line, column, identifierName, filename) { var _this$_map; (_this$_map = this._map) == null ? void 0 : _this$_map.mark(this._position, line, column, identifierName, filename); } removeTrailingNewline() { const queueCursor = this._queueCursor; if (queueCursor !== 0 && this._queue[queueCursor - 1].char === 10) { this._queueCursor--; } } removeLastSemicolon() { const queueCursor = this._queueCursor; if (queueCursor !== 0 && this._queue[queueCursor - 1].char === 59) { this._queueCursor--; } } getLastChar() { const queueCursor = this._queueCursor; return queueCursor !== 0 ? this._queue[queueCursor - 1].char : this._last; } getNewlineCount() { const queueCursor = this._queueCursor; let count = 0; if (queueCursor === 0) return this._last === 10 ? 1 : 0; for (let i = queueCursor - 1; i >= 0; i--) { if (this._queue[i].char !== 10) { break; } count++; } return count === queueCursor && this._last === 10 ? count + 1 : count; } endsWithCharAndNewline() { const queue = this._queue; const queueCursor = this._queueCursor; if (queueCursor !== 0) { const lastCp = queue[queueCursor - 1].char; if (lastCp !== 10) return; if (queueCursor > 1) { return queue[queueCursor - 2].char; } else { return this._last; } } } hasContent() { return this._queueCursor !== 0 || !!this._last; } exactSource(loc, cb) { if (!this._map) return cb(); this.source("start", loc); cb(); this.source("end", loc); } source(prop, loc) { if (!this._map) return; this._normalizePosition(prop, loc, 0, 0); } sourceWithOffset(prop, loc, lineOffset, columnOffset) { if (!this._map) return; this._normalizePosition(prop, loc, lineOffset, columnOffset); } withSource(prop, loc, cb) { if (!this._map) return cb(); this.source(prop, loc); cb(); } _normalizePosition(prop, loc, lineOffset, columnOffset) { const pos = loc[prop]; const target = this._sourcePosition; target.identifierName = prop === "start" && loc.identifierName || undefined; if (pos) { target.line = pos.line + lineOffset; target.column = pos.column + columnOffset; target.filename = loc.filename; } } getCurrentColumn() { const queue = this._queue; const queueCursor = this._queueCursor; let lastIndex = -1; let len = 0; for (let i = 0; i < queueCursor; i++) { const item = queue[i]; if (item.char === 10) { lastIndex = len; } len += item.repeat; } return lastIndex === -1 ? this._position.column + len : len - 1 - lastIndex; } getCurrentLine() { let count = 0; const queue = this._queue; for (let i = 0; i < this._queueCursor; i++) { if (queue[i].char === 10) { count++; } } return this._position.line + count; } } exports.default = Buffer; },{}],49:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.BlockStatement = BlockStatement; exports.Directive = Directive; exports.DirectiveLiteral = DirectiveLiteral; exports.File = File; exports.InterpreterDirective = InterpreterDirective; exports.Placeholder = Placeholder; exports.Program = Program; function File(node) { if (node.program) { this.print(node.program.interpreter, node); } this.print(node.program, node); } function Program(node) { var _node$directives; this.printInnerComments(node, false); const directivesLen = (_node$directives = node.directives) == null ? void 0 : _node$directives.length; if (directivesLen) { var _node$directives$trai; const newline = node.body.length ? 2 : 1; this.printSequence(node.directives, node, { trailingCommentsLineOffset: newline }); if (!((_node$directives$trai = node.directives[directivesLen - 1].trailingComments) != null && _node$directives$trai.length)) { this.newline(newline); } } this.printSequence(node.body, node); } function BlockStatement(node) { var _node$directives2; this.tokenChar(123); this.printInnerComments(node); const directivesLen = (_node$directives2 = node.directives) == null ? void 0 : _node$directives2.length; if (directivesLen) { var _node$directives$trai2; const newline = node.body.length ? 2 : 1; this.printSequence(node.directives, node, { indent: true, trailingCommentsLineOffset: newline }); if (!((_node$directives$trai2 = node.directives[directivesLen - 1].trailingComments) != null && _node$directives$trai2.length)) { this.newline(newline); } } this.printSequence(node.body, node, { indent: true }); this.sourceWithOffset("end", node.loc, 0, -1); this.rightBrace(); } function Directive(node) { this.print(node.value, node); this.semicolon(); } const unescapedSingleQuoteRE = /(?:^|[^\\])(?:\\\\)*'/; const unescapedDoubleQuoteRE = /(?:^|[^\\])(?:\\\\)*"/; function DirectiveLiteral(node) { const raw = this.getPossibleRaw(node); if (!this.format.minified && raw !== undefined) { this.token(raw); return; } const { value } = node; if (!unescapedDoubleQuoteRE.test(value)) { this.token(`"${value}"`); } else if (!unescapedSingleQuoteRE.test(value)) { this.token(`'${value}'`); } else { throw new Error("Malformed AST: it is not possible to print a directive containing" + " both unescaped single and double quotes."); } } function InterpreterDirective(node) { this.token(`#!${node.value}`); this.newline(1, true); } function Placeholder(node) { this.token("%%"); this.print(node.name); this.token("%%"); if (node.expectedNode === "Statement") { this.semicolon(); } } },{}],50:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.ClassAccessorProperty = ClassAccessorProperty; exports.ClassBody = ClassBody; exports.ClassExpression = exports.ClassDeclaration = ClassDeclaration; exports.ClassMethod = ClassMethod; exports.ClassPrivateMethod = ClassPrivateMethod; exports.ClassPrivateProperty = ClassPrivateProperty; exports.ClassProperty = ClassProperty; exports.StaticBlock = StaticBlock; exports._classMethodHead = _classMethodHead; var _t = require("@babel/types"); const { isExportDefaultDeclaration, isExportNamedDeclaration } = _t; function ClassDeclaration(node, parent) { { if (!this.format.decoratorsBeforeExport || !isExportDefaultDeclaration(parent) && !isExportNamedDeclaration(parent)) { this.printJoin(node.decorators, node); } } if (node.declare) { this.word("declare"); this.space(); } if (node.abstract) { this.word("abstract"); this.space(); } this.word("class"); this.printInnerComments(node); if (node.id) { this.space(); this.print(node.id, node); } this.print(node.typeParameters, node); if (node.superClass) { this.space(); this.word("extends"); this.space(); this.print(node.superClass, node); this.print(node.superTypeParameters, node); } if (node.implements) { this.space(); this.word("implements"); this.space(); this.printList(node.implements, node); } this.space(); this.print(node.body, node); } function ClassBody(node) { this.tokenChar(123); this.printInnerComments(node); if (node.body.length === 0) { this.tokenChar(125); } else { this.newline(); this.indent(); this.printSequence(node.body, node); this.dedent(); if (!this.endsWith(10)) this.newline(); this.sourceWithOffset("end", node.loc, 0, -1); this.rightBrace(); } } function ClassProperty(node) { var _node$key$loc, _node$key$loc$end; this.printJoin(node.decorators, node); const endLine = (_node$key$loc = node.key.loc) == null ? void 0 : (_node$key$loc$end = _node$key$loc.end) == null ? void 0 : _node$key$loc$end.line; if (endLine) this.catchUp(endLine); this.tsPrintClassMemberModifiers(node); if (node.computed) { this.tokenChar(91); this.print(node.key, node); this.tokenChar(93); } else { this._variance(node); this.print(node.key, node); } if (node.optional) { this.tokenChar(63); } if (node.definite) { this.tokenChar(33); } this.print(node.typeAnnotation, node); if (node.value) { this.space(); this.tokenChar(61); this.space(); this.print(node.value, node); } this.semicolon(); } function ClassAccessorProperty(node) { var _node$key$loc2, _node$key$loc2$end; this.printJoin(node.decorators, node); const endLine = (_node$key$loc2 = node.key.loc) == null ? void 0 : (_node$key$loc2$end = _node$key$loc2.end) == null ? void 0 : _node$key$loc2$end.line; if (endLine) this.catchUp(endLine); this.tsPrintClassMemberModifiers(node); this.word("accessor"); this.printInnerComments(node); this.space(); if (node.computed) { this.tokenChar(91); this.print(node.key, node); this.tokenChar(93); } else { this._variance(node); this.print(node.key, node); } if (node.optional) { this.tokenChar(63); } if (node.definite) { this.tokenChar(33); } this.print(node.typeAnnotation, node); if (node.value) { this.space(); this.tokenChar(61); this.space(); this.print(node.value, node); } this.semicolon(); } function ClassPrivateProperty(node) { this.printJoin(node.decorators, node); if (node.static) { this.word("static"); this.space(); } this.print(node.key, node); this.print(node.typeAnnotation, node); if (node.value) { this.space(); this.tokenChar(61); this.space(); this.print(node.value, node); } this.semicolon(); } function ClassMethod(node) { this._classMethodHead(node); this.space(); this.print(node.body, node); } function ClassPrivateMethod(node) { this._classMethodHead(node); this.space(); this.print(node.body, node); } function _classMethodHead(node) { var _node$key$loc3, _node$key$loc3$end; this.printJoin(node.decorators, node); const endLine = (_node$key$loc3 = node.key.loc) == null ? void 0 : (_node$key$loc3$end = _node$key$loc3.end) == null ? void 0 : _node$key$loc3$end.line; if (endLine) this.catchUp(endLine); this.tsPrintClassMemberModifiers(node); this._methodHead(node); } function StaticBlock(node) { this.word("static"); this.space(); this.tokenChar(123); if (node.body.length === 0) { this.tokenChar(125); } else { this.newline(); this.printSequence(node.body, node, { indent: true }); this.sourceWithOffset("end", node.loc, 0, -1); this.rightBrace(); } } },{"@babel/types":359}],51:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.LogicalExpression = exports.BinaryExpression = exports.AssignmentExpression = AssignmentExpression; exports.AssignmentPattern = AssignmentPattern; exports.AwaitExpression = AwaitExpression; exports.BindExpression = BindExpression; exports.CallExpression = CallExpression; exports.ConditionalExpression = ConditionalExpression; exports.Decorator = Decorator; exports.DoExpression = DoExpression; exports.EmptyStatement = EmptyStatement; exports.ExpressionStatement = ExpressionStatement; exports.Import = Import; exports.MemberExpression = MemberExpression; exports.MetaProperty = MetaProperty; exports.ModuleExpression = ModuleExpression; exports.NewExpression = NewExpression; exports.OptionalCallExpression = OptionalCallExpression; exports.OptionalMemberExpression = OptionalMemberExpression; exports.ParenthesizedExpression = ParenthesizedExpression; exports.PrivateName = PrivateName; exports.SequenceExpression = SequenceExpression; exports.Super = Super; exports.ThisExpression = ThisExpression; exports.UnaryExpression = UnaryExpression; exports.UpdateExpression = UpdateExpression; exports.V8IntrinsicIdentifier = V8IntrinsicIdentifier; exports.YieldExpression = YieldExpression; var _t = require("@babel/types"); var n = require("../node"); const { isCallExpression, isLiteral, isMemberExpression, isNewExpression } = _t; function UnaryExpression(node) { if (node.operator === "void" || node.operator === "delete" || node.operator === "typeof" || node.operator === "throw") { this.word(node.operator); this.space(); } else { this.token(node.operator); } this.print(node.argument, node); } function DoExpression(node) { if (node.async) { this.word("async"); this.space(); } this.word("do"); this.space(); this.print(node.body, node); } function ParenthesizedExpression(node) { this.tokenChar(40); this.print(node.expression, node); this.tokenChar(41); } function UpdateExpression(node) { if (node.prefix) { this.token(node.operator); this.print(node.argument, node); } else { this.printTerminatorless(node.argument, node, true); this.token(node.operator); } } function ConditionalExpression(node) { this.print(node.test, node); this.space(); this.tokenChar(63); this.space(); this.print(node.consequent, node); this.space(); this.tokenChar(58); this.space(); this.print(node.alternate, node); } function NewExpression(node, parent) { this.word("new"); this.space(); this.print(node.callee, node); if (this.format.minified && node.arguments.length === 0 && !node.optional && !isCallExpression(parent, { callee: node }) && !isMemberExpression(parent) && !isNewExpression(parent)) { return; } this.print(node.typeArguments, node); this.print(node.typeParameters, node); if (node.optional) { this.token("?."); } this.tokenChar(40); this.printList(node.arguments, node); this.tokenChar(41); } function SequenceExpression(node) { this.printList(node.expressions, node); } function ThisExpression() { this.word("this"); } function Super() { this.word("super"); } function isDecoratorMemberExpression(node) { switch (node.type) { case "Identifier": return true; case "MemberExpression": return !node.computed && node.property.type === "Identifier" && isDecoratorMemberExpression(node.object); default: return false; } } function shouldParenthesizeDecoratorExpression(node) { if (node.type === "ParenthesizedExpression") { return false; } return !isDecoratorMemberExpression(node.type === "CallExpression" ? node.callee : node); } function Decorator(node) { this.tokenChar(64); const { expression } = node; if (shouldParenthesizeDecoratorExpression(expression)) { this.tokenChar(40); this.print(expression, node); this.tokenChar(41); } else { this.print(expression, node); } this.newline(); } function OptionalMemberExpression(node) { this.print(node.object, node); if (!node.computed && isMemberExpression(node.property)) { throw new TypeError("Got a MemberExpression for MemberExpression property"); } let computed = node.computed; if (isLiteral(node.property) && typeof node.property.value === "number") { computed = true; } if (node.optional) { this.token("?."); } if (computed) { this.tokenChar(91); this.print(node.property, node); this.tokenChar(93); } else { if (!node.optional) { this.tokenChar(46); } this.print(node.property, node); } } function OptionalCallExpression(node) { this.print(node.callee, node); this.print(node.typeParameters, node); if (node.optional) { this.token("?."); } this.print(node.typeArguments, node); this.tokenChar(40); this.printList(node.arguments, node); this.tokenChar(41); } function CallExpression(node) { this.print(node.callee, node); this.print(node.typeArguments, node); this.print(node.typeParameters, node); this.tokenChar(40); this.printList(node.arguments, node); this.tokenChar(41); } function Import() { this.word("import"); } function AwaitExpression(node) { this.word("await"); if (node.argument) { this.space(); this.printTerminatorless(node.argument, node, false); } } function YieldExpression(node) { this.word("yield"); if (node.delegate) { this.tokenChar(42); } if (node.argument) { this.space(); this.printTerminatorless(node.argument, node, false); } } function EmptyStatement() { this.semicolon(true); } function ExpressionStatement(node) { this.print(node.expression, node); this.semicolon(); } function AssignmentPattern(node) { this.print(node.left, node); if (node.left.optional) this.tokenChar(63); this.print(node.left.typeAnnotation, node); this.space(); this.tokenChar(61); this.space(); this.print(node.right, node); } function AssignmentExpression(node, parent) { const parens = this.inForStatementInitCounter && node.operator === "in" && !n.needsParens(node, parent); if (parens) { this.tokenChar(40); } this.print(node.left, node); this.space(); if (node.operator === "in" || node.operator === "instanceof") { this.word(node.operator); } else { this.token(node.operator); } this.space(); this.print(node.right, node); if (parens) { this.tokenChar(41); } } function BindExpression(node) { this.print(node.object, node); this.token("::"); this.print(node.callee, node); } function MemberExpression(node) { this.print(node.object, node); if (!node.computed && isMemberExpression(node.property)) { throw new TypeError("Got a MemberExpression for MemberExpression property"); } let computed = node.computed; if (isLiteral(node.property) && typeof node.property.value === "number") { computed = true; } if (computed) { this.tokenChar(91); this.print(node.property, node); this.tokenChar(93); } else { this.tokenChar(46); this.print(node.property, node); } } function MetaProperty(node) { this.print(node.meta, node); this.tokenChar(46); this.print(node.property, node); } function PrivateName(node) { this.tokenChar(35); this.print(node.id, node); } function V8IntrinsicIdentifier(node) { this.tokenChar(37); this.word(node.name); } function ModuleExpression(node) { this.word("module"); this.ensureNoLineTerminator(() => { this.printInnerComments(node); this.space(); }); this.tokenChar(123); this.indent(); const { body } = node; if (body.body.length || body.directives.length) { this.newline(); } this.print(body, node); this.dedent(); this.sourceWithOffset("end", node.loc, 0, -1); this.rightBrace(); } },{"../node":62,"@babel/types":359}],52:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.AnyTypeAnnotation = AnyTypeAnnotation; exports.ArrayTypeAnnotation = ArrayTypeAnnotation; exports.BooleanLiteralTypeAnnotation = BooleanLiteralTypeAnnotation; exports.BooleanTypeAnnotation = BooleanTypeAnnotation; exports.DeclareClass = DeclareClass; exports.DeclareExportAllDeclaration = DeclareExportAllDeclaration; exports.DeclareExportDeclaration = DeclareExportDeclaration; exports.DeclareFunction = DeclareFunction; exports.DeclareInterface = DeclareInterface; exports.DeclareModule = DeclareModule; exports.DeclareModuleExports = DeclareModuleExports; exports.DeclareOpaqueType = DeclareOpaqueType; exports.DeclareTypeAlias = DeclareTypeAlias; exports.DeclareVariable = DeclareVariable; exports.DeclaredPredicate = DeclaredPredicate; exports.EmptyTypeAnnotation = EmptyTypeAnnotation; exports.EnumBooleanBody = EnumBooleanBody; exports.EnumBooleanMember = EnumBooleanMember; exports.EnumDeclaration = EnumDeclaration; exports.EnumDefaultedMember = EnumDefaultedMember; exports.EnumNumberBody = EnumNumberBody; exports.EnumNumberMember = EnumNumberMember; exports.EnumStringBody = EnumStringBody; exports.EnumStringMember = EnumStringMember; exports.EnumSymbolBody = EnumSymbolBody; exports.ExistsTypeAnnotation = ExistsTypeAnnotation; exports.FunctionTypeAnnotation = FunctionTypeAnnotation; exports.FunctionTypeParam = FunctionTypeParam; exports.IndexedAccessType = IndexedAccessType; exports.InferredPredicate = InferredPredicate; exports.InterfaceDeclaration = InterfaceDeclaration; exports.GenericTypeAnnotation = exports.ClassImplements = exports.InterfaceExtends = InterfaceExtends; exports.InterfaceTypeAnnotation = InterfaceTypeAnnotation; exports.IntersectionTypeAnnotation = IntersectionTypeAnnotation; exports.MixedTypeAnnotation = MixedTypeAnnotation; exports.NullLiteralTypeAnnotation = NullLiteralTypeAnnotation; exports.NullableTypeAnnotation = NullableTypeAnnotation; Object.defineProperty(exports, "NumberLiteralTypeAnnotation", { enumerable: true, get: function () { return _types2.NumericLiteral; } }); exports.NumberTypeAnnotation = NumberTypeAnnotation; exports.ObjectTypeAnnotation = ObjectTypeAnnotation; exports.ObjectTypeCallProperty = ObjectTypeCallProperty; exports.ObjectTypeIndexer = ObjectTypeIndexer; exports.ObjectTypeInternalSlot = ObjectTypeInternalSlot; exports.ObjectTypeProperty = ObjectTypeProperty; exports.ObjectTypeSpreadProperty = ObjectTypeSpreadProperty; exports.OpaqueType = OpaqueType; exports.OptionalIndexedAccessType = OptionalIndexedAccessType; exports.QualifiedTypeIdentifier = QualifiedTypeIdentifier; Object.defineProperty(exports, "StringLiteralTypeAnnotation", { enumerable: true, get: function () { return _types2.StringLiteral; } }); exports.StringTypeAnnotation = StringTypeAnnotation; exports.SymbolTypeAnnotation = SymbolTypeAnnotation; exports.ThisTypeAnnotation = ThisTypeAnnotation; exports.TupleTypeAnnotation = TupleTypeAnnotation; exports.TypeAlias = TypeAlias; exports.TypeAnnotation = TypeAnnotation; exports.TypeCastExpression = TypeCastExpression; exports.TypeParameter = TypeParameter; exports.TypeParameterDeclaration = exports.TypeParameterInstantiation = TypeParameterInstantiation; exports.TypeofTypeAnnotation = TypeofTypeAnnotation; exports.UnionTypeAnnotation = UnionTypeAnnotation; exports.Variance = Variance; exports.VoidTypeAnnotation = VoidTypeAnnotation; exports._interfaceish = _interfaceish; exports._variance = _variance; var _t = require("@babel/types"); var _modules = require("./modules"); var _types2 = require("./types"); const { isDeclareExportDeclaration, isStatement } = _t; function AnyTypeAnnotation() { this.word("any"); } function ArrayTypeAnnotation(node) { this.print(node.elementType, node, true); this.tokenChar(91); this.tokenChar(93); } function BooleanTypeAnnotation() { this.word("boolean"); } function BooleanLiteralTypeAnnotation(node) { this.word(node.value ? "true" : "false"); } function NullLiteralTypeAnnotation() { this.word("null"); } function DeclareClass(node, parent) { if (!isDeclareExportDeclaration(parent)) { this.word("declare"); this.space(); } this.word("class"); this.space(); this._interfaceish(node); } function DeclareFunction(node, parent) { if (!isDeclareExportDeclaration(parent)) { this.word("declare"); this.space(); } this.word("function"); this.space(); this.print(node.id, node); this.print(node.id.typeAnnotation.typeAnnotation, node); if (node.predicate) { this.space(); this.print(node.predicate, node); } this.semicolon(); } function InferredPredicate() { this.tokenChar(37); this.word("checks"); } function DeclaredPredicate(node) { this.tokenChar(37); this.word("checks"); this.tokenChar(40); this.print(node.value, node); this.tokenChar(41); } function DeclareInterface(node) { this.word("declare"); this.space(); this.InterfaceDeclaration(node); } function DeclareModule(node) { this.word("declare"); this.space(); this.word("module"); this.space(); this.print(node.id, node); this.space(); this.print(node.body, node); } function DeclareModuleExports(node) { this.word("declare"); this.space(); this.word("module"); this.tokenChar(46); this.word("exports"); this.print(node.typeAnnotation, node); } function DeclareTypeAlias(node) { this.word("declare"); this.space(); this.TypeAlias(node); } function DeclareOpaqueType(node, parent) { if (!isDeclareExportDeclaration(parent)) { this.word("declare"); this.space(); } this.OpaqueType(node); } function DeclareVariable(node, parent) { if (!isDeclareExportDeclaration(parent)) { this.word("declare"); this.space(); } this.word("var"); this.space(); this.print(node.id, node); this.print(node.id.typeAnnotation, node); this.semicolon(); } function DeclareExportDeclaration(node) { this.word("declare"); this.space(); this.word("export"); this.space(); if (node.default) { this.word("default"); this.space(); } FlowExportDeclaration.call(this, node); } function DeclareExportAllDeclaration(node) { this.word("declare"); this.space(); _modules.ExportAllDeclaration.call(this, node); } function EnumDeclaration(node) { const { id, body } = node; this.word("enum"); this.space(); this.print(id, node); this.print(body, node); } function enumExplicitType(context, name, hasExplicitType) { if (hasExplicitType) { context.space(); context.word("of"); context.space(); context.word(name); } context.space(); } function enumBody(context, node) { const { members } = node; context.token("{"); context.indent(); context.newline(); for (const member of members) { context.print(member, node); context.newline(); } if (node.hasUnknownMembers) { context.token("..."); context.newline(); } context.dedent(); context.token("}"); } function EnumBooleanBody(node) { const { explicitType } = node; enumExplicitType(this, "boolean", explicitType); enumBody(this, node); } function EnumNumberBody(node) { const { explicitType } = node; enumExplicitType(this, "number", explicitType); enumBody(this, node); } function EnumStringBody(node) { const { explicitType } = node; enumExplicitType(this, "string", explicitType); enumBody(this, node); } function EnumSymbolBody(node) { enumExplicitType(this, "symbol", true); enumBody(this, node); } function EnumDefaultedMember(node) { const { id } = node; this.print(id, node); this.tokenChar(44); } function enumInitializedMember(context, node) { const { id, init } = node; context.print(id, node); context.space(); context.token("="); context.space(); context.print(init, node); context.token(","); } function EnumBooleanMember(node) { enumInitializedMember(this, node); } function EnumNumberMember(node) { enumInitializedMember(this, node); } function EnumStringMember(node) { enumInitializedMember(this, node); } function FlowExportDeclaration(node) { if (node.declaration) { const declar = node.declaration; this.print(declar, node); if (!isStatement(declar)) this.semicolon(); } else { this.tokenChar(123); if (node.specifiers.length) { this.space(); this.printList(node.specifiers, node); this.space(); } this.tokenChar(125); if (node.source) { this.space(); this.word("from"); this.space(); this.print(node.source, node); } this.semicolon(); } } function ExistsTypeAnnotation() { this.tokenChar(42); } function FunctionTypeAnnotation(node, parent) { this.print(node.typeParameters, node); this.tokenChar(40); if (node.this) { this.word("this"); this.tokenChar(58); this.space(); this.print(node.this.typeAnnotation, node); if (node.params.length || node.rest) { this.tokenChar(44); this.space(); } } this.printList(node.params, node); if (node.rest) { if (node.params.length) { this.tokenChar(44); this.space(); } this.token("..."); this.print(node.rest, node); } this.tokenChar(41); if (parent && (parent.type === "ObjectTypeCallProperty" || parent.type === "ObjectTypeInternalSlot" || parent.type === "DeclareFunction" || parent.type === "ObjectTypeProperty" && parent.method)) { this.tokenChar(58); } else { this.space(); this.token("=>"); } this.space(); this.print(node.returnType, node); } function FunctionTypeParam(node) { this.print(node.name, node); if (node.optional) this.tokenChar(63); if (node.name) { this.tokenChar(58); this.space(); } this.print(node.typeAnnotation, node); } function InterfaceExtends(node) { this.print(node.id, node); this.print(node.typeParameters, node, true); } function _interfaceish(node) { var _node$extends; this.print(node.id, node); this.print(node.typeParameters, node); if ((_node$extends = node.extends) != null && _node$extends.length) { this.space(); this.word("extends"); this.space(); this.printList(node.extends, node); } if (node.mixins && node.mixins.length) { this.space(); this.word("mixins"); this.space(); this.printList(node.mixins, node); } if (node.implements && node.implements.length) { this.space(); this.word("implements"); this.space(); this.printList(node.implements, node); } this.space(); this.print(node.body, node); } function _variance(node) { if (node.variance) { if (node.variance.kind === "plus") { this.tokenChar(43); } else if (node.variance.kind === "minus") { this.tokenChar(45); } } } function InterfaceDeclaration(node) { this.word("interface"); this.space(); this._interfaceish(node); } function andSeparator() { this.space(); this.tokenChar(38); this.space(); } function InterfaceTypeAnnotation(node) { this.word("interface"); if (node.extends && node.extends.length) { this.space(); this.word("extends"); this.space(); this.printList(node.extends, node); } this.space(); this.print(node.body, node); } function IntersectionTypeAnnotation(node) { this.printJoin(node.types, node, { separator: andSeparator }); } function MixedTypeAnnotation() { this.word("mixed"); } function EmptyTypeAnnotation() { this.word("empty"); } function NullableTypeAnnotation(node) { this.tokenChar(63); this.print(node.typeAnnotation, node); } function NumberTypeAnnotation() { this.word("number"); } function StringTypeAnnotation() { this.word("string"); } function ThisTypeAnnotation() { this.word("this"); } function TupleTypeAnnotation(node) { this.tokenChar(91); this.printList(node.types, node); this.tokenChar(93); } function TypeofTypeAnnotation(node) { this.word("typeof"); this.space(); this.print(node.argument, node); } function TypeAlias(node) { this.word("type"); this.space(); this.print(node.id, node); this.print(node.typeParameters, node); this.space(); this.tokenChar(61); this.space(); this.print(node.right, node); this.semicolon(); } function TypeAnnotation(node) { this.tokenChar(58); this.space(); if (node.optional) this.tokenChar(63); this.print(node.typeAnnotation, node); } function TypeParameterInstantiation(node) { this.tokenChar(60); this.printList(node.params, node, {}); this.tokenChar(62); } function TypeParameter(node) { this._variance(node); this.word(node.name); if (node.bound) { this.print(node.bound, node); } if (node.default) { this.space(); this.tokenChar(61); this.space(); this.print(node.default, node); } } function OpaqueType(node) { this.word("opaque"); this.space(); this.word("type"); this.space(); this.print(node.id, node); this.print(node.typeParameters, node); if (node.supertype) { this.tokenChar(58); this.space(); this.print(node.supertype, node); } if (node.impltype) { this.space(); this.tokenChar(61); this.space(); this.print(node.impltype, node); } this.semicolon(); } function ObjectTypeAnnotation(node) { if (node.exact) { this.token("{|"); } else { this.tokenChar(123); } const props = [...node.properties, ...(node.callProperties || []), ...(node.indexers || []), ...(node.internalSlots || [])]; if (props.length) { this.newline(); this.space(); this.printJoin(props, node, { addNewlines(leading) { if (leading && !props[0]) return 1; }, indent: true, statement: true, iterator: () => { if (props.length !== 1 || node.inexact) { this.tokenChar(44); this.space(); } } }); this.space(); } if (node.inexact) { this.indent(); this.token("..."); if (props.length) { this.newline(); } this.dedent(); } if (node.exact) { this.token("|}"); } else { this.tokenChar(125); } } function ObjectTypeInternalSlot(node) { if (node.static) { this.word("static"); this.space(); } this.tokenChar(91); this.tokenChar(91); this.print(node.id, node); this.tokenChar(93); this.tokenChar(93); if (node.optional) this.tokenChar(63); if (!node.method) { this.tokenChar(58); this.space(); } this.print(node.value, node); } function ObjectTypeCallProperty(node) { if (node.static) { this.word("static"); this.space(); } this.print(node.value, node); } function ObjectTypeIndexer(node) { if (node.static) { this.word("static"); this.space(); } this._variance(node); this.tokenChar(91); if (node.id) { this.print(node.id, node); this.tokenChar(58); this.space(); } this.print(node.key, node); this.tokenChar(93); this.tokenChar(58); this.space(); this.print(node.value, node); } function ObjectTypeProperty(node) { if (node.proto) { this.word("proto"); this.space(); } if (node.static) { this.word("static"); this.space(); } if (node.kind === "get" || node.kind === "set") { this.word(node.kind); this.space(); } this._variance(node); this.print(node.key, node); if (node.optional) this.tokenChar(63); if (!node.method) { this.tokenChar(58); this.space(); } this.print(node.value, node); } function ObjectTypeSpreadProperty(node) { this.token("..."); this.print(node.argument, node); } function QualifiedTypeIdentifier(node) { this.print(node.qualification, node); this.tokenChar(46); this.print(node.id, node); } function SymbolTypeAnnotation() { this.word("symbol"); } function orSeparator() { this.space(); this.tokenChar(124); this.space(); } function UnionTypeAnnotation(node) { this.printJoin(node.types, node, { separator: orSeparator }); } function TypeCastExpression(node) { this.tokenChar(40); this.print(node.expression, node); this.print(node.typeAnnotation, node); this.tokenChar(41); } function Variance(node) { if (node.kind === "plus") { this.tokenChar(43); } else { this.tokenChar(45); } } function VoidTypeAnnotation() { this.word("void"); } function IndexedAccessType(node) { this.print(node.objectType, node, true); this.tokenChar(91); this.print(node.indexType, node); this.tokenChar(93); } function OptionalIndexedAccessType(node) { this.print(node.objectType, node); if (node.optional) { this.token("?."); } this.tokenChar(91); this.print(node.indexType, node); this.tokenChar(93); } },{"./modules":56,"./types":59,"@babel/types":359}],53:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); var _templateLiterals = require("./template-literals"); Object.keys(_templateLiterals).forEach(function (key) { if (key === "default" || key === "__esModule") return; if (key in exports && exports[key] === _templateLiterals[key]) return; Object.defineProperty(exports, key, { enumerable: true, get: function () { return _templateLiterals[key]; } }); }); var _expressions = require("./expressions"); Object.keys(_expressions).forEach(function (key) { if (key === "default" || key === "__esModule") return; if (key in exports && exports[key] === _expressions[key]) return; Object.defineProperty(exports, key, { enumerable: true, get: function () { return _expressions[key]; } }); }); var _statements = require("./statements"); Object.keys(_statements).forEach(function (key) { if (key === "default" || key === "__esModule") return; if (key in exports && exports[key] === _statements[key]) return; Object.defineProperty(exports, key, { enumerable: true, get: function () { return _statements[key]; } }); }); var _classes = require("./classes"); Object.keys(_classes).forEach(function (key) { if (key === "default" || key === "__esModule") return; if (key in exports && exports[key] === _classes[key]) return; Object.defineProperty(exports, key, { enumerable: true, get: function () { return _classes[key]; } }); }); var _methods = require("./methods"); Object.keys(_methods).forEach(function (key) { if (key === "default" || key === "__esModule") return; if (key in exports && exports[key] === _methods[key]) return; Object.defineProperty(exports, key, { enumerable: true, get: function () { return _methods[key]; } }); }); var _modules = require("./modules"); Object.keys(_modules).forEach(function (key) { if (key === "default" || key === "__esModule") return; if (key in exports && exports[key] === _modules[key]) return; Object.defineProperty(exports, key, { enumerable: true, get: function () { return _modules[key]; } }); }); var _types = require("./types"); Object.keys(_types).forEach(function (key) { if (key === "default" || key === "__esModule") return; if (key in exports && exports[key] === _types[key]) return; Object.defineProperty(exports, key, { enumerable: true, get: function () { return _types[key]; } }); }); var _flow = require("./flow"); Object.keys(_flow).forEach(function (key) { if (key === "default" || key === "__esModule") return; if (key in exports && exports[key] === _flow[key]) return; Object.defineProperty(exports, key, { enumerable: true, get: function () { return _flow[key]; } }); }); var _base = require("./base"); Object.keys(_base).forEach(function (key) { if (key === "default" || key === "__esModule") return; if (key in exports && exports[key] === _base[key]) return; Object.defineProperty(exports, key, { enumerable: true, get: function () { return _base[key]; } }); }); var _jsx = require("./jsx"); Object.keys(_jsx).forEach(function (key) { if (key === "default" || key === "__esModule") return; if (key in exports && exports[key] === _jsx[key]) return; Object.defineProperty(exports, key, { enumerable: true, get: function () { return _jsx[key]; } }); }); var _typescript = require("./typescript"); Object.keys(_typescript).forEach(function (key) { if (key === "default" || key === "__esModule") return; if (key in exports && exports[key] === _typescript[key]) return; Object.defineProperty(exports, key, { enumerable: true, get: function () { return _typescript[key]; } }); }); },{"./base":49,"./classes":50,"./expressions":51,"./flow":52,"./jsx":54,"./methods":55,"./modules":56,"./statements":57,"./template-literals":58,"./types":59,"./typescript":60}],54:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.JSXAttribute = JSXAttribute; exports.JSXClosingElement = JSXClosingElement; exports.JSXClosingFragment = JSXClosingFragment; exports.JSXElement = JSXElement; exports.JSXEmptyExpression = JSXEmptyExpression; exports.JSXExpressionContainer = JSXExpressionContainer; exports.JSXFragment = JSXFragment; exports.JSXIdentifier = JSXIdentifier; exports.JSXMemberExpression = JSXMemberExpression; exports.JSXNamespacedName = JSXNamespacedName; exports.JSXOpeningElement = JSXOpeningElement; exports.JSXOpeningFragment = JSXOpeningFragment; exports.JSXSpreadAttribute = JSXSpreadAttribute; exports.JSXSpreadChild = JSXSpreadChild; exports.JSXText = JSXText; function JSXAttribute(node) { this.print(node.name, node); if (node.value) { this.tokenChar(61); this.print(node.value, node); } } function JSXIdentifier(node) { this.word(node.name); } function JSXNamespacedName(node) { this.print(node.namespace, node); this.tokenChar(58); this.print(node.name, node); } function JSXMemberExpression(node) { this.print(node.object, node); this.tokenChar(46); this.print(node.property, node); } function JSXSpreadAttribute(node) { this.tokenChar(123); this.token("..."); this.print(node.argument, node); this.tokenChar(125); } function JSXExpressionContainer(node) { this.tokenChar(123); this.print(node.expression, node); this.tokenChar(125); } function JSXSpreadChild(node) { this.tokenChar(123); this.token("..."); this.print(node.expression, node); this.tokenChar(125); } function JSXText(node) { const raw = this.getPossibleRaw(node); if (raw !== undefined) { this.token(raw, true); } else { this.token(node.value, true); } } function JSXElement(node) { const open = node.openingElement; this.print(open, node); if (open.selfClosing) return; this.indent(); for (const child of node.children) { this.print(child, node); } this.dedent(); this.print(node.closingElement, node); } function spaceSeparator() { this.space(); } function JSXOpeningElement(node) { this.tokenChar(60); this.print(node.name, node); this.print(node.typeParameters, node); if (node.attributes.length > 0) { this.space(); this.printJoin(node.attributes, node, { separator: spaceSeparator }); } if (node.selfClosing) { this.space(); this.token("/>"); } else { this.tokenChar(62); } } function JSXClosingElement(node) { this.token(""); this.space(); this.print(node.body, node); } function hasTypesOrComments(node, param) { var _param$leadingComment, _param$trailingCommen; return !!(node.typeParameters || node.returnType || node.predicate || param.typeAnnotation || param.optional || (_param$leadingComment = param.leadingComments) != null && _param$leadingComment.length || (_param$trailingCommen = param.trailingComments) != null && _param$trailingCommen.length); } },{"@babel/types":359}],56:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.ExportAllDeclaration = ExportAllDeclaration; exports.ExportDefaultDeclaration = ExportDefaultDeclaration; exports.ExportDefaultSpecifier = ExportDefaultSpecifier; exports.ExportNamedDeclaration = ExportNamedDeclaration; exports.ExportNamespaceSpecifier = ExportNamespaceSpecifier; exports.ExportSpecifier = ExportSpecifier; exports.ImportAttribute = ImportAttribute; exports.ImportDeclaration = ImportDeclaration; exports.ImportDefaultSpecifier = ImportDefaultSpecifier; exports.ImportNamespaceSpecifier = ImportNamespaceSpecifier; exports.ImportSpecifier = ImportSpecifier; var _t = require("@babel/types"); const { isClassDeclaration, isExportDefaultSpecifier, isExportNamespaceSpecifier, isImportDefaultSpecifier, isImportNamespaceSpecifier, isStatement } = _t; function ImportSpecifier(node) { if (node.importKind === "type" || node.importKind === "typeof") { this.word(node.importKind); this.space(); } this.print(node.imported, node); if (node.local && node.local.name !== node.imported.name) { this.space(); this.word("as"); this.space(); this.print(node.local, node); } } function ImportDefaultSpecifier(node) { this.print(node.local, node); } function ExportDefaultSpecifier(node) { this.print(node.exported, node); } function ExportSpecifier(node) { if (node.exportKind === "type") { this.word("type"); this.space(); } this.print(node.local, node); if (node.exported && node.local.name !== node.exported.name) { this.space(); this.word("as"); this.space(); this.print(node.exported, node); } } function ExportNamespaceSpecifier(node) { this.tokenChar(42); this.space(); this.word("as"); this.space(); this.print(node.exported, node); } function ExportAllDeclaration(node) { this.word("export"); this.space(); if (node.exportKind === "type") { this.word("type"); this.space(); } this.tokenChar(42); this.space(); this.word("from"); this.space(); this.print(node.source, node); this.printAssertions(node); this.semicolon(); } function ExportNamedDeclaration(node) { { if (this.format.decoratorsBeforeExport && isClassDeclaration(node.declaration)) { this.printJoin(node.declaration.decorators, node); } } this.word("export"); this.space(); if (node.declaration) { const declar = node.declaration; this.print(declar, node); if (!isStatement(declar)) this.semicolon(); } else { if (node.exportKind === "type") { this.word("type"); this.space(); } const specifiers = node.specifiers.slice(0); let hasSpecial = false; for (;;) { const first = specifiers[0]; if (isExportDefaultSpecifier(first) || isExportNamespaceSpecifier(first)) { hasSpecial = true; this.print(specifiers.shift(), node); if (specifiers.length) { this.tokenChar(44); this.space(); } } else { break; } } if (specifiers.length || !specifiers.length && !hasSpecial) { this.tokenChar(123); if (specifiers.length) { this.space(); this.printList(specifiers, node); this.space(); } this.tokenChar(125); } if (node.source) { this.space(); this.word("from"); this.space(); this.print(node.source, node); this.printAssertions(node); } this.semicolon(); } } function ExportDefaultDeclaration(node) { { if (this.format.decoratorsBeforeExport && isClassDeclaration(node.declaration)) { this.printJoin(node.declaration.decorators, node); } } this.word("export"); this.space(); this.word("default"); this.space(); const declar = node.declaration; this.print(declar, node); if (!isStatement(declar)) this.semicolon(); } function ImportDeclaration(node) { this.word("import"); this.space(); const isTypeKind = node.importKind === "type" || node.importKind === "typeof"; if (isTypeKind) { this.word(node.importKind); this.space(); } const specifiers = node.specifiers.slice(0); const hasSpecifiers = !!specifiers.length; while (hasSpecifiers) { const first = specifiers[0]; if (isImportDefaultSpecifier(first) || isImportNamespaceSpecifier(first)) { this.print(specifiers.shift(), node); if (specifiers.length) { this.tokenChar(44); this.space(); } } else { break; } } if (specifiers.length) { this.tokenChar(123); this.space(); this.printList(specifiers, node); this.space(); this.tokenChar(125); } else if (isTypeKind && !hasSpecifiers) { this.tokenChar(123); this.tokenChar(125); } if (hasSpecifiers || isTypeKind) { this.space(); this.word("from"); this.space(); } this.print(node.source, node); this.printAssertions(node); { var _node$attributes; if ((_node$attributes = node.attributes) != null && _node$attributes.length) { this.space(); this.word("with"); this.space(); this.printList(node.attributes, node); } } this.semicolon(); } function ImportAttribute(node) { this.print(node.key); this.tokenChar(58); this.space(); this.print(node.value); } function ImportNamespaceSpecifier(node) { this.tokenChar(42); this.space(); this.word("as"); this.space(); this.print(node.local, node); } },{"@babel/types":359}],57:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.BreakStatement = BreakStatement; exports.CatchClause = CatchClause; exports.ContinueStatement = ContinueStatement; exports.DebuggerStatement = DebuggerStatement; exports.DoWhileStatement = DoWhileStatement; exports.ForOfStatement = exports.ForInStatement = void 0; exports.ForStatement = ForStatement; exports.IfStatement = IfStatement; exports.LabeledStatement = LabeledStatement; exports.ReturnStatement = ReturnStatement; exports.SwitchCase = SwitchCase; exports.SwitchStatement = SwitchStatement; exports.ThrowStatement = ThrowStatement; exports.TryStatement = TryStatement; exports.VariableDeclaration = VariableDeclaration; exports.VariableDeclarator = VariableDeclarator; exports.WhileStatement = WhileStatement; exports.WithStatement = WithStatement; var _t = require("@babel/types"); const { isFor, isForStatement, isIfStatement, isStatement } = _t; function WithStatement(node) { this.word("with"); this.space(); this.tokenChar(40); this.print(node.object, node); this.tokenChar(41); this.printBlock(node); } function IfStatement(node) { this.word("if"); this.space(); this.tokenChar(40); this.print(node.test, node); this.tokenChar(41); this.space(); const needsBlock = node.alternate && isIfStatement(getLastStatement(node.consequent)); if (needsBlock) { this.tokenChar(123); this.newline(); this.indent(); } this.printAndIndentOnComments(node.consequent, node); if (needsBlock) { this.dedent(); this.newline(); this.tokenChar(125); } if (node.alternate) { if (this.endsWith(125)) this.space(); this.word("else"); this.space(); this.printAndIndentOnComments(node.alternate, node); } } function getLastStatement(statement) { const { body } = statement; if (isStatement(body) === false) { return statement; } return getLastStatement(body); } function ForStatement(node) { this.word("for"); this.space(); this.tokenChar(40); this.inForStatementInitCounter++; this.print(node.init, node); this.inForStatementInitCounter--; this.tokenChar(59); if (node.test) { this.space(); this.print(node.test, node); } this.tokenChar(59); if (node.update) { this.space(); this.print(node.update, node); } this.tokenChar(41); this.printBlock(node); } function WhileStatement(node) { this.word("while"); this.space(); this.tokenChar(40); this.print(node.test, node); this.tokenChar(41); this.printBlock(node); } function ForXStatement(node) { this.word("for"); this.space(); const isForOf = node.type === "ForOfStatement"; if (isForOf && node.await) { this.word("await"); this.space(); } this.tokenChar(40); this.print(node.left, node); this.space(); this.word(isForOf ? "of" : "in"); this.space(); this.print(node.right, node); this.tokenChar(41); this.printBlock(node); } const ForInStatement = ForXStatement; exports.ForInStatement = ForInStatement; const ForOfStatement = ForXStatement; exports.ForOfStatement = ForOfStatement; function DoWhileStatement(node) { this.word("do"); this.space(); this.print(node.body, node); this.space(); this.word("while"); this.space(); this.tokenChar(40); this.print(node.test, node); this.tokenChar(41); this.semicolon(); } function printStatementAfterKeyword(printer, node, parent, isLabel) { if (node) { printer.space(); printer.printTerminatorless(node, parent, isLabel); } printer.semicolon(); } function BreakStatement(node) { this.word("break"); printStatementAfterKeyword(this, node.label, node, true); } function ContinueStatement(node) { this.word("continue"); printStatementAfterKeyword(this, node.label, node, true); } function ReturnStatement(node) { this.word("return"); printStatementAfterKeyword(this, node.argument, node, false); } function ThrowStatement(node) { this.word("throw"); printStatementAfterKeyword(this, node.argument, node, false); } function LabeledStatement(node) { this.print(node.label, node); this.tokenChar(58); this.space(); this.print(node.body, node); } function TryStatement(node) { this.word("try"); this.space(); this.print(node.block, node); this.space(); if (node.handlers) { this.print(node.handlers[0], node); } else { this.print(node.handler, node); } if (node.finalizer) { this.space(); this.word("finally"); this.space(); this.print(node.finalizer, node); } } function CatchClause(node) { this.word("catch"); this.space(); if (node.param) { this.tokenChar(40); this.print(node.param, node); this.print(node.param.typeAnnotation, node); this.tokenChar(41); this.space(); } this.print(node.body, node); } function SwitchStatement(node) { this.word("switch"); this.space(); this.tokenChar(40); this.print(node.discriminant, node); this.tokenChar(41); this.space(); this.tokenChar(123); this.printSequence(node.cases, node, { indent: true, addNewlines(leading, cas) { if (!leading && node.cases[node.cases.length - 1] === cas) return -1; } }); this.tokenChar(125); } function SwitchCase(node) { if (node.test) { this.word("case"); this.space(); this.print(node.test, node); this.tokenChar(58); } else { this.word("default"); this.tokenChar(58); } if (node.consequent.length) { this.newline(); this.printSequence(node.consequent, node, { indent: true }); } } function DebuggerStatement() { this.word("debugger"); this.semicolon(); } function VariableDeclaration(node, parent) { if (node.declare) { this.word("declare"); this.space(); } this.word(node.kind); this.space(); let hasInits = false; if (!isFor(parent)) { for (const declar of node.declarations) { if (declar.init) { hasInits = true; } } } this.printList(node.declarations, node, { separator: hasInits ? function () { this.tokenChar(44); this.newline(); } : undefined, indent: node.declarations.length > 1 ? true : false }); if (isFor(parent)) { if (isForStatement(parent)) { if (parent.init === node) return; } else { if (parent.left === node) return; } } this.semicolon(); } function VariableDeclarator(node) { this.print(node.id, node); if (node.definite) this.tokenChar(33); this.print(node.id.typeAnnotation, node); if (node.init) { this.space(); this.tokenChar(61); this.space(); this.print(node.init, node); } } },{"@babel/types":359}],58:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.TaggedTemplateExpression = TaggedTemplateExpression; exports.TemplateElement = TemplateElement; exports.TemplateLiteral = TemplateLiteral; function TaggedTemplateExpression(node) { this.print(node.tag, node); this.print(node.typeParameters, node); this.print(node.quasi, node); } function TemplateElement(node, parent) { const isFirst = parent.quasis[0] === node; const isLast = parent.quasis[parent.quasis.length - 1] === node; const value = (isFirst ? "`" : "}") + node.value.raw + (isLast ? "`" : "${"); this.token(value, true); } function TemplateLiteral(node) { const quasis = node.quasis; for (let i = 0; i < quasis.length; i++) { this.print(quasis[i], node); if (i + 1 < quasis.length) { this.print(node.expressions[i], node); } } } },{}],59:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.ArgumentPlaceholder = ArgumentPlaceholder; exports.ArrayPattern = exports.ArrayExpression = ArrayExpression; exports.BigIntLiteral = BigIntLiteral; exports.BooleanLiteral = BooleanLiteral; exports.DecimalLiteral = DecimalLiteral; exports.Identifier = Identifier; exports.NullLiteral = NullLiteral; exports.NumericLiteral = NumericLiteral; exports.ObjectPattern = exports.ObjectExpression = ObjectExpression; exports.ObjectMethod = ObjectMethod; exports.ObjectProperty = ObjectProperty; exports.PipelineBareFunction = PipelineBareFunction; exports.PipelinePrimaryTopicReference = PipelinePrimaryTopicReference; exports.PipelineTopicExpression = PipelineTopicExpression; exports.RecordExpression = RecordExpression; exports.RegExpLiteral = RegExpLiteral; exports.SpreadElement = exports.RestElement = RestElement; exports.StringLiteral = StringLiteral; exports.TopicReference = TopicReference; exports.TupleExpression = TupleExpression; var _t = require("@babel/types"); var _jsesc = require("jsesc"); const { isAssignmentPattern, isIdentifier } = _t; function Identifier(node) { this.word(node.name); } function ArgumentPlaceholder() { this.tokenChar(63); } function RestElement(node) { this.token("..."); this.print(node.argument, node); } function ObjectExpression(node) { const props = node.properties; this.tokenChar(123); this.printInnerComments(node); if (props.length) { this.space(); this.printList(props, node, { indent: true, statement: true }); this.space(); } this.sourceWithOffset("end", node.loc, 0, -1); this.tokenChar(125); } function ObjectMethod(node) { this.printJoin(node.decorators, node); this._methodHead(node); this.space(); this.print(node.body, node); } function ObjectProperty(node) { this.printJoin(node.decorators, node); if (node.computed) { this.tokenChar(91); this.print(node.key, node); this.tokenChar(93); } else { if (isAssignmentPattern(node.value) && isIdentifier(node.key) && node.key.name === node.value.left.name) { this.print(node.value, node); return; } this.print(node.key, node); if (node.shorthand && isIdentifier(node.key) && isIdentifier(node.value) && node.key.name === node.value.name) { return; } } this.tokenChar(58); this.space(); this.print(node.value, node); } function ArrayExpression(node) { const elems = node.elements; const len = elems.length; this.tokenChar(91); this.printInnerComments(node); for (let i = 0; i < elems.length; i++) { const elem = elems[i]; if (elem) { if (i > 0) this.space(); this.print(elem, node); if (i < len - 1) this.tokenChar(44); } else { this.tokenChar(44); } } this.tokenChar(93); } function RecordExpression(node) { const props = node.properties; let startToken; let endToken; if (this.format.recordAndTupleSyntaxType === "bar") { startToken = "{|"; endToken = "|}"; } else if (this.format.recordAndTupleSyntaxType !== "hash" && this.format.recordAndTupleSyntaxType != null) { throw new Error(`The "recordAndTupleSyntaxType" generator option must be "bar" or "hash" (${JSON.stringify(this.format.recordAndTupleSyntaxType)} received).`); } else { startToken = "#{"; endToken = "}"; } this.token(startToken); this.printInnerComments(node); if (props.length) { this.space(); this.printList(props, node, { indent: true, statement: true }); this.space(); } this.token(endToken); } function TupleExpression(node) { const elems = node.elements; const len = elems.length; let startToken; let endToken; if (this.format.recordAndTupleSyntaxType === "bar") { startToken = "[|"; endToken = "|]"; } else if (this.format.recordAndTupleSyntaxType === "hash") { startToken = "#["; endToken = "]"; } else { throw new Error(`${this.format.recordAndTupleSyntaxType} is not a valid recordAndTuple syntax type`); } this.token(startToken); this.printInnerComments(node); for (let i = 0; i < elems.length; i++) { const elem = elems[i]; if (elem) { if (i > 0) this.space(); this.print(elem, node); if (i < len - 1) this.tokenChar(44); } } this.token(endToken); } function RegExpLiteral(node) { this.word(`/${node.pattern}/${node.flags}`); } function BooleanLiteral(node) { this.word(node.value ? "true" : "false"); } function NullLiteral() { this.word("null"); } function NumericLiteral(node) { const raw = this.getPossibleRaw(node); const opts = this.format.jsescOption; const value = node.value + ""; if (opts.numbers) { this.number(_jsesc(node.value, opts)); } else if (raw == null) { this.number(value); } else if (this.format.minified) { this.number(raw.length < value.length ? raw : value); } else { this.number(raw); } } function StringLiteral(node) { const raw = this.getPossibleRaw(node); if (!this.format.minified && raw !== undefined) { this.token(raw); return; } const val = _jsesc(node.value, Object.assign(this.format.jsescOption, this.format.jsonCompatibleStrings && { json: true })); return this.token(val); } function BigIntLiteral(node) { const raw = this.getPossibleRaw(node); if (!this.format.minified && raw !== undefined) { this.word(raw); return; } this.word(node.value + "n"); } function DecimalLiteral(node) { const raw = this.getPossibleRaw(node); if (!this.format.minified && raw !== undefined) { this.word(raw); return; } this.word(node.value + "m"); } const validTopicTokenSet = new Set(["^^", "@@", "^", "%", "#"]); function TopicReference() { const { topicToken } = this.format; if (validTopicTokenSet.has(topicToken)) { this.token(topicToken); } else { const givenTopicTokenJSON = JSON.stringify(topicToken); const validTopics = Array.from(validTopicTokenSet, v => JSON.stringify(v)); throw new Error(`The "topicToken" generator option must be one of ` + `${validTopics.join(", ")} (${givenTopicTokenJSON} received instead).`); } } function PipelineTopicExpression(node) { this.print(node.expression, node); } function PipelineBareFunction(node) { this.print(node.callee, node); } function PipelinePrimaryTopicReference() { this.tokenChar(35); } },{"@babel/types":359,"jsesc":453}],60:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.TSAnyKeyword = TSAnyKeyword; exports.TSArrayType = TSArrayType; exports.TSAsExpression = TSAsExpression; exports.TSBigIntKeyword = TSBigIntKeyword; exports.TSBooleanKeyword = TSBooleanKeyword; exports.TSCallSignatureDeclaration = TSCallSignatureDeclaration; exports.TSConditionalType = TSConditionalType; exports.TSConstructSignatureDeclaration = TSConstructSignatureDeclaration; exports.TSConstructorType = TSConstructorType; exports.TSDeclareFunction = TSDeclareFunction; exports.TSDeclareMethod = TSDeclareMethod; exports.TSEnumDeclaration = TSEnumDeclaration; exports.TSEnumMember = TSEnumMember; exports.TSExportAssignment = TSExportAssignment; exports.TSExpressionWithTypeArguments = TSExpressionWithTypeArguments; exports.TSExternalModuleReference = TSExternalModuleReference; exports.TSFunctionType = TSFunctionType; exports.TSImportEqualsDeclaration = TSImportEqualsDeclaration; exports.TSImportType = TSImportType; exports.TSIndexSignature = TSIndexSignature; exports.TSIndexedAccessType = TSIndexedAccessType; exports.TSInferType = TSInferType; exports.TSInstantiationExpression = TSInstantiationExpression; exports.TSInterfaceBody = TSInterfaceBody; exports.TSInterfaceDeclaration = TSInterfaceDeclaration; exports.TSIntersectionType = TSIntersectionType; exports.TSIntrinsicKeyword = TSIntrinsicKeyword; exports.TSLiteralType = TSLiteralType; exports.TSMappedType = TSMappedType; exports.TSMethodSignature = TSMethodSignature; exports.TSModuleBlock = TSModuleBlock; exports.TSModuleDeclaration = TSModuleDeclaration; exports.TSNamedTupleMember = TSNamedTupleMember; exports.TSNamespaceExportDeclaration = TSNamespaceExportDeclaration; exports.TSNeverKeyword = TSNeverKeyword; exports.TSNonNullExpression = TSNonNullExpression; exports.TSNullKeyword = TSNullKeyword; exports.TSNumberKeyword = TSNumberKeyword; exports.TSObjectKeyword = TSObjectKeyword; exports.TSOptionalType = TSOptionalType; exports.TSParameterProperty = TSParameterProperty; exports.TSParenthesizedType = TSParenthesizedType; exports.TSPropertySignature = TSPropertySignature; exports.TSQualifiedName = TSQualifiedName; exports.TSRestType = TSRestType; exports.TSStringKeyword = TSStringKeyword; exports.TSSymbolKeyword = TSSymbolKeyword; exports.TSThisType = TSThisType; exports.TSTupleType = TSTupleType; exports.TSTypeAliasDeclaration = TSTypeAliasDeclaration; exports.TSTypeAnnotation = TSTypeAnnotation; exports.TSTypeAssertion = TSTypeAssertion; exports.TSTypeLiteral = TSTypeLiteral; exports.TSTypeOperator = TSTypeOperator; exports.TSTypeParameter = TSTypeParameter; exports.TSTypeParameterDeclaration = exports.TSTypeParameterInstantiation = TSTypeParameterInstantiation; exports.TSTypePredicate = TSTypePredicate; exports.TSTypeQuery = TSTypeQuery; exports.TSTypeReference = TSTypeReference; exports.TSUndefinedKeyword = TSUndefinedKeyword; exports.TSUnionType = TSUnionType; exports.TSUnknownKeyword = TSUnknownKeyword; exports.TSVoidKeyword = TSVoidKeyword; exports.tsPrintClassMemberModifiers = tsPrintClassMemberModifiers; exports.tsPrintFunctionOrConstructorType = tsPrintFunctionOrConstructorType; exports.tsPrintPropertyOrMethodName = tsPrintPropertyOrMethodName; exports.tsPrintSignatureDeclarationBase = tsPrintSignatureDeclarationBase; exports.tsPrintTypeLiteralOrInterfaceBody = tsPrintTypeLiteralOrInterfaceBody; function TSTypeAnnotation(node) { this.tokenChar(58); this.space(); if (node.optional) this.tokenChar(63); this.print(node.typeAnnotation, node); } function TSTypeParameterInstantiation(node, parent) { this.tokenChar(60); this.printList(node.params, node, {}); if (parent.type === "ArrowFunctionExpression" && node.params.length === 1) { this.tokenChar(44); } this.tokenChar(62); } function TSTypeParameter(node) { if (node.in) { this.word("in"); this.space(); } if (node.out) { this.word("out"); this.space(); } this.word(node.name); if (node.constraint) { this.space(); this.word("extends"); this.space(); this.print(node.constraint, node); } if (node.default) { this.space(); this.tokenChar(61); this.space(); this.print(node.default, node); } } function TSParameterProperty(node) { if (node.accessibility) { this.word(node.accessibility); this.space(); } if (node.readonly) { this.word("readonly"); this.space(); } this._param(node.parameter); } function TSDeclareFunction(node) { if (node.declare) { this.word("declare"); this.space(); } this._functionHead(node); this.tokenChar(59); } function TSDeclareMethod(node) { this._classMethodHead(node); this.tokenChar(59); } function TSQualifiedName(node) { this.print(node.left, node); this.tokenChar(46); this.print(node.right, node); } function TSCallSignatureDeclaration(node) { this.tsPrintSignatureDeclarationBase(node); this.tokenChar(59); } function TSConstructSignatureDeclaration(node) { this.word("new"); this.space(); this.tsPrintSignatureDeclarationBase(node); this.tokenChar(59); } function TSPropertySignature(node) { const { readonly, initializer } = node; if (readonly) { this.word("readonly"); this.space(); } this.tsPrintPropertyOrMethodName(node); this.print(node.typeAnnotation, node); if (initializer) { this.space(); this.tokenChar(61); this.space(); this.print(initializer, node); } this.tokenChar(59); } function tsPrintPropertyOrMethodName(node) { if (node.computed) { this.tokenChar(91); } this.print(node.key, node); if (node.computed) { this.tokenChar(93); } if (node.optional) { this.tokenChar(63); } } function TSMethodSignature(node) { const { kind } = node; if (kind === "set" || kind === "get") { this.word(kind); this.space(); } this.tsPrintPropertyOrMethodName(node); this.tsPrintSignatureDeclarationBase(node); this.tokenChar(59); } function TSIndexSignature(node) { const { readonly, static: isStatic } = node; if (isStatic) { this.word("static"); this.space(); } if (readonly) { this.word("readonly"); this.space(); } this.tokenChar(91); this._parameters(node.parameters, node); this.tokenChar(93); this.print(node.typeAnnotation, node); this.tokenChar(59); } function TSAnyKeyword() { this.word("any"); } function TSBigIntKeyword() { this.word("bigint"); } function TSUnknownKeyword() { this.word("unknown"); } function TSNumberKeyword() { this.word("number"); } function TSObjectKeyword() { this.word("object"); } function TSBooleanKeyword() { this.word("boolean"); } function TSStringKeyword() { this.word("string"); } function TSSymbolKeyword() { this.word("symbol"); } function TSVoidKeyword() { this.word("void"); } function TSUndefinedKeyword() { this.word("undefined"); } function TSNullKeyword() { this.word("null"); } function TSNeverKeyword() { this.word("never"); } function TSIntrinsicKeyword() { this.word("intrinsic"); } function TSThisType() { this.word("this"); } function TSFunctionType(node) { this.tsPrintFunctionOrConstructorType(node); } function TSConstructorType(node) { if (node.abstract) { this.word("abstract"); this.space(); } this.word("new"); this.space(); this.tsPrintFunctionOrConstructorType(node); } function tsPrintFunctionOrConstructorType(node) { const { typeParameters } = node; const parameters = node.parameters; this.print(typeParameters, node); this.tokenChar(40); this._parameters(parameters, node); this.tokenChar(41); this.space(); this.token("=>"); this.space(); const returnType = node.typeAnnotation; this.print(returnType.typeAnnotation, node); } function TSTypeReference(node) { this.print(node.typeName, node, true); this.print(node.typeParameters, node, true); } function TSTypePredicate(node) { if (node.asserts) { this.word("asserts"); this.space(); } this.print(node.parameterName); if (node.typeAnnotation) { this.space(); this.word("is"); this.space(); this.print(node.typeAnnotation.typeAnnotation); } } function TSTypeQuery(node) { this.word("typeof"); this.space(); this.print(node.exprName); if (node.typeParameters) { this.print(node.typeParameters, node); } } function TSTypeLiteral(node) { this.tsPrintTypeLiteralOrInterfaceBody(node.members, node); } function tsPrintTypeLiteralOrInterfaceBody(members, node) { tsPrintBraced(this, members, node); } function tsPrintBraced(printer, members, node) { printer.token("{"); if (members.length) { printer.indent(); printer.newline(); for (const member of members) { printer.print(member, node); printer.newline(); } printer.dedent(); } printer.sourceWithOffset("end", node.loc, 0, -1); printer.rightBrace(); } function TSArrayType(node) { this.print(node.elementType, node, true); this.token("[]"); } function TSTupleType(node) { this.tokenChar(91); this.printList(node.elementTypes, node); this.tokenChar(93); } function TSOptionalType(node) { this.print(node.typeAnnotation, node); this.tokenChar(63); } function TSRestType(node) { this.token("..."); this.print(node.typeAnnotation, node); } function TSNamedTupleMember(node) { this.print(node.label, node); if (node.optional) this.tokenChar(63); this.tokenChar(58); this.space(); this.print(node.elementType, node); } function TSUnionType(node) { tsPrintUnionOrIntersectionType(this, node, "|"); } function TSIntersectionType(node) { tsPrintUnionOrIntersectionType(this, node, "&"); } function tsPrintUnionOrIntersectionType(printer, node, sep) { printer.printJoin(node.types, node, { separator() { this.space(); this.token(sep); this.space(); } }); } function TSConditionalType(node) { this.print(node.checkType); this.space(); this.word("extends"); this.space(); this.print(node.extendsType); this.space(); this.tokenChar(63); this.space(); this.print(node.trueType); this.space(); this.tokenChar(58); this.space(); this.print(node.falseType); } function TSInferType(node) { this.token("infer"); this.space(); this.print(node.typeParameter); } function TSParenthesizedType(node) { this.tokenChar(40); this.print(node.typeAnnotation, node); this.tokenChar(41); } function TSTypeOperator(node) { this.word(node.operator); this.space(); this.print(node.typeAnnotation, node); } function TSIndexedAccessType(node) { this.print(node.objectType, node, true); this.tokenChar(91); this.print(node.indexType, node); this.tokenChar(93); } function TSMappedType(node) { const { nameType, optional, readonly, typeParameter } = node; this.tokenChar(123); this.space(); if (readonly) { tokenIfPlusMinus(this, readonly); this.word("readonly"); this.space(); } this.tokenChar(91); this.word(typeParameter.name); this.space(); this.word("in"); this.space(); this.print(typeParameter.constraint, typeParameter); if (nameType) { this.space(); this.word("as"); this.space(); this.print(nameType, node); } this.tokenChar(93); if (optional) { tokenIfPlusMinus(this, optional); this.tokenChar(63); } this.tokenChar(58); this.space(); this.print(node.typeAnnotation, node); this.space(); this.tokenChar(125); } function tokenIfPlusMinus(self, tok) { if (tok !== true) { self.token(tok); } } function TSLiteralType(node) { this.print(node.literal, node); } function TSExpressionWithTypeArguments(node) { this.print(node.expression, node); this.print(node.typeParameters, node); } function TSInterfaceDeclaration(node) { const { declare, id, typeParameters, extends: extendz, body } = node; if (declare) { this.word("declare"); this.space(); } this.word("interface"); this.space(); this.print(id, node); this.print(typeParameters, node); if (extendz != null && extendz.length) { this.space(); this.word("extends"); this.space(); this.printList(extendz, node); } this.space(); this.print(body, node); } function TSInterfaceBody(node) { this.tsPrintTypeLiteralOrInterfaceBody(node.body, node); } function TSTypeAliasDeclaration(node) { const { declare, id, typeParameters, typeAnnotation } = node; if (declare) { this.word("declare"); this.space(); } this.word("type"); this.space(); this.print(id, node); this.print(typeParameters, node); this.space(); this.tokenChar(61); this.space(); this.print(typeAnnotation, node); this.tokenChar(59); } function TSAsExpression(node) { const { expression, typeAnnotation } = node; this.print(expression, node); this.space(); this.word("as"); this.space(); this.print(typeAnnotation, node); } function TSTypeAssertion(node) { const { typeAnnotation, expression } = node; this.tokenChar(60); this.print(typeAnnotation, node); this.tokenChar(62); this.space(); this.print(expression, node); } function TSInstantiationExpression(node) { this.print(node.expression, node); this.print(node.typeParameters, node); } function TSEnumDeclaration(node) { const { declare, const: isConst, id, members } = node; if (declare) { this.word("declare"); this.space(); } if (isConst) { this.word("const"); this.space(); } this.word("enum"); this.space(); this.print(id, node); this.space(); tsPrintBraced(this, members, node); } function TSEnumMember(node) { const { id, initializer } = node; this.print(id, node); if (initializer) { this.space(); this.tokenChar(61); this.space(); this.print(initializer, node); } this.tokenChar(44); } function TSModuleDeclaration(node) { const { declare, id } = node; if (declare) { this.word("declare"); this.space(); } if (!node.global) { this.word(id.type === "Identifier" ? "namespace" : "module"); this.space(); } this.print(id, node); if (!node.body) { this.tokenChar(59); return; } let body = node.body; while (body.type === "TSModuleDeclaration") { this.tokenChar(46); this.print(body.id, body); body = body.body; } this.space(); this.print(body, node); } function TSModuleBlock(node) { tsPrintBraced(this, node.body, node); } function TSImportType(node) { const { argument, qualifier, typeParameters } = node; this.word("import"); this.tokenChar(40); this.print(argument, node); this.tokenChar(41); if (qualifier) { this.tokenChar(46); this.print(qualifier, node); } if (typeParameters) { this.print(typeParameters, node); } } function TSImportEqualsDeclaration(node) { const { isExport, id, moduleReference } = node; if (isExport) { this.word("export"); this.space(); } this.word("import"); this.space(); this.print(id, node); this.space(); this.tokenChar(61); this.space(); this.print(moduleReference, node); this.tokenChar(59); } function TSExternalModuleReference(node) { this.token("require("); this.print(node.expression, node); this.tokenChar(41); } function TSNonNullExpression(node) { this.print(node.expression, node); this.tokenChar(33); } function TSExportAssignment(node) { this.word("export"); this.space(); this.tokenChar(61); this.space(); this.print(node.expression, node); this.tokenChar(59); } function TSNamespaceExportDeclaration(node) { this.word("export"); this.space(); this.word("as"); this.space(); this.word("namespace"); this.space(); this.print(node.id, node); } function tsPrintSignatureDeclarationBase(node) { const { typeParameters } = node; const parameters = node.parameters; this.print(typeParameters, node); this.tokenChar(40); this._parameters(parameters, node); this.tokenChar(41); const returnType = node.typeAnnotation; this.print(returnType, node); } function tsPrintClassMemberModifiers(node) { const isField = node.type === "ClassAccessorProperty" || node.type === "ClassProperty"; if (isField && node.declare) { this.word("declare"); this.space(); } if (node.accessibility) { this.word(node.accessibility); this.space(); } if (node.static) { this.word("static"); this.space(); } if (node.override) { this.word("override"); this.space(); } if (node.abstract) { this.word("abstract"); this.space(); } if (isField && node.readonly) { this.word("readonly"); this.space(); } } },{}],61:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.CodeGenerator = void 0; exports.default = generate; var _sourceMap = require("./source-map"); var _printer = require("./printer"); class Generator extends _printer.default { constructor(ast, opts = {}, code) { const format = normalizeOptions(code, opts); const map = opts.sourceMaps ? new _sourceMap.default(opts, code) : null; super(format, map); this.ast = void 0; this.ast = ast; } generate() { return super.generate(this.ast); } } function normalizeOptions(code, opts) { const format = { auxiliaryCommentBefore: opts.auxiliaryCommentBefore, auxiliaryCommentAfter: opts.auxiliaryCommentAfter, shouldPrintComment: opts.shouldPrintComment, retainLines: opts.retainLines, retainFunctionParens: opts.retainFunctionParens, comments: opts.comments == null || opts.comments, compact: opts.compact, minified: opts.minified, concise: opts.concise, indent: { adjustMultilineComment: true, style: " " }, jsescOption: Object.assign({ quotes: "double", wrap: true, minimal: false }, opts.jsescOption), recordAndTupleSyntaxType: opts.recordAndTupleSyntaxType, topicToken: opts.topicToken }; { format.decoratorsBeforeExport = !!opts.decoratorsBeforeExport; format.jsonCompatibleStrings = opts.jsonCompatibleStrings; } if (format.minified) { format.compact = true; format.shouldPrintComment = format.shouldPrintComment || (() => format.comments); } else { format.shouldPrintComment = format.shouldPrintComment || (value => format.comments || value.includes("@license") || value.includes("@preserve")); } if (format.compact === "auto") { format.compact = code.length > 500000; if (format.compact) { console.error("[BABEL] Note: The code generator has deoptimised the styling of " + `${opts.filename} as it exceeds the max of ${"500KB"}.`); } } if (format.compact) { format.indent.adjustMultilineComment = false; } return format; } class CodeGenerator { constructor(ast, opts, code) { this._generator = void 0; this._generator = new Generator(ast, opts, code); } generate() { return this._generator.generate(); } } exports.CodeGenerator = CodeGenerator; function generate(ast, opts, code) { const gen = new Generator(ast, opts, code); return gen.generate(); } },{"./printer":65,"./source-map":66}],62:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.needsParens = needsParens; exports.needsWhitespace = needsWhitespace; exports.needsWhitespaceAfter = needsWhitespaceAfter; exports.needsWhitespaceBefore = needsWhitespaceBefore; var whitespace = require("./whitespace"); var parens = require("./parentheses"); var _t = require("@babel/types"); const { FLIPPED_ALIAS_KEYS, isCallExpression, isExpressionStatement, isMemberExpression, isNewExpression } = _t; function expandAliases(obj) { const newObj = {}; function add(type, func) { const fn = newObj[type]; newObj[type] = fn ? function (node, parent, stack) { const result = fn(node, parent, stack); return result == null ? func(node, parent, stack) : result; } : func; } for (const type of Object.keys(obj)) { const aliases = FLIPPED_ALIAS_KEYS[type]; if (aliases) { for (const alias of aliases) { add(alias, obj[type]); } } else { add(type, obj[type]); } } return newObj; } const expandedParens = expandAliases(parens); const expandedWhitespaceNodes = expandAliases(whitespace.nodes); function find(obj, node, parent, printStack) { const fn = obj[node.type]; return fn ? fn(node, parent, printStack) : null; } function isOrHasCallExpression(node) { if (isCallExpression(node)) { return true; } return isMemberExpression(node) && isOrHasCallExpression(node.object); } function needsWhitespace(node, parent, type) { if (!node) return false; if (isExpressionStatement(node)) { node = node.expression; } const flag = find(expandedWhitespaceNodes, node, parent); if (typeof flag === "number") { return (flag & type) !== 0; } return false; } function needsWhitespaceBefore(node, parent) { return needsWhitespace(node, parent, 1); } function needsWhitespaceAfter(node, parent) { return needsWhitespace(node, parent, 2); } function needsParens(node, parent, printStack) { if (!parent) return false; if (isNewExpression(parent) && parent.callee === node) { if (isOrHasCallExpression(node)) return true; } return find(expandedParens, node, parent, printStack); } },{"./parentheses":63,"./whitespace":64,"@babel/types":359}],63:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.ArrowFunctionExpression = ArrowFunctionExpression; exports.AssignmentExpression = AssignmentExpression; exports.Binary = Binary; exports.BinaryExpression = BinaryExpression; exports.ClassExpression = ClassExpression; exports.ConditionalExpression = ConditionalExpression; exports.DoExpression = DoExpression; exports.FunctionExpression = FunctionExpression; exports.FunctionTypeAnnotation = FunctionTypeAnnotation; exports.Identifier = Identifier; exports.LogicalExpression = LogicalExpression; exports.NullableTypeAnnotation = NullableTypeAnnotation; exports.ObjectExpression = ObjectExpression; exports.OptionalIndexedAccessType = OptionalIndexedAccessType; exports.OptionalCallExpression = exports.OptionalMemberExpression = OptionalMemberExpression; exports.SequenceExpression = SequenceExpression; exports.TSAsExpression = TSAsExpression; exports.TSInferType = TSInferType; exports.TSInstantiationExpression = TSInstantiationExpression; exports.TSTypeAssertion = TSTypeAssertion; exports.TSIntersectionType = exports.TSUnionType = TSUnionType; exports.UnaryLike = UnaryLike; exports.IntersectionTypeAnnotation = exports.UnionTypeAnnotation = UnionTypeAnnotation; exports.UpdateExpression = UpdateExpression; exports.AwaitExpression = exports.YieldExpression = YieldExpression; var _t = require("@babel/types"); const { isArrayTypeAnnotation, isArrowFunctionExpression, isAssignmentExpression, isAwaitExpression, isBinary, isBinaryExpression, isUpdateExpression, isCallExpression, isClass, isClassExpression, isConditional, isConditionalExpression, isExportDeclaration, isExportDefaultDeclaration, isExpressionStatement, isFor, isForInStatement, isForOfStatement, isForStatement, isFunctionExpression, isIfStatement, isIndexedAccessType, isIntersectionTypeAnnotation, isLogicalExpression, isMemberExpression, isNewExpression, isNullableTypeAnnotation, isObjectPattern, isOptionalCallExpression, isOptionalMemberExpression, isReturnStatement, isSequenceExpression, isSwitchStatement, isTSArrayType, isTSAsExpression, isTSInstantiationExpression, isTSIntersectionType, isTSNonNullExpression, isTSOptionalType, isTSRestType, isTSTypeAssertion, isTSUnionType, isTaggedTemplateExpression, isThrowStatement, isTypeAnnotation, isUnaryLike, isUnionTypeAnnotation, isVariableDeclarator, isWhileStatement, isYieldExpression } = _t; const PRECEDENCE = { "||": 0, "??": 0, "|>": 0, "&&": 1, "|": 2, "^": 3, "&": 4, "==": 5, "===": 5, "!=": 5, "!==": 5, "<": 6, ">": 6, "<=": 6, ">=": 6, in: 6, instanceof: 6, ">>": 7, "<<": 7, ">>>": 7, "+": 8, "-": 8, "*": 9, "/": 9, "%": 9, "**": 10 }; const isClassExtendsClause = (node, parent) => isClass(parent, { superClass: node }); const hasPostfixPart = (node, parent) => (isMemberExpression(parent) || isOptionalMemberExpression(parent)) && parent.object === node || (isCallExpression(parent) || isOptionalCallExpression(parent) || isNewExpression(parent)) && parent.callee === node || isTaggedTemplateExpression(parent) && parent.tag === node || isTSNonNullExpression(parent); function NullableTypeAnnotation(node, parent) { return isArrayTypeAnnotation(parent); } function FunctionTypeAnnotation(node, parent, printStack) { if (printStack.length < 3) return; return isUnionTypeAnnotation(parent) || isIntersectionTypeAnnotation(parent) || isArrayTypeAnnotation(parent) || isTypeAnnotation(parent) && isArrowFunctionExpression(printStack[printStack.length - 3]); } function UpdateExpression(node, parent) { return hasPostfixPart(node, parent) || isClassExtendsClause(node, parent); } function ObjectExpression(node, parent, printStack) { return isFirstInContext(printStack, 1 | 2); } function DoExpression(node, parent, printStack) { return !node.async && isFirstInContext(printStack, 1); } function Binary(node, parent) { if (node.operator === "**" && isBinaryExpression(parent, { operator: "**" })) { return parent.left === node; } if (isClassExtendsClause(node, parent)) { return true; } if (hasPostfixPart(node, parent) || isUnaryLike(parent) || isAwaitExpression(parent)) { return true; } if (isBinary(parent)) { const parentOp = parent.operator; const parentPos = PRECEDENCE[parentOp]; const nodeOp = node.operator; const nodePos = PRECEDENCE[nodeOp]; if (parentPos === nodePos && parent.right === node && !isLogicalExpression(parent) || parentPos > nodePos) { return true; } } } function UnionTypeAnnotation(node, parent) { return isArrayTypeAnnotation(parent) || isNullableTypeAnnotation(parent) || isIntersectionTypeAnnotation(parent) || isUnionTypeAnnotation(parent); } function OptionalIndexedAccessType(node, parent) { return isIndexedAccessType(parent, { objectType: node }); } function TSAsExpression() { return true; } function TSTypeAssertion() { return true; } function TSUnionType(node, parent) { return isTSArrayType(parent) || isTSOptionalType(parent) || isTSIntersectionType(parent) || isTSUnionType(parent) || isTSRestType(parent); } function TSInferType(node, parent) { return isTSArrayType(parent) || isTSOptionalType(parent); } function TSInstantiationExpression(node, parent) { return (isCallExpression(parent) || isOptionalCallExpression(parent) || isNewExpression(parent) || isTSInstantiationExpression(parent)) && !!parent.typeParameters; } function BinaryExpression(node, parent) { return node.operator === "in" && (isVariableDeclarator(parent) || isFor(parent)); } function SequenceExpression(node, parent) { if (isForStatement(parent) || isThrowStatement(parent) || isReturnStatement(parent) || isIfStatement(parent) && parent.test === node || isWhileStatement(parent) && parent.test === node || isForInStatement(parent) && parent.right === node || isSwitchStatement(parent) && parent.discriminant === node || isExpressionStatement(parent) && parent.expression === node) { return false; } return true; } function YieldExpression(node, parent) { return isBinary(parent) || isUnaryLike(parent) || hasPostfixPart(node, parent) || isAwaitExpression(parent) && isYieldExpression(node) || isConditionalExpression(parent) && node === parent.test || isClassExtendsClause(node, parent); } function ClassExpression(node, parent, printStack) { return isFirstInContext(printStack, 1 | 4); } function UnaryLike(node, parent) { return hasPostfixPart(node, parent) || isBinaryExpression(parent, { operator: "**", left: node }) || isClassExtendsClause(node, parent); } function FunctionExpression(node, parent, printStack) { return isFirstInContext(printStack, 1 | 4); } function ArrowFunctionExpression(node, parent) { return isExportDeclaration(parent) || ConditionalExpression(node, parent); } function ConditionalExpression(node, parent) { if (isUnaryLike(parent) || isBinary(parent) || isConditionalExpression(parent, { test: node }) || isAwaitExpression(parent) || isTSTypeAssertion(parent) || isTSAsExpression(parent)) { return true; } return UnaryLike(node, parent); } function OptionalMemberExpression(node, parent) { return isCallExpression(parent, { callee: node }) || isMemberExpression(parent, { object: node }); } function AssignmentExpression(node, parent) { if (isObjectPattern(node.left)) { return true; } else { return ConditionalExpression(node, parent); } } function LogicalExpression(node, parent) { switch (node.operator) { case "||": if (!isLogicalExpression(parent)) return false; return parent.operator === "??" || parent.operator === "&&"; case "&&": return isLogicalExpression(parent, { operator: "??" }); case "??": return isLogicalExpression(parent) && parent.operator !== "??"; } } function Identifier(node, parent, printStack) { var _node$extra; if ((_node$extra = node.extra) != null && _node$extra.parenthesized && isAssignmentExpression(parent, { left: node }) && (isFunctionExpression(parent.right) || isClassExpression(parent.right)) && parent.right.id == null) { return true; } if (node.name === "let") { const isFollowedByBracket = isMemberExpression(parent, { object: node, computed: true }) || isOptionalMemberExpression(parent, { object: node, computed: true, optional: false }); return isFirstInContext(printStack, isFollowedByBracket ? 1 | 8 | 16 | 32 : 32); } return node.name === "async" && isForOfStatement(parent) && node === parent.left; } function isFirstInContext(printStack, checkParam) { const expressionStatement = checkParam & 1; const arrowBody = checkParam & 2; const exportDefault = checkParam & 4; const forHead = checkParam & 8; const forInHead = checkParam & 16; const forOfHead = checkParam & 32; let i = printStack.length - 1; if (i <= 0) return; let node = printStack[i]; i--; let parent = printStack[i]; while (i >= 0) { if (expressionStatement && isExpressionStatement(parent, { expression: node }) || exportDefault && isExportDefaultDeclaration(parent, { declaration: node }) || arrowBody && isArrowFunctionExpression(parent, { body: node }) || forHead && isForStatement(parent, { init: node }) || forInHead && isForInStatement(parent, { left: node }) || forOfHead && isForOfStatement(parent, { left: node })) { return true; } if (i > 0 && (hasPostfixPart(node, parent) && !isNewExpression(parent) || isSequenceExpression(parent) && parent.expressions[0] === node || isUpdateExpression(parent) && !parent.prefix || isConditional(parent, { test: node }) || isBinary(parent, { left: node }) || isAssignmentExpression(parent, { left: node }))) { node = parent; i--; parent = printStack[i]; } else { return false; } } return false; } },{"@babel/types":359}],64:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.nodes = void 0; var _t = require("@babel/types"); const { FLIPPED_ALIAS_KEYS, isArrayExpression, isAssignmentExpression, isBinary, isBlockStatement, isCallExpression, isFunction, isIdentifier, isLiteral, isMemberExpression, isObjectExpression, isOptionalCallExpression, isOptionalMemberExpression, isStringLiteral } = _t; function crawlInternal(node, state) { if (!node) return state; if (isMemberExpression(node) || isOptionalMemberExpression(node)) { crawlInternal(node.object, state); if (node.computed) crawlInternal(node.property, state); } else if (isBinary(node) || isAssignmentExpression(node)) { crawlInternal(node.left, state); crawlInternal(node.right, state); } else if (isCallExpression(node) || isOptionalCallExpression(node)) { state.hasCall = true; crawlInternal(node.callee, state); } else if (isFunction(node)) { state.hasFunction = true; } else if (isIdentifier(node)) { state.hasHelper = state.hasHelper || node.callee && isHelper(node.callee); } return state; } function crawl(node) { return crawlInternal(node, { hasCall: false, hasFunction: false, hasHelper: false }); } function isHelper(node) { if (!node) return false; if (isMemberExpression(node)) { return isHelper(node.object) || isHelper(node.property); } else if (isIdentifier(node)) { return node.name === "require" || node.name.charCodeAt(0) === 95; } else if (isCallExpression(node)) { return isHelper(node.callee); } else if (isBinary(node) || isAssignmentExpression(node)) { return isIdentifier(node.left) && isHelper(node.left) || isHelper(node.right); } else { return false; } } function isType(node) { return isLiteral(node) || isObjectExpression(node) || isArrayExpression(node) || isIdentifier(node) || isMemberExpression(node); } const nodes = { AssignmentExpression(node) { const state = crawl(node.right); if (state.hasCall && state.hasHelper || state.hasFunction) { return state.hasFunction ? 1 | 2 : 2; } }, SwitchCase(node, parent) { return (!!node.consequent.length || parent.cases[0] === node ? 1 : 0) | (!node.consequent.length && parent.cases[parent.cases.length - 1] === node ? 2 : 0); }, LogicalExpression(node) { if (isFunction(node.left) || isFunction(node.right)) { return 2; } }, Literal(node) { if (isStringLiteral(node) && node.value === "use strict") { return 2; } }, CallExpression(node) { if (isFunction(node.callee) || isHelper(node)) { return 1 | 2; } }, OptionalCallExpression(node) { if (isFunction(node.callee)) { return 1 | 2; } }, VariableDeclaration(node) { for (let i = 0; i < node.declarations.length; i++) { const declar = node.declarations[i]; let enabled = isHelper(declar.id) && !isType(declar.init); if (!enabled && declar.init) { const state = crawl(declar.init); enabled = isHelper(declar.init) && state.hasCall || state.hasFunction; } if (enabled) { return 1 | 2; } } }, IfStatement(node) { if (isBlockStatement(node.consequent)) { return 1 | 2; } } }; exports.nodes = nodes; nodes.ObjectProperty = nodes.ObjectTypeProperty = nodes.ObjectMethod = function (node, parent) { if (parent.properties[0] === node) { return 1; } }; nodes.ObjectTypeCallProperty = function (node, parent) { var _parent$properties; if (parent.callProperties[0] === node && !((_parent$properties = parent.properties) != null && _parent$properties.length)) { return 1; } }; nodes.ObjectTypeIndexer = function (node, parent) { var _parent$properties2, _parent$callPropertie; if (parent.indexers[0] === node && !((_parent$properties2 = parent.properties) != null && _parent$properties2.length) && !((_parent$callPropertie = parent.callProperties) != null && _parent$callPropertie.length)) { return 1; } }; nodes.ObjectTypeInternalSlot = function (node, parent) { var _parent$properties3, _parent$callPropertie2, _parent$indexers; if (parent.internalSlots[0] === node && !((_parent$properties3 = parent.properties) != null && _parent$properties3.length) && !((_parent$callPropertie2 = parent.callProperties) != null && _parent$callPropertie2.length) && !((_parent$indexers = parent.indexers) != null && _parent$indexers.length)) { return 1; } }; [["Function", true], ["Class", true], ["Loop", true], ["LabeledStatement", true], ["SwitchStatement", true], ["TryStatement", true]].forEach(function ([type, amounts]) { [type].concat(FLIPPED_ALIAS_KEYS[type] || []).forEach(function (type) { const ret = amounts ? 1 | 2 : 0; nodes[type] = () => ret; }); }); },{"@babel/types":359}],65:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = void 0; var _buffer = require("./buffer"); var n = require("./node"); var generatorFunctions = require("./generators"); const SCIENTIFIC_NOTATION = /e/i; const ZERO_DECIMAL_INTEGER = /\.0+$/; const NON_DECIMAL_LITERAL = /^0[box]/; const PURE_ANNOTATION_RE = /^\s*[@#]__PURE__\s*$/; const { needsParens } = n; class Printer { constructor(format, map) { this.inForStatementInitCounter = 0; this._printStack = []; this._indent = 0; this._indentChar = 0; this._indentRepeat = 0; this._insideAux = false; this._parenPushNewlineState = null; this._noLineTerminator = false; this._printAuxAfterOnNextUserNode = false; this._printedComments = new Set(); this._endsWithInteger = false; this._endsWithWord = false; this._lastCommentLine = 0; this.format = format; this._buf = new _buffer.default(map); this._indentChar = format.indent.style.charCodeAt(0); this._indentRepeat = format.indent.style.length; } generate(ast) { this.print(ast); this._maybeAddAuxComment(); return this._buf.get(); } indent() { if (this.format.compact || this.format.concise) return; this._indent++; } dedent() { if (this.format.compact || this.format.concise) return; this._indent--; } semicolon(force = false) { this._maybeAddAuxComment(); if (force) { this._appendChar(59); } else { this._queue(59); } } rightBrace() { if (this.format.minified) { this._buf.removeLastSemicolon(); } this.tokenChar(125); } space(force = false) { if (this.format.compact) return; if (force) { this._space(); } else if (this._buf.hasContent()) { const lastCp = this.getLastChar(); if (lastCp !== 32 && lastCp !== 10) { this._space(); } } } word(str) { if (this._endsWithWord || str.charCodeAt(0) === 47 && this.endsWith(47)) { this._space(); } this._maybeAddAuxComment(); this._append(str, false); this._endsWithWord = true; } number(str) { this.word(str); this._endsWithInteger = Number.isInteger(+str) && !NON_DECIMAL_LITERAL.test(str) && !SCIENTIFIC_NOTATION.test(str) && !ZERO_DECIMAL_INTEGER.test(str) && str.charCodeAt(str.length - 1) !== 46; } token(str, maybeNewline = false) { const lastChar = this.getLastChar(); const strFirst = str.charCodeAt(0); if (lastChar === 33 && str === "--" || strFirst === 43 && lastChar === 43 || strFirst === 45 && lastChar === 45 || strFirst === 46 && this._endsWithInteger) { this._space(); } this._maybeAddAuxComment(); this._append(str, maybeNewline); } tokenChar(char) { const lastChar = this.getLastChar(); if (char === 43 && lastChar === 43 || char === 45 && lastChar === 45 || char === 46 && this._endsWithInteger) { this._space(); } this._maybeAddAuxComment(); this._appendChar(char); } newline(i = 1, force) { if (i <= 0) return; if (!force) { if (this.format.retainLines || this.format.compact) return; if (this.format.concise) { this.space(); return; } } if (i > 2) i = 2; i -= this._buf.getNewlineCount(); for (let j = 0; j < i; j++) { this._newline(); } return; } endsWith(char) { return this.getLastChar() === char; } getLastChar() { return this._buf.getLastChar(); } endsWithCharAndNewline() { return this._buf.endsWithCharAndNewline(); } removeTrailingNewline() { this._buf.removeTrailingNewline(); } exactSource(loc, cb) { if (!loc) return cb(); this._catchUp("start", loc); this._buf.exactSource(loc, cb); } source(prop, loc) { if (!loc) return; this._catchUp(prop, loc); this._buf.source(prop, loc); } sourceWithOffset(prop, loc, lineOffset, columnOffset) { if (!loc) return; this._catchUp(prop, loc); this._buf.sourceWithOffset(prop, loc, lineOffset, columnOffset); } withSource(prop, loc, cb) { if (!loc) return cb(); this._catchUp(prop, loc); this._buf.withSource(prop, loc, cb); } _space() { this._queue(32); } _newline() { this._queue(10); } _append(str, maybeNewline) { this._maybeAddParen(str); this._maybeIndent(str.charCodeAt(0)); this._buf.append(str, maybeNewline); this._endsWithWord = false; this._endsWithInteger = false; } _appendChar(char) { this._maybeAddParenChar(char); this._maybeIndent(char); this._buf.appendChar(char); this._endsWithWord = false; this._endsWithInteger = false; } _queue(char) { this._maybeAddParenChar(char); this._maybeIndent(char); this._buf.queue(char); this._endsWithWord = false; this._endsWithInteger = false; } _maybeIndent(firstChar) { if (this._indent && firstChar !== 10 && this.endsWith(10)) { this._buf.queueIndentation(this._indentChar, this._getIndent()); } } _shouldIndent(firstChar) { if (this._indent && firstChar !== 10 && this.endsWith(10)) { return true; } } _maybeAddParenChar(char) { const parenPushNewlineState = this._parenPushNewlineState; if (!parenPushNewlineState) return; if (char === 32) { return; } if (char !== 10) { this._parenPushNewlineState = null; return; } this.tokenChar(40); this.indent(); parenPushNewlineState.printed = true; } _maybeAddParen(str) { const parenPushNewlineState = this._parenPushNewlineState; if (!parenPushNewlineState) return; const len = str.length; let i; for (i = 0; i < len && str.charCodeAt(i) === 32; i++) continue; if (i === len) { return; } const cha = str.charCodeAt(i); if (cha !== 10) { if (cha !== 47 || i + 1 === len) { this._parenPushNewlineState = null; return; } const chaPost = str.charCodeAt(i + 1); if (chaPost === 42) { if (PURE_ANNOTATION_RE.test(str.slice(i + 2, len - 2))) { return; } } else if (chaPost !== 47) { this._parenPushNewlineState = null; return; } } this.tokenChar(40); this.indent(); parenPushNewlineState.printed = true; } catchUp(line) { if (!this.format.retainLines) return; const count = line - this._buf.getCurrentLine(); for (let i = 0; i < count; i++) { this._newline(); } } _catchUp(prop, loc) { if (!this.format.retainLines) return; const pos = loc ? loc[prop] : null; if ((pos == null ? void 0 : pos.line) != null) { const count = pos.line - this._buf.getCurrentLine(); for (let i = 0; i < count; i++) { this._newline(); } } } _getIndent() { return this._indentRepeat * this._indent; } ensureNoLineTerminator(fn) { const { _noLineTerminator } = this; this._noLineTerminator = true; fn(); this._noLineTerminator = _noLineTerminator; } printTerminatorless(node, parent, isLabel) { if (isLabel) { this.ensureNoLineTerminator(() => { this.print(node, parent); }); } else { const terminatorState = { printed: false }; this._parenPushNewlineState = terminatorState; this.print(node, parent); if (terminatorState.printed) { this.dedent(); this.newline(); this.tokenChar(41); } } } print(node, parent, noLineTerminator, trailingCommentsLineOffset) { if (!node) return; const nodeType = node.type; const format = this.format; const oldConcise = format.concise; if (node._compact) { format.concise = true; } const printMethod = this[nodeType]; if (printMethod === undefined) { throw new ReferenceError(`unknown node of type ${JSON.stringify(nodeType)} with constructor ${JSON.stringify(node.constructor.name)}`); } this._printStack.push(node); const oldInAux = this._insideAux; this._insideAux = node.loc == undefined; this._maybeAddAuxComment(this._insideAux && !oldInAux); let shouldPrintParens = false; if (format.retainFunctionParens && nodeType === "FunctionExpression" && node.extra && node.extra.parenthesized) { shouldPrintParens = true; } else { shouldPrintParens = needsParens(node, parent, this._printStack); } if (shouldPrintParens) this.tokenChar(40); this._lastCommentLine = 0; this._printLeadingComments(node); const loc = nodeType === "Program" || nodeType === "File" ? null : node.loc; this.exactSource(loc, printMethod.bind(this, node, parent)); if (noLineTerminator && !this._noLineTerminator) { this._noLineTerminator = true; this._printTrailingComments(node); this._noLineTerminator = false; } else { this._printTrailingComments(node, trailingCommentsLineOffset); } if (shouldPrintParens) this.tokenChar(41); this._printStack.pop(); format.concise = oldConcise; this._insideAux = oldInAux; } _maybeAddAuxComment(enteredPositionlessNode) { if (enteredPositionlessNode) this._printAuxBeforeComment(); if (!this._insideAux) this._printAuxAfterComment(); } _printAuxBeforeComment() { if (this._printAuxAfterOnNextUserNode) return; this._printAuxAfterOnNextUserNode = true; const comment = this.format.auxiliaryCommentBefore; if (comment) { this._printComment({ type: "CommentBlock", value: comment }, 0); } } _printAuxAfterComment() { if (!this._printAuxAfterOnNextUserNode) return; this._printAuxAfterOnNextUserNode = false; const comment = this.format.auxiliaryCommentAfter; if (comment) { this._printComment({ type: "CommentBlock", value: comment }, 0); } } getPossibleRaw(node) { const extra = node.extra; if (extra && extra.raw != null && extra.rawValue != null && node.value === extra.rawValue) { return extra.raw; } } printJoin(nodes, parent, opts = {}) { if (!(nodes != null && nodes.length)) return; if (opts.indent) this.indent(); const newlineOpts = { addNewlines: opts.addNewlines, nextNodeStartLine: 0 }; const separator = opts.separator ? opts.separator.bind(this) : null; const len = nodes.length; for (let i = 0; i < len; i++) { const node = nodes[i]; if (!node) continue; if (opts.statement) this._printNewline(i === 0, newlineOpts); this.print(node, parent, undefined, opts.trailingCommentsLineOffset || 0); opts.iterator == null ? void 0 : opts.iterator(node, i); if (i < len - 1) separator == null ? void 0 : separator(); if (opts.statement) { if (i + 1 === len) { this.newline(1); } else { var _nextNode$loc; const nextNode = nodes[i + 1]; newlineOpts.nextNodeStartLine = ((_nextNode$loc = nextNode.loc) == null ? void 0 : _nextNode$loc.start.line) || 0; this._printNewline(true, newlineOpts); } } } if (opts.indent) this.dedent(); } printAndIndentOnComments(node, parent) { const indent = node.leadingComments && node.leadingComments.length > 0; if (indent) this.indent(); this.print(node, parent); if (indent) this.dedent(); } printBlock(parent) { const node = parent.body; if (node.type !== "EmptyStatement") { this.space(); } this.print(node, parent); } _printTrailingComments(node, lineOffset) { const comments = this._getComments(false, node); if (!(comments != null && comments.length)) return; this._printComments(2, comments, node, lineOffset); } _printLeadingComments(node) { const comments = this._getComments(true, node); if (!(comments != null && comments.length)) return; this._printComments(0, comments, node); } printInnerComments(node, indent = true) { var _node$innerComments; if (!((_node$innerComments = node.innerComments) != null && _node$innerComments.length)) return; if (indent) this.indent(); this._printComments(1, node.innerComments, node); if (indent) this.dedent(); } printSequence(nodes, parent, opts = {}) { opts.statement = true; return this.printJoin(nodes, parent, opts); } printList(items, parent, opts = {}) { if (opts.separator == null) { opts.separator = commaSeparator; } return this.printJoin(items, parent, opts); } _printNewline(newLine, opts) { if (this.format.retainLines || this.format.compact) return; if (this.format.concise) { this.space(); return; } if (!newLine) { return; } const startLine = opts.nextNodeStartLine; const lastCommentLine = this._lastCommentLine; if (startLine > 0 && lastCommentLine > 0) { const offset = startLine - lastCommentLine; if (offset >= 0) { this.newline(offset || 1); return; } } if (this._buf.hasContent()) { this.newline(1); } } _getComments(leading, node) { return node && (leading ? node.leadingComments : node.trailingComments) || null; } _printComment(comment, skipNewLines) { if (comment.ignore) return; if (this._printedComments.has(comment)) return; if (!this.format.shouldPrintComment(comment.value)) return; this._printedComments.add(comment); const isBlockComment = comment.type === "CommentBlock"; const printNewLines = isBlockComment && skipNewLines !== 1 && !this._noLineTerminator; if (printNewLines && this._buf.hasContent() && skipNewLines !== 2) { this.newline(1); } const lastCharCode = this.getLastChar(); if (lastCharCode !== 91 && lastCharCode !== 123) { this.space(); } let val; if (isBlockComment) { val = `/*${comment.value}*/`; if (this.format.indent.adjustMultilineComment) { var _comment$loc; const offset = (_comment$loc = comment.loc) == null ? void 0 : _comment$loc.start.column; if (offset) { const newlineRegex = new RegExp("\\n\\s{1," + offset + "}", "g"); val = val.replace(newlineRegex, "\n"); } let indentSize = this.format.retainLines ? 0 : this._buf.getCurrentColumn(); if (this._shouldIndent(47) || this.format.retainLines) { indentSize += this._getIndent(); } val = val.replace(/\n(?!$)/g, `\n${" ".repeat(indentSize)}`); } } else if (!this._noLineTerminator) { val = `//${comment.value}`; } else { val = `/*${comment.value}*/`; } if (this.endsWith(47)) this._space(); this.source("start", comment.loc); this._append(val, isBlockComment); if (!isBlockComment && !this._noLineTerminator) { this.newline(1, true); } if (printNewLines && skipNewLines !== 3) { this.newline(1); } } _printComments(type, comments, node, lineOffset = 0) { { const nodeLoc = node.loc; const len = comments.length; let hasLoc = !!nodeLoc; const nodeStartLine = hasLoc ? nodeLoc.start.line : 0; const nodeEndLine = hasLoc ? nodeLoc.end.line : 0; let lastLine = 0; let leadingCommentNewline = 0; for (let i = 0; i < len; i++) { const comment = comments[i]; if (hasLoc && comment.loc && !this._printedComments.has(comment)) { const commentStartLine = comment.loc.start.line; const commentEndLine = comment.loc.end.line; if (type === 0) { let offset = 0; if (i === 0) { if (this._buf.hasContent() && (comment.type === "CommentLine" || commentStartLine != commentEndLine)) { offset = leadingCommentNewline = 1; } } else { offset = commentStartLine - lastLine; } lastLine = commentEndLine; this.newline(offset); this._printComment(comment, 1); if (i + 1 === len) { this.newline(Math.max(nodeStartLine - lastLine, leadingCommentNewline)); lastLine = nodeStartLine; } } else if (type === 1) { const offset = commentStartLine - (i === 0 ? nodeStartLine : lastLine); lastLine = commentEndLine; this.newline(offset); this._printComment(comment, 1); if (i + 1 === len) { this.newline(Math.min(1, nodeEndLine - lastLine)); lastLine = nodeEndLine; } } else { const offset = commentStartLine - (i === 0 ? nodeEndLine - lineOffset : lastLine); lastLine = commentEndLine; this.newline(offset); this._printComment(comment, 1); } } else { hasLoc = false; if (len === 1) { this._printComment(comment, 1); } else if (type === 1 && !(node.type === "ObjectExpression" && node.properties.length > 1) && node.type !== "ClassBody") { this._printComment(comment, i === 0 ? 2 : i === len - 1 ? 3 : 0); } else { this._printComment(comment, 0); } } } if (type === 2 && hasLoc && lastLine) { this._lastCommentLine = lastLine; } } } printAssertions(node) { var _node$assertions; if ((_node$assertions = node.assertions) != null && _node$assertions.length) { this.space(); this.word("assert"); this.space(); this.tokenChar(123); this.space(); this.printList(node.assertions, node); this.space(); this.tokenChar(125); } } } Object.assign(Printer.prototype, generatorFunctions); { Printer.prototype.Noop = function Noop() {}; } var _default = Printer; exports.default = _default; function commaSeparator() { this.tokenChar(44); this.space(); } },{"./buffer":48,"./generators":53,"./node":62}],66:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = void 0; var _genMapping = require("@jridgewell/gen-mapping"); class SourceMap { constructor(opts, code) { var _opts$sourceFileName; this._map = void 0; this._rawMappings = void 0; this._sourceFileName = void 0; this._lastGenLine = 0; this._lastSourceLine = 0; this._lastSourceColumn = 0; const map = this._map = new _genMapping.GenMapping({ sourceRoot: opts.sourceRoot }); this._sourceFileName = (_opts$sourceFileName = opts.sourceFileName) == null ? void 0 : _opts$sourceFileName.replace(/\\/g, "/"); this._rawMappings = undefined; if (typeof code === "string") { (0, _genMapping.setSourceContent)(map, this._sourceFileName, code); } else if (typeof code === "object") { Object.keys(code).forEach(sourceFileName => { (0, _genMapping.setSourceContent)(map, sourceFileName.replace(/\\/g, "/"), code[sourceFileName]); }); } } get() { return (0, _genMapping.toEncodedMap)(this._map); } getDecoded() { return (0, _genMapping.toDecodedMap)(this._map); } getRawMappings() { return this._rawMappings || (this._rawMappings = (0, _genMapping.allMappings)(this._map)); } mark(generated, line, column, identifierName, filename) { this._rawMappings = undefined; (0, _genMapping.maybeAddMapping)(this._map, { name: identifierName, generated, source: line == null ? undefined : (filename == null ? void 0 : filename.replace(/\\/g, "/")) || this._sourceFileName, original: line == null ? undefined : { line: line, column: column } }); } } exports.default = SourceMap; },{"@jridgewell/gen-mapping":395}],67:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = annotateAsPure; var _t = require("@babel/types"); const { addComment } = _t; const PURE_ANNOTATION = "#__PURE__"; const isPureAnnotated = ({ leadingComments }) => !!leadingComments && leadingComments.some(comment => /[@#]__PURE__/.test(comment.value)); function annotateAsPure(pathOrNode) { const node = pathOrNode["node"] || pathOrNode; if (isPureAnnotated(node)) { return; } addComment(node, "leading", PURE_ANNOTATION); } },{"@babel/types":359}],68:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.getInclusionReasons = getInclusionReasons; var _semver = require("semver"); var _pretty = require("./pretty"); var _utils = require("./utils"); function getInclusionReasons(item, targetVersions, list) { const minVersions = list[item] || {}; return Object.keys(targetVersions).reduce((result, env) => { const minVersion = (0, _utils.getLowestImplementedVersion)(minVersions, env); const targetVersion = targetVersions[env]; if (!minVersion) { result[env] = (0, _pretty.prettifyVersion)(targetVersion); } else { const minIsUnreleased = (0, _utils.isUnreleasedVersion)(minVersion, env); const targetIsUnreleased = (0, _utils.isUnreleasedVersion)(targetVersion, env); if (!targetIsUnreleased && (minIsUnreleased || _semver.lt(targetVersion.toString(), (0, _utils.semverify)(minVersion)))) { result[env] = (0, _pretty.prettifyVersion)(targetVersion); } } return result; }, {}); } },{"./pretty":72,"./utils":74,"semver":75}],69:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = filterItems; exports.isRequired = isRequired; exports.targetsSupported = targetsSupported; var _semver = require("semver"); var _plugins = require("@babel/compat-data/plugins"); var _utils = require("./utils"); function targetsSupported(target, support) { const targetEnvironments = Object.keys(target); if (targetEnvironments.length === 0) { return false; } const unsupportedEnvironments = targetEnvironments.filter(environment => { const lowestImplementedVersion = (0, _utils.getLowestImplementedVersion)(support, environment); if (!lowestImplementedVersion) { return true; } const lowestTargetedVersion = target[environment]; if ((0, _utils.isUnreleasedVersion)(lowestTargetedVersion, environment)) { return false; } if ((0, _utils.isUnreleasedVersion)(lowestImplementedVersion, environment)) { return true; } if (!_semver.valid(lowestTargetedVersion.toString())) { throw new Error(`Invalid version passed for target "${environment}": "${lowestTargetedVersion}". ` + "Versions must be in semver format (major.minor.patch)"); } return _semver.gt((0, _utils.semverify)(lowestImplementedVersion), lowestTargetedVersion.toString()); }); return unsupportedEnvironments.length === 0; } function isRequired(name, targets, { compatData = _plugins, includes, excludes } = {}) { if (excludes != null && excludes.has(name)) return false; if (includes != null && includes.has(name)) return true; return !targetsSupported(targets, compatData[name]); } function filterItems(list, includes, excludes, targets, defaultIncludes, defaultExcludes, pluginSyntaxMap) { const result = new Set(); const options = { compatData: list, includes, excludes }; for (const item in list) { if (isRequired(item, targets, options)) { result.add(item); } else if (pluginSyntaxMap) { const shippedProposalsSyntax = 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; } },{"./utils":74,"@babel/compat-data/plugins":8,"semver":75}],70:[function(require,module,exports){ (function (process){(function (){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); Object.defineProperty(exports, "TargetNames", { enumerable: true, get: function () { return _options.TargetNames; } }); exports.default = getTargets; Object.defineProperty(exports, "filterItems", { enumerable: true, get: function () { return _filterItems.default; } }); Object.defineProperty(exports, "getInclusionReasons", { enumerable: true, get: function () { return _debug.getInclusionReasons; } }); exports.isBrowsersQueryValid = isBrowsersQueryValid; Object.defineProperty(exports, "isRequired", { enumerable: true, get: function () { return _filterItems.isRequired; } }); Object.defineProperty(exports, "prettifyTargets", { enumerable: true, get: function () { return _pretty.prettifyTargets; } }); Object.defineProperty(exports, "unreleasedLabels", { enumerable: true, get: function () { return _targets.unreleasedLabels; } }); var _browserslist = require("browserslist"); var _helperValidatorOption = require("@babel/helper-validator-option"); var _nativeModules = require("@babel/compat-data/native-modules"); var _utils = require("./utils"); var _targets = require("./targets"); var _options = require("./options"); var _pretty = require("./pretty"); var _debug = require("./debug"); var _filterItems = require("./filter-items"); const ESM_SUPPORT = _nativeModules["es6.module"]; const v = new _helperValidatorOption.OptionValidator("@babel/helper-compilation-targets"); function validateTargetNames(targets) { const validTargets = Object.keys(_options.TargetNames); for (const target of Object.keys(targets)) { if (!(target in _options.TargetNames)) { throw new Error(v.formatMessage(`'${target}' is not a valid target - Did you mean '${(0, _helperValidatorOption.findSuggestion)(target, validTargets)}'?`)); } } return targets; } function isBrowsersQueryValid(browsers) { return typeof browsers === "string" || Array.isArray(browsers) && browsers.every(b => typeof b === "string"); } function validateBrowsers(browsers) { v.invariant(browsers === undefined || isBrowsersQueryValid(browsers), `'${String(browsers)}' is not a valid browserslist query`); return browsers; } function getLowestVersions(browsers) { return browsers.reduce((all, browser) => { const [browserName, browserVersion] = browser.split(" "); const target = _targets.browserNameMap[browserName]; if (!target) { return all; } try { const splitVersion = browserVersion.split("-")[0].toLowerCase(); const isSplitUnreleased = (0, _utils.isUnreleasedVersion)(splitVersion, target); if (!all[target]) { all[target] = isSplitUnreleased ? splitVersion : (0, _utils.semverify)(splitVersion); return all; } const version = all[target]; const isUnreleased = (0, _utils.isUnreleasedVersion)(version, target); if (isUnreleased && isSplitUnreleased) { all[target] = (0, _utils.getLowestUnreleased)(version, splitVersion, target); } else if (isUnreleased) { all[target] = (0, _utils.semverify)(splitVersion); } else if (!isUnreleased && !isSplitUnreleased) { const parsedBrowserVersion = (0, _utils.semverify)(splitVersion); all[target] = (0, _utils.semverMin)(version, parsedBrowserVersion); } } catch (e) {} return all; }, {}); } function outputDecimalWarning(decimalTargets) { if (!decimalTargets.length) { return; } console.warn("Warning, the following targets are using a decimal version:\n"); decimalTargets.forEach(({ target, value }) => console.warn(` ${target}: ${value}`)); console.warn(` We recommend using a string for minor/patch versions to avoid numbers like 6.10 getting parsed as 6.1, which can lead to unexpected behavior. `); } function semverifyTarget(target, value) { try { return (0, _utils.semverify)(value); } catch (error) { throw new Error(v.formatMessage(`'${value}' is not a valid value for 'targets.${target}'.`)); } } function nodeTargetParser(value) { const parsed = value === true || value === "current" ? process.versions.node : semverifyTarget("node", value); return ["node", parsed]; } function defaultTargetParser(target, value) { const version = (0, _utils.isUnreleasedVersion)(value, target) ? value.toLowerCase() : semverifyTarget(target, value); return [target, version]; } function generateTargets(inputTargets) { const input = Object.assign({}, inputTargets); delete input.esmodules; delete input.browsers; return input; } function resolveTargets(queries, env) { const resolved = _browserslist(queries, { mobileToDesktop: true, env }); return getLowestVersions(resolved); } function getTargets(inputTargets = {}, options = {}) { var _browsers, _browsers2; let { browsers, esmodules } = inputTargets; const { configPath = "." } = options; validateBrowsers(browsers); const input = generateTargets(inputTargets); let targets = validateTargetNames(input); const shouldParseBrowsers = !!browsers; const hasTargets = shouldParseBrowsers || Object.keys(targets).length > 0; const shouldSearchForConfig = !options.ignoreBrowserslistConfig && !hasTargets; if (!browsers && shouldSearchForConfig) { browsers = _browserslist.loadConfig({ config: options.configFile, path: configPath, env: options.browserslistEnv }); if (browsers == null) { { browsers = []; } } } if (esmodules && (esmodules !== "intersect" || !((_browsers = browsers) != null && _browsers.length))) { browsers = Object.keys(ESM_SUPPORT).map(browser => `${browser} >= ${ESM_SUPPORT[browser]}`).join(", "); esmodules = false; } if ((_browsers2 = browsers) != null && _browsers2.length) { const queryBrowsers = resolveTargets(browsers, options.browserslistEnv); if (esmodules === "intersect") { for (const browser of Object.keys(queryBrowsers)) { const version = queryBrowsers[browser]; const esmSupportVersion = ESM_SUPPORT[browser]; if (esmSupportVersion) { queryBrowsers[browser] = (0, _utils.getHighestUnreleased)(version, (0, _utils.semverify)(esmSupportVersion), browser); } else { delete queryBrowsers[browser]; } } } targets = Object.assign(queryBrowsers, targets); } const result = {}; const decimalWarnings = []; for (const target of Object.keys(targets).sort()) { const value = targets[target]; if (typeof value === "number" && value % 1 !== 0) { decimalWarnings.push({ target, value }); } const [parsedTarget, parsedValue] = target === "node" ? nodeTargetParser(value) : defaultTargetParser(target, value); if (parsedValue) { result[parsedTarget] = parsedValue; } } outputDecimalWarning(decimalWarnings); return result; } }).call(this)}).call(this,require('_process')) },{"./debug":68,"./filter-items":69,"./options":71,"./pretty":72,"./targets":73,"./utils":74,"@babel/compat-data/native-modules":7,"@babel/helper-validator-option":259,"_process":460,"browserslist":412}],71:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.TargetNames = void 0; const TargetNames = { node: "node", chrome: "chrome", opera: "opera", edge: "edge", firefox: "firefox", safari: "safari", ie: "ie", ios: "ios", android: "android", electron: "electron", samsung: "samsung", rhino: "rhino" }; exports.TargetNames = TargetNames; },{}],72:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.prettifyTargets = prettifyTargets; exports.prettifyVersion = prettifyVersion; var _semver = require("semver"); var _targets = require("./targets"); function prettifyVersion(version) { if (typeof version !== "string") { return version; } const parts = [_semver.major(version)]; const minor = _semver.minor(version); const patch = _semver.patch(version); if (minor || patch) { parts.push(minor); } if (patch) { parts.push(patch); } return parts.join("."); } function prettifyTargets(targets) { return Object.keys(targets).reduce((results, target) => { let value = targets[target]; const unreleasedLabel = _targets.unreleasedLabels[target]; if (typeof value === "string" && unreleasedLabel !== value) { value = prettifyVersion(value); } results[target] = value; return results; }, {}); } },{"./targets":73,"semver":75}],73:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.unreleasedLabels = exports.browserNameMap = void 0; const unreleasedLabels = { safari: "tp" }; exports.unreleasedLabels = unreleasedLabels; const browserNameMap = { and_chr: "chrome", and_ff: "firefox", android: "android", chrome: "chrome", edge: "edge", firefox: "firefox", ie: "ie", ie_mob: "ie", ios_saf: "ios", node: "node", op_mob: "opera", opera: "opera", safari: "safari", samsung: "samsung" }; exports.browserNameMap = browserNameMap; },{}],74:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.getHighestUnreleased = getHighestUnreleased; exports.getLowestImplementedVersion = getLowestImplementedVersion; exports.getLowestUnreleased = getLowestUnreleased; exports.isUnreleasedVersion = isUnreleasedVersion; exports.semverMin = semverMin; exports.semverify = semverify; var _semver = require("semver"); var _helperValidatorOption = require("@babel/helper-validator-option"); var _targets = require("./targets"); const versionRegExp = /^(\d+|\d+.\d+)$/; const v = new _helperValidatorOption.OptionValidator("@babel/helper-compilation-targets"); function semverMin(first, second) { return first && _semver.lt(first, second) ? first : second; } function semverify(version) { if (typeof version === "string" && _semver.valid(version)) { return version; } v.invariant(typeof version === "number" || typeof version === "string" && versionRegExp.test(version), `'${version}' is not a valid version`); const split = version.toString().split("."); while (split.length < 3) { split.push("0"); } return split.join("."); } function isUnreleasedVersion(version, env) { const unreleasedLabel = _targets.unreleasedLabels[env]; return !!unreleasedLabel && unreleasedLabel === version.toString().toLowerCase(); } function getLowestUnreleased(a, b, env) { const unreleasedLabel = _targets.unreleasedLabels[env]; if (a === unreleasedLabel) { return b; } if (b === unreleasedLabel) { return a; } return semverMin(a, b); } function getHighestUnreleased(a, b, env) { return getLowestUnreleased(a, b, env) === a ? b : a; } function getLowestImplementedVersion(plugin, environment) { const result = plugin[environment]; if (!result && environment === "android") { return plugin.chrome; } return result; } },{"./targets":73,"@babel/helper-validator-option":259,"semver":75}],75:[function(require,module,exports){ arguments[4][47][0].apply(exports,arguments) },{"_process":460,"dup":47}],76:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = void 0; exports.requeueComputedKeyAndDecorators = requeueComputedKeyAndDecorators; exports.skipAllButComputedKey = skipAllButComputedKey; function skipAllButComputedKey(path) { path.skip(); if (path.node.computed) { path.context.maybeQueue(path.get("key")); } } function requeueComputedKeyAndDecorators(path) { const { context, node } = path; if (node.computed) { context.maybeQueue(path.get("key")); } if (node.decorators) { for (const decorator of path.get("decorators")) { context.maybeQueue(decorator); } } } const visitor = { FunctionParent(path) { if (path.isArrowFunctionExpression()) { return; } else { path.skip(); if (path.isMethod()) { requeueComputedKeyAndDecorators(path); } } }, Property(path) { if (path.isObjectProperty()) { return; } path.skip(); requeueComputedKeyAndDecorators(path); } }; var _default = visitor; exports.default = _default; },{}],77:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = _default; var _template = require("@babel/template"); var _t = require("@babel/types"); const { NOT_LOCAL_BINDING, cloneNode, identifier, isAssignmentExpression, isAssignmentPattern, isFunction, isIdentifier, isLiteral, isNullLiteral, isObjectMethod, isObjectProperty, isRegExpLiteral, isRestElement, isTemplateLiteral, isVariableDeclarator, toBindingIdentifierName } = _t; function getFunctionArity(node) { const count = node.params.findIndex(param => isAssignmentPattern(param) || isRestElement(param)); return count === -1 ? node.params.length : count; } const buildPropertyMethodAssignmentWrapper = _template.default.statement(` (function (FUNCTION_KEY) { function FUNCTION_ID() { return FUNCTION_KEY.apply(this, arguments); } FUNCTION_ID.toString = function () { return FUNCTION_KEY.toString(); } return FUNCTION_ID; })(FUNCTION) `); const buildGeneratorPropertyMethodAssignmentWrapper = _template.default.statement(` (function (FUNCTION_KEY) { function* FUNCTION_ID() { return yield* FUNCTION_KEY.apply(this, arguments); } FUNCTION_ID.toString = function () { return FUNCTION_KEY.toString(); }; return FUNCTION_ID; })(FUNCTION) `); const visitor = { "ReferencedIdentifier|BindingIdentifier"(path, state) { if (path.node.name !== state.name) return; const localDeclar = path.scope.getBindingIdentifier(state.name); if (localDeclar !== state.outerDeclar) return; state.selfReference = true; path.stop(); } }; function getNameFromLiteralId(id) { if (isNullLiteral(id)) { return "null"; } if (isRegExpLiteral(id)) { return `_${id.pattern}_${id.flags}`; } if (isTemplateLiteral(id)) { return id.quasis.map(quasi => quasi.value.raw).join(""); } if (id.value !== undefined) { return id.value + ""; } return ""; } function wrap(state, method, id, scope) { if (state.selfReference) { if (scope.hasBinding(id.name) && !scope.hasGlobal(id.name)) { scope.rename(id.name); } else { if (!isFunction(method)) return; let build = buildPropertyMethodAssignmentWrapper; if (method.generator) { build = buildGeneratorPropertyMethodAssignmentWrapper; } const template = build({ FUNCTION: method, FUNCTION_ID: id, FUNCTION_KEY: scope.generateUidIdentifier(id.name) }).expression; const params = template.callee.body.body[0].params; for (let i = 0, len = getFunctionArity(method); i < len; i++) { params.push(scope.generateUidIdentifier("x")); } return template; } } method.id = id; scope.getProgramParent().references[id.name] = true; } function visit(node, name, scope) { const state = { selfAssignment: false, selfReference: false, outerDeclar: scope.getBindingIdentifier(name), name: name }; const binding = scope.getOwnBinding(name); if (binding) { if (binding.kind === "param") { state.selfReference = true; } else {} } else if (state.outerDeclar || scope.hasGlobal(name)) { scope.traverse(node, visitor, state); } return state; } function _default({ node, parent, scope, id }, localBinding = false, supportUnicodeId = false) { if (node.id) return; if ((isObjectProperty(parent) || isObjectMethod(parent, { kind: "method" })) && (!parent.computed || isLiteral(parent.key))) { id = parent.key; } else if (isVariableDeclarator(parent)) { id = parent.id; if (isIdentifier(id) && !localBinding) { const binding = scope.parent.getBinding(id.name); if (binding && binding.constant && scope.getBinding(id.name) === binding) { node.id = cloneNode(id); node.id[NOT_LOCAL_BINDING] = true; return; } } } else if (isAssignmentExpression(parent, { operator: "=" })) { id = parent.left; } else if (!id) { return; } let name; if (id && isLiteral(id)) { name = getNameFromLiteralId(id); } else if (id && isIdentifier(id)) { name = id.name; } if (name === undefined) { return; } if (!supportUnicodeId && isFunction(node) && /[\uD800-\uDFFF]/.test(name)) { return; } name = toBindingIdentifierName(name); const newId = identifier(name); newId[NOT_LOCAL_BINDING] = true; const state = visit(node, name, scope); return wrap(state, node, newId, scope) || node; } },{"@babel/template":281,"@babel/types":359}],78:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = hoistVariables; var _t = require("@babel/types"); const { assignmentExpression, expressionStatement, identifier } = _t; const visitor = { Scope(path, state) { if (state.kind === "let") path.skip(); }, FunctionParent(path) { path.skip(); }, VariableDeclaration(path, state) { if (state.kind && path.node.kind !== state.kind) return; const nodes = []; const declarations = path.get("declarations"); let firstId; for (const declar of declarations) { firstId = declar.node.id; if (declar.node.init) { nodes.push(expressionStatement(assignmentExpression("=", declar.node.id, declar.node.init))); } for (const name of Object.keys(declar.getBindingIdentifiers())) { state.emit(identifier(name), name, declar.node.init !== null); } } if (path.parentPath.isFor({ left: path.node })) { path.replaceWith(firstId); } else { path.replaceWithMultiple(nodes); } } }; function hoistVariables(path, emit, kind = "var") { path.traverse(visitor, { kind, emit }); } },{"@babel/types":359}],79:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, '__esModule', { value: true }); var _t = require('@babel/types'); function _interopNamespace(e) { if (e && e.__esModule) return e; var n = Object.create(null); if (e) { Object.keys(e).forEach(function (k) { if (k !== 'default') { var d = Object.getOwnPropertyDescriptor(e, k); Object.defineProperty(n, k, d.get ? d : { enumerable: true, get: function () { return e[k]; } }); } }); } n["default"] = e; return Object.freeze(n); } var _t__namespace = /*#__PURE__*/_interopNamespace(_t); function willPathCastToBoolean(path) { const maybeWrapped = path; const { node, parentPath } = maybeWrapped; if (parentPath.isLogicalExpression()) { const { operator, right } = parentPath.node; if (operator === "&&" || operator === "||" || operator === "??" && node === right) { return willPathCastToBoolean(parentPath); } } if (parentPath.isSequenceExpression()) { const { expressions } = parentPath.node; if (expressions[expressions.length - 1] === node) { return willPathCastToBoolean(parentPath); } else { return true; } } return parentPath.isConditional({ test: node }) || parentPath.isUnaryExpression({ operator: "!" }) || parentPath.isLoop({ test: node }); } const { LOGICAL_OPERATORS, arrowFunctionExpression, assignmentExpression, binaryExpression, booleanLiteral, callExpression, cloneNode, conditionalExpression, identifier, isMemberExpression, isOptionalCallExpression, isOptionalMemberExpression, isUpdateExpression, logicalExpression, memberExpression, nullLiteral, optionalCallExpression, optionalMemberExpression, sequenceExpression, updateExpression } = _t__namespace; class AssignmentMemoiser { constructor() { this._map = void 0; this._map = new WeakMap(); } has(key) { return this._map.has(key); } get(key) { if (!this.has(key)) return; const record = this._map.get(key); const { value } = record; record.count--; if (record.count === 0) { return assignmentExpression("=", value, key); } return value; } set(key, value, count) { return this._map.set(key, { count, value }); } } function toNonOptional(path, base) { const { node } = path; if (isOptionalMemberExpression(node)) { return memberExpression(base, node.property, node.computed); } if (path.isOptionalCallExpression()) { const callee = path.get("callee"); if (path.node.optional && callee.isOptionalMemberExpression()) { const object = callee.node.object; const context = path.scope.maybeGenerateMemoised(object); callee.get("object").replaceWith(assignmentExpression("=", context, object)); return callExpression(memberExpression(base, identifier("call")), [context, ...path.node.arguments]); } return callExpression(base, path.node.arguments); } return path.node; } function isInDetachedTree(path) { while (path) { if (path.isProgram()) break; const { parentPath, container, listKey } = path; const parentNode = parentPath.node; if (listKey) { if (container !== parentNode[listKey]) { return true; } } else { if (container !== parentNode) return true; } path = parentPath; } return false; } const handle = { memoise() {}, handle(member, noDocumentAll) { const { node, parent, parentPath, scope } = member; if (member.isOptionalMemberExpression()) { if (isInDetachedTree(member)) return; const endPath = member.find(({ node, parent }) => { if (isOptionalMemberExpression(parent)) { return parent.optional || parent.object !== node; } if (isOptionalCallExpression(parent)) { return node !== member.node && parent.optional || parent.callee !== node; } return true; }); if (scope.path.isPattern()) { endPath.replaceWith(callExpression(arrowFunctionExpression([], endPath.node), [])); return; } const willEndPathCastToBoolean = willPathCastToBoolean(endPath); const rootParentPath = endPath.parentPath; if (rootParentPath.isUpdateExpression({ argument: node }) || rootParentPath.isAssignmentExpression({ left: node })) { throw member.buildCodeFrameError(`can't handle assignment`); } const isDeleteOperation = rootParentPath.isUnaryExpression({ operator: "delete" }); if (isDeleteOperation && endPath.isOptionalMemberExpression() && endPath.get("property").isPrivateName()) { throw member.buildCodeFrameError(`can't delete a private class element`); } let startingOptional = member; for (;;) { if (startingOptional.isOptionalMemberExpression()) { if (startingOptional.node.optional) break; startingOptional = startingOptional.get("object"); continue; } else if (startingOptional.isOptionalCallExpression()) { if (startingOptional.node.optional) break; startingOptional = startingOptional.get("callee"); continue; } throw new Error(`Internal error: unexpected ${startingOptional.node.type}`); } const startingNode = startingOptional.isOptionalMemberExpression() ? startingOptional.node.object : startingOptional.node.callee; const baseNeedsMemoised = scope.maybeGenerateMemoised(startingNode); const baseRef = baseNeedsMemoised != null ? baseNeedsMemoised : startingNode; const parentIsOptionalCall = parentPath.isOptionalCallExpression({ callee: node }); const isOptionalCall = parent => parentIsOptionalCall; const parentIsCall = parentPath.isCallExpression({ callee: node }); startingOptional.replaceWith(toNonOptional(startingOptional, baseRef)); if (isOptionalCall()) { if (parent.optional) { parentPath.replaceWith(this.optionalCall(member, parent.arguments)); } else { parentPath.replaceWith(this.call(member, parent.arguments)); } } else if (parentIsCall) { member.replaceWith(this.boundGet(member)); } else { member.replaceWith(this.get(member)); } let regular = member.node; for (let current = member; current !== endPath;) { const parentPath = current.parentPath; if (parentPath === endPath && isOptionalCall() && parent.optional) { regular = parentPath.node; break; } regular = toNonOptional(parentPath, regular); current = parentPath; } let context; const endParentPath = endPath.parentPath; if (isMemberExpression(regular) && endParentPath.isOptionalCallExpression({ callee: endPath.node, optional: true })) { const { object } = regular; context = member.scope.maybeGenerateMemoised(object); if (context) { regular.object = assignmentExpression("=", context, object); } } let replacementPath = endPath; if (isDeleteOperation) { replacementPath = endParentPath; regular = endParentPath.node; } const baseMemoised = baseNeedsMemoised ? assignmentExpression("=", cloneNode(baseRef), cloneNode(startingNode)) : cloneNode(baseRef); if (willEndPathCastToBoolean) { let nonNullishCheck; if (noDocumentAll) { nonNullishCheck = binaryExpression("!=", baseMemoised, nullLiteral()); } else { nonNullishCheck = logicalExpression("&&", binaryExpression("!==", baseMemoised, nullLiteral()), binaryExpression("!==", cloneNode(baseRef), scope.buildUndefinedNode())); } replacementPath.replaceWith(logicalExpression("&&", nonNullishCheck, regular)); } else { let nullishCheck; if (noDocumentAll) { nullishCheck = binaryExpression("==", baseMemoised, nullLiteral()); } else { nullishCheck = logicalExpression("||", binaryExpression("===", baseMemoised, nullLiteral()), binaryExpression("===", cloneNode(baseRef), scope.buildUndefinedNode())); } replacementPath.replaceWith(conditionalExpression(nullishCheck, isDeleteOperation ? booleanLiteral(true) : scope.buildUndefinedNode(), regular)); } if (context) { const endParent = endParentPath.node; endParentPath.replaceWith(optionalCallExpression(optionalMemberExpression(endParent.callee, identifier("call"), false, true), [cloneNode(context), ...endParent.arguments], false)); } return; } if (isUpdateExpression(parent, { argument: node })) { if (this.simpleSet) { member.replaceWith(this.simpleSet(member)); return; } const { operator, prefix } = parent; this.memoise(member, 2); const ref = scope.generateUidIdentifierBasedOnNode(node); scope.push({ id: ref }); const seq = [assignmentExpression("=", cloneNode(ref), this.get(member))]; if (prefix) { seq.push(updateExpression(operator, cloneNode(ref), prefix)); const value = sequenceExpression(seq); parentPath.replaceWith(this.set(member, value)); return; } else { const ref2 = scope.generateUidIdentifierBasedOnNode(node); scope.push({ id: ref2 }); seq.push(assignmentExpression("=", cloneNode(ref2), updateExpression(operator, cloneNode(ref), prefix)), cloneNode(ref)); const value = sequenceExpression(seq); parentPath.replaceWith(sequenceExpression([this.set(member, value), cloneNode(ref2)])); return; } } if (parentPath.isAssignmentExpression({ left: node })) { if (this.simpleSet) { member.replaceWith(this.simpleSet(member)); return; } const { operator, right: value } = parentPath.node; if (operator === "=") { parentPath.replaceWith(this.set(member, value)); } else { const operatorTrunc = operator.slice(0, -1); if (LOGICAL_OPERATORS.includes(operatorTrunc)) { this.memoise(member, 1); parentPath.replaceWith(logicalExpression(operatorTrunc, this.get(member), this.set(member, value))); } else { this.memoise(member, 2); parentPath.replaceWith(this.set(member, binaryExpression(operatorTrunc, this.get(member), value))); } } return; } if (parentPath.isCallExpression({ callee: node })) { parentPath.replaceWith(this.call(member, parentPath.node.arguments)); return; } if (parentPath.isOptionalCallExpression({ callee: node })) { if (scope.path.isPattern()) { parentPath.replaceWith(callExpression(arrowFunctionExpression([], parentPath.node), [])); return; } parentPath.replaceWith(this.optionalCall(member, parentPath.node.arguments)); return; } if (parentPath.isForXStatement({ left: node }) || parentPath.isObjectProperty({ value: node }) && parentPath.parentPath.isObjectPattern() || parentPath.isAssignmentPattern({ left: node }) && parentPath.parentPath.isObjectProperty({ value: parent }) && parentPath.parentPath.parentPath.isObjectPattern() || parentPath.isArrayPattern() || parentPath.isAssignmentPattern({ left: node }) && parentPath.parentPath.isArrayPattern() || parentPath.isRestElement()) { member.replaceWith(this.destructureSet(member)); return; } if (parentPath.isTaggedTemplateExpression()) { member.replaceWith(this.boundGet(member)); } else { member.replaceWith(this.get(member)); } } }; function memberExpressionToFunctions(path, visitor, state) { path.traverse(visitor, Object.assign({}, handle, state, { memoiser: new AssignmentMemoiser() })); } exports["default"] = memberExpressionToFunctions; },{"@babel/types":359}],80:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = void 0; var _assert = require("assert"); var _t = require("@babel/types"); const { callExpression, cloneNode, expressionStatement, identifier, importDeclaration, importDefaultSpecifier, importNamespaceSpecifier, importSpecifier, memberExpression, stringLiteral, variableDeclaration, variableDeclarator } = _t; class ImportBuilder { constructor(importedSource, scope, hub) { this._statements = []; this._resultName = null; this._importedSource = void 0; this._scope = scope; this._hub = hub; this._importedSource = importedSource; } done() { return { statements: this._statements, resultName: this._resultName }; } import() { this._statements.push(importDeclaration([], stringLiteral(this._importedSource))); return this; } require() { this._statements.push(expressionStatement(callExpression(identifier("require"), [stringLiteral(this._importedSource)]))); return this; } namespace(name = "namespace") { const local = this._scope.generateUidIdentifier(name); const statement = this._statements[this._statements.length - 1]; _assert(statement.type === "ImportDeclaration"); _assert(statement.specifiers.length === 0); statement.specifiers = [importNamespaceSpecifier(local)]; this._resultName = cloneNode(local); return this; } default(name) { const id = this._scope.generateUidIdentifier(name); const statement = this._statements[this._statements.length - 1]; _assert(statement.type === "ImportDeclaration"); _assert(statement.specifiers.length === 0); statement.specifiers = [importDefaultSpecifier(id)]; this._resultName = cloneNode(id); return this; } named(name, importName) { if (importName === "default") return this.default(name); const id = this._scope.generateUidIdentifier(name); const statement = this._statements[this._statements.length - 1]; _assert(statement.type === "ImportDeclaration"); _assert(statement.specifiers.length === 0); statement.specifiers = [importSpecifier(id, identifier(importName))]; this._resultName = cloneNode(id); return this; } var(name) { const id = this._scope.generateUidIdentifier(name); let statement = this._statements[this._statements.length - 1]; if (statement.type !== "ExpressionStatement") { _assert(this._resultName); statement = expressionStatement(this._resultName); this._statements.push(statement); } this._statements[this._statements.length - 1] = variableDeclaration("var", [variableDeclarator(id, statement.expression)]); this._resultName = cloneNode(id); return this; } defaultInterop() { return this._interop(this._hub.addHelper("interopRequireDefault")); } wildcardInterop() { return this._interop(this._hub.addHelper("interopRequireWildcard")); } _interop(callee) { const statement = this._statements[this._statements.length - 1]; if (statement.type === "ExpressionStatement") { statement.expression = callExpression(callee, [statement.expression]); } else if (statement.type === "VariableDeclaration") { _assert(statement.declarations.length === 1); statement.declarations[0].init = callExpression(callee, [statement.declarations[0].init]); } else { _assert.fail("Unexpected type."); } return this; } prop(name) { const statement = this._statements[this._statements.length - 1]; if (statement.type === "ExpressionStatement") { statement.expression = memberExpression(statement.expression, identifier(name)); } else if (statement.type === "VariableDeclaration") { _assert(statement.declarations.length === 1); statement.declarations[0].init = memberExpression(statement.declarations[0].init, identifier(name)); } else { _assert.fail("Unexpected type:" + statement.type); } return this; } read(name) { this._resultName = memberExpression(this._resultName, identifier(name)); } } exports.default = ImportBuilder; },{"@babel/types":128,"assert":402}],81:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = void 0; var _assert = require("assert"); var _t = require("@babel/types"); var _importBuilder = require("./import-builder"); var _isModule = require("./is-module"); const { numericLiteral, sequenceExpression } = _t; class ImportInjector { constructor(path, importedSource, opts) { this._defaultOpts = { importedSource: null, importedType: "commonjs", importedInterop: "babel", importingInterop: "babel", ensureLiveReference: false, ensureNoContext: false, importPosition: "before" }; const programPath = path.find(p => p.isProgram()); this._programPath = programPath; this._programScope = programPath.scope; this._hub = programPath.hub; this._defaultOpts = this._applyDefaults(importedSource, opts, true); } addDefault(importedSourceIn, opts) { return this.addNamed("default", importedSourceIn, opts); } addNamed(importName, importedSourceIn, opts) { _assert(typeof importName === "string"); return this._generateImport(this._applyDefaults(importedSourceIn, opts), importName); } addNamespace(importedSourceIn, opts) { return this._generateImport(this._applyDefaults(importedSourceIn, opts), null); } addSideEffect(importedSourceIn, opts) { return this._generateImport(this._applyDefaults(importedSourceIn, opts), void 0); } _applyDefaults(importedSource, opts, isInit = false) { let newOpts; if (typeof importedSource === "string") { newOpts = Object.assign({}, this._defaultOpts, { importedSource }, opts); } else { _assert(!opts, "Unexpected secondary arguments."); newOpts = Object.assign({}, this._defaultOpts, importedSource); } if (!isInit && opts) { if (opts.nameHint !== undefined) newOpts.nameHint = opts.nameHint; if (opts.blockHoist !== undefined) newOpts.blockHoist = opts.blockHoist; } return newOpts; } _generateImport(opts, importName) { const isDefault = importName === "default"; const isNamed = !!importName && !isDefault; const isNamespace = importName === null; const { importedSource, importedType, importedInterop, importingInterop, ensureLiveReference, ensureNoContext, nameHint, importPosition, blockHoist } = opts; let name = nameHint || importName; const isMod = (0, _isModule.default)(this._programPath); const isModuleForNode = isMod && importingInterop === "node"; const isModuleForBabel = isMod && importingInterop === "babel"; if (importPosition === "after" && !isMod) { throw new Error(`"importPosition": "after" is only supported in modules`); } const builder = new _importBuilder.default(importedSource, this._programScope, this._hub); if (importedType === "es6") { if (!isModuleForNode && !isModuleForBabel) { throw new Error("Cannot import an ES6 module from CommonJS"); } builder.import(); if (isNamespace) { builder.namespace(nameHint || importedSource); } else if (isDefault || isNamed) { builder.named(name, importName); } } else if (importedType !== "commonjs") { throw new Error(`Unexpected interopType "${importedType}"`); } else if (importedInterop === "babel") { if (isModuleForNode) { name = name !== "default" ? name : importedSource; const es6Default = `${importedSource}$es6Default`; builder.import(); if (isNamespace) { builder.default(es6Default).var(name || importedSource).wildcardInterop(); } else if (isDefault) { if (ensureLiveReference) { builder.default(es6Default).var(name || importedSource).defaultInterop().read("default"); } else { builder.default(es6Default).var(name).defaultInterop().prop(importName); } } else if (isNamed) { builder.default(es6Default).read(importName); } } else if (isModuleForBabel) { builder.import(); if (isNamespace) { builder.namespace(name || importedSource); } else if (isDefault || isNamed) { builder.named(name, importName); } } else { builder.require(); if (isNamespace) { builder.var(name || importedSource).wildcardInterop(); } else if ((isDefault || isNamed) && ensureLiveReference) { if (isDefault) { name = name !== "default" ? name : importedSource; builder.var(name).read(importName); builder.defaultInterop(); } else { builder.var(importedSource).read(importName); } } else if (isDefault) { builder.var(name).defaultInterop().prop(importName); } else if (isNamed) { builder.var(name).prop(importName); } } } else if (importedInterop === "compiled") { if (isModuleForNode) { builder.import(); if (isNamespace) { builder.default(name || importedSource); } else if (isDefault || isNamed) { builder.default(importedSource).read(name); } } else if (isModuleForBabel) { builder.import(); if (isNamespace) { builder.namespace(name || importedSource); } else if (isDefault || isNamed) { builder.named(name, importName); } } else { builder.require(); if (isNamespace) { builder.var(name || importedSource); } else if (isDefault || isNamed) { if (ensureLiveReference) { builder.var(importedSource).read(name); } else { builder.prop(importName).var(name); } } } } else if (importedInterop === "uncompiled") { if (isDefault && ensureLiveReference) { throw new Error("No live reference for commonjs default"); } if (isModuleForNode) { builder.import(); if (isNamespace) { builder.default(name || importedSource); } else if (isDefault) { builder.default(name); } else if (isNamed) { builder.default(importedSource).read(name); } } else if (isModuleForBabel) { builder.import(); if (isNamespace) { builder.default(name || importedSource); } else if (isDefault) { builder.default(name); } else if (isNamed) { builder.named(name, importName); } } else { builder.require(); if (isNamespace) { builder.var(name || importedSource); } else if (isDefault) { builder.var(name); } else if (isNamed) { if (ensureLiveReference) { builder.var(importedSource).read(name); } else { builder.var(name).prop(importName); } } } } else { throw new Error(`Unknown importedInterop "${importedInterop}".`); } const { statements, resultName } = builder.done(); this._insertStatements(statements, importPosition, blockHoist); if ((isDefault || isNamed) && ensureNoContext && resultName.type !== "Identifier") { return sequenceExpression([numericLiteral(0), resultName]); } return resultName; } _insertStatements(statements, importPosition = "before", blockHoist = 3) { const body = this._programPath.get("body"); if (importPosition === "after") { for (let i = body.length - 1; i >= 0; i--) { if (body[i].isImportDeclaration()) { body[i].insertAfter(statements); return; } } } else { statements.forEach(node => { node._blockHoist = blockHoist; }); const targetPath = body.find(p => { const val = p.node._blockHoist; return Number.isFinite(val) && val < 4; }); if (targetPath) { targetPath.insertBefore(statements); return; } } this._programPath.unshiftContainer("body", statements); } } exports.default = ImportInjector; },{"./import-builder":80,"./is-module":83,"@babel/types":128,"assert":402}],82:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); Object.defineProperty(exports, "ImportInjector", { enumerable: true, get: function () { return _importInjector.default; } }); exports.addDefault = addDefault; exports.addNamed = addNamed; exports.addNamespace = addNamespace; exports.addSideEffect = addSideEffect; Object.defineProperty(exports, "isModule", { enumerable: true, get: function () { return _isModule.default; } }); var _importInjector = require("./import-injector"); var _isModule = require("./is-module"); function addDefault(path, importedSource, opts) { return new _importInjector.default(path).addDefault(importedSource, opts); } function addNamed(path, name, importedSource, opts) { return new _importInjector.default(path).addNamed(name, importedSource, opts); } function addNamespace(path, importedSource, opts) { return new _importInjector.default(path).addNamespace(importedSource, opts); } function addSideEffect(path, importedSource, opts) { return new _importInjector.default(path).addSideEffect(importedSource, opts); } },{"./import-injector":81,"./is-module":83}],83:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = isModule; function isModule(path) { const { sourceType } = path.node; if (sourceType !== "module" && sourceType !== "script") { throw path.buildCodeFrameError(`Unknown sourceType "${sourceType}", cannot transform.`); } return path.node.sourceType === "module"; } },{}],84:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = assertNode; var _isNode = require("../validators/isNode"); function assertNode(node) { if (!(0, _isNode.default)(node)) { var _node$type; const type = (_node$type = node == null ? void 0 : node.type) != null ? _node$type : JSON.stringify(node); throw new TypeError(`Not a valid node of type "${type}"`); } } },{"../validators/isNode":150}],85:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.assertAccessor = assertAccessor; exports.assertAnyTypeAnnotation = assertAnyTypeAnnotation; exports.assertArgumentPlaceholder = assertArgumentPlaceholder; exports.assertArrayExpression = assertArrayExpression; exports.assertArrayPattern = assertArrayPattern; exports.assertArrayTypeAnnotation = assertArrayTypeAnnotation; exports.assertArrowFunctionExpression = assertArrowFunctionExpression; exports.assertAssignmentExpression = assertAssignmentExpression; exports.assertAssignmentPattern = assertAssignmentPattern; exports.assertAwaitExpression = assertAwaitExpression; exports.assertBigIntLiteral = assertBigIntLiteral; exports.assertBinary = assertBinary; exports.assertBinaryExpression = assertBinaryExpression; exports.assertBindExpression = assertBindExpression; exports.assertBlock = assertBlock; exports.assertBlockParent = assertBlockParent; exports.assertBlockStatement = assertBlockStatement; exports.assertBooleanLiteral = assertBooleanLiteral; exports.assertBooleanLiteralTypeAnnotation = assertBooleanLiteralTypeAnnotation; exports.assertBooleanTypeAnnotation = assertBooleanTypeAnnotation; exports.assertBreakStatement = assertBreakStatement; exports.assertCallExpression = assertCallExpression; exports.assertCatchClause = assertCatchClause; exports.assertClass = assertClass; exports.assertClassAccessorProperty = assertClassAccessorProperty; exports.assertClassBody = assertClassBody; exports.assertClassDeclaration = assertClassDeclaration; exports.assertClassExpression = assertClassExpression; exports.assertClassImplements = assertClassImplements; exports.assertClassMethod = assertClassMethod; exports.assertClassPrivateMethod = assertClassPrivateMethod; exports.assertClassPrivateProperty = assertClassPrivateProperty; exports.assertClassProperty = assertClassProperty; exports.assertCompletionStatement = assertCompletionStatement; exports.assertConditional = assertConditional; exports.assertConditionalExpression = assertConditionalExpression; exports.assertContinueStatement = assertContinueStatement; exports.assertDebuggerStatement = assertDebuggerStatement; exports.assertDecimalLiteral = assertDecimalLiteral; exports.assertDeclaration = assertDeclaration; exports.assertDeclareClass = assertDeclareClass; exports.assertDeclareExportAllDeclaration = assertDeclareExportAllDeclaration; exports.assertDeclareExportDeclaration = assertDeclareExportDeclaration; exports.assertDeclareFunction = assertDeclareFunction; exports.assertDeclareInterface = assertDeclareInterface; exports.assertDeclareModule = assertDeclareModule; exports.assertDeclareModuleExports = assertDeclareModuleExports; exports.assertDeclareOpaqueType = assertDeclareOpaqueType; exports.assertDeclareTypeAlias = assertDeclareTypeAlias; exports.assertDeclareVariable = assertDeclareVariable; exports.assertDeclaredPredicate = assertDeclaredPredicate; exports.assertDecorator = assertDecorator; exports.assertDirective = assertDirective; exports.assertDirectiveLiteral = assertDirectiveLiteral; exports.assertDoExpression = assertDoExpression; exports.assertDoWhileStatement = assertDoWhileStatement; exports.assertEmptyStatement = assertEmptyStatement; exports.assertEmptyTypeAnnotation = assertEmptyTypeAnnotation; exports.assertEnumBody = assertEnumBody; exports.assertEnumBooleanBody = assertEnumBooleanBody; exports.assertEnumBooleanMember = assertEnumBooleanMember; exports.assertEnumDeclaration = assertEnumDeclaration; exports.assertEnumDefaultedMember = assertEnumDefaultedMember; exports.assertEnumMember = assertEnumMember; exports.assertEnumNumberBody = assertEnumNumberBody; exports.assertEnumNumberMember = assertEnumNumberMember; exports.assertEnumStringBody = assertEnumStringBody; exports.assertEnumStringMember = assertEnumStringMember; exports.assertEnumSymbolBody = assertEnumSymbolBody; exports.assertExistsTypeAnnotation = assertExistsTypeAnnotation; exports.assertExportAllDeclaration = assertExportAllDeclaration; exports.assertExportDeclaration = assertExportDeclaration; exports.assertExportDefaultDeclaration = assertExportDefaultDeclaration; exports.assertExportDefaultSpecifier = assertExportDefaultSpecifier; exports.assertExportNamedDeclaration = assertExportNamedDeclaration; exports.assertExportNamespaceSpecifier = assertExportNamespaceSpecifier; exports.assertExportSpecifier = assertExportSpecifier; exports.assertExpression = assertExpression; exports.assertExpressionStatement = assertExpressionStatement; exports.assertExpressionWrapper = assertExpressionWrapper; exports.assertFile = assertFile; exports.assertFlow = assertFlow; exports.assertFlowBaseAnnotation = assertFlowBaseAnnotation; exports.assertFlowDeclaration = assertFlowDeclaration; exports.assertFlowPredicate = assertFlowPredicate; exports.assertFlowType = assertFlowType; exports.assertFor = assertFor; exports.assertForInStatement = assertForInStatement; exports.assertForOfStatement = assertForOfStatement; exports.assertForStatement = assertForStatement; exports.assertForXStatement = assertForXStatement; exports.assertFunction = assertFunction; exports.assertFunctionDeclaration = assertFunctionDeclaration; exports.assertFunctionExpression = assertFunctionExpression; exports.assertFunctionParent = assertFunctionParent; exports.assertFunctionTypeAnnotation = assertFunctionTypeAnnotation; exports.assertFunctionTypeParam = assertFunctionTypeParam; exports.assertGenericTypeAnnotation = assertGenericTypeAnnotation; exports.assertIdentifier = assertIdentifier; exports.assertIfStatement = assertIfStatement; exports.assertImmutable = assertImmutable; exports.assertImport = assertImport; exports.assertImportAttribute = assertImportAttribute; exports.assertImportDeclaration = assertImportDeclaration; exports.assertImportDefaultSpecifier = assertImportDefaultSpecifier; exports.assertImportNamespaceSpecifier = assertImportNamespaceSpecifier; exports.assertImportSpecifier = assertImportSpecifier; exports.assertIndexedAccessType = assertIndexedAccessType; exports.assertInferredPredicate = assertInferredPredicate; exports.assertInterfaceDeclaration = assertInterfaceDeclaration; exports.assertInterfaceExtends = assertInterfaceExtends; exports.assertInterfaceTypeAnnotation = assertInterfaceTypeAnnotation; exports.assertInterpreterDirective = assertInterpreterDirective; exports.assertIntersectionTypeAnnotation = assertIntersectionTypeAnnotation; exports.assertJSX = assertJSX; exports.assertJSXAttribute = assertJSXAttribute; exports.assertJSXClosingElement = assertJSXClosingElement; exports.assertJSXClosingFragment = assertJSXClosingFragment; exports.assertJSXElement = assertJSXElement; exports.assertJSXEmptyExpression = assertJSXEmptyExpression; exports.assertJSXExpressionContainer = assertJSXExpressionContainer; exports.assertJSXFragment = assertJSXFragment; exports.assertJSXIdentifier = assertJSXIdentifier; exports.assertJSXMemberExpression = assertJSXMemberExpression; exports.assertJSXNamespacedName = assertJSXNamespacedName; exports.assertJSXOpeningElement = assertJSXOpeningElement; exports.assertJSXOpeningFragment = assertJSXOpeningFragment; exports.assertJSXSpreadAttribute = assertJSXSpreadAttribute; exports.assertJSXSpreadChild = assertJSXSpreadChild; exports.assertJSXText = assertJSXText; exports.assertLVal = assertLVal; exports.assertLabeledStatement = assertLabeledStatement; exports.assertLiteral = assertLiteral; exports.assertLogicalExpression = assertLogicalExpression; exports.assertLoop = assertLoop; exports.assertMemberExpression = assertMemberExpression; exports.assertMetaProperty = assertMetaProperty; exports.assertMethod = assertMethod; exports.assertMiscellaneous = assertMiscellaneous; exports.assertMixedTypeAnnotation = assertMixedTypeAnnotation; exports.assertModuleDeclaration = assertModuleDeclaration; exports.assertModuleExpression = assertModuleExpression; exports.assertModuleSpecifier = assertModuleSpecifier; exports.assertNewExpression = assertNewExpression; exports.assertNoop = assertNoop; exports.assertNullLiteral = assertNullLiteral; exports.assertNullLiteralTypeAnnotation = assertNullLiteralTypeAnnotation; exports.assertNullableTypeAnnotation = assertNullableTypeAnnotation; exports.assertNumberLiteral = assertNumberLiteral; exports.assertNumberLiteralTypeAnnotation = assertNumberLiteralTypeAnnotation; exports.assertNumberTypeAnnotation = assertNumberTypeAnnotation; exports.assertNumericLiteral = assertNumericLiteral; exports.assertObjectExpression = assertObjectExpression; exports.assertObjectMember = assertObjectMember; exports.assertObjectMethod = assertObjectMethod; exports.assertObjectPattern = assertObjectPattern; exports.assertObjectProperty = assertObjectProperty; exports.assertObjectTypeAnnotation = assertObjectTypeAnnotation; exports.assertObjectTypeCallProperty = assertObjectTypeCallProperty; exports.assertObjectTypeIndexer = assertObjectTypeIndexer; exports.assertObjectTypeInternalSlot = assertObjectTypeInternalSlot; exports.assertObjectTypeProperty = assertObjectTypeProperty; exports.assertObjectTypeSpreadProperty = assertObjectTypeSpreadProperty; exports.assertOpaqueType = assertOpaqueType; exports.assertOptionalCallExpression = assertOptionalCallExpression; exports.assertOptionalIndexedAccessType = assertOptionalIndexedAccessType; exports.assertOptionalMemberExpression = assertOptionalMemberExpression; exports.assertParenthesizedExpression = assertParenthesizedExpression; exports.assertPattern = assertPattern; exports.assertPatternLike = assertPatternLike; exports.assertPipelineBareFunction = assertPipelineBareFunction; exports.assertPipelinePrimaryTopicReference = assertPipelinePrimaryTopicReference; exports.assertPipelineTopicExpression = assertPipelineTopicExpression; exports.assertPlaceholder = assertPlaceholder; exports.assertPrivate = assertPrivate; exports.assertPrivateName = assertPrivateName; exports.assertProgram = assertProgram; exports.assertProperty = assertProperty; exports.assertPureish = assertPureish; exports.assertQualifiedTypeIdentifier = assertQualifiedTypeIdentifier; exports.assertRecordExpression = assertRecordExpression; exports.assertRegExpLiteral = assertRegExpLiteral; exports.assertRegexLiteral = assertRegexLiteral; exports.assertRestElement = assertRestElement; exports.assertRestProperty = assertRestProperty; exports.assertReturnStatement = assertReturnStatement; exports.assertScopable = assertScopable; exports.assertSequenceExpression = assertSequenceExpression; exports.assertSpreadElement = assertSpreadElement; exports.assertSpreadProperty = assertSpreadProperty; exports.assertStandardized = assertStandardized; exports.assertStatement = assertStatement; exports.assertStaticBlock = assertStaticBlock; exports.assertStringLiteral = assertStringLiteral; exports.assertStringLiteralTypeAnnotation = assertStringLiteralTypeAnnotation; exports.assertStringTypeAnnotation = assertStringTypeAnnotation; exports.assertSuper = assertSuper; exports.assertSwitchCase = assertSwitchCase; exports.assertSwitchStatement = assertSwitchStatement; exports.assertSymbolTypeAnnotation = assertSymbolTypeAnnotation; exports.assertTSAnyKeyword = assertTSAnyKeyword; exports.assertTSArrayType = assertTSArrayType; exports.assertTSAsExpression = assertTSAsExpression; exports.assertTSBaseType = assertTSBaseType; exports.assertTSBigIntKeyword = assertTSBigIntKeyword; exports.assertTSBooleanKeyword = assertTSBooleanKeyword; exports.assertTSCallSignatureDeclaration = assertTSCallSignatureDeclaration; exports.assertTSConditionalType = assertTSConditionalType; exports.assertTSConstructSignatureDeclaration = assertTSConstructSignatureDeclaration; exports.assertTSConstructorType = assertTSConstructorType; exports.assertTSDeclareFunction = assertTSDeclareFunction; exports.assertTSDeclareMethod = assertTSDeclareMethod; exports.assertTSEntityName = assertTSEntityName; exports.assertTSEnumDeclaration = assertTSEnumDeclaration; exports.assertTSEnumMember = assertTSEnumMember; exports.assertTSExportAssignment = assertTSExportAssignment; exports.assertTSExpressionWithTypeArguments = assertTSExpressionWithTypeArguments; exports.assertTSExternalModuleReference = assertTSExternalModuleReference; exports.assertTSFunctionType = assertTSFunctionType; exports.assertTSImportEqualsDeclaration = assertTSImportEqualsDeclaration; exports.assertTSImportType = assertTSImportType; exports.assertTSIndexSignature = assertTSIndexSignature; exports.assertTSIndexedAccessType = assertTSIndexedAccessType; exports.assertTSInferType = assertTSInferType; exports.assertTSInstantiationExpression = assertTSInstantiationExpression; exports.assertTSInterfaceBody = assertTSInterfaceBody; exports.assertTSInterfaceDeclaration = assertTSInterfaceDeclaration; exports.assertTSIntersectionType = assertTSIntersectionType; exports.assertTSIntrinsicKeyword = assertTSIntrinsicKeyword; exports.assertTSLiteralType = assertTSLiteralType; exports.assertTSMappedType = assertTSMappedType; exports.assertTSMethodSignature = assertTSMethodSignature; exports.assertTSModuleBlock = assertTSModuleBlock; exports.assertTSModuleDeclaration = assertTSModuleDeclaration; exports.assertTSNamedTupleMember = assertTSNamedTupleMember; exports.assertTSNamespaceExportDeclaration = assertTSNamespaceExportDeclaration; exports.assertTSNeverKeyword = assertTSNeverKeyword; exports.assertTSNonNullExpression = assertTSNonNullExpression; exports.assertTSNullKeyword = assertTSNullKeyword; exports.assertTSNumberKeyword = assertTSNumberKeyword; exports.assertTSObjectKeyword = assertTSObjectKeyword; exports.assertTSOptionalType = assertTSOptionalType; exports.assertTSParameterProperty = assertTSParameterProperty; exports.assertTSParenthesizedType = assertTSParenthesizedType; exports.assertTSPropertySignature = assertTSPropertySignature; exports.assertTSQualifiedName = assertTSQualifiedName; exports.assertTSRestType = assertTSRestType; exports.assertTSStringKeyword = assertTSStringKeyword; exports.assertTSSymbolKeyword = assertTSSymbolKeyword; exports.assertTSThisType = assertTSThisType; exports.assertTSTupleType = assertTSTupleType; exports.assertTSType = assertTSType; exports.assertTSTypeAliasDeclaration = assertTSTypeAliasDeclaration; exports.assertTSTypeAnnotation = assertTSTypeAnnotation; exports.assertTSTypeAssertion = assertTSTypeAssertion; exports.assertTSTypeElement = assertTSTypeElement; exports.assertTSTypeLiteral = assertTSTypeLiteral; exports.assertTSTypeOperator = assertTSTypeOperator; exports.assertTSTypeParameter = assertTSTypeParameter; exports.assertTSTypeParameterDeclaration = assertTSTypeParameterDeclaration; exports.assertTSTypeParameterInstantiation = assertTSTypeParameterInstantiation; exports.assertTSTypePredicate = assertTSTypePredicate; exports.assertTSTypeQuery = assertTSTypeQuery; exports.assertTSTypeReference = assertTSTypeReference; exports.assertTSUndefinedKeyword = assertTSUndefinedKeyword; exports.assertTSUnionType = assertTSUnionType; exports.assertTSUnknownKeyword = assertTSUnknownKeyword; exports.assertTSVoidKeyword = assertTSVoidKeyword; exports.assertTaggedTemplateExpression = assertTaggedTemplateExpression; exports.assertTemplateElement = assertTemplateElement; exports.assertTemplateLiteral = assertTemplateLiteral; exports.assertTerminatorless = assertTerminatorless; exports.assertThisExpression = assertThisExpression; exports.assertThisTypeAnnotation = assertThisTypeAnnotation; exports.assertThrowStatement = assertThrowStatement; exports.assertTopicReference = assertTopicReference; exports.assertTryStatement = assertTryStatement; exports.assertTupleExpression = assertTupleExpression; exports.assertTupleTypeAnnotation = assertTupleTypeAnnotation; exports.assertTypeAlias = assertTypeAlias; exports.assertTypeAnnotation = assertTypeAnnotation; exports.assertTypeCastExpression = assertTypeCastExpression; exports.assertTypeParameter = assertTypeParameter; exports.assertTypeParameterDeclaration = assertTypeParameterDeclaration; exports.assertTypeParameterInstantiation = assertTypeParameterInstantiation; exports.assertTypeScript = assertTypeScript; exports.assertTypeofTypeAnnotation = assertTypeofTypeAnnotation; exports.assertUnaryExpression = assertUnaryExpression; exports.assertUnaryLike = assertUnaryLike; exports.assertUnionTypeAnnotation = assertUnionTypeAnnotation; exports.assertUpdateExpression = assertUpdateExpression; exports.assertUserWhitespacable = assertUserWhitespacable; exports.assertV8IntrinsicIdentifier = assertV8IntrinsicIdentifier; exports.assertVariableDeclaration = assertVariableDeclaration; exports.assertVariableDeclarator = assertVariableDeclarator; exports.assertVariance = assertVariance; exports.assertVoidTypeAnnotation = assertVoidTypeAnnotation; exports.assertWhile = assertWhile; exports.assertWhileStatement = assertWhileStatement; exports.assertWithStatement = assertWithStatement; exports.assertYieldExpression = assertYieldExpression; var _is = require("../../validators/is"); function assert(type, node, opts) { if (!(0, _is.default)(type, node, opts)) { throw new Error(`Expected type "${type}" with option ${JSON.stringify(opts)}, ` + `but instead got "${node.type}".`); } } function assertArrayExpression(node, opts) { assert("ArrayExpression", node, opts); } function assertAssignmentExpression(node, opts) { assert("AssignmentExpression", node, opts); } function assertBinaryExpression(node, opts) { assert("BinaryExpression", node, opts); } function assertInterpreterDirective(node, opts) { assert("InterpreterDirective", node, opts); } function assertDirective(node, opts) { assert("Directive", node, opts); } function assertDirectiveLiteral(node, opts) { assert("DirectiveLiteral", node, opts); } function assertBlockStatement(node, opts) { assert("BlockStatement", node, opts); } function assertBreakStatement(node, opts) { assert("BreakStatement", node, opts); } function assertCallExpression(node, opts) { assert("CallExpression", node, opts); } function assertCatchClause(node, opts) { assert("CatchClause", node, opts); } function assertConditionalExpression(node, opts) { assert("ConditionalExpression", node, opts); } function assertContinueStatement(node, opts) { assert("ContinueStatement", node, opts); } function assertDebuggerStatement(node, opts) { assert("DebuggerStatement", node, opts); } function assertDoWhileStatement(node, opts) { assert("DoWhileStatement", node, opts); } function assertEmptyStatement(node, opts) { assert("EmptyStatement", node, opts); } function assertExpressionStatement(node, opts) { assert("ExpressionStatement", node, opts); } function assertFile(node, opts) { assert("File", node, opts); } function assertForInStatement(node, opts) { assert("ForInStatement", node, opts); } function assertForStatement(node, opts) { assert("ForStatement", node, opts); } function assertFunctionDeclaration(node, opts) { assert("FunctionDeclaration", node, opts); } function assertFunctionExpression(node, opts) { assert("FunctionExpression", node, opts); } function assertIdentifier(node, opts) { assert("Identifier", node, opts); } function assertIfStatement(node, opts) { assert("IfStatement", node, opts); } function assertLabeledStatement(node, opts) { assert("LabeledStatement", node, opts); } function assertStringLiteral(node, opts) { assert("StringLiteral", node, opts); } function assertNumericLiteral(node, opts) { assert("NumericLiteral", node, opts); } function assertNullLiteral(node, opts) { assert("NullLiteral", node, opts); } function assertBooleanLiteral(node, opts) { assert("BooleanLiteral", node, opts); } function assertRegExpLiteral(node, opts) { assert("RegExpLiteral", node, opts); } function assertLogicalExpression(node, opts) { assert("LogicalExpression", node, opts); } function assertMemberExpression(node, opts) { assert("MemberExpression", node, opts); } function assertNewExpression(node, opts) { assert("NewExpression", node, opts); } function assertProgram(node, opts) { assert("Program", node, opts); } function assertObjectExpression(node, opts) { assert("ObjectExpression", node, opts); } function assertObjectMethod(node, opts) { assert("ObjectMethod", node, opts); } function assertObjectProperty(node, opts) { assert("ObjectProperty", node, opts); } function assertRestElement(node, opts) { assert("RestElement", node, opts); } function assertReturnStatement(node, opts) { assert("ReturnStatement", node, opts); } function assertSequenceExpression(node, opts) { assert("SequenceExpression", node, opts); } function assertParenthesizedExpression(node, opts) { assert("ParenthesizedExpression", node, opts); } function assertSwitchCase(node, opts) { assert("SwitchCase", node, opts); } function assertSwitchStatement(node, opts) { assert("SwitchStatement", node, opts); } function assertThisExpression(node, opts) { assert("ThisExpression", node, opts); } function assertThrowStatement(node, opts) { assert("ThrowStatement", node, opts); } function assertTryStatement(node, opts) { assert("TryStatement", node, opts); } function assertUnaryExpression(node, opts) { assert("UnaryExpression", node, opts); } function assertUpdateExpression(node, opts) { assert("UpdateExpression", node, opts); } function assertVariableDeclaration(node, opts) { assert("VariableDeclaration", node, opts); } function assertVariableDeclarator(node, opts) { assert("VariableDeclarator", node, opts); } function assertWhileStatement(node, opts) { assert("WhileStatement", node, opts); } function assertWithStatement(node, opts) { assert("WithStatement", node, opts); } function assertAssignmentPattern(node, opts) { assert("AssignmentPattern", node, opts); } function assertArrayPattern(node, opts) { assert("ArrayPattern", node, opts); } function assertArrowFunctionExpression(node, opts) { assert("ArrowFunctionExpression", node, opts); } function assertClassBody(node, opts) { assert("ClassBody", node, opts); } function assertClassExpression(node, opts) { assert("ClassExpression", node, opts); } function assertClassDeclaration(node, opts) { assert("ClassDeclaration", node, opts); } function assertExportAllDeclaration(node, opts) { assert("ExportAllDeclaration", node, opts); } function assertExportDefaultDeclaration(node, opts) { assert("ExportDefaultDeclaration", node, opts); } function assertExportNamedDeclaration(node, opts) { assert("ExportNamedDeclaration", node, opts); } function assertExportSpecifier(node, opts) { assert("ExportSpecifier", node, opts); } function assertForOfStatement(node, opts) { assert("ForOfStatement", node, opts); } function assertImportDeclaration(node, opts) { assert("ImportDeclaration", node, opts); } function assertImportDefaultSpecifier(node, opts) { assert("ImportDefaultSpecifier", node, opts); } function assertImportNamespaceSpecifier(node, opts) { assert("ImportNamespaceSpecifier", node, opts); } function assertImportSpecifier(node, opts) { assert("ImportSpecifier", node, opts); } function assertMetaProperty(node, opts) { assert("MetaProperty", node, opts); } function assertClassMethod(node, opts) { assert("ClassMethod", node, opts); } function assertObjectPattern(node, opts) { assert("ObjectPattern", node, opts); } function assertSpreadElement(node, opts) { assert("SpreadElement", node, opts); } function assertSuper(node, opts) { assert("Super", node, opts); } function assertTaggedTemplateExpression(node, opts) { assert("TaggedTemplateExpression", node, opts); } function assertTemplateElement(node, opts) { assert("TemplateElement", node, opts); } function assertTemplateLiteral(node, opts) { assert("TemplateLiteral", node, opts); } function assertYieldExpression(node, opts) { assert("YieldExpression", node, opts); } function assertAwaitExpression(node, opts) { assert("AwaitExpression", node, opts); } function assertImport(node, opts) { assert("Import", node, opts); } function assertBigIntLiteral(node, opts) { assert("BigIntLiteral", node, opts); } function assertExportNamespaceSpecifier(node, opts) { assert("ExportNamespaceSpecifier", node, opts); } function assertOptionalMemberExpression(node, opts) { assert("OptionalMemberExpression", node, opts); } function assertOptionalCallExpression(node, opts) { assert("OptionalCallExpression", node, opts); } function assertClassProperty(node, opts) { assert("ClassProperty", node, opts); } function assertClassAccessorProperty(node, opts) { assert("ClassAccessorProperty", node, opts); } function assertClassPrivateProperty(node, opts) { assert("ClassPrivateProperty", node, opts); } function assertClassPrivateMethod(node, opts) { assert("ClassPrivateMethod", node, opts); } function assertPrivateName(node, opts) { assert("PrivateName", node, opts); } function assertStaticBlock(node, opts) { assert("StaticBlock", node, opts); } function assertAnyTypeAnnotation(node, opts) { assert("AnyTypeAnnotation", node, opts); } function assertArrayTypeAnnotation(node, opts) { assert("ArrayTypeAnnotation", node, opts); } function assertBooleanTypeAnnotation(node, opts) { assert("BooleanTypeAnnotation", node, opts); } function assertBooleanLiteralTypeAnnotation(node, opts) { assert("BooleanLiteralTypeAnnotation", node, opts); } function assertNullLiteralTypeAnnotation(node, opts) { assert("NullLiteralTypeAnnotation", node, opts); } function assertClassImplements(node, opts) { assert("ClassImplements", node, opts); } function assertDeclareClass(node, opts) { assert("DeclareClass", node, opts); } function assertDeclareFunction(node, opts) { assert("DeclareFunction", node, opts); } function assertDeclareInterface(node, opts) { assert("DeclareInterface", node, opts); } function assertDeclareModule(node, opts) { assert("DeclareModule", node, opts); } function assertDeclareModuleExports(node, opts) { assert("DeclareModuleExports", node, opts); } function assertDeclareTypeAlias(node, opts) { assert("DeclareTypeAlias", node, opts); } function assertDeclareOpaqueType(node, opts) { assert("DeclareOpaqueType", node, opts); } function assertDeclareVariable(node, opts) { assert("DeclareVariable", node, opts); } function assertDeclareExportDeclaration(node, opts) { assert("DeclareExportDeclaration", node, opts); } function assertDeclareExportAllDeclaration(node, opts) { assert("DeclareExportAllDeclaration", node, opts); } function assertDeclaredPredicate(node, opts) { assert("DeclaredPredicate", node, opts); } function assertExistsTypeAnnotation(node, opts) { assert("ExistsTypeAnnotation", node, opts); } function assertFunctionTypeAnnotation(node, opts) { assert("FunctionTypeAnnotation", node, opts); } function assertFunctionTypeParam(node, opts) { assert("FunctionTypeParam", node, opts); } function assertGenericTypeAnnotation(node, opts) { assert("GenericTypeAnnotation", node, opts); } function assertInferredPredicate(node, opts) { assert("InferredPredicate", node, opts); } function assertInterfaceExtends(node, opts) { assert("InterfaceExtends", node, opts); } function assertInterfaceDeclaration(node, opts) { assert("InterfaceDeclaration", node, opts); } function assertInterfaceTypeAnnotation(node, opts) { assert("InterfaceTypeAnnotation", node, opts); } function assertIntersectionTypeAnnotation(node, opts) { assert("IntersectionTypeAnnotation", node, opts); } function assertMixedTypeAnnotation(node, opts) { assert("MixedTypeAnnotation", node, opts); } function assertEmptyTypeAnnotation(node, opts) { assert("EmptyTypeAnnotation", node, opts); } function assertNullableTypeAnnotation(node, opts) { assert("NullableTypeAnnotation", node, opts); } function assertNumberLiteralTypeAnnotation(node, opts) { assert("NumberLiteralTypeAnnotation", node, opts); } function assertNumberTypeAnnotation(node, opts) { assert("NumberTypeAnnotation", node, opts); } function assertObjectTypeAnnotation(node, opts) { assert("ObjectTypeAnnotation", node, opts); } function assertObjectTypeInternalSlot(node, opts) { assert("ObjectTypeInternalSlot", node, opts); } function assertObjectTypeCallProperty(node, opts) { assert("ObjectTypeCallProperty", node, opts); } function assertObjectTypeIndexer(node, opts) { assert("ObjectTypeIndexer", node, opts); } function assertObjectTypeProperty(node, opts) { assert("ObjectTypeProperty", node, opts); } function assertObjectTypeSpreadProperty(node, opts) { assert("ObjectTypeSpreadProperty", node, opts); } function assertOpaqueType(node, opts) { assert("OpaqueType", node, opts); } function assertQualifiedTypeIdentifier(node, opts) { assert("QualifiedTypeIdentifier", node, opts); } function assertStringLiteralTypeAnnotation(node, opts) { assert("StringLiteralTypeAnnotation", node, opts); } function assertStringTypeAnnotation(node, opts) { assert("StringTypeAnnotation", node, opts); } function assertSymbolTypeAnnotation(node, opts) { assert("SymbolTypeAnnotation", node, opts); } function assertThisTypeAnnotation(node, opts) { assert("ThisTypeAnnotation", node, opts); } function assertTupleTypeAnnotation(node, opts) { assert("TupleTypeAnnotation", node, opts); } function assertTypeofTypeAnnotation(node, opts) { assert("TypeofTypeAnnotation", node, opts); } function assertTypeAlias(node, opts) { assert("TypeAlias", node, opts); } function assertTypeAnnotation(node, opts) { assert("TypeAnnotation", node, opts); } function assertTypeCastExpression(node, opts) { assert("TypeCastExpression", node, opts); } function assertTypeParameter(node, opts) { assert("TypeParameter", node, opts); } function assertTypeParameterDeclaration(node, opts) { assert("TypeParameterDeclaration", node, opts); } function assertTypeParameterInstantiation(node, opts) { assert("TypeParameterInstantiation", node, opts); } function assertUnionTypeAnnotation(node, opts) { assert("UnionTypeAnnotation", node, opts); } function assertVariance(node, opts) { assert("Variance", node, opts); } function assertVoidTypeAnnotation(node, opts) { assert("VoidTypeAnnotation", node, opts); } function assertEnumDeclaration(node, opts) { assert("EnumDeclaration", node, opts); } function assertEnumBooleanBody(node, opts) { assert("EnumBooleanBody", node, opts); } function assertEnumNumberBody(node, opts) { assert("EnumNumberBody", node, opts); } function assertEnumStringBody(node, opts) { assert("EnumStringBody", node, opts); } function assertEnumSymbolBody(node, opts) { assert("EnumSymbolBody", node, opts); } function assertEnumBooleanMember(node, opts) { assert("EnumBooleanMember", node, opts); } function assertEnumNumberMember(node, opts) { assert("EnumNumberMember", node, opts); } function assertEnumStringMember(node, opts) { assert("EnumStringMember", node, opts); } function assertEnumDefaultedMember(node, opts) { assert("EnumDefaultedMember", node, opts); } function assertIndexedAccessType(node, opts) { assert("IndexedAccessType", node, opts); } function assertOptionalIndexedAccessType(node, opts) { assert("OptionalIndexedAccessType", node, opts); } function assertJSXAttribute(node, opts) { assert("JSXAttribute", node, opts); } function assertJSXClosingElement(node, opts) { assert("JSXClosingElement", node, opts); } function assertJSXElement(node, opts) { assert("JSXElement", node, opts); } function assertJSXEmptyExpression(node, opts) { assert("JSXEmptyExpression", node, opts); } function assertJSXExpressionContainer(node, opts) { assert("JSXExpressionContainer", node, opts); } function assertJSXSpreadChild(node, opts) { assert("JSXSpreadChild", node, opts); } function assertJSXIdentifier(node, opts) { assert("JSXIdentifier", node, opts); } function assertJSXMemberExpression(node, opts) { assert("JSXMemberExpression", node, opts); } function assertJSXNamespacedName(node, opts) { assert("JSXNamespacedName", node, opts); } function assertJSXOpeningElement(node, opts) { assert("JSXOpeningElement", node, opts); } function assertJSXSpreadAttribute(node, opts) { assert("JSXSpreadAttribute", node, opts); } function assertJSXText(node, opts) { assert("JSXText", node, opts); } function assertJSXFragment(node, opts) { assert("JSXFragment", node, opts); } function assertJSXOpeningFragment(node, opts) { assert("JSXOpeningFragment", node, opts); } function assertJSXClosingFragment(node, opts) { assert("JSXClosingFragment", node, opts); } function assertNoop(node, opts) { assert("Noop", node, opts); } function assertPlaceholder(node, opts) { assert("Placeholder", node, opts); } function assertV8IntrinsicIdentifier(node, opts) { assert("V8IntrinsicIdentifier", node, opts); } function assertArgumentPlaceholder(node, opts) { assert("ArgumentPlaceholder", node, opts); } function assertBindExpression(node, opts) { assert("BindExpression", node, opts); } function assertImportAttribute(node, opts) { assert("ImportAttribute", node, opts); } function assertDecorator(node, opts) { assert("Decorator", node, opts); } function assertDoExpression(node, opts) { assert("DoExpression", node, opts); } function assertExportDefaultSpecifier(node, opts) { assert("ExportDefaultSpecifier", node, opts); } function assertRecordExpression(node, opts) { assert("RecordExpression", node, opts); } function assertTupleExpression(node, opts) { assert("TupleExpression", node, opts); } function assertDecimalLiteral(node, opts) { assert("DecimalLiteral", node, opts); } function assertModuleExpression(node, opts) { assert("ModuleExpression", node, opts); } function assertTopicReference(node, opts) { assert("TopicReference", node, opts); } function assertPipelineTopicExpression(node, opts) { assert("PipelineTopicExpression", node, opts); } function assertPipelineBareFunction(node, opts) { assert("PipelineBareFunction", node, opts); } function assertPipelinePrimaryTopicReference(node, opts) { assert("PipelinePrimaryTopicReference", node, opts); } function assertTSParameterProperty(node, opts) { assert("TSParameterProperty", node, opts); } function assertTSDeclareFunction(node, opts) { assert("TSDeclareFunction", node, opts); } function assertTSDeclareMethod(node, opts) { assert("TSDeclareMethod", node, opts); } function assertTSQualifiedName(node, opts) { assert("TSQualifiedName", node, opts); } function assertTSCallSignatureDeclaration(node, opts) { assert("TSCallSignatureDeclaration", node, opts); } function assertTSConstructSignatureDeclaration(node, opts) { assert("TSConstructSignatureDeclaration", node, opts); } function assertTSPropertySignature(node, opts) { assert("TSPropertySignature", node, opts); } function assertTSMethodSignature(node, opts) { assert("TSMethodSignature", node, opts); } function assertTSIndexSignature(node, opts) { assert("TSIndexSignature", node, opts); } function assertTSAnyKeyword(node, opts) { assert("TSAnyKeyword", node, opts); } function assertTSBooleanKeyword(node, opts) { assert("TSBooleanKeyword", node, opts); } function assertTSBigIntKeyword(node, opts) { assert("TSBigIntKeyword", node, opts); } function assertTSIntrinsicKeyword(node, opts) { assert("TSIntrinsicKeyword", node, opts); } function assertTSNeverKeyword(node, opts) { assert("TSNeverKeyword", node, opts); } function assertTSNullKeyword(node, opts) { assert("TSNullKeyword", node, opts); } function assertTSNumberKeyword(node, opts) { assert("TSNumberKeyword", node, opts); } function assertTSObjectKeyword(node, opts) { assert("TSObjectKeyword", node, opts); } function assertTSStringKeyword(node, opts) { assert("TSStringKeyword", node, opts); } function assertTSSymbolKeyword(node, opts) { assert("TSSymbolKeyword", node, opts); } function assertTSUndefinedKeyword(node, opts) { assert("TSUndefinedKeyword", node, opts); } function assertTSUnknownKeyword(node, opts) { assert("TSUnknownKeyword", node, opts); } function assertTSVoidKeyword(node, opts) { assert("TSVoidKeyword", node, opts); } function assertTSThisType(node, opts) { assert("TSThisType", node, opts); } function assertTSFunctionType(node, opts) { assert("TSFunctionType", node, opts); } function assertTSConstructorType(node, opts) { assert("TSConstructorType", node, opts); } function assertTSTypeReference(node, opts) { assert("TSTypeReference", node, opts); } function assertTSTypePredicate(node, opts) { assert("TSTypePredicate", node, opts); } function assertTSTypeQuery(node, opts) { assert("TSTypeQuery", node, opts); } function assertTSTypeLiteral(node, opts) { assert("TSTypeLiteral", node, opts); } function assertTSArrayType(node, opts) { assert("TSArrayType", node, opts); } function assertTSTupleType(node, opts) { assert("TSTupleType", node, opts); } function assertTSOptionalType(node, opts) { assert("TSOptionalType", node, opts); } function assertTSRestType(node, opts) { assert("TSRestType", node, opts); } function assertTSNamedTupleMember(node, opts) { assert("TSNamedTupleMember", node, opts); } function assertTSUnionType(node, opts) { assert("TSUnionType", node, opts); } function assertTSIntersectionType(node, opts) { assert("TSIntersectionType", node, opts); } function assertTSConditionalType(node, opts) { assert("TSConditionalType", node, opts); } function assertTSInferType(node, opts) { assert("TSInferType", node, opts); } function assertTSParenthesizedType(node, opts) { assert("TSParenthesizedType", node, opts); } function assertTSTypeOperator(node, opts) { assert("TSTypeOperator", node, opts); } function assertTSIndexedAccessType(node, opts) { assert("TSIndexedAccessType", node, opts); } function assertTSMappedType(node, opts) { assert("TSMappedType", node, opts); } function assertTSLiteralType(node, opts) { assert("TSLiteralType", node, opts); } function assertTSExpressionWithTypeArguments(node, opts) { assert("TSExpressionWithTypeArguments", node, opts); } function assertTSInterfaceDeclaration(node, opts) { assert("TSInterfaceDeclaration", node, opts); } function assertTSInterfaceBody(node, opts) { assert("TSInterfaceBody", node, opts); } function assertTSTypeAliasDeclaration(node, opts) { assert("TSTypeAliasDeclaration", node, opts); } function assertTSInstantiationExpression(node, opts) { assert("TSInstantiationExpression", node, opts); } function assertTSAsExpression(node, opts) { assert("TSAsExpression", node, opts); } function assertTSTypeAssertion(node, opts) { assert("TSTypeAssertion", node, opts); } function assertTSEnumDeclaration(node, opts) { assert("TSEnumDeclaration", node, opts); } function assertTSEnumMember(node, opts) { assert("TSEnumMember", node, opts); } function assertTSModuleDeclaration(node, opts) { assert("TSModuleDeclaration", node, opts); } function assertTSModuleBlock(node, opts) { assert("TSModuleBlock", node, opts); } function assertTSImportType(node, opts) { assert("TSImportType", node, opts); } function assertTSImportEqualsDeclaration(node, opts) { assert("TSImportEqualsDeclaration", node, opts); } function assertTSExternalModuleReference(node, opts) { assert("TSExternalModuleReference", node, opts); } function assertTSNonNullExpression(node, opts) { assert("TSNonNullExpression", node, opts); } function assertTSExportAssignment(node, opts) { assert("TSExportAssignment", node, opts); } function assertTSNamespaceExportDeclaration(node, opts) { assert("TSNamespaceExportDeclaration", node, opts); } function assertTSTypeAnnotation(node, opts) { assert("TSTypeAnnotation", node, opts); } function assertTSTypeParameterInstantiation(node, opts) { assert("TSTypeParameterInstantiation", node, opts); } function assertTSTypeParameterDeclaration(node, opts) { assert("TSTypeParameterDeclaration", node, opts); } function assertTSTypeParameter(node, opts) { assert("TSTypeParameter", node, opts); } function assertStandardized(node, opts) { assert("Standardized", node, opts); } function assertExpression(node, opts) { assert("Expression", node, opts); } function assertBinary(node, opts) { assert("Binary", node, opts); } function assertScopable(node, opts) { assert("Scopable", node, opts); } function assertBlockParent(node, opts) { assert("BlockParent", node, opts); } function assertBlock(node, opts) { assert("Block", node, opts); } function assertStatement(node, opts) { assert("Statement", node, opts); } function assertTerminatorless(node, opts) { assert("Terminatorless", node, opts); } function assertCompletionStatement(node, opts) { assert("CompletionStatement", node, opts); } function assertConditional(node, opts) { assert("Conditional", node, opts); } function assertLoop(node, opts) { assert("Loop", node, opts); } function assertWhile(node, opts) { assert("While", node, opts); } function assertExpressionWrapper(node, opts) { assert("ExpressionWrapper", node, opts); } function assertFor(node, opts) { assert("For", node, opts); } function assertForXStatement(node, opts) { assert("ForXStatement", node, opts); } function assertFunction(node, opts) { assert("Function", node, opts); } function assertFunctionParent(node, opts) { assert("FunctionParent", node, opts); } function assertPureish(node, opts) { assert("Pureish", node, opts); } function assertDeclaration(node, opts) { assert("Declaration", node, opts); } function assertPatternLike(node, opts) { assert("PatternLike", node, opts); } function assertLVal(node, opts) { assert("LVal", node, opts); } function assertTSEntityName(node, opts) { assert("TSEntityName", node, opts); } function assertLiteral(node, opts) { assert("Literal", node, opts); } function assertImmutable(node, opts) { assert("Immutable", node, opts); } function assertUserWhitespacable(node, opts) { assert("UserWhitespacable", node, opts); } function assertMethod(node, opts) { assert("Method", node, opts); } function assertObjectMember(node, opts) { assert("ObjectMember", node, opts); } function assertProperty(node, opts) { assert("Property", node, opts); } function assertUnaryLike(node, opts) { assert("UnaryLike", node, opts); } function assertPattern(node, opts) { assert("Pattern", node, opts); } function assertClass(node, opts) { assert("Class", node, opts); } function assertModuleDeclaration(node, opts) { assert("ModuleDeclaration", node, opts); } function assertExportDeclaration(node, opts) { assert("ExportDeclaration", node, opts); } function assertModuleSpecifier(node, opts) { assert("ModuleSpecifier", node, opts); } function assertAccessor(node, opts) { assert("Accessor", node, opts); } function assertPrivate(node, opts) { assert("Private", node, opts); } function assertFlow(node, opts) { assert("Flow", node, opts); } function assertFlowType(node, opts) { assert("FlowType", node, opts); } function assertFlowBaseAnnotation(node, opts) { assert("FlowBaseAnnotation", node, opts); } function assertFlowDeclaration(node, opts) { assert("FlowDeclaration", node, opts); } function assertFlowPredicate(node, opts) { assert("FlowPredicate", node, opts); } function assertEnumBody(node, opts) { assert("EnumBody", node, opts); } function assertEnumMember(node, opts) { assert("EnumMember", node, opts); } function assertJSX(node, opts) { assert("JSX", node, opts); } function assertMiscellaneous(node, opts) { assert("Miscellaneous", node, opts); } function assertTypeScript(node, opts) { assert("TypeScript", node, opts); } function assertTSTypeElement(node, opts) { assert("TSTypeElement", node, opts); } function assertTSType(node, opts) { assert("TSType", node, opts); } function assertTSBaseType(node, opts) { assert("TSBaseType", node, opts); } function assertNumberLiteral(node, opts) { console.trace("The node type NumberLiteral has been renamed to NumericLiteral"); assert("NumberLiteral", node, opts); } function assertRegexLiteral(node, opts) { console.trace("The node type RegexLiteral has been renamed to RegExpLiteral"); assert("RegexLiteral", node, opts); } function assertRestProperty(node, opts) { console.trace("The node type RestProperty has been renamed to RestElement"); assert("RestProperty", node, opts); } function assertSpreadProperty(node, opts) { console.trace("The node type SpreadProperty has been renamed to SpreadElement"); assert("SpreadProperty", node, opts); } },{"../../validators/is":145}],86:[function(require,module,exports){ arguments[4][9][0].apply(exports,arguments) },{"dup":9}],87:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = createFlowUnionType; var _generated = require("../generated"); var _removeTypeDuplicates = require("../../modifications/flow/removeTypeDuplicates"); function createFlowUnionType(types) { const flattened = (0, _removeTypeDuplicates.default)(types); if (flattened.length === 1) { return flattened[0]; } else { return (0, _generated.unionTypeAnnotation)(flattened); } } },{"../../modifications/flow/removeTypeDuplicates":130,"../generated":89}],88:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = void 0; var _generated = require("../generated"); var _default = createTypeAnnotationBasedOnTypeof; exports.default = _default; function createTypeAnnotationBasedOnTypeof(type) { switch (type) { case "string": return (0, _generated.stringTypeAnnotation)(); case "number": return (0, _generated.numberTypeAnnotation)(); case "undefined": return (0, _generated.voidTypeAnnotation)(); case "boolean": return (0, _generated.booleanTypeAnnotation)(); case "function": return (0, _generated.genericTypeAnnotation)((0, _generated.identifier)("Function")); case "object": return (0, _generated.genericTypeAnnotation)((0, _generated.identifier)("Object")); case "symbol": return (0, _generated.genericTypeAnnotation)((0, _generated.identifier)("Symbol")); case "bigint": return (0, _generated.anyTypeAnnotation)(); } throw new Error("Invalid typeof value: " + type); } },{"../generated":89}],89:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.anyTypeAnnotation = anyTypeAnnotation; exports.argumentPlaceholder = argumentPlaceholder; exports.arrayExpression = arrayExpression; exports.arrayPattern = arrayPattern; exports.arrayTypeAnnotation = arrayTypeAnnotation; exports.arrowFunctionExpression = arrowFunctionExpression; exports.assignmentExpression = assignmentExpression; exports.assignmentPattern = assignmentPattern; exports.awaitExpression = awaitExpression; exports.bigIntLiteral = bigIntLiteral; exports.binaryExpression = binaryExpression; exports.bindExpression = bindExpression; exports.blockStatement = blockStatement; exports.booleanLiteral = booleanLiteral; exports.booleanLiteralTypeAnnotation = booleanLiteralTypeAnnotation; exports.booleanTypeAnnotation = booleanTypeAnnotation; exports.breakStatement = breakStatement; exports.callExpression = callExpression; exports.catchClause = catchClause; exports.classAccessorProperty = classAccessorProperty; exports.classBody = classBody; exports.classDeclaration = classDeclaration; exports.classExpression = classExpression; exports.classImplements = classImplements; exports.classMethod = classMethod; exports.classPrivateMethod = classPrivateMethod; exports.classPrivateProperty = classPrivateProperty; exports.classProperty = classProperty; exports.conditionalExpression = conditionalExpression; exports.continueStatement = continueStatement; exports.debuggerStatement = debuggerStatement; exports.decimalLiteral = decimalLiteral; exports.declareClass = declareClass; exports.declareExportAllDeclaration = declareExportAllDeclaration; exports.declareExportDeclaration = declareExportDeclaration; exports.declareFunction = declareFunction; exports.declareInterface = declareInterface; exports.declareModule = declareModule; exports.declareModuleExports = declareModuleExports; exports.declareOpaqueType = declareOpaqueType; exports.declareTypeAlias = declareTypeAlias; exports.declareVariable = declareVariable; exports.declaredPredicate = declaredPredicate; exports.decorator = decorator; exports.directive = directive; exports.directiveLiteral = directiveLiteral; exports.doExpression = doExpression; exports.doWhileStatement = doWhileStatement; exports.emptyStatement = emptyStatement; exports.emptyTypeAnnotation = emptyTypeAnnotation; exports.enumBooleanBody = enumBooleanBody; exports.enumBooleanMember = enumBooleanMember; exports.enumDeclaration = enumDeclaration; exports.enumDefaultedMember = enumDefaultedMember; exports.enumNumberBody = enumNumberBody; exports.enumNumberMember = enumNumberMember; exports.enumStringBody = enumStringBody; exports.enumStringMember = enumStringMember; exports.enumSymbolBody = enumSymbolBody; exports.existsTypeAnnotation = existsTypeAnnotation; exports.exportAllDeclaration = exportAllDeclaration; exports.exportDefaultDeclaration = exportDefaultDeclaration; exports.exportDefaultSpecifier = exportDefaultSpecifier; exports.exportNamedDeclaration = exportNamedDeclaration; exports.exportNamespaceSpecifier = exportNamespaceSpecifier; exports.exportSpecifier = exportSpecifier; exports.expressionStatement = expressionStatement; exports.file = file; exports.forInStatement = forInStatement; exports.forOfStatement = forOfStatement; exports.forStatement = forStatement; exports.functionDeclaration = functionDeclaration; exports.functionExpression = functionExpression; exports.functionTypeAnnotation = functionTypeAnnotation; exports.functionTypeParam = functionTypeParam; exports.genericTypeAnnotation = genericTypeAnnotation; exports.identifier = identifier; exports.ifStatement = ifStatement; exports.import = _import; exports.importAttribute = importAttribute; exports.importDeclaration = importDeclaration; exports.importDefaultSpecifier = importDefaultSpecifier; exports.importNamespaceSpecifier = importNamespaceSpecifier; exports.importSpecifier = importSpecifier; exports.indexedAccessType = indexedAccessType; exports.inferredPredicate = inferredPredicate; exports.interfaceDeclaration = interfaceDeclaration; exports.interfaceExtends = interfaceExtends; exports.interfaceTypeAnnotation = interfaceTypeAnnotation; exports.interpreterDirective = interpreterDirective; exports.intersectionTypeAnnotation = intersectionTypeAnnotation; exports.jSXAttribute = exports.jsxAttribute = jsxAttribute; exports.jSXClosingElement = exports.jsxClosingElement = jsxClosingElement; exports.jSXClosingFragment = exports.jsxClosingFragment = jsxClosingFragment; exports.jSXElement = exports.jsxElement = jsxElement; exports.jSXEmptyExpression = exports.jsxEmptyExpression = jsxEmptyExpression; exports.jSXExpressionContainer = exports.jsxExpressionContainer = jsxExpressionContainer; exports.jSXFragment = exports.jsxFragment = jsxFragment; exports.jSXIdentifier = exports.jsxIdentifier = jsxIdentifier; exports.jSXMemberExpression = exports.jsxMemberExpression = jsxMemberExpression; exports.jSXNamespacedName = exports.jsxNamespacedName = jsxNamespacedName; exports.jSXOpeningElement = exports.jsxOpeningElement = jsxOpeningElement; exports.jSXOpeningFragment = exports.jsxOpeningFragment = jsxOpeningFragment; exports.jSXSpreadAttribute = exports.jsxSpreadAttribute = jsxSpreadAttribute; exports.jSXSpreadChild = exports.jsxSpreadChild = jsxSpreadChild; exports.jSXText = exports.jsxText = jsxText; exports.labeledStatement = labeledStatement; exports.logicalExpression = logicalExpression; exports.memberExpression = memberExpression; exports.metaProperty = metaProperty; exports.mixedTypeAnnotation = mixedTypeAnnotation; exports.moduleExpression = moduleExpression; exports.newExpression = newExpression; exports.noop = noop; exports.nullLiteral = nullLiteral; exports.nullLiteralTypeAnnotation = nullLiteralTypeAnnotation; exports.nullableTypeAnnotation = nullableTypeAnnotation; exports.numberLiteral = NumberLiteral; exports.numberLiteralTypeAnnotation = numberLiteralTypeAnnotation; exports.numberTypeAnnotation = numberTypeAnnotation; exports.numericLiteral = numericLiteral; exports.objectExpression = objectExpression; exports.objectMethod = objectMethod; exports.objectPattern = objectPattern; exports.objectProperty = objectProperty; exports.objectTypeAnnotation = objectTypeAnnotation; exports.objectTypeCallProperty = objectTypeCallProperty; exports.objectTypeIndexer = objectTypeIndexer; exports.objectTypeInternalSlot = objectTypeInternalSlot; exports.objectTypeProperty = objectTypeProperty; exports.objectTypeSpreadProperty = objectTypeSpreadProperty; exports.opaqueType = opaqueType; exports.optionalCallExpression = optionalCallExpression; exports.optionalIndexedAccessType = optionalIndexedAccessType; exports.optionalMemberExpression = optionalMemberExpression; exports.parenthesizedExpression = parenthesizedExpression; exports.pipelineBareFunction = pipelineBareFunction; exports.pipelinePrimaryTopicReference = pipelinePrimaryTopicReference; exports.pipelineTopicExpression = pipelineTopicExpression; exports.placeholder = placeholder; exports.privateName = privateName; exports.program = program; exports.qualifiedTypeIdentifier = qualifiedTypeIdentifier; exports.recordExpression = recordExpression; exports.regExpLiteral = regExpLiteral; exports.regexLiteral = RegexLiteral; exports.restElement = restElement; exports.restProperty = RestProperty; exports.returnStatement = returnStatement; exports.sequenceExpression = sequenceExpression; exports.spreadElement = spreadElement; exports.spreadProperty = SpreadProperty; exports.staticBlock = staticBlock; exports.stringLiteral = stringLiteral; exports.stringLiteralTypeAnnotation = stringLiteralTypeAnnotation; exports.stringTypeAnnotation = stringTypeAnnotation; exports.super = _super; exports.switchCase = switchCase; exports.switchStatement = switchStatement; exports.symbolTypeAnnotation = symbolTypeAnnotation; exports.taggedTemplateExpression = taggedTemplateExpression; exports.templateElement = templateElement; exports.templateLiteral = templateLiteral; exports.thisExpression = thisExpression; exports.thisTypeAnnotation = thisTypeAnnotation; exports.throwStatement = throwStatement; exports.topicReference = topicReference; exports.tryStatement = tryStatement; exports.tSAnyKeyword = exports.tsAnyKeyword = tsAnyKeyword; exports.tSArrayType = exports.tsArrayType = tsArrayType; exports.tSAsExpression = exports.tsAsExpression = tsAsExpression; exports.tSBigIntKeyword = exports.tsBigIntKeyword = tsBigIntKeyword; exports.tSBooleanKeyword = exports.tsBooleanKeyword = tsBooleanKeyword; exports.tSCallSignatureDeclaration = exports.tsCallSignatureDeclaration = tsCallSignatureDeclaration; exports.tSConditionalType = exports.tsConditionalType = tsConditionalType; exports.tSConstructSignatureDeclaration = exports.tsConstructSignatureDeclaration = tsConstructSignatureDeclaration; exports.tSConstructorType = exports.tsConstructorType = tsConstructorType; exports.tSDeclareFunction = exports.tsDeclareFunction = tsDeclareFunction; exports.tSDeclareMethod = exports.tsDeclareMethod = tsDeclareMethod; exports.tSEnumDeclaration = exports.tsEnumDeclaration = tsEnumDeclaration; exports.tSEnumMember = exports.tsEnumMember = tsEnumMember; exports.tSExportAssignment = exports.tsExportAssignment = tsExportAssignment; exports.tSExpressionWithTypeArguments = exports.tsExpressionWithTypeArguments = tsExpressionWithTypeArguments; exports.tSExternalModuleReference = exports.tsExternalModuleReference = tsExternalModuleReference; exports.tSFunctionType = exports.tsFunctionType = tsFunctionType; exports.tSImportEqualsDeclaration = exports.tsImportEqualsDeclaration = tsImportEqualsDeclaration; exports.tSImportType = exports.tsImportType = tsImportType; exports.tSIndexSignature = exports.tsIndexSignature = tsIndexSignature; exports.tSIndexedAccessType = exports.tsIndexedAccessType = tsIndexedAccessType; exports.tSInferType = exports.tsInferType = tsInferType; exports.tSInstantiationExpression = exports.tsInstantiationExpression = tsInstantiationExpression; exports.tSInterfaceBody = exports.tsInterfaceBody = tsInterfaceBody; exports.tSInterfaceDeclaration = exports.tsInterfaceDeclaration = tsInterfaceDeclaration; exports.tSIntersectionType = exports.tsIntersectionType = tsIntersectionType; exports.tSIntrinsicKeyword = exports.tsIntrinsicKeyword = tsIntrinsicKeyword; exports.tSLiteralType = exports.tsLiteralType = tsLiteralType; exports.tSMappedType = exports.tsMappedType = tsMappedType; exports.tSMethodSignature = exports.tsMethodSignature = tsMethodSignature; exports.tSModuleBlock = exports.tsModuleBlock = tsModuleBlock; exports.tSModuleDeclaration = exports.tsModuleDeclaration = tsModuleDeclaration; exports.tSNamedTupleMember = exports.tsNamedTupleMember = tsNamedTupleMember; exports.tSNamespaceExportDeclaration = exports.tsNamespaceExportDeclaration = tsNamespaceExportDeclaration; exports.tSNeverKeyword = exports.tsNeverKeyword = tsNeverKeyword; exports.tSNonNullExpression = exports.tsNonNullExpression = tsNonNullExpression; exports.tSNullKeyword = exports.tsNullKeyword = tsNullKeyword; exports.tSNumberKeyword = exports.tsNumberKeyword = tsNumberKeyword; exports.tSObjectKeyword = exports.tsObjectKeyword = tsObjectKeyword; exports.tSOptionalType = exports.tsOptionalType = tsOptionalType; exports.tSParameterProperty = exports.tsParameterProperty = tsParameterProperty; exports.tSParenthesizedType = exports.tsParenthesizedType = tsParenthesizedType; exports.tSPropertySignature = exports.tsPropertySignature = tsPropertySignature; exports.tSQualifiedName = exports.tsQualifiedName = tsQualifiedName; exports.tSRestType = exports.tsRestType = tsRestType; exports.tSStringKeyword = exports.tsStringKeyword = tsStringKeyword; exports.tSSymbolKeyword = exports.tsSymbolKeyword = tsSymbolKeyword; exports.tSThisType = exports.tsThisType = tsThisType; exports.tSTupleType = exports.tsTupleType = tsTupleType; exports.tSTypeAliasDeclaration = exports.tsTypeAliasDeclaration = tsTypeAliasDeclaration; exports.tSTypeAnnotation = exports.tsTypeAnnotation = tsTypeAnnotation; exports.tSTypeAssertion = exports.tsTypeAssertion = tsTypeAssertion; exports.tSTypeLiteral = exports.tsTypeLiteral = tsTypeLiteral; exports.tSTypeOperator = exports.tsTypeOperator = tsTypeOperator; exports.tSTypeParameter = exports.tsTypeParameter = tsTypeParameter; exports.tSTypeParameterDeclaration = exports.tsTypeParameterDeclaration = tsTypeParameterDeclaration; exports.tSTypeParameterInstantiation = exports.tsTypeParameterInstantiation = tsTypeParameterInstantiation; exports.tSTypePredicate = exports.tsTypePredicate = tsTypePredicate; exports.tSTypeQuery = exports.tsTypeQuery = tsTypeQuery; exports.tSTypeReference = exports.tsTypeReference = tsTypeReference; exports.tSUndefinedKeyword = exports.tsUndefinedKeyword = tsUndefinedKeyword; exports.tSUnionType = exports.tsUnionType = tsUnionType; exports.tSUnknownKeyword = exports.tsUnknownKeyword = tsUnknownKeyword; exports.tSVoidKeyword = exports.tsVoidKeyword = tsVoidKeyword; exports.tupleExpression = tupleExpression; exports.tupleTypeAnnotation = tupleTypeAnnotation; exports.typeAlias = typeAlias; exports.typeAnnotation = typeAnnotation; exports.typeCastExpression = typeCastExpression; exports.typeParameter = typeParameter; exports.typeParameterDeclaration = typeParameterDeclaration; exports.typeParameterInstantiation = typeParameterInstantiation; exports.typeofTypeAnnotation = typeofTypeAnnotation; exports.unaryExpression = unaryExpression; exports.unionTypeAnnotation = unionTypeAnnotation; exports.updateExpression = updateExpression; exports.v8IntrinsicIdentifier = v8IntrinsicIdentifier; exports.variableDeclaration = variableDeclaration; exports.variableDeclarator = variableDeclarator; exports.variance = variance; exports.voidTypeAnnotation = voidTypeAnnotation; exports.whileStatement = whileStatement; exports.withStatement = withStatement; exports.yieldExpression = yieldExpression; var _validateNode = require("../validateNode"); function arrayExpression(elements = []) { return (0, _validateNode.default)({ type: "ArrayExpression", elements }); } function assignmentExpression(operator, left, right) { return (0, _validateNode.default)({ type: "AssignmentExpression", operator, left, right }); } function binaryExpression(operator, left, right) { return (0, _validateNode.default)({ type: "BinaryExpression", operator, left, right }); } function interpreterDirective(value) { return (0, _validateNode.default)({ type: "InterpreterDirective", value }); } function directive(value) { return (0, _validateNode.default)({ type: "Directive", value }); } function directiveLiteral(value) { return (0, _validateNode.default)({ type: "DirectiveLiteral", value }); } function blockStatement(body, directives = []) { return (0, _validateNode.default)({ type: "BlockStatement", body, directives }); } function breakStatement(label = null) { return (0, _validateNode.default)({ type: "BreakStatement", label }); } function callExpression(callee, _arguments) { return (0, _validateNode.default)({ type: "CallExpression", callee, arguments: _arguments }); } function catchClause(param = null, body) { return (0, _validateNode.default)({ type: "CatchClause", param, body }); } function conditionalExpression(test, consequent, alternate) { return (0, _validateNode.default)({ type: "ConditionalExpression", test, consequent, alternate }); } function continueStatement(label = null) { return (0, _validateNode.default)({ type: "ContinueStatement", label }); } function debuggerStatement() { return { type: "DebuggerStatement" }; } function doWhileStatement(test, body) { return (0, _validateNode.default)({ type: "DoWhileStatement", test, body }); } function emptyStatement() { return { type: "EmptyStatement" }; } function expressionStatement(expression) { return (0, _validateNode.default)({ type: "ExpressionStatement", expression }); } function file(program, comments = null, tokens = null) { return (0, _validateNode.default)({ type: "File", program, comments, tokens }); } function forInStatement(left, right, body) { return (0, _validateNode.default)({ type: "ForInStatement", left, right, body }); } function forStatement(init = null, test = null, update = null, body) { return (0, _validateNode.default)({ type: "ForStatement", init, test, update, body }); } function functionDeclaration(id = null, params, body, generator = false, async = false) { return (0, _validateNode.default)({ type: "FunctionDeclaration", id, params, body, generator, async }); } function functionExpression(id = null, params, body, generator = false, async = false) { return (0, _validateNode.default)({ type: "FunctionExpression", id, params, body, generator, async }); } function identifier(name) { return (0, _validateNode.default)({ type: "Identifier", name }); } function ifStatement(test, consequent, alternate = null) { return (0, _validateNode.default)({ type: "IfStatement", test, consequent, alternate }); } function labeledStatement(label, body) { return (0, _validateNode.default)({ type: "LabeledStatement", label, body }); } function stringLiteral(value) { return (0, _validateNode.default)({ type: "StringLiteral", value }); } function numericLiteral(value) { return (0, _validateNode.default)({ type: "NumericLiteral", value }); } function nullLiteral() { return { type: "NullLiteral" }; } function booleanLiteral(value) { return (0, _validateNode.default)({ type: "BooleanLiteral", value }); } function regExpLiteral(pattern, flags = "") { return (0, _validateNode.default)({ type: "RegExpLiteral", pattern, flags }); } function logicalExpression(operator, left, right) { return (0, _validateNode.default)({ type: "LogicalExpression", operator, left, right }); } function memberExpression(object, property, computed = false, optional = null) { return (0, _validateNode.default)({ type: "MemberExpression", object, property, computed, optional }); } function newExpression(callee, _arguments) { return (0, _validateNode.default)({ type: "NewExpression", callee, arguments: _arguments }); } function program(body, directives = [], sourceType = "script", interpreter = null) { return (0, _validateNode.default)({ type: "Program", body, directives, sourceType, interpreter, sourceFile: null }); } function objectExpression(properties) { return (0, _validateNode.default)({ type: "ObjectExpression", properties }); } function objectMethod(kind = "method", key, params, body, computed = false, generator = false, async = false) { return (0, _validateNode.default)({ type: "ObjectMethod", kind, key, params, body, computed, generator, async }); } function objectProperty(key, value, computed = false, shorthand = false, decorators = null) { return (0, _validateNode.default)({ type: "ObjectProperty", key, value, computed, shorthand, decorators }); } function restElement(argument) { return (0, _validateNode.default)({ type: "RestElement", argument }); } function returnStatement(argument = null) { return (0, _validateNode.default)({ type: "ReturnStatement", argument }); } function sequenceExpression(expressions) { return (0, _validateNode.default)({ type: "SequenceExpression", expressions }); } function parenthesizedExpression(expression) { return (0, _validateNode.default)({ type: "ParenthesizedExpression", expression }); } function switchCase(test = null, consequent) { return (0, _validateNode.default)({ type: "SwitchCase", test, consequent }); } function switchStatement(discriminant, cases) { return (0, _validateNode.default)({ type: "SwitchStatement", discriminant, cases }); } function thisExpression() { return { type: "ThisExpression" }; } function throwStatement(argument) { return (0, _validateNode.default)({ type: "ThrowStatement", argument }); } function tryStatement(block, handler = null, finalizer = null) { return (0, _validateNode.default)({ type: "TryStatement", block, handler, finalizer }); } function unaryExpression(operator, argument, prefix = true) { return (0, _validateNode.default)({ type: "UnaryExpression", operator, argument, prefix }); } function updateExpression(operator, argument, prefix = false) { return (0, _validateNode.default)({ type: "UpdateExpression", operator, argument, prefix }); } function variableDeclaration(kind, declarations) { return (0, _validateNode.default)({ type: "VariableDeclaration", kind, declarations }); } function variableDeclarator(id, init = null) { return (0, _validateNode.default)({ type: "VariableDeclarator", id, init }); } function whileStatement(test, body) { return (0, _validateNode.default)({ type: "WhileStatement", test, body }); } function withStatement(object, body) { return (0, _validateNode.default)({ type: "WithStatement", object, body }); } function assignmentPattern(left, right) { return (0, _validateNode.default)({ type: "AssignmentPattern", left, right }); } function arrayPattern(elements) { return (0, _validateNode.default)({ type: "ArrayPattern", elements }); } function arrowFunctionExpression(params, body, async = false) { return (0, _validateNode.default)({ type: "ArrowFunctionExpression", params, body, async, expression: null }); } function classBody(body) { return (0, _validateNode.default)({ type: "ClassBody", body }); } function classExpression(id = null, superClass = null, body, decorators = null) { return (0, _validateNode.default)({ type: "ClassExpression", id, superClass, body, decorators }); } function classDeclaration(id, superClass = null, body, decorators = null) { return (0, _validateNode.default)({ type: "ClassDeclaration", id, superClass, body, decorators }); } function exportAllDeclaration(source) { return (0, _validateNode.default)({ type: "ExportAllDeclaration", source }); } function exportDefaultDeclaration(declaration) { return (0, _validateNode.default)({ type: "ExportDefaultDeclaration", declaration }); } function exportNamedDeclaration(declaration = null, specifiers = [], source = null) { return (0, _validateNode.default)({ type: "ExportNamedDeclaration", declaration, specifiers, source }); } function exportSpecifier(local, exported) { return (0, _validateNode.default)({ type: "ExportSpecifier", local, exported }); } function forOfStatement(left, right, body, _await = false) { return (0, _validateNode.default)({ type: "ForOfStatement", left, right, body, await: _await }); } function importDeclaration(specifiers, source) { return (0, _validateNode.default)({ type: "ImportDeclaration", specifiers, source }); } function importDefaultSpecifier(local) { return (0, _validateNode.default)({ type: "ImportDefaultSpecifier", local }); } function importNamespaceSpecifier(local) { return (0, _validateNode.default)({ type: "ImportNamespaceSpecifier", local }); } function importSpecifier(local, imported) { return (0, _validateNode.default)({ type: "ImportSpecifier", local, imported }); } function metaProperty(meta, property) { return (0, _validateNode.default)({ type: "MetaProperty", meta, property }); } function classMethod(kind = "method", key, params, body, computed = false, _static = false, generator = false, async = false) { return (0, _validateNode.default)({ type: "ClassMethod", kind, key, params, body, computed, static: _static, generator, async }); } function objectPattern(properties) { return (0, _validateNode.default)({ type: "ObjectPattern", properties }); } function spreadElement(argument) { return (0, _validateNode.default)({ type: "SpreadElement", argument }); } function _super() { return { type: "Super" }; } function taggedTemplateExpression(tag, quasi) { return (0, _validateNode.default)({ type: "TaggedTemplateExpression", tag, quasi }); } function templateElement(value, tail = false) { return (0, _validateNode.default)({ type: "TemplateElement", value, tail }); } function templateLiteral(quasis, expressions) { return (0, _validateNode.default)({ type: "TemplateLiteral", quasis, expressions }); } function yieldExpression(argument = null, delegate = false) { return (0, _validateNode.default)({ type: "YieldExpression", argument, delegate }); } function awaitExpression(argument) { return (0, _validateNode.default)({ type: "AwaitExpression", argument }); } function _import() { return { type: "Import" }; } function bigIntLiteral(value) { return (0, _validateNode.default)({ type: "BigIntLiteral", value }); } function exportNamespaceSpecifier(exported) { return (0, _validateNode.default)({ type: "ExportNamespaceSpecifier", exported }); } function optionalMemberExpression(object, property, computed = false, optional) { return (0, _validateNode.default)({ type: "OptionalMemberExpression", object, property, computed, optional }); } function optionalCallExpression(callee, _arguments, optional) { return (0, _validateNode.default)({ type: "OptionalCallExpression", callee, arguments: _arguments, optional }); } function classProperty(key, value = null, typeAnnotation = null, decorators = null, computed = false, _static = false) { return (0, _validateNode.default)({ type: "ClassProperty", key, value, typeAnnotation, decorators, computed, static: _static }); } function classAccessorProperty(key, value = null, typeAnnotation = null, decorators = null, computed = false, _static = false) { return (0, _validateNode.default)({ type: "ClassAccessorProperty", key, value, typeAnnotation, decorators, computed, static: _static }); } function classPrivateProperty(key, value = null, decorators = null, _static) { return (0, _validateNode.default)({ type: "ClassPrivateProperty", key, value, decorators, static: _static }); } function classPrivateMethod(kind = "method", key, params, body, _static = false) { return (0, _validateNode.default)({ type: "ClassPrivateMethod", kind, key, params, body, static: _static }); } function privateName(id) { return (0, _validateNode.default)({ type: "PrivateName", id }); } function staticBlock(body) { return (0, _validateNode.default)({ type: "StaticBlock", body }); } function anyTypeAnnotation() { return { type: "AnyTypeAnnotation" }; } function arrayTypeAnnotation(elementType) { return (0, _validateNode.default)({ type: "ArrayTypeAnnotation", elementType }); } function booleanTypeAnnotation() { return { type: "BooleanTypeAnnotation" }; } function booleanLiteralTypeAnnotation(value) { return (0, _validateNode.default)({ type: "BooleanLiteralTypeAnnotation", value }); } function nullLiteralTypeAnnotation() { return { type: "NullLiteralTypeAnnotation" }; } function classImplements(id, typeParameters = null) { return (0, _validateNode.default)({ type: "ClassImplements", id, typeParameters }); } function declareClass(id, typeParameters = null, _extends = null, body) { return (0, _validateNode.default)({ type: "DeclareClass", id, typeParameters, extends: _extends, body }); } function declareFunction(id) { return (0, _validateNode.default)({ type: "DeclareFunction", id }); } function declareInterface(id, typeParameters = null, _extends = null, body) { return (0, _validateNode.default)({ type: "DeclareInterface", id, typeParameters, extends: _extends, body }); } function declareModule(id, body, kind = null) { return (0, _validateNode.default)({ type: "DeclareModule", id, body, kind }); } function declareModuleExports(typeAnnotation) { return (0, _validateNode.default)({ type: "DeclareModuleExports", typeAnnotation }); } function declareTypeAlias(id, typeParameters = null, right) { return (0, _validateNode.default)({ type: "DeclareTypeAlias", id, typeParameters, right }); } function declareOpaqueType(id, typeParameters = null, supertype = null) { return (0, _validateNode.default)({ type: "DeclareOpaqueType", id, typeParameters, supertype }); } function declareVariable(id) { return (0, _validateNode.default)({ type: "DeclareVariable", id }); } function declareExportDeclaration(declaration = null, specifiers = null, source = null) { return (0, _validateNode.default)({ type: "DeclareExportDeclaration", declaration, specifiers, source }); } function declareExportAllDeclaration(source) { return (0, _validateNode.default)({ type: "DeclareExportAllDeclaration", source }); } function declaredPredicate(value) { return (0, _validateNode.default)({ type: "DeclaredPredicate", value }); } function existsTypeAnnotation() { return { type: "ExistsTypeAnnotation" }; } function functionTypeAnnotation(typeParameters = null, params, rest = null, returnType) { return (0, _validateNode.default)({ type: "FunctionTypeAnnotation", typeParameters, params, rest, returnType }); } function functionTypeParam(name = null, typeAnnotation) { return (0, _validateNode.default)({ type: "FunctionTypeParam", name, typeAnnotation }); } function genericTypeAnnotation(id, typeParameters = null) { return (0, _validateNode.default)({ type: "GenericTypeAnnotation", id, typeParameters }); } function inferredPredicate() { return { type: "InferredPredicate" }; } function interfaceExtends(id, typeParameters = null) { return (0, _validateNode.default)({ type: "InterfaceExtends", id, typeParameters }); } function interfaceDeclaration(id, typeParameters = null, _extends = null, body) { return (0, _validateNode.default)({ type: "InterfaceDeclaration", id, typeParameters, extends: _extends, body }); } function interfaceTypeAnnotation(_extends = null, body) { return (0, _validateNode.default)({ type: "InterfaceTypeAnnotation", extends: _extends, body }); } function intersectionTypeAnnotation(types) { return (0, _validateNode.default)({ type: "IntersectionTypeAnnotation", types }); } function mixedTypeAnnotation() { return { type: "MixedTypeAnnotation" }; } function emptyTypeAnnotation() { return { type: "EmptyTypeAnnotation" }; } function nullableTypeAnnotation(typeAnnotation) { return (0, _validateNode.default)({ type: "NullableTypeAnnotation", typeAnnotation }); } function numberLiteralTypeAnnotation(value) { return (0, _validateNode.default)({ type: "NumberLiteralTypeAnnotation", value }); } function numberTypeAnnotation() { return { type: "NumberTypeAnnotation" }; } function objectTypeAnnotation(properties, indexers = [], callProperties = [], internalSlots = [], exact = false) { return (0, _validateNode.default)({ type: "ObjectTypeAnnotation", properties, indexers, callProperties, internalSlots, exact }); } function objectTypeInternalSlot(id, value, optional, _static, method) { return (0, _validateNode.default)({ type: "ObjectTypeInternalSlot", id, value, optional, static: _static, method }); } function objectTypeCallProperty(value) { return (0, _validateNode.default)({ type: "ObjectTypeCallProperty", value, static: null }); } function objectTypeIndexer(id = null, key, value, variance = null) { return (0, _validateNode.default)({ type: "ObjectTypeIndexer", id, key, value, variance, static: null }); } function objectTypeProperty(key, value, variance = null) { return (0, _validateNode.default)({ type: "ObjectTypeProperty", key, value, variance, kind: null, method: null, optional: null, proto: null, static: null }); } function objectTypeSpreadProperty(argument) { return (0, _validateNode.default)({ type: "ObjectTypeSpreadProperty", argument }); } function opaqueType(id, typeParameters = null, supertype = null, impltype) { return (0, _validateNode.default)({ type: "OpaqueType", id, typeParameters, supertype, impltype }); } function qualifiedTypeIdentifier(id, qualification) { return (0, _validateNode.default)({ type: "QualifiedTypeIdentifier", id, qualification }); } function stringLiteralTypeAnnotation(value) { return (0, _validateNode.default)({ type: "StringLiteralTypeAnnotation", value }); } function stringTypeAnnotation() { return { type: "StringTypeAnnotation" }; } function symbolTypeAnnotation() { return { type: "SymbolTypeAnnotation" }; } function thisTypeAnnotation() { return { type: "ThisTypeAnnotation" }; } function tupleTypeAnnotation(types) { return (0, _validateNode.default)({ type: "TupleTypeAnnotation", types }); } function typeofTypeAnnotation(argument) { return (0, _validateNode.default)({ type: "TypeofTypeAnnotation", argument }); } function typeAlias(id, typeParameters = null, right) { return (0, _validateNode.default)({ type: "TypeAlias", id, typeParameters, right }); } function typeAnnotation(typeAnnotation) { return (0, _validateNode.default)({ type: "TypeAnnotation", typeAnnotation }); } function typeCastExpression(expression, typeAnnotation) { return (0, _validateNode.default)({ type: "TypeCastExpression", expression, typeAnnotation }); } function typeParameter(bound = null, _default = null, variance = null) { return (0, _validateNode.default)({ type: "TypeParameter", bound, default: _default, variance, name: null }); } function typeParameterDeclaration(params) { return (0, _validateNode.default)({ type: "TypeParameterDeclaration", params }); } function typeParameterInstantiation(params) { return (0, _validateNode.default)({ type: "TypeParameterInstantiation", params }); } function unionTypeAnnotation(types) { return (0, _validateNode.default)({ type: "UnionTypeAnnotation", types }); } function variance(kind) { return (0, _validateNode.default)({ type: "Variance", kind }); } function voidTypeAnnotation() { return { type: "VoidTypeAnnotation" }; } function enumDeclaration(id, body) { return (0, _validateNode.default)({ type: "EnumDeclaration", id, body }); } function enumBooleanBody(members) { return (0, _validateNode.default)({ type: "EnumBooleanBody", members, explicitType: null, hasUnknownMembers: null }); } function enumNumberBody(members) { return (0, _validateNode.default)({ type: "EnumNumberBody", members, explicitType: null, hasUnknownMembers: null }); } function enumStringBody(members) { return (0, _validateNode.default)({ type: "EnumStringBody", members, explicitType: null, hasUnknownMembers: null }); } function enumSymbolBody(members) { return (0, _validateNode.default)({ type: "EnumSymbolBody", members, hasUnknownMembers: null }); } function enumBooleanMember(id) { return (0, _validateNode.default)({ type: "EnumBooleanMember", id, init: null }); } function enumNumberMember(id, init) { return (0, _validateNode.default)({ type: "EnumNumberMember", id, init }); } function enumStringMember(id, init) { return (0, _validateNode.default)({ type: "EnumStringMember", id, init }); } function enumDefaultedMember(id) { return (0, _validateNode.default)({ type: "EnumDefaultedMember", id }); } function indexedAccessType(objectType, indexType) { return (0, _validateNode.default)({ type: "IndexedAccessType", objectType, indexType }); } function optionalIndexedAccessType(objectType, indexType) { return (0, _validateNode.default)({ type: "OptionalIndexedAccessType", objectType, indexType, optional: null }); } function jsxAttribute(name, value = null) { return (0, _validateNode.default)({ type: "JSXAttribute", name, value }); } function jsxClosingElement(name) { return (0, _validateNode.default)({ type: "JSXClosingElement", name }); } function jsxElement(openingElement, closingElement = null, children, selfClosing = null) { return (0, _validateNode.default)({ type: "JSXElement", openingElement, closingElement, children, selfClosing }); } function jsxEmptyExpression() { return { type: "JSXEmptyExpression" }; } function jsxExpressionContainer(expression) { return (0, _validateNode.default)({ type: "JSXExpressionContainer", expression }); } function jsxSpreadChild(expression) { return (0, _validateNode.default)({ type: "JSXSpreadChild", expression }); } function jsxIdentifier(name) { return (0, _validateNode.default)({ type: "JSXIdentifier", name }); } function jsxMemberExpression(object, property) { return (0, _validateNode.default)({ type: "JSXMemberExpression", object, property }); } function jsxNamespacedName(namespace, name) { return (0, _validateNode.default)({ type: "JSXNamespacedName", namespace, name }); } function jsxOpeningElement(name, attributes, selfClosing = false) { return (0, _validateNode.default)({ type: "JSXOpeningElement", name, attributes, selfClosing }); } function jsxSpreadAttribute(argument) { return (0, _validateNode.default)({ type: "JSXSpreadAttribute", argument }); } function jsxText(value) { return (0, _validateNode.default)({ type: "JSXText", value }); } function jsxFragment(openingFragment, closingFragment, children) { return (0, _validateNode.default)({ type: "JSXFragment", openingFragment, closingFragment, children }); } function jsxOpeningFragment() { return { type: "JSXOpeningFragment" }; } function jsxClosingFragment() { return { type: "JSXClosingFragment" }; } function noop() { return { type: "Noop" }; } function placeholder(expectedNode, name) { return (0, _validateNode.default)({ type: "Placeholder", expectedNode, name }); } function v8IntrinsicIdentifier(name) { return (0, _validateNode.default)({ type: "V8IntrinsicIdentifier", name }); } function argumentPlaceholder() { return { type: "ArgumentPlaceholder" }; } function bindExpression(object, callee) { return (0, _validateNode.default)({ type: "BindExpression", object, callee }); } function importAttribute(key, value) { return (0, _validateNode.default)({ type: "ImportAttribute", key, value }); } function decorator(expression) { return (0, _validateNode.default)({ type: "Decorator", expression }); } function doExpression(body, async = false) { return (0, _validateNode.default)({ type: "DoExpression", body, async }); } function exportDefaultSpecifier(exported) { return (0, _validateNode.default)({ type: "ExportDefaultSpecifier", exported }); } function recordExpression(properties) { return (0, _validateNode.default)({ type: "RecordExpression", properties }); } function tupleExpression(elements = []) { return (0, _validateNode.default)({ type: "TupleExpression", elements }); } function decimalLiteral(value) { return (0, _validateNode.default)({ type: "DecimalLiteral", value }); } function moduleExpression(body) { return (0, _validateNode.default)({ type: "ModuleExpression", body }); } function topicReference() { return { type: "TopicReference" }; } function pipelineTopicExpression(expression) { return (0, _validateNode.default)({ type: "PipelineTopicExpression", expression }); } function pipelineBareFunction(callee) { return (0, _validateNode.default)({ type: "PipelineBareFunction", callee }); } function pipelinePrimaryTopicReference() { return { type: "PipelinePrimaryTopicReference" }; } function tsParameterProperty(parameter) { return (0, _validateNode.default)({ type: "TSParameterProperty", parameter }); } function tsDeclareFunction(id = null, typeParameters = null, params, returnType = null) { return (0, _validateNode.default)({ type: "TSDeclareFunction", id, typeParameters, params, returnType }); } function tsDeclareMethod(decorators = null, key, typeParameters = null, params, returnType = null) { return (0, _validateNode.default)({ type: "TSDeclareMethod", decorators, key, typeParameters, params, returnType }); } function tsQualifiedName(left, right) { return (0, _validateNode.default)({ type: "TSQualifiedName", left, right }); } function tsCallSignatureDeclaration(typeParameters = null, parameters, typeAnnotation = null) { return (0, _validateNode.default)({ type: "TSCallSignatureDeclaration", typeParameters, parameters, typeAnnotation }); } function tsConstructSignatureDeclaration(typeParameters = null, parameters, typeAnnotation = null) { return (0, _validateNode.default)({ type: "TSConstructSignatureDeclaration", typeParameters, parameters, typeAnnotation }); } function tsPropertySignature(key, typeAnnotation = null, initializer = null) { return (0, _validateNode.default)({ type: "TSPropertySignature", key, typeAnnotation, initializer, kind: null }); } function tsMethodSignature(key, typeParameters = null, parameters, typeAnnotation = null) { return (0, _validateNode.default)({ type: "TSMethodSignature", key, typeParameters, parameters, typeAnnotation, kind: null }); } function tsIndexSignature(parameters, typeAnnotation = null) { return (0, _validateNode.default)({ type: "TSIndexSignature", parameters, typeAnnotation }); } function tsAnyKeyword() { return { type: "TSAnyKeyword" }; } function tsBooleanKeyword() { return { type: "TSBooleanKeyword" }; } function tsBigIntKeyword() { return { type: "TSBigIntKeyword" }; } function tsIntrinsicKeyword() { return { type: "TSIntrinsicKeyword" }; } function tsNeverKeyword() { return { type: "TSNeverKeyword" }; } function tsNullKeyword() { return { type: "TSNullKeyword" }; } function tsNumberKeyword() { return { type: "TSNumberKeyword" }; } function tsObjectKeyword() { return { type: "TSObjectKeyword" }; } function tsStringKeyword() { return { type: "TSStringKeyword" }; } function tsSymbolKeyword() { return { type: "TSSymbolKeyword" }; } function tsUndefinedKeyword() { return { type: "TSUndefinedKeyword" }; } function tsUnknownKeyword() { return { type: "TSUnknownKeyword" }; } function tsVoidKeyword() { return { type: "TSVoidKeyword" }; } function tsThisType() { return { type: "TSThisType" }; } function tsFunctionType(typeParameters = null, parameters, typeAnnotation = null) { return (0, _validateNode.default)({ type: "TSFunctionType", typeParameters, parameters, typeAnnotation }); } function tsConstructorType(typeParameters = null, parameters, typeAnnotation = null) { return (0, _validateNode.default)({ type: "TSConstructorType", typeParameters, parameters, typeAnnotation }); } function tsTypeReference(typeName, typeParameters = null) { return (0, _validateNode.default)({ type: "TSTypeReference", typeName, typeParameters }); } function tsTypePredicate(parameterName, typeAnnotation = null, asserts = null) { return (0, _validateNode.default)({ type: "TSTypePredicate", parameterName, typeAnnotation, asserts }); } function tsTypeQuery(exprName, typeParameters = null) { return (0, _validateNode.default)({ type: "TSTypeQuery", exprName, typeParameters }); } function tsTypeLiteral(members) { return (0, _validateNode.default)({ type: "TSTypeLiteral", members }); } function tsArrayType(elementType) { return (0, _validateNode.default)({ type: "TSArrayType", elementType }); } function tsTupleType(elementTypes) { return (0, _validateNode.default)({ type: "TSTupleType", elementTypes }); } function tsOptionalType(typeAnnotation) { return (0, _validateNode.default)({ type: "TSOptionalType", typeAnnotation }); } function tsRestType(typeAnnotation) { return (0, _validateNode.default)({ type: "TSRestType", typeAnnotation }); } function tsNamedTupleMember(label, elementType, optional = false) { return (0, _validateNode.default)({ type: "TSNamedTupleMember", label, elementType, optional }); } function tsUnionType(types) { return (0, _validateNode.default)({ type: "TSUnionType", types }); } function tsIntersectionType(types) { return (0, _validateNode.default)({ type: "TSIntersectionType", types }); } function tsConditionalType(checkType, extendsType, trueType, falseType) { return (0, _validateNode.default)({ type: "TSConditionalType", checkType, extendsType, trueType, falseType }); } function tsInferType(typeParameter) { return (0, _validateNode.default)({ type: "TSInferType", typeParameter }); } function tsParenthesizedType(typeAnnotation) { return (0, _validateNode.default)({ type: "TSParenthesizedType", typeAnnotation }); } function tsTypeOperator(typeAnnotation) { return (0, _validateNode.default)({ type: "TSTypeOperator", typeAnnotation, operator: null }); } function tsIndexedAccessType(objectType, indexType) { return (0, _validateNode.default)({ type: "TSIndexedAccessType", objectType, indexType }); } function tsMappedType(typeParameter, typeAnnotation = null, nameType = null) { return (0, _validateNode.default)({ type: "TSMappedType", typeParameter, typeAnnotation, nameType }); } function tsLiteralType(literal) { return (0, _validateNode.default)({ type: "TSLiteralType", literal }); } function tsExpressionWithTypeArguments(expression, typeParameters = null) { return (0, _validateNode.default)({ type: "TSExpressionWithTypeArguments", expression, typeParameters }); } function tsInterfaceDeclaration(id, typeParameters = null, _extends = null, body) { return (0, _validateNode.default)({ type: "TSInterfaceDeclaration", id, typeParameters, extends: _extends, body }); } function tsInterfaceBody(body) { return (0, _validateNode.default)({ type: "TSInterfaceBody", body }); } function tsTypeAliasDeclaration(id, typeParameters = null, typeAnnotation) { return (0, _validateNode.default)({ type: "TSTypeAliasDeclaration", id, typeParameters, typeAnnotation }); } function tsInstantiationExpression(expression, typeParameters = null) { return (0, _validateNode.default)({ type: "TSInstantiationExpression", expression, typeParameters }); } function tsAsExpression(expression, typeAnnotation) { return (0, _validateNode.default)({ type: "TSAsExpression", expression, typeAnnotation }); } function tsTypeAssertion(typeAnnotation, expression) { return (0, _validateNode.default)({ type: "TSTypeAssertion", typeAnnotation, expression }); } function tsEnumDeclaration(id, members) { return (0, _validateNode.default)({ type: "TSEnumDeclaration", id, members }); } function tsEnumMember(id, initializer = null) { return (0, _validateNode.default)({ type: "TSEnumMember", id, initializer }); } function tsModuleDeclaration(id, body) { return (0, _validateNode.default)({ type: "TSModuleDeclaration", id, body }); } function tsModuleBlock(body) { return (0, _validateNode.default)({ type: "TSModuleBlock", body }); } function tsImportType(argument, qualifier = null, typeParameters = null) { return (0, _validateNode.default)({ type: "TSImportType", argument, qualifier, typeParameters }); } function tsImportEqualsDeclaration(id, moduleReference) { return (0, _validateNode.default)({ type: "TSImportEqualsDeclaration", id, moduleReference, isExport: null }); } function tsExternalModuleReference(expression) { return (0, _validateNode.default)({ type: "TSExternalModuleReference", expression }); } function tsNonNullExpression(expression) { return (0, _validateNode.default)({ type: "TSNonNullExpression", expression }); } function tsExportAssignment(expression) { return (0, _validateNode.default)({ type: "TSExportAssignment", expression }); } function tsNamespaceExportDeclaration(id) { return (0, _validateNode.default)({ type: "TSNamespaceExportDeclaration", id }); } function tsTypeAnnotation(typeAnnotation) { return (0, _validateNode.default)({ type: "TSTypeAnnotation", typeAnnotation }); } function tsTypeParameterInstantiation(params) { return (0, _validateNode.default)({ type: "TSTypeParameterInstantiation", params }); } function tsTypeParameterDeclaration(params) { return (0, _validateNode.default)({ type: "TSTypeParameterDeclaration", params }); } function tsTypeParameter(constraint = null, _default = null, name) { return (0, _validateNode.default)({ type: "TSTypeParameter", constraint, default: _default, name }); } function NumberLiteral(value) { console.trace("The node type NumberLiteral has been renamed to NumericLiteral"); return numericLiteral(value); } function RegexLiteral(pattern, flags = "") { console.trace("The node type RegexLiteral has been renamed to RegExpLiteral"); return regExpLiteral(pattern, flags); } function RestProperty(argument) { console.trace("The node type RestProperty has been renamed to RestElement"); return restElement(argument); } function SpreadProperty(argument) { console.trace("The node type SpreadProperty has been renamed to SpreadElement"); return spreadElement(argument); } },{"../validateNode":93}],90:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); Object.defineProperty(exports, "AnyTypeAnnotation", { enumerable: true, get: function () { return _index.anyTypeAnnotation; } }); Object.defineProperty(exports, "ArgumentPlaceholder", { enumerable: true, get: function () { return _index.argumentPlaceholder; } }); Object.defineProperty(exports, "ArrayExpression", { enumerable: true, get: function () { return _index.arrayExpression; } }); Object.defineProperty(exports, "ArrayPattern", { enumerable: true, get: function () { return _index.arrayPattern; } }); Object.defineProperty(exports, "ArrayTypeAnnotation", { enumerable: true, get: function () { return _index.arrayTypeAnnotation; } }); Object.defineProperty(exports, "ArrowFunctionExpression", { enumerable: true, get: function () { return _index.arrowFunctionExpression; } }); Object.defineProperty(exports, "AssignmentExpression", { enumerable: true, get: function () { return _index.assignmentExpression; } }); Object.defineProperty(exports, "AssignmentPattern", { enumerable: true, get: function () { return _index.assignmentPattern; } }); Object.defineProperty(exports, "AwaitExpression", { enumerable: true, get: function () { return _index.awaitExpression; } }); Object.defineProperty(exports, "BigIntLiteral", { enumerable: true, get: function () { return _index.bigIntLiteral; } }); Object.defineProperty(exports, "BinaryExpression", { enumerable: true, get: function () { return _index.binaryExpression; } }); Object.defineProperty(exports, "BindExpression", { enumerable: true, get: function () { return _index.bindExpression; } }); Object.defineProperty(exports, "BlockStatement", { enumerable: true, get: function () { return _index.blockStatement; } }); Object.defineProperty(exports, "BooleanLiteral", { enumerable: true, get: function () { return _index.booleanLiteral; } }); Object.defineProperty(exports, "BooleanLiteralTypeAnnotation", { enumerable: true, get: function () { return _index.booleanLiteralTypeAnnotation; } }); Object.defineProperty(exports, "BooleanTypeAnnotation", { enumerable: true, get: function () { return _index.booleanTypeAnnotation; } }); Object.defineProperty(exports, "BreakStatement", { enumerable: true, get: function () { return _index.breakStatement; } }); Object.defineProperty(exports, "CallExpression", { enumerable: true, get: function () { return _index.callExpression; } }); Object.defineProperty(exports, "CatchClause", { enumerable: true, get: function () { return _index.catchClause; } }); Object.defineProperty(exports, "ClassAccessorProperty", { enumerable: true, get: function () { return _index.classAccessorProperty; } }); Object.defineProperty(exports, "ClassBody", { enumerable: true, get: function () { return _index.classBody; } }); Object.defineProperty(exports, "ClassDeclaration", { enumerable: true, get: function () { return _index.classDeclaration; } }); Object.defineProperty(exports, "ClassExpression", { enumerable: true, get: function () { return _index.classExpression; } }); Object.defineProperty(exports, "ClassImplements", { enumerable: true, get: function () { return _index.classImplements; } }); Object.defineProperty(exports, "ClassMethod", { enumerable: true, get: function () { return _index.classMethod; } }); Object.defineProperty(exports, "ClassPrivateMethod", { enumerable: true, get: function () { return _index.classPrivateMethod; } }); Object.defineProperty(exports, "ClassPrivateProperty", { enumerable: true, get: function () { return _index.classPrivateProperty; } }); Object.defineProperty(exports, "ClassProperty", { enumerable: true, get: function () { return _index.classProperty; } }); Object.defineProperty(exports, "ConditionalExpression", { enumerable: true, get: function () { return _index.conditionalExpression; } }); Object.defineProperty(exports, "ContinueStatement", { enumerable: true, get: function () { return _index.continueStatement; } }); Object.defineProperty(exports, "DebuggerStatement", { enumerable: true, get: function () { return _index.debuggerStatement; } }); Object.defineProperty(exports, "DecimalLiteral", { enumerable: true, get: function () { return _index.decimalLiteral; } }); Object.defineProperty(exports, "DeclareClass", { enumerable: true, get: function () { return _index.declareClass; } }); Object.defineProperty(exports, "DeclareExportAllDeclaration", { enumerable: true, get: function () { return _index.declareExportAllDeclaration; } }); Object.defineProperty(exports, "DeclareExportDeclaration", { enumerable: true, get: function () { return _index.declareExportDeclaration; } }); Object.defineProperty(exports, "DeclareFunction", { enumerable: true, get: function () { return _index.declareFunction; } }); Object.defineProperty(exports, "DeclareInterface", { enumerable: true, get: function () { return _index.declareInterface; } }); Object.defineProperty(exports, "DeclareModule", { enumerable: true, get: function () { return _index.declareModule; } }); Object.defineProperty(exports, "DeclareModuleExports", { enumerable: true, get: function () { return _index.declareModuleExports; } }); Object.defineProperty(exports, "DeclareOpaqueType", { enumerable: true, get: function () { return _index.declareOpaqueType; } }); Object.defineProperty(exports, "DeclareTypeAlias", { enumerable: true, get: function () { return _index.declareTypeAlias; } }); Object.defineProperty(exports, "DeclareVariable", { enumerable: true, get: function () { return _index.declareVariable; } }); Object.defineProperty(exports, "DeclaredPredicate", { enumerable: true, get: function () { return _index.declaredPredicate; } }); Object.defineProperty(exports, "Decorator", { enumerable: true, get: function () { return _index.decorator; } }); Object.defineProperty(exports, "Directive", { enumerable: true, get: function () { return _index.directive; } }); Object.defineProperty(exports, "DirectiveLiteral", { enumerable: true, get: function () { return _index.directiveLiteral; } }); Object.defineProperty(exports, "DoExpression", { enumerable: true, get: function () { return _index.doExpression; } }); Object.defineProperty(exports, "DoWhileStatement", { enumerable: true, get: function () { return _index.doWhileStatement; } }); Object.defineProperty(exports, "EmptyStatement", { enumerable: true, get: function () { return _index.emptyStatement; } }); Object.defineProperty(exports, "EmptyTypeAnnotation", { enumerable: true, get: function () { return _index.emptyTypeAnnotation; } }); Object.defineProperty(exports, "EnumBooleanBody", { enumerable: true, get: function () { return _index.enumBooleanBody; } }); Object.defineProperty(exports, "EnumBooleanMember", { enumerable: true, get: function () { return _index.enumBooleanMember; } }); Object.defineProperty(exports, "EnumDeclaration", { enumerable: true, get: function () { return _index.enumDeclaration; } }); Object.defineProperty(exports, "EnumDefaultedMember", { enumerable: true, get: function () { return _index.enumDefaultedMember; } }); Object.defineProperty(exports, "EnumNumberBody", { enumerable: true, get: function () { return _index.enumNumberBody; } }); Object.defineProperty(exports, "EnumNumberMember", { enumerable: true, get: function () { return _index.enumNumberMember; } }); Object.defineProperty(exports, "EnumStringBody", { enumerable: true, get: function () { return _index.enumStringBody; } }); Object.defineProperty(exports, "EnumStringMember", { enumerable: true, get: function () { return _index.enumStringMember; } }); Object.defineProperty(exports, "EnumSymbolBody", { enumerable: true, get: function () { return _index.enumSymbolBody; } }); Object.defineProperty(exports, "ExistsTypeAnnotation", { enumerable: true, get: function () { return _index.existsTypeAnnotation; } }); Object.defineProperty(exports, "ExportAllDeclaration", { enumerable: true, get: function () { return _index.exportAllDeclaration; } }); Object.defineProperty(exports, "ExportDefaultDeclaration", { enumerable: true, get: function () { return _index.exportDefaultDeclaration; } }); Object.defineProperty(exports, "ExportDefaultSpecifier", { enumerable: true, get: function () { return _index.exportDefaultSpecifier; } }); Object.defineProperty(exports, "ExportNamedDeclaration", { enumerable: true, get: function () { return _index.exportNamedDeclaration; } }); Object.defineProperty(exports, "ExportNamespaceSpecifier", { enumerable: true, get: function () { return _index.exportNamespaceSpecifier; } }); Object.defineProperty(exports, "ExportSpecifier", { enumerable: true, get: function () { return _index.exportSpecifier; } }); Object.defineProperty(exports, "ExpressionStatement", { enumerable: true, get: function () { return _index.expressionStatement; } }); Object.defineProperty(exports, "File", { enumerable: true, get: function () { return _index.file; } }); Object.defineProperty(exports, "ForInStatement", { enumerable: true, get: function () { return _index.forInStatement; } }); Object.defineProperty(exports, "ForOfStatement", { enumerable: true, get: function () { return _index.forOfStatement; } }); Object.defineProperty(exports, "ForStatement", { enumerable: true, get: function () { return _index.forStatement; } }); Object.defineProperty(exports, "FunctionDeclaration", { enumerable: true, get: function () { return _index.functionDeclaration; } }); Object.defineProperty(exports, "FunctionExpression", { enumerable: true, get: function () { return _index.functionExpression; } }); Object.defineProperty(exports, "FunctionTypeAnnotation", { enumerable: true, get: function () { return _index.functionTypeAnnotation; } }); Object.defineProperty(exports, "FunctionTypeParam", { enumerable: true, get: function () { return _index.functionTypeParam; } }); Object.defineProperty(exports, "GenericTypeAnnotation", { enumerable: true, get: function () { return _index.genericTypeAnnotation; } }); Object.defineProperty(exports, "Identifier", { enumerable: true, get: function () { return _index.identifier; } }); Object.defineProperty(exports, "IfStatement", { enumerable: true, get: function () { return _index.ifStatement; } }); Object.defineProperty(exports, "Import", { enumerable: true, get: function () { return _index.import; } }); Object.defineProperty(exports, "ImportAttribute", { enumerable: true, get: function () { return _index.importAttribute; } }); Object.defineProperty(exports, "ImportDeclaration", { enumerable: true, get: function () { return _index.importDeclaration; } }); Object.defineProperty(exports, "ImportDefaultSpecifier", { enumerable: true, get: function () { return _index.importDefaultSpecifier; } }); Object.defineProperty(exports, "ImportNamespaceSpecifier", { enumerable: true, get: function () { return _index.importNamespaceSpecifier; } }); Object.defineProperty(exports, "ImportSpecifier", { enumerable: true, get: function () { return _index.importSpecifier; } }); Object.defineProperty(exports, "IndexedAccessType", { enumerable: true, get: function () { return _index.indexedAccessType; } }); Object.defineProperty(exports, "InferredPredicate", { enumerable: true, get: function () { return _index.inferredPredicate; } }); Object.defineProperty(exports, "InterfaceDeclaration", { enumerable: true, get: function () { return _index.interfaceDeclaration; } }); Object.defineProperty(exports, "InterfaceExtends", { enumerable: true, get: function () { return _index.interfaceExtends; } }); Object.defineProperty(exports, "InterfaceTypeAnnotation", { enumerable: true, get: function () { return _index.interfaceTypeAnnotation; } }); Object.defineProperty(exports, "InterpreterDirective", { enumerable: true, get: function () { return _index.interpreterDirective; } }); Object.defineProperty(exports, "IntersectionTypeAnnotation", { enumerable: true, get: function () { return _index.intersectionTypeAnnotation; } }); Object.defineProperty(exports, "JSXAttribute", { enumerable: true, get: function () { return _index.jsxAttribute; } }); Object.defineProperty(exports, "JSXClosingElement", { enumerable: true, get: function () { return _index.jsxClosingElement; } }); Object.defineProperty(exports, "JSXClosingFragment", { enumerable: true, get: function () { return _index.jsxClosingFragment; } }); Object.defineProperty(exports, "JSXElement", { enumerable: true, get: function () { return _index.jsxElement; } }); Object.defineProperty(exports, "JSXEmptyExpression", { enumerable: true, get: function () { return _index.jsxEmptyExpression; } }); Object.defineProperty(exports, "JSXExpressionContainer", { enumerable: true, get: function () { return _index.jsxExpressionContainer; } }); Object.defineProperty(exports, "JSXFragment", { enumerable: true, get: function () { return _index.jsxFragment; } }); Object.defineProperty(exports, "JSXIdentifier", { enumerable: true, get: function () { return _index.jsxIdentifier; } }); Object.defineProperty(exports, "JSXMemberExpression", { enumerable: true, get: function () { return _index.jsxMemberExpression; } }); Object.defineProperty(exports, "JSXNamespacedName", { enumerable: true, get: function () { return _index.jsxNamespacedName; } }); Object.defineProperty(exports, "JSXOpeningElement", { enumerable: true, get: function () { return _index.jsxOpeningElement; } }); Object.defineProperty(exports, "JSXOpeningFragment", { enumerable: true, get: function () { return _index.jsxOpeningFragment; } }); Object.defineProperty(exports, "JSXSpreadAttribute", { enumerable: true, get: function () { return _index.jsxSpreadAttribute; } }); Object.defineProperty(exports, "JSXSpreadChild", { enumerable: true, get: function () { return _index.jsxSpreadChild; } }); Object.defineProperty(exports, "JSXText", { enumerable: true, get: function () { return _index.jsxText; } }); Object.defineProperty(exports, "LabeledStatement", { enumerable: true, get: function () { return _index.labeledStatement; } }); Object.defineProperty(exports, "LogicalExpression", { enumerable: true, get: function () { return _index.logicalExpression; } }); Object.defineProperty(exports, "MemberExpression", { enumerable: true, get: function () { return _index.memberExpression; } }); Object.defineProperty(exports, "MetaProperty", { enumerable: true, get: function () { return _index.metaProperty; } }); Object.defineProperty(exports, "MixedTypeAnnotation", { enumerable: true, get: function () { return _index.mixedTypeAnnotation; } }); Object.defineProperty(exports, "ModuleExpression", { enumerable: true, get: function () { return _index.moduleExpression; } }); Object.defineProperty(exports, "NewExpression", { enumerable: true, get: function () { return _index.newExpression; } }); Object.defineProperty(exports, "Noop", { enumerable: true, get: function () { return _index.noop; } }); Object.defineProperty(exports, "NullLiteral", { enumerable: true, get: function () { return _index.nullLiteral; } }); Object.defineProperty(exports, "NullLiteralTypeAnnotation", { enumerable: true, get: function () { return _index.nullLiteralTypeAnnotation; } }); Object.defineProperty(exports, "NullableTypeAnnotation", { enumerable: true, get: function () { return _index.nullableTypeAnnotation; } }); Object.defineProperty(exports, "NumberLiteral", { enumerable: true, get: function () { return _index.numberLiteral; } }); Object.defineProperty(exports, "NumberLiteralTypeAnnotation", { enumerable: true, get: function () { return _index.numberLiteralTypeAnnotation; } }); Object.defineProperty(exports, "NumberTypeAnnotation", { enumerable: true, get: function () { return _index.numberTypeAnnotation; } }); Object.defineProperty(exports, "NumericLiteral", { enumerable: true, get: function () { return _index.numericLiteral; } }); Object.defineProperty(exports, "ObjectExpression", { enumerable: true, get: function () { return _index.objectExpression; } }); Object.defineProperty(exports, "ObjectMethod", { enumerable: true, get: function () { return _index.objectMethod; } }); Object.defineProperty(exports, "ObjectPattern", { enumerable: true, get: function () { return _index.objectPattern; } }); Object.defineProperty(exports, "ObjectProperty", { enumerable: true, get: function () { return _index.objectProperty; } }); Object.defineProperty(exports, "ObjectTypeAnnotation", { enumerable: true, get: function () { return _index.objectTypeAnnotation; } }); Object.defineProperty(exports, "ObjectTypeCallProperty", { enumerable: true, get: function () { return _index.objectTypeCallProperty; } }); Object.defineProperty(exports, "ObjectTypeIndexer", { enumerable: true, get: function () { return _index.objectTypeIndexer; } }); Object.defineProperty(exports, "ObjectTypeInternalSlot", { enumerable: true, get: function () { return _index.objectTypeInternalSlot; } }); Object.defineProperty(exports, "ObjectTypeProperty", { enumerable: true, get: function () { return _index.objectTypeProperty; } }); Object.defineProperty(exports, "ObjectTypeSpreadProperty", { enumerable: true, get: function () { return _index.objectTypeSpreadProperty; } }); Object.defineProperty(exports, "OpaqueType", { enumerable: true, get: function () { return _index.opaqueType; } }); Object.defineProperty(exports, "OptionalCallExpression", { enumerable: true, get: function () { return _index.optionalCallExpression; } }); Object.defineProperty(exports, "OptionalIndexedAccessType", { enumerable: true, get: function () { return _index.optionalIndexedAccessType; } }); Object.defineProperty(exports, "OptionalMemberExpression", { enumerable: true, get: function () { return _index.optionalMemberExpression; } }); Object.defineProperty(exports, "ParenthesizedExpression", { enumerable: true, get: function () { return _index.parenthesizedExpression; } }); Object.defineProperty(exports, "PipelineBareFunction", { enumerable: true, get: function () { return _index.pipelineBareFunction; } }); Object.defineProperty(exports, "PipelinePrimaryTopicReference", { enumerable: true, get: function () { return _index.pipelinePrimaryTopicReference; } }); Object.defineProperty(exports, "PipelineTopicExpression", { enumerable: true, get: function () { return _index.pipelineTopicExpression; } }); Object.defineProperty(exports, "Placeholder", { enumerable: true, get: function () { return _index.placeholder; } }); Object.defineProperty(exports, "PrivateName", { enumerable: true, get: function () { return _index.privateName; } }); Object.defineProperty(exports, "Program", { enumerable: true, get: function () { return _index.program; } }); Object.defineProperty(exports, "QualifiedTypeIdentifier", { enumerable: true, get: function () { return _index.qualifiedTypeIdentifier; } }); Object.defineProperty(exports, "RecordExpression", { enumerable: true, get: function () { return _index.recordExpression; } }); Object.defineProperty(exports, "RegExpLiteral", { enumerable: true, get: function () { return _index.regExpLiteral; } }); Object.defineProperty(exports, "RegexLiteral", { enumerable: true, get: function () { return _index.regexLiteral; } }); Object.defineProperty(exports, "RestElement", { enumerable: true, get: function () { return _index.restElement; } }); Object.defineProperty(exports, "RestProperty", { enumerable: true, get: function () { return _index.restProperty; } }); Object.defineProperty(exports, "ReturnStatement", { enumerable: true, get: function () { return _index.returnStatement; } }); Object.defineProperty(exports, "SequenceExpression", { enumerable: true, get: function () { return _index.sequenceExpression; } }); Object.defineProperty(exports, "SpreadElement", { enumerable: true, get: function () { return _index.spreadElement; } }); Object.defineProperty(exports, "SpreadProperty", { enumerable: true, get: function () { return _index.spreadProperty; } }); Object.defineProperty(exports, "StaticBlock", { enumerable: true, get: function () { return _index.staticBlock; } }); Object.defineProperty(exports, "StringLiteral", { enumerable: true, get: function () { return _index.stringLiteral; } }); Object.defineProperty(exports, "StringLiteralTypeAnnotation", { enumerable: true, get: function () { return _index.stringLiteralTypeAnnotation; } }); Object.defineProperty(exports, "StringTypeAnnotation", { enumerable: true, get: function () { return _index.stringTypeAnnotation; } }); Object.defineProperty(exports, "Super", { enumerable: true, get: function () { return _index.super; } }); Object.defineProperty(exports, "SwitchCase", { enumerable: true, get: function () { return _index.switchCase; } }); Object.defineProperty(exports, "SwitchStatement", { enumerable: true, get: function () { return _index.switchStatement; } }); Object.defineProperty(exports, "SymbolTypeAnnotation", { enumerable: true, get: function () { return _index.symbolTypeAnnotation; } }); Object.defineProperty(exports, "TSAnyKeyword", { enumerable: true, get: function () { return _index.tsAnyKeyword; } }); Object.defineProperty(exports, "TSArrayType", { enumerable: true, get: function () { return _index.tsArrayType; } }); Object.defineProperty(exports, "TSAsExpression", { enumerable: true, get: function () { return _index.tsAsExpression; } }); Object.defineProperty(exports, "TSBigIntKeyword", { enumerable: true, get: function () { return _index.tsBigIntKeyword; } }); Object.defineProperty(exports, "TSBooleanKeyword", { enumerable: true, get: function () { return _index.tsBooleanKeyword; } }); Object.defineProperty(exports, "TSCallSignatureDeclaration", { enumerable: true, get: function () { return _index.tsCallSignatureDeclaration; } }); Object.defineProperty(exports, "TSConditionalType", { enumerable: true, get: function () { return _index.tsConditionalType; } }); Object.defineProperty(exports, "TSConstructSignatureDeclaration", { enumerable: true, get: function () { return _index.tsConstructSignatureDeclaration; } }); Object.defineProperty(exports, "TSConstructorType", { enumerable: true, get: function () { return _index.tsConstructorType; } }); Object.defineProperty(exports, "TSDeclareFunction", { enumerable: true, get: function () { return _index.tsDeclareFunction; } }); Object.defineProperty(exports, "TSDeclareMethod", { enumerable: true, get: function () { return _index.tsDeclareMethod; } }); Object.defineProperty(exports, "TSEnumDeclaration", { enumerable: true, get: function () { return _index.tsEnumDeclaration; } }); Object.defineProperty(exports, "TSEnumMember", { enumerable: true, get: function () { return _index.tsEnumMember; } }); Object.defineProperty(exports, "TSExportAssignment", { enumerable: true, get: function () { return _index.tsExportAssignment; } }); Object.defineProperty(exports, "TSExpressionWithTypeArguments", { enumerable: true, get: function () { return _index.tsExpressionWithTypeArguments; } }); Object.defineProperty(exports, "TSExternalModuleReference", { enumerable: true, get: function () { return _index.tsExternalModuleReference; } }); Object.defineProperty(exports, "TSFunctionType", { enumerable: true, get: function () { return _index.tsFunctionType; } }); Object.defineProperty(exports, "TSImportEqualsDeclaration", { enumerable: true, get: function () { return _index.tsImportEqualsDeclaration; } }); Object.defineProperty(exports, "TSImportType", { enumerable: true, get: function () { return _index.tsImportType; } }); Object.defineProperty(exports, "TSIndexSignature", { enumerable: true, get: function () { return _index.tsIndexSignature; } }); Object.defineProperty(exports, "TSIndexedAccessType", { enumerable: true, get: function () { return _index.tsIndexedAccessType; } }); Object.defineProperty(exports, "TSInferType", { enumerable: true, get: function () { return _index.tsInferType; } }); Object.defineProperty(exports, "TSInstantiationExpression", { enumerable: true, get: function () { return _index.tsInstantiationExpression; } }); Object.defineProperty(exports, "TSInterfaceBody", { enumerable: true, get: function () { return _index.tsInterfaceBody; } }); Object.defineProperty(exports, "TSInterfaceDeclaration", { enumerable: true, get: function () { return _index.tsInterfaceDeclaration; } }); Object.defineProperty(exports, "TSIntersectionType", { enumerable: true, get: function () { return _index.tsIntersectionType; } }); Object.defineProperty(exports, "TSIntrinsicKeyword", { enumerable: true, get: function () { return _index.tsIntrinsicKeyword; } }); Object.defineProperty(exports, "TSLiteralType", { enumerable: true, get: function () { return _index.tsLiteralType; } }); Object.defineProperty(exports, "TSMappedType", { enumerable: true, get: function () { return _index.tsMappedType; } }); Object.defineProperty(exports, "TSMethodSignature", { enumerable: true, get: function () { return _index.tsMethodSignature; } }); Object.defineProperty(exports, "TSModuleBlock", { enumerable: true, get: function () { return _index.tsModuleBlock; } }); Object.defineProperty(exports, "TSModuleDeclaration", { enumerable: true, get: function () { return _index.tsModuleDeclaration; } }); Object.defineProperty(exports, "TSNamedTupleMember", { enumerable: true, get: function () { return _index.tsNamedTupleMember; } }); Object.defineProperty(exports, "TSNamespaceExportDeclaration", { enumerable: true, get: function () { return _index.tsNamespaceExportDeclaration; } }); Object.defineProperty(exports, "TSNeverKeyword", { enumerable: true, get: function () { return _index.tsNeverKeyword; } }); Object.defineProperty(exports, "TSNonNullExpression", { enumerable: true, get: function () { return _index.tsNonNullExpression; } }); Object.defineProperty(exports, "TSNullKeyword", { enumerable: true, get: function () { return _index.tsNullKeyword; } }); Object.defineProperty(exports, "TSNumberKeyword", { enumerable: true, get: function () { return _index.tsNumberKeyword; } }); Object.defineProperty(exports, "TSObjectKeyword", { enumerable: true, get: function () { return _index.tsObjectKeyword; } }); Object.defineProperty(exports, "TSOptionalType", { enumerable: true, get: function () { return _index.tsOptionalType; } }); Object.defineProperty(exports, "TSParameterProperty", { enumerable: true, get: function () { return _index.tsParameterProperty; } }); Object.defineProperty(exports, "TSParenthesizedType", { enumerable: true, get: function () { return _index.tsParenthesizedType; } }); Object.defineProperty(exports, "TSPropertySignature", { enumerable: true, get: function () { return _index.tsPropertySignature; } }); Object.defineProperty(exports, "TSQualifiedName", { enumerable: true, get: function () { return _index.tsQualifiedName; } }); Object.defineProperty(exports, "TSRestType", { enumerable: true, get: function () { return _index.tsRestType; } }); Object.defineProperty(exports, "TSStringKeyword", { enumerable: true, get: function () { return _index.tsStringKeyword; } }); Object.defineProperty(exports, "TSSymbolKeyword", { enumerable: true, get: function () { return _index.tsSymbolKeyword; } }); Object.defineProperty(exports, "TSThisType", { enumerable: true, get: function () { return _index.tsThisType; } }); Object.defineProperty(exports, "TSTupleType", { enumerable: true, get: function () { return _index.tsTupleType; } }); Object.defineProperty(exports, "TSTypeAliasDeclaration", { enumerable: true, get: function () { return _index.tsTypeAliasDeclaration; } }); Object.defineProperty(exports, "TSTypeAnnotation", { enumerable: true, get: function () { return _index.tsTypeAnnotation; } }); Object.defineProperty(exports, "TSTypeAssertion", { enumerable: true, get: function () { return _index.tsTypeAssertion; } }); Object.defineProperty(exports, "TSTypeLiteral", { enumerable: true, get: function () { return _index.tsTypeLiteral; } }); Object.defineProperty(exports, "TSTypeOperator", { enumerable: true, get: function () { return _index.tsTypeOperator; } }); Object.defineProperty(exports, "TSTypeParameter", { enumerable: true, get: function () { return _index.tsTypeParameter; } }); Object.defineProperty(exports, "TSTypeParameterDeclaration", { enumerable: true, get: function () { return _index.tsTypeParameterDeclaration; } }); Object.defineProperty(exports, "TSTypeParameterInstantiation", { enumerable: true, get: function () { return _index.tsTypeParameterInstantiation; } }); Object.defineProperty(exports, "TSTypePredicate", { enumerable: true, get: function () { return _index.tsTypePredicate; } }); Object.defineProperty(exports, "TSTypeQuery", { enumerable: true, get: function () { return _index.tsTypeQuery; } }); Object.defineProperty(exports, "TSTypeReference", { enumerable: true, get: function () { return _index.tsTypeReference; } }); Object.defineProperty(exports, "TSUndefinedKeyword", { enumerable: true, get: function () { return _index.tsUndefinedKeyword; } }); Object.defineProperty(exports, "TSUnionType", { enumerable: true, get: function () { return _index.tsUnionType; } }); Object.defineProperty(exports, "TSUnknownKeyword", { enumerable: true, get: function () { return _index.tsUnknownKeyword; } }); Object.defineProperty(exports, "TSVoidKeyword", { enumerable: true, get: function () { return _index.tsVoidKeyword; } }); Object.defineProperty(exports, "TaggedTemplateExpression", { enumerable: true, get: function () { return _index.taggedTemplateExpression; } }); Object.defineProperty(exports, "TemplateElement", { enumerable: true, get: function () { return _index.templateElement; } }); Object.defineProperty(exports, "TemplateLiteral", { enumerable: true, get: function () { return _index.templateLiteral; } }); Object.defineProperty(exports, "ThisExpression", { enumerable: true, get: function () { return _index.thisExpression; } }); Object.defineProperty(exports, "ThisTypeAnnotation", { enumerable: true, get: function () { return _index.thisTypeAnnotation; } }); Object.defineProperty(exports, "ThrowStatement", { enumerable: true, get: function () { return _index.throwStatement; } }); Object.defineProperty(exports, "TopicReference", { enumerable: true, get: function () { return _index.topicReference; } }); Object.defineProperty(exports, "TryStatement", { enumerable: true, get: function () { return _index.tryStatement; } }); Object.defineProperty(exports, "TupleExpression", { enumerable: true, get: function () { return _index.tupleExpression; } }); Object.defineProperty(exports, "TupleTypeAnnotation", { enumerable: true, get: function () { return _index.tupleTypeAnnotation; } }); Object.defineProperty(exports, "TypeAlias", { enumerable: true, get: function () { return _index.typeAlias; } }); Object.defineProperty(exports, "TypeAnnotation", { enumerable: true, get: function () { return _index.typeAnnotation; } }); Object.defineProperty(exports, "TypeCastExpression", { enumerable: true, get: function () { return _index.typeCastExpression; } }); Object.defineProperty(exports, "TypeParameter", { enumerable: true, get: function () { return _index.typeParameter; } }); Object.defineProperty(exports, "TypeParameterDeclaration", { enumerable: true, get: function () { return _index.typeParameterDeclaration; } }); Object.defineProperty(exports, "TypeParameterInstantiation", { enumerable: true, get: function () { return _index.typeParameterInstantiation; } }); Object.defineProperty(exports, "TypeofTypeAnnotation", { enumerable: true, get: function () { return _index.typeofTypeAnnotation; } }); Object.defineProperty(exports, "UnaryExpression", { enumerable: true, get: function () { return _index.unaryExpression; } }); Object.defineProperty(exports, "UnionTypeAnnotation", { enumerable: true, get: function () { return _index.unionTypeAnnotation; } }); Object.defineProperty(exports, "UpdateExpression", { enumerable: true, get: function () { return _index.updateExpression; } }); Object.defineProperty(exports, "V8IntrinsicIdentifier", { enumerable: true, get: function () { return _index.v8IntrinsicIdentifier; } }); Object.defineProperty(exports, "VariableDeclaration", { enumerable: true, get: function () { return _index.variableDeclaration; } }); Object.defineProperty(exports, "VariableDeclarator", { enumerable: true, get: function () { return _index.variableDeclarator; } }); Object.defineProperty(exports, "Variance", { enumerable: true, get: function () { return _index.variance; } }); Object.defineProperty(exports, "VoidTypeAnnotation", { enumerable: true, get: function () { return _index.voidTypeAnnotation; } }); Object.defineProperty(exports, "WhileStatement", { enumerable: true, get: function () { return _index.whileStatement; } }); Object.defineProperty(exports, "WithStatement", { enumerable: true, get: function () { return _index.withStatement; } }); Object.defineProperty(exports, "YieldExpression", { enumerable: true, get: function () { return _index.yieldExpression; } }); var _index = require("./index"); },{"./index":89}],91:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = buildChildren; var _generated = require("../../validators/generated"); var _cleanJSXElementLiteralChild = require("../../utils/react/cleanJSXElementLiteralChild"); function buildChildren(node) { const elements = []; for (let i = 0; i < node.children.length; i++) { let child = node.children[i]; if ((0, _generated.isJSXText)(child)) { (0, _cleanJSXElementLiteralChild.default)(child, elements); continue; } if ((0, _generated.isJSXExpressionContainer)(child)) child = child.expression; if ((0, _generated.isJSXEmptyExpression)(child)) continue; elements.push(child); } return elements; } },{"../../utils/react/cleanJSXElementLiteralChild":141,"../../validators/generated":144}],92:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = createTSUnionType; var _generated = require("../generated"); var _removeTypeDuplicates = require("../../modifications/typescript/removeTypeDuplicates"); function createTSUnionType(typeAnnotations) { const types = typeAnnotations.map(type => type.typeAnnotation); const flattened = (0, _removeTypeDuplicates.default)(types); if (flattened.length === 1) { return flattened[0]; } else { return (0, _generated.tsUnionType)(flattened); } } },{"../../modifications/typescript/removeTypeDuplicates":135,"../generated":89}],93:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = validateNode; var _validate = require("../validators/validate"); var _ = require(".."); function validateNode(node) { const keys = _.BUILDER_KEYS[node.type]; for (const key of keys) { (0, _validate.default)(node, key, node[key]); } return node; } },{"..":128,"../validators/validate":163}],94:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = clone; var _cloneNode = require("./cloneNode"); function clone(node) { return (0, _cloneNode.default)(node, false); } },{"./cloneNode":97}],95:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = cloneDeep; var _cloneNode = require("./cloneNode"); function cloneDeep(node) { return (0, _cloneNode.default)(node); } },{"./cloneNode":97}],96:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = cloneDeepWithoutLoc; var _cloneNode = require("./cloneNode"); function cloneDeepWithoutLoc(node) { return (0, _cloneNode.default)(node, true, true); } },{"./cloneNode":97}],97:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = cloneNode; var _definitions = require("../definitions"); var _generated = require("../validators/generated"); const has = Function.call.bind(Object.prototype.hasOwnProperty); function cloneIfNode(obj, deep, withoutLoc, commentsCache) { if (obj && typeof obj.type === "string") { return cloneNodeInternal(obj, deep, withoutLoc, commentsCache); } return obj; } function cloneIfNodeOrArray(obj, deep, withoutLoc, commentsCache) { if (Array.isArray(obj)) { return obj.map(node => cloneIfNode(node, deep, withoutLoc, commentsCache)); } return cloneIfNode(obj, deep, withoutLoc, commentsCache); } function cloneNode(node, deep = true, withoutLoc = false) { return cloneNodeInternal(node, deep, withoutLoc, new Map()); } function cloneNodeInternal(node, deep = true, withoutLoc = false, commentsCache) { if (!node) return node; const { type } = node; const newNode = { type: node.type }; if ((0, _generated.isIdentifier)(node)) { newNode.name = node.name; if (has(node, "optional") && typeof node.optional === "boolean") { newNode.optional = node.optional; } if (has(node, "typeAnnotation")) { newNode.typeAnnotation = deep ? cloneIfNodeOrArray(node.typeAnnotation, true, withoutLoc, commentsCache) : node.typeAnnotation; } } else if (!has(_definitions.NODE_FIELDS, type)) { throw new Error(`Unknown node type: "${type}"`); } else { for (const field of Object.keys(_definitions.NODE_FIELDS[type])) { if (has(node, field)) { if (deep) { newNode[field] = (0, _generated.isFile)(node) && field === "comments" ? maybeCloneComments(node.comments, deep, withoutLoc, commentsCache) : cloneIfNodeOrArray(node[field], true, withoutLoc, commentsCache); } else { newNode[field] = node[field]; } } } } if (has(node, "loc")) { if (withoutLoc) { newNode.loc = null; } else { newNode.loc = node.loc; } } if (has(node, "leadingComments")) { newNode.leadingComments = maybeCloneComments(node.leadingComments, deep, withoutLoc, commentsCache); } if (has(node, "innerComments")) { newNode.innerComments = maybeCloneComments(node.innerComments, deep, withoutLoc, commentsCache); } if (has(node, "trailingComments")) { newNode.trailingComments = maybeCloneComments(node.trailingComments, deep, withoutLoc, commentsCache); } if (has(node, "extra")) { newNode.extra = Object.assign({}, node.extra); } return newNode; } function maybeCloneComments(comments, deep, withoutLoc, commentsCache) { if (!comments || !deep) { return comments; } return comments.map(comment => { const cache = commentsCache.get(comment); if (cache) return cache; const { type, value, loc } = comment; const ret = { type, value, loc }; if (withoutLoc) { ret.loc = null; } commentsCache.set(comment, ret); return ret; }); } },{"../definitions":122,"../validators/generated":144}],98:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = cloneWithoutLoc; var _cloneNode = require("./cloneNode"); function cloneWithoutLoc(node) { return (0, _cloneNode.default)(node, false, true); } },{"./cloneNode":97}],99:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = addComment; var _addComments = require("./addComments"); function addComment(node, type, content, line) { return (0, _addComments.default)(node, type, [{ type: line ? "CommentLine" : "CommentBlock", value: content }]); } },{"./addComments":100}],100:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = addComments; function addComments(node, type, comments) { if (!comments || !node) return node; const key = `${type}Comments`; if (node[key]) { if (type === "leading") { node[key] = comments.concat(node[key]); } else { node[key].push(...comments); } } else { node[key] = comments; } return node; } },{}],101:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = inheritInnerComments; var _inherit = require("../utils/inherit"); function inheritInnerComments(child, parent) { (0, _inherit.default)("innerComments", child, parent); } },{"../utils/inherit":140}],102:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = inheritLeadingComments; var _inherit = require("../utils/inherit"); function inheritLeadingComments(child, parent) { (0, _inherit.default)("leadingComments", child, parent); } },{"../utils/inherit":140}],103:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = inheritTrailingComments; var _inherit = require("../utils/inherit"); function inheritTrailingComments(child, parent) { (0, _inherit.default)("trailingComments", child, parent); } },{"../utils/inherit":140}],104:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = inheritsComments; var _inheritTrailingComments = require("./inheritTrailingComments"); var _inheritLeadingComments = require("./inheritLeadingComments"); var _inheritInnerComments = require("./inheritInnerComments"); function inheritsComments(child, parent) { (0, _inheritTrailingComments.default)(child, parent); (0, _inheritLeadingComments.default)(child, parent); (0, _inheritInnerComments.default)(child, parent); return child; } },{"./inheritInnerComments":101,"./inheritLeadingComments":102,"./inheritTrailingComments":103}],105:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = removeComments; var _constants = require("../constants"); function removeComments(node) { _constants.COMMENT_KEYS.forEach(key => { node[key] = null; }); return node; } },{"../constants":107}],106:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.WHILE_TYPES = exports.USERWHITESPACABLE_TYPES = exports.UNARYLIKE_TYPES = exports.TYPESCRIPT_TYPES = exports.TSTYPE_TYPES = exports.TSTYPEELEMENT_TYPES = exports.TSENTITYNAME_TYPES = exports.TSBASETYPE_TYPES = exports.TERMINATORLESS_TYPES = exports.STATEMENT_TYPES = exports.STANDARDIZED_TYPES = exports.SCOPABLE_TYPES = exports.PUREISH_TYPES = exports.PROPERTY_TYPES = exports.PRIVATE_TYPES = exports.PATTERN_TYPES = exports.PATTERNLIKE_TYPES = exports.OBJECTMEMBER_TYPES = exports.MODULESPECIFIER_TYPES = exports.MODULEDECLARATION_TYPES = exports.MISCELLANEOUS_TYPES = exports.METHOD_TYPES = exports.LVAL_TYPES = exports.LOOP_TYPES = exports.LITERAL_TYPES = exports.JSX_TYPES = exports.IMMUTABLE_TYPES = exports.FUNCTION_TYPES = exports.FUNCTIONPARENT_TYPES = exports.FOR_TYPES = exports.FORXSTATEMENT_TYPES = exports.FLOW_TYPES = exports.FLOWTYPE_TYPES = exports.FLOWPREDICATE_TYPES = exports.FLOWDECLARATION_TYPES = exports.FLOWBASEANNOTATION_TYPES = exports.EXPRESSION_TYPES = exports.EXPRESSIONWRAPPER_TYPES = exports.EXPORTDECLARATION_TYPES = exports.ENUMMEMBER_TYPES = exports.ENUMBODY_TYPES = exports.DECLARATION_TYPES = exports.CONDITIONAL_TYPES = exports.COMPLETIONSTATEMENT_TYPES = exports.CLASS_TYPES = exports.BLOCK_TYPES = exports.BLOCKPARENT_TYPES = exports.BINARY_TYPES = exports.ACCESSOR_TYPES = void 0; var _definitions = require("../../definitions"); const STANDARDIZED_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Standardized"]; exports.STANDARDIZED_TYPES = STANDARDIZED_TYPES; const EXPRESSION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Expression"]; exports.EXPRESSION_TYPES = EXPRESSION_TYPES; const BINARY_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Binary"]; exports.BINARY_TYPES = BINARY_TYPES; const SCOPABLE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Scopable"]; exports.SCOPABLE_TYPES = SCOPABLE_TYPES; const BLOCKPARENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["BlockParent"]; exports.BLOCKPARENT_TYPES = BLOCKPARENT_TYPES; const BLOCK_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Block"]; exports.BLOCK_TYPES = BLOCK_TYPES; const STATEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Statement"]; exports.STATEMENT_TYPES = STATEMENT_TYPES; const TERMINATORLESS_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Terminatorless"]; exports.TERMINATORLESS_TYPES = TERMINATORLESS_TYPES; const COMPLETIONSTATEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["CompletionStatement"]; exports.COMPLETIONSTATEMENT_TYPES = COMPLETIONSTATEMENT_TYPES; const CONDITIONAL_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Conditional"]; exports.CONDITIONAL_TYPES = CONDITIONAL_TYPES; const LOOP_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Loop"]; exports.LOOP_TYPES = LOOP_TYPES; const WHILE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["While"]; exports.WHILE_TYPES = WHILE_TYPES; const EXPRESSIONWRAPPER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ExpressionWrapper"]; exports.EXPRESSIONWRAPPER_TYPES = EXPRESSIONWRAPPER_TYPES; const FOR_TYPES = _definitions.FLIPPED_ALIAS_KEYS["For"]; exports.FOR_TYPES = FOR_TYPES; const FORXSTATEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ForXStatement"]; exports.FORXSTATEMENT_TYPES = FORXSTATEMENT_TYPES; const FUNCTION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Function"]; exports.FUNCTION_TYPES = FUNCTION_TYPES; const FUNCTIONPARENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FunctionParent"]; exports.FUNCTIONPARENT_TYPES = FUNCTIONPARENT_TYPES; const PUREISH_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Pureish"]; exports.PUREISH_TYPES = PUREISH_TYPES; const DECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Declaration"]; exports.DECLARATION_TYPES = DECLARATION_TYPES; const PATTERNLIKE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["PatternLike"]; exports.PATTERNLIKE_TYPES = PATTERNLIKE_TYPES; const LVAL_TYPES = _definitions.FLIPPED_ALIAS_KEYS["LVal"]; exports.LVAL_TYPES = LVAL_TYPES; const TSENTITYNAME_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSEntityName"]; exports.TSENTITYNAME_TYPES = TSENTITYNAME_TYPES; const LITERAL_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Literal"]; exports.LITERAL_TYPES = LITERAL_TYPES; const IMMUTABLE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Immutable"]; exports.IMMUTABLE_TYPES = IMMUTABLE_TYPES; const USERWHITESPACABLE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["UserWhitespacable"]; exports.USERWHITESPACABLE_TYPES = USERWHITESPACABLE_TYPES; const METHOD_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Method"]; exports.METHOD_TYPES = METHOD_TYPES; const OBJECTMEMBER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ObjectMember"]; exports.OBJECTMEMBER_TYPES = OBJECTMEMBER_TYPES; const PROPERTY_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Property"]; exports.PROPERTY_TYPES = PROPERTY_TYPES; const UNARYLIKE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["UnaryLike"]; exports.UNARYLIKE_TYPES = UNARYLIKE_TYPES; const PATTERN_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Pattern"]; exports.PATTERN_TYPES = PATTERN_TYPES; const CLASS_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Class"]; exports.CLASS_TYPES = CLASS_TYPES; const MODULEDECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ModuleDeclaration"]; exports.MODULEDECLARATION_TYPES = MODULEDECLARATION_TYPES; const EXPORTDECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ExportDeclaration"]; exports.EXPORTDECLARATION_TYPES = EXPORTDECLARATION_TYPES; const MODULESPECIFIER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ModuleSpecifier"]; exports.MODULESPECIFIER_TYPES = MODULESPECIFIER_TYPES; const ACCESSOR_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Accessor"]; exports.ACCESSOR_TYPES = ACCESSOR_TYPES; const PRIVATE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Private"]; exports.PRIVATE_TYPES = PRIVATE_TYPES; const FLOW_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Flow"]; exports.FLOW_TYPES = FLOW_TYPES; const FLOWTYPE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowType"]; exports.FLOWTYPE_TYPES = FLOWTYPE_TYPES; const FLOWBASEANNOTATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowBaseAnnotation"]; exports.FLOWBASEANNOTATION_TYPES = FLOWBASEANNOTATION_TYPES; const FLOWDECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowDeclaration"]; exports.FLOWDECLARATION_TYPES = FLOWDECLARATION_TYPES; const FLOWPREDICATE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowPredicate"]; exports.FLOWPREDICATE_TYPES = FLOWPREDICATE_TYPES; const ENUMBODY_TYPES = _definitions.FLIPPED_ALIAS_KEYS["EnumBody"]; exports.ENUMBODY_TYPES = ENUMBODY_TYPES; const ENUMMEMBER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["EnumMember"]; exports.ENUMMEMBER_TYPES = ENUMMEMBER_TYPES; const JSX_TYPES = _definitions.FLIPPED_ALIAS_KEYS["JSX"]; exports.JSX_TYPES = JSX_TYPES; const MISCELLANEOUS_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Miscellaneous"]; exports.MISCELLANEOUS_TYPES = MISCELLANEOUS_TYPES; const TYPESCRIPT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TypeScript"]; exports.TYPESCRIPT_TYPES = TYPESCRIPT_TYPES; const TSTYPEELEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSTypeElement"]; exports.TSTYPEELEMENT_TYPES = TSTYPEELEMENT_TYPES; const TSTYPE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSType"]; exports.TSTYPE_TYPES = TSTYPE_TYPES; const TSBASETYPE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSBaseType"]; exports.TSBASETYPE_TYPES = TSBASETYPE_TYPES; },{"../../definitions":122}],107:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.UPDATE_OPERATORS = exports.UNARY_OPERATORS = exports.STRING_UNARY_OPERATORS = exports.STATEMENT_OR_BLOCK_KEYS = exports.NUMBER_UNARY_OPERATORS = exports.NUMBER_BINARY_OPERATORS = exports.NOT_LOCAL_BINDING = exports.LOGICAL_OPERATORS = exports.INHERIT_KEYS = exports.FOR_INIT_KEYS = exports.FLATTENABLE_KEYS = exports.EQUALITY_BINARY_OPERATORS = exports.COMPARISON_BINARY_OPERATORS = exports.COMMENT_KEYS = exports.BOOLEAN_UNARY_OPERATORS = exports.BOOLEAN_NUMBER_BINARY_OPERATORS = exports.BOOLEAN_BINARY_OPERATORS = exports.BLOCK_SCOPED_SYMBOL = exports.BINARY_OPERATORS = exports.ASSIGNMENT_OPERATORS = void 0; const STATEMENT_OR_BLOCK_KEYS = ["consequent", "body", "alternate"]; exports.STATEMENT_OR_BLOCK_KEYS = STATEMENT_OR_BLOCK_KEYS; const FLATTENABLE_KEYS = ["body", "expressions"]; exports.FLATTENABLE_KEYS = FLATTENABLE_KEYS; const FOR_INIT_KEYS = ["left", "init"]; exports.FOR_INIT_KEYS = FOR_INIT_KEYS; const COMMENT_KEYS = ["leadingComments", "trailingComments", "innerComments"]; exports.COMMENT_KEYS = COMMENT_KEYS; const LOGICAL_OPERATORS = ["||", "&&", "??"]; exports.LOGICAL_OPERATORS = LOGICAL_OPERATORS; const UPDATE_OPERATORS = ["++", "--"]; exports.UPDATE_OPERATORS = UPDATE_OPERATORS; const BOOLEAN_NUMBER_BINARY_OPERATORS = [">", "<", ">=", "<="]; exports.BOOLEAN_NUMBER_BINARY_OPERATORS = BOOLEAN_NUMBER_BINARY_OPERATORS; const EQUALITY_BINARY_OPERATORS = ["==", "===", "!=", "!=="]; exports.EQUALITY_BINARY_OPERATORS = EQUALITY_BINARY_OPERATORS; const COMPARISON_BINARY_OPERATORS = [...EQUALITY_BINARY_OPERATORS, "in", "instanceof"]; exports.COMPARISON_BINARY_OPERATORS = COMPARISON_BINARY_OPERATORS; const BOOLEAN_BINARY_OPERATORS = [...COMPARISON_BINARY_OPERATORS, ...BOOLEAN_NUMBER_BINARY_OPERATORS]; exports.BOOLEAN_BINARY_OPERATORS = BOOLEAN_BINARY_OPERATORS; const NUMBER_BINARY_OPERATORS = ["-", "/", "%", "*", "**", "&", "|", ">>", ">>>", "<<", "^"]; exports.NUMBER_BINARY_OPERATORS = NUMBER_BINARY_OPERATORS; const BINARY_OPERATORS = ["+", ...NUMBER_BINARY_OPERATORS, ...BOOLEAN_BINARY_OPERATORS, "|>"]; exports.BINARY_OPERATORS = BINARY_OPERATORS; const ASSIGNMENT_OPERATORS = ["=", "+=", ...NUMBER_BINARY_OPERATORS.map(op => op + "="), ...LOGICAL_OPERATORS.map(op => op + "=")]; exports.ASSIGNMENT_OPERATORS = ASSIGNMENT_OPERATORS; const BOOLEAN_UNARY_OPERATORS = ["delete", "!"]; exports.BOOLEAN_UNARY_OPERATORS = BOOLEAN_UNARY_OPERATORS; const NUMBER_UNARY_OPERATORS = ["+", "-", "~"]; exports.NUMBER_UNARY_OPERATORS = NUMBER_UNARY_OPERATORS; const STRING_UNARY_OPERATORS = ["typeof"]; exports.STRING_UNARY_OPERATORS = STRING_UNARY_OPERATORS; const UNARY_OPERATORS = ["void", "throw", ...BOOLEAN_UNARY_OPERATORS, ...NUMBER_UNARY_OPERATORS, ...STRING_UNARY_OPERATORS]; exports.UNARY_OPERATORS = UNARY_OPERATORS; const INHERIT_KEYS = { optional: ["typeAnnotation", "typeParameters", "returnType"], force: ["start", "loc", "end"] }; exports.INHERIT_KEYS = INHERIT_KEYS; const BLOCK_SCOPED_SYMBOL = Symbol.for("var used to be block scoped"); exports.BLOCK_SCOPED_SYMBOL = BLOCK_SCOPED_SYMBOL; const NOT_LOCAL_BINDING = Symbol.for("should not be considered a local binding"); exports.NOT_LOCAL_BINDING = NOT_LOCAL_BINDING; },{}],108:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = ensureBlock; var _toBlock = require("./toBlock"); function ensureBlock(node, key = "body") { const result = (0, _toBlock.default)(node[key], node); node[key] = result; return result; } },{"./toBlock":111}],109:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = gatherSequenceExpressions; var _getBindingIdentifiers = require("../retrievers/getBindingIdentifiers"); var _generated = require("../validators/generated"); var _generated2 = require("../builders/generated"); var _cloneNode = require("../clone/cloneNode"); function gatherSequenceExpressions(nodes, scope, declars) { const exprs = []; let ensureLastUndefined = true; for (const node of nodes) { if (!(0, _generated.isEmptyStatement)(node)) { ensureLastUndefined = false; } if ((0, _generated.isExpression)(node)) { exprs.push(node); } else if ((0, _generated.isExpressionStatement)(node)) { exprs.push(node.expression); } else if ((0, _generated.isVariableDeclaration)(node)) { if (node.kind !== "var") return; for (const declar of node.declarations) { const bindings = (0, _getBindingIdentifiers.default)(declar); for (const key of Object.keys(bindings)) { declars.push({ kind: node.kind, id: (0, _cloneNode.default)(bindings[key]) }); } if (declar.init) { exprs.push((0, _generated2.assignmentExpression)("=", declar.id, declar.init)); } } ensureLastUndefined = true; } else if ((0, _generated.isIfStatement)(node)) { const consequent = node.consequent ? gatherSequenceExpressions([node.consequent], scope, declars) : scope.buildUndefinedNode(); const alternate = node.alternate ? gatherSequenceExpressions([node.alternate], scope, declars) : scope.buildUndefinedNode(); if (!consequent || !alternate) return; exprs.push((0, _generated2.conditionalExpression)(node.test, consequent, alternate)); } else if ((0, _generated.isBlockStatement)(node)) { const body = gatherSequenceExpressions(node.body, scope, declars); if (!body) return; exprs.push(body); } else if ((0, _generated.isEmptyStatement)(node)) { if (nodes.indexOf(node) === 0) { ensureLastUndefined = true; } } else { return; } } if (ensureLastUndefined) { exprs.push(scope.buildUndefinedNode()); } if (exprs.length === 1) { return exprs[0]; } else { return (0, _generated2.sequenceExpression)(exprs); } } },{"../builders/generated":89,"../clone/cloneNode":97,"../retrievers/getBindingIdentifiers":136,"../validators/generated":144}],110:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = toBindingIdentifierName; var _toIdentifier = require("./toIdentifier"); function toBindingIdentifierName(name) { name = (0, _toIdentifier.default)(name); if (name === "eval" || name === "arguments") name = "_" + name; return name; } },{"./toIdentifier":114}],111:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = toBlock; var _generated = require("../validators/generated"); var _generated2 = require("../builders/generated"); function toBlock(node, parent) { if ((0, _generated.isBlockStatement)(node)) { return node; } let blockNodes = []; if ((0, _generated.isEmptyStatement)(node)) { blockNodes = []; } else { if (!(0, _generated.isStatement)(node)) { if ((0, _generated.isFunction)(parent)) { node = (0, _generated2.returnStatement)(node); } else { node = (0, _generated2.expressionStatement)(node); } } blockNodes = [node]; } return (0, _generated2.blockStatement)(blockNodes); } },{"../builders/generated":89,"../validators/generated":144}],112:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = toComputedKey; var _generated = require("../validators/generated"); var _generated2 = require("../builders/generated"); function toComputedKey(node, key = node.key || node.property) { if (!node.computed && (0, _generated.isIdentifier)(key)) key = (0, _generated2.stringLiteral)(key.name); return key; } },{"../builders/generated":89,"../validators/generated":144}],113:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = void 0; var _generated = require("../validators/generated"); var _default = toExpression; exports.default = _default; function toExpression(node) { if ((0, _generated.isExpressionStatement)(node)) { node = node.expression; } if ((0, _generated.isExpression)(node)) { return node; } if ((0, _generated.isClass)(node)) { node.type = "ClassExpression"; } else if ((0, _generated.isFunction)(node)) { node.type = "FunctionExpression"; } if (!(0, _generated.isExpression)(node)) { throw new Error(`cannot turn ${node.type} to an expression`); } return node; } },{"../validators/generated":144}],114:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = toIdentifier; var _isValidIdentifier = require("../validators/isValidIdentifier"); var _helperValidatorIdentifier = require("@babel/helper-validator-identifier"); function toIdentifier(input) { input = input + ""; let name = ""; for (const c of input) { name += (0, _helperValidatorIdentifier.isIdentifierChar)(c.codePointAt(0)) ? c : "-"; } name = name.replace(/^[-0-9]+/, ""); name = name.replace(/[-\s]+(.)?/g, function (match, c) { return c ? c.toUpperCase() : ""; }); if (!(0, _isValidIdentifier.default)(name)) { name = `_${name}`; } return name || "_"; } },{"../validators/isValidIdentifier":158,"@babel/helper-validator-identifier":256}],115:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = toKeyAlias; var _generated = require("../validators/generated"); var _cloneNode = require("../clone/cloneNode"); var _removePropertiesDeep = require("../modifications/removePropertiesDeep"); function toKeyAlias(node, key = node.key) { let alias; if (node.kind === "method") { return toKeyAlias.increment() + ""; } else if ((0, _generated.isIdentifier)(key)) { alias = key.name; } else if ((0, _generated.isStringLiteral)(key)) { alias = JSON.stringify(key.value); } else { alias = JSON.stringify((0, _removePropertiesDeep.default)((0, _cloneNode.default)(key))); } if (node.computed) { alias = `[${alias}]`; } if (node.static) { alias = `static:${alias}`; } return alias; } toKeyAlias.uid = 0; toKeyAlias.increment = function () { if (toKeyAlias.uid >= Number.MAX_SAFE_INTEGER) { return toKeyAlias.uid = 0; } else { return toKeyAlias.uid++; } }; },{"../clone/cloneNode":97,"../modifications/removePropertiesDeep":134,"../validators/generated":144}],116:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = toSequenceExpression; var _gatherSequenceExpressions = require("./gatherSequenceExpressions"); function toSequenceExpression(nodes, scope) { if (!(nodes != null && nodes.length)) return; const declars = []; const result = (0, _gatherSequenceExpressions.default)(nodes, scope, declars); if (!result) return; for (const declar of declars) { scope.push(declar); } return result; } },{"./gatherSequenceExpressions":109}],117:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = void 0; var _generated = require("../validators/generated"); var _generated2 = require("../builders/generated"); var _default = toStatement; exports.default = _default; function toStatement(node, ignore) { if ((0, _generated.isStatement)(node)) { return node; } let mustHaveId = false; let newType; if ((0, _generated.isClass)(node)) { mustHaveId = true; newType = "ClassDeclaration"; } else if ((0, _generated.isFunction)(node)) { mustHaveId = true; newType = "FunctionDeclaration"; } else if ((0, _generated.isAssignmentExpression)(node)) { return (0, _generated2.expressionStatement)(node); } if (mustHaveId && !node.id) { newType = false; } if (!newType) { if (ignore) { return false; } else { throw new Error(`cannot turn ${node.type} to a statement`); } } node.type = newType; return node; } },{"../builders/generated":89,"../validators/generated":144}],118:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = void 0; var _isValidIdentifier = require("../validators/isValidIdentifier"); var _generated = require("../builders/generated"); var _default = valueToNode; exports.default = _default; const objectToString = Function.call.bind(Object.prototype.toString); function isRegExp(value) { return objectToString(value) === "[object RegExp]"; } function isPlainObject(value) { if (typeof value !== "object" || value === null || Object.prototype.toString.call(value) !== "[object Object]") { return false; } const proto = Object.getPrototypeOf(value); return proto === null || Object.getPrototypeOf(proto) === null; } function valueToNode(value) { if (value === undefined) { return (0, _generated.identifier)("undefined"); } if (value === true || value === false) { return (0, _generated.booleanLiteral)(value); } if (value === null) { return (0, _generated.nullLiteral)(); } if (typeof value === "string") { return (0, _generated.stringLiteral)(value); } if (typeof value === "number") { let result; if (Number.isFinite(value)) { result = (0, _generated.numericLiteral)(Math.abs(value)); } else { let numerator; if (Number.isNaN(value)) { numerator = (0, _generated.numericLiteral)(0); } else { numerator = (0, _generated.numericLiteral)(1); } result = (0, _generated.binaryExpression)("/", numerator, (0, _generated.numericLiteral)(0)); } if (value < 0 || Object.is(value, -0)) { result = (0, _generated.unaryExpression)("-", result); } return result; } if (isRegExp(value)) { const pattern = value.source; const flags = value.toString().match(/\/([a-z]+|)$/)[1]; return (0, _generated.regExpLiteral)(pattern, flags); } if (Array.isArray(value)) { return (0, _generated.arrayExpression)(value.map(valueToNode)); } if (isPlainObject(value)) { const props = []; for (const key of Object.keys(value)) { let nodeKey; if ((0, _isValidIdentifier.default)(key)) { nodeKey = (0, _generated.identifier)(key); } else { nodeKey = (0, _generated.stringLiteral)(key); } props.push((0, _generated.objectProperty)(nodeKey, valueToNode(value[key]))); } return (0, _generated.objectExpression)(props); } throw new Error("don't know how to turn this value into a node"); } },{"../builders/generated":89,"../validators/isValidIdentifier":158}],119:[function(require,module,exports){ (function (process){(function (){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.patternLikeCommon = exports.functionTypeAnnotationCommon = exports.functionDeclarationCommon = exports.functionCommon = exports.classMethodOrPropertyCommon = exports.classMethodOrDeclareMethodCommon = void 0; var _is = require("../validators/is"); var _isValidIdentifier = require("../validators/isValidIdentifier"); var _helperValidatorIdentifier = require("@babel/helper-validator-identifier"); var _constants = require("../constants"); var _utils = require("./utils"); const defineType = (0, _utils.defineAliasedType)("Standardized"); defineType("ArrayExpression", { fields: { elements: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeOrValueType)("null", "Expression", "SpreadElement"))), default: !process.env.BABEL_TYPES_8_BREAKING ? [] : undefined } }, visitor: ["elements"], aliases: ["Expression"] }); defineType("AssignmentExpression", { fields: { operator: { validate: function () { if (!process.env.BABEL_TYPES_8_BREAKING) { return (0, _utils.assertValueType)("string"); } const identifier = (0, _utils.assertOneOf)(..._constants.ASSIGNMENT_OPERATORS); const pattern = (0, _utils.assertOneOf)("="); return function (node, key, val) { const validator = (0, _is.default)("Pattern", node.left) ? pattern : identifier; validator(node, key, val); }; }() }, left: { validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("LVal") : (0, _utils.assertNodeType)("Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern", "TSAsExpression", "TSTypeAssertion", "TSNonNullExpression") }, right: { validate: (0, _utils.assertNodeType)("Expression") } }, builder: ["operator", "left", "right"], visitor: ["left", "right"], aliases: ["Expression"] }); defineType("BinaryExpression", { builder: ["operator", "left", "right"], fields: { operator: { validate: (0, _utils.assertOneOf)(..._constants.BINARY_OPERATORS) }, left: { validate: function () { const expression = (0, _utils.assertNodeType)("Expression"); const inOp = (0, _utils.assertNodeType)("Expression", "PrivateName"); const validator = Object.assign(function (node, key, val) { const validator = node.operator === "in" ? inOp : expression; validator(node, key, val); }, { oneOfNodeTypes: ["Expression", "PrivateName"] }); return validator; }() }, right: { validate: (0, _utils.assertNodeType)("Expression") } }, visitor: ["left", "right"], aliases: ["Binary", "Expression"] }); defineType("InterpreterDirective", { builder: ["value"], fields: { value: { validate: (0, _utils.assertValueType)("string") } } }); defineType("Directive", { visitor: ["value"], fields: { value: { validate: (0, _utils.assertNodeType)("DirectiveLiteral") } } }); defineType("DirectiveLiteral", { builder: ["value"], fields: { value: { validate: (0, _utils.assertValueType)("string") } } }); defineType("BlockStatement", { builder: ["body", "directives"], visitor: ["directives", "body"], fields: { directives: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Directive"))), default: [] }, body: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement"))) } }, aliases: ["Scopable", "BlockParent", "Block", "Statement"] }); defineType("BreakStatement", { visitor: ["label"], fields: { label: { validate: (0, _utils.assertNodeType)("Identifier"), optional: true } }, aliases: ["Statement", "Terminatorless", "CompletionStatement"] }); defineType("CallExpression", { visitor: ["callee", "arguments", "typeParameters", "typeArguments"], builder: ["callee", "arguments"], aliases: ["Expression"], fields: Object.assign({ callee: { validate: (0, _utils.assertNodeType)("Expression", "V8IntrinsicIdentifier") }, arguments: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement", "JSXNamespacedName", "ArgumentPlaceholder"))) } }, !process.env.BABEL_TYPES_8_BREAKING ? { optional: { validate: (0, _utils.assertOneOf)(true, false), optional: true } } : {}, { typeArguments: { validate: (0, _utils.assertNodeType)("TypeParameterInstantiation"), optional: true }, typeParameters: { validate: (0, _utils.assertNodeType)("TSTypeParameterInstantiation"), optional: true } }) }); defineType("CatchClause", { visitor: ["param", "body"], fields: { param: { validate: (0, _utils.assertNodeType)("Identifier", "ArrayPattern", "ObjectPattern"), optional: true }, body: { validate: (0, _utils.assertNodeType)("BlockStatement") } }, aliases: ["Scopable", "BlockParent"] }); defineType("ConditionalExpression", { visitor: ["test", "consequent", "alternate"], fields: { test: { validate: (0, _utils.assertNodeType)("Expression") }, consequent: { validate: (0, _utils.assertNodeType)("Expression") }, alternate: { validate: (0, _utils.assertNodeType)("Expression") } }, aliases: ["Expression", "Conditional"] }); defineType("ContinueStatement", { visitor: ["label"], fields: { label: { validate: (0, _utils.assertNodeType)("Identifier"), optional: true } }, aliases: ["Statement", "Terminatorless", "CompletionStatement"] }); defineType("DebuggerStatement", { aliases: ["Statement"] }); defineType("DoWhileStatement", { visitor: ["test", "body"], fields: { test: { validate: (0, _utils.assertNodeType)("Expression") }, body: { validate: (0, _utils.assertNodeType)("Statement") } }, aliases: ["Statement", "BlockParent", "Loop", "While", "Scopable"] }); defineType("EmptyStatement", { aliases: ["Statement"] }); defineType("ExpressionStatement", { visitor: ["expression"], fields: { expression: { validate: (0, _utils.assertNodeType)("Expression") } }, aliases: ["Statement", "ExpressionWrapper"] }); defineType("File", { builder: ["program", "comments", "tokens"], visitor: ["program"], fields: { program: { validate: (0, _utils.assertNodeType)("Program") }, comments: { validate: !process.env.BABEL_TYPES_8_BREAKING ? Object.assign(() => {}, { each: { oneOfNodeTypes: ["CommentBlock", "CommentLine"] } }) : (0, _utils.assertEach)((0, _utils.assertNodeType)("CommentBlock", "CommentLine")), optional: true }, tokens: { validate: (0, _utils.assertEach)(Object.assign(() => {}, { type: "any" })), optional: true } } }); defineType("ForInStatement", { visitor: ["left", "right", "body"], aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop", "ForXStatement"], fields: { left: { validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("VariableDeclaration", "LVal") : (0, _utils.assertNodeType)("VariableDeclaration", "Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern", "TSAsExpression", "TSTypeAssertion", "TSNonNullExpression") }, right: { validate: (0, _utils.assertNodeType)("Expression") }, body: { validate: (0, _utils.assertNodeType)("Statement") } } }); defineType("ForStatement", { visitor: ["init", "test", "update", "body"], aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop"], fields: { init: { validate: (0, _utils.assertNodeType)("VariableDeclaration", "Expression"), optional: true }, test: { validate: (0, _utils.assertNodeType)("Expression"), optional: true }, update: { validate: (0, _utils.assertNodeType)("Expression"), optional: true }, body: { validate: (0, _utils.assertNodeType)("Statement") } } }); const functionCommon = { params: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Identifier", "Pattern", "RestElement"))) }, generator: { default: false }, async: { default: false } }; exports.functionCommon = functionCommon; const functionTypeAnnotationCommon = { returnType: { validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"), optional: true }, typeParameters: { validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"), optional: true } }; exports.functionTypeAnnotationCommon = functionTypeAnnotationCommon; const functionDeclarationCommon = Object.assign({}, functionCommon, { declare: { validate: (0, _utils.assertValueType)("boolean"), optional: true }, id: { validate: (0, _utils.assertNodeType)("Identifier"), optional: true } }); exports.functionDeclarationCommon = functionDeclarationCommon; defineType("FunctionDeclaration", { builder: ["id", "params", "body", "generator", "async"], visitor: ["id", "params", "body", "returnType", "typeParameters"], fields: Object.assign({}, functionDeclarationCommon, functionTypeAnnotationCommon, { body: { validate: (0, _utils.assertNodeType)("BlockStatement") }, predicate: { validate: (0, _utils.assertNodeType)("DeclaredPredicate", "InferredPredicate"), optional: true } }), aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Statement", "Pureish", "Declaration"], validate: function () { if (!process.env.BABEL_TYPES_8_BREAKING) return () => {}; const identifier = (0, _utils.assertNodeType)("Identifier"); return function (parent, key, node) { if (!(0, _is.default)("ExportDefaultDeclaration", parent)) { identifier(node, "id", node.id); } }; }() }); defineType("FunctionExpression", { inherits: "FunctionDeclaration", aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Expression", "Pureish"], fields: Object.assign({}, functionCommon, functionTypeAnnotationCommon, { id: { validate: (0, _utils.assertNodeType)("Identifier"), optional: true }, body: { validate: (0, _utils.assertNodeType)("BlockStatement") }, predicate: { validate: (0, _utils.assertNodeType)("DeclaredPredicate", "InferredPredicate"), optional: true } }) }); const patternLikeCommon = { typeAnnotation: { validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"), optional: true }, decorators: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))) } }; exports.patternLikeCommon = patternLikeCommon; defineType("Identifier", { builder: ["name"], visitor: ["typeAnnotation", "decorators"], aliases: ["Expression", "PatternLike", "LVal", "TSEntityName"], fields: Object.assign({}, patternLikeCommon, { name: { validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), Object.assign(function (node, key, val) { if (!process.env.BABEL_TYPES_8_BREAKING) return; if (!(0, _isValidIdentifier.default)(val, false)) { throw new TypeError(`"${val}" is not a valid identifier name`); } }, { type: "string" })) }, optional: { validate: (0, _utils.assertValueType)("boolean"), optional: true } }), validate(parent, key, node) { if (!process.env.BABEL_TYPES_8_BREAKING) return; const match = /\.(\w+)$/.exec(key); if (!match) return; const [, parentKey] = match; const nonComp = { computed: false }; if (parentKey === "property") { if ((0, _is.default)("MemberExpression", parent, nonComp)) return; if ((0, _is.default)("OptionalMemberExpression", parent, nonComp)) return; } else if (parentKey === "key") { if ((0, _is.default)("Property", parent, nonComp)) return; if ((0, _is.default)("Method", parent, nonComp)) return; } else if (parentKey === "exported") { if ((0, _is.default)("ExportSpecifier", parent)) return; } else if (parentKey === "imported") { if ((0, _is.default)("ImportSpecifier", parent, { imported: node })) return; } else if (parentKey === "meta") { if ((0, _is.default)("MetaProperty", parent, { meta: node })) return; } if (((0, _helperValidatorIdentifier.isKeyword)(node.name) || (0, _helperValidatorIdentifier.isReservedWord)(node.name, false)) && node.name !== "this") { throw new TypeError(`"${node.name}" is not a valid identifier`); } } }); defineType("IfStatement", { visitor: ["test", "consequent", "alternate"], aliases: ["Statement", "Conditional"], fields: { test: { validate: (0, _utils.assertNodeType)("Expression") }, consequent: { validate: (0, _utils.assertNodeType)("Statement") }, alternate: { optional: true, validate: (0, _utils.assertNodeType)("Statement") } } }); defineType("LabeledStatement", { visitor: ["label", "body"], aliases: ["Statement"], fields: { label: { validate: (0, _utils.assertNodeType)("Identifier") }, body: { validate: (0, _utils.assertNodeType)("Statement") } } }); defineType("StringLiteral", { builder: ["value"], fields: { value: { validate: (0, _utils.assertValueType)("string") } }, aliases: ["Expression", "Pureish", "Literal", "Immutable"] }); defineType("NumericLiteral", { builder: ["value"], deprecatedAlias: "NumberLiteral", fields: { value: { validate: (0, _utils.assertValueType)("number") } }, aliases: ["Expression", "Pureish", "Literal", "Immutable"] }); defineType("NullLiteral", { aliases: ["Expression", "Pureish", "Literal", "Immutable"] }); defineType("BooleanLiteral", { builder: ["value"], fields: { value: { validate: (0, _utils.assertValueType)("boolean") } }, aliases: ["Expression", "Pureish", "Literal", "Immutable"] }); defineType("RegExpLiteral", { builder: ["pattern", "flags"], deprecatedAlias: "RegexLiteral", aliases: ["Expression", "Pureish", "Literal"], fields: { pattern: { validate: (0, _utils.assertValueType)("string") }, flags: { validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), Object.assign(function (node, key, val) { if (!process.env.BABEL_TYPES_8_BREAKING) return; const invalid = /[^gimsuy]/.exec(val); if (invalid) { throw new TypeError(`"${invalid[0]}" is not a valid RegExp flag`); } }, { type: "string" })), default: "" } } }); defineType("LogicalExpression", { builder: ["operator", "left", "right"], visitor: ["left", "right"], aliases: ["Binary", "Expression"], fields: { operator: { validate: (0, _utils.assertOneOf)(..._constants.LOGICAL_OPERATORS) }, left: { validate: (0, _utils.assertNodeType)("Expression") }, right: { validate: (0, _utils.assertNodeType)("Expression") } } }); defineType("MemberExpression", { builder: ["object", "property", "computed", ...(!process.env.BABEL_TYPES_8_BREAKING ? ["optional"] : [])], visitor: ["object", "property"], aliases: ["Expression", "LVal"], fields: Object.assign({ object: { validate: (0, _utils.assertNodeType)("Expression") }, property: { validate: function () { const normal = (0, _utils.assertNodeType)("Identifier", "PrivateName"); const computed = (0, _utils.assertNodeType)("Expression"); const validator = function (node, key, val) { const validator = node.computed ? computed : normal; validator(node, key, val); }; validator.oneOfNodeTypes = ["Expression", "Identifier", "PrivateName"]; return validator; }() }, computed: { default: false } }, !process.env.BABEL_TYPES_8_BREAKING ? { optional: { validate: (0, _utils.assertOneOf)(true, false), optional: true } } : {}) }); defineType("NewExpression", { inherits: "CallExpression" }); defineType("Program", { visitor: ["directives", "body"], builder: ["body", "directives", "sourceType", "interpreter"], fields: { sourceFile: { validate: (0, _utils.assertValueType)("string") }, sourceType: { validate: (0, _utils.assertOneOf)("script", "module"), default: "script" }, interpreter: { validate: (0, _utils.assertNodeType)("InterpreterDirective"), default: null, optional: true }, directives: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Directive"))), default: [] }, body: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement"))) } }, aliases: ["Scopable", "BlockParent", "Block"] }); defineType("ObjectExpression", { visitor: ["properties"], aliases: ["Expression"], fields: { properties: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ObjectMethod", "ObjectProperty", "SpreadElement"))) } } }); defineType("ObjectMethod", { builder: ["kind", "key", "params", "body", "computed", "generator", "async"], fields: Object.assign({}, functionCommon, functionTypeAnnotationCommon, { kind: Object.assign({ validate: (0, _utils.assertOneOf)("method", "get", "set") }, !process.env.BABEL_TYPES_8_BREAKING ? { default: "method" } : {}), computed: { default: false }, key: { validate: function () { const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral"); const computed = (0, _utils.assertNodeType)("Expression"); const validator = function (node, key, val) { const validator = node.computed ? computed : normal; validator(node, key, val); }; validator.oneOfNodeTypes = ["Expression", "Identifier", "StringLiteral", "NumericLiteral"]; return validator; }() }, decorators: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))), optional: true }, body: { validate: (0, _utils.assertNodeType)("BlockStatement") } }), visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"], aliases: ["UserWhitespacable", "Function", "Scopable", "BlockParent", "FunctionParent", "Method", "ObjectMember"] }); defineType("ObjectProperty", { builder: ["key", "value", "computed", "shorthand", ...(!process.env.BABEL_TYPES_8_BREAKING ? ["decorators"] : [])], fields: { computed: { default: false }, key: { validate: function () { const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "DecimalLiteral", "PrivateName"); const computed = (0, _utils.assertNodeType)("Expression"); const validator = Object.assign(function (node, key, val) { const validator = node.computed ? computed : normal; validator(node, key, val); }, { oneOfNodeTypes: ["Expression", "Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "DecimalLiteral", "PrivateName"] }); return validator; }() }, value: { validate: (0, _utils.assertNodeType)("Expression", "PatternLike") }, shorthand: { validate: (0, _utils.chain)((0, _utils.assertValueType)("boolean"), Object.assign(function (node, key, val) { if (!process.env.BABEL_TYPES_8_BREAKING) return; if (val && node.computed) { throw new TypeError("Property shorthand of ObjectProperty cannot be true if computed is true"); } }, { type: "boolean" }), function (node, key, val) { if (!process.env.BABEL_TYPES_8_BREAKING) return; if (val && !(0, _is.default)("Identifier", node.key)) { throw new TypeError("Property shorthand of ObjectProperty cannot be true if key is not an Identifier"); } }), default: false }, decorators: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))), optional: true } }, visitor: ["key", "value", "decorators"], aliases: ["UserWhitespacable", "Property", "ObjectMember"], validate: function () { const pattern = (0, _utils.assertNodeType)("Identifier", "Pattern", "TSAsExpression", "TSNonNullExpression", "TSTypeAssertion"); const expression = (0, _utils.assertNodeType)("Expression"); return function (parent, key, node) { if (!process.env.BABEL_TYPES_8_BREAKING) return; const validator = (0, _is.default)("ObjectPattern", parent) ? pattern : expression; validator(node, "value", node.value); }; }() }); defineType("RestElement", { visitor: ["argument", "typeAnnotation"], builder: ["argument"], aliases: ["LVal", "PatternLike"], deprecatedAlias: "RestProperty", fields: Object.assign({}, patternLikeCommon, { argument: { validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("LVal") : (0, _utils.assertNodeType)("Identifier", "ArrayPattern", "ObjectPattern", "MemberExpression", "TSAsExpression", "TSTypeAssertion", "TSNonNullExpression") }, optional: { validate: (0, _utils.assertValueType)("boolean"), optional: true } }), validate(parent, key) { if (!process.env.BABEL_TYPES_8_BREAKING) return; const match = /(\w+)\[(\d+)\]/.exec(key); if (!match) throw new Error("Internal Babel error: malformed key."); const [, listKey, index] = match; if (parent[listKey].length > +index + 1) { throw new TypeError(`RestElement must be last element of ${listKey}`); } } }); defineType("ReturnStatement", { visitor: ["argument"], aliases: ["Statement", "Terminatorless", "CompletionStatement"], fields: { argument: { validate: (0, _utils.assertNodeType)("Expression"), optional: true } } }); defineType("SequenceExpression", { visitor: ["expressions"], fields: { expressions: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression"))) } }, aliases: ["Expression"] }); defineType("ParenthesizedExpression", { visitor: ["expression"], aliases: ["Expression", "ExpressionWrapper"], fields: { expression: { validate: (0, _utils.assertNodeType)("Expression") } } }); defineType("SwitchCase", { visitor: ["test", "consequent"], fields: { test: { validate: (0, _utils.assertNodeType)("Expression"), optional: true }, consequent: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement"))) } } }); defineType("SwitchStatement", { visitor: ["discriminant", "cases"], aliases: ["Statement", "BlockParent", "Scopable"], fields: { discriminant: { validate: (0, _utils.assertNodeType)("Expression") }, cases: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("SwitchCase"))) } } }); defineType("ThisExpression", { aliases: ["Expression"] }); defineType("ThrowStatement", { visitor: ["argument"], aliases: ["Statement", "Terminatorless", "CompletionStatement"], fields: { argument: { validate: (0, _utils.assertNodeType)("Expression") } } }); defineType("TryStatement", { visitor: ["block", "handler", "finalizer"], aliases: ["Statement"], fields: { block: { validate: (0, _utils.chain)((0, _utils.assertNodeType)("BlockStatement"), Object.assign(function (node) { if (!process.env.BABEL_TYPES_8_BREAKING) return; if (!node.handler && !node.finalizer) { throw new TypeError("TryStatement expects either a handler or finalizer, or both"); } }, { oneOfNodeTypes: ["BlockStatement"] })) }, handler: { optional: true, validate: (0, _utils.assertNodeType)("CatchClause") }, finalizer: { optional: true, validate: (0, _utils.assertNodeType)("BlockStatement") } } }); defineType("UnaryExpression", { builder: ["operator", "argument", "prefix"], fields: { prefix: { default: true }, argument: { validate: (0, _utils.assertNodeType)("Expression") }, operator: { validate: (0, _utils.assertOneOf)(..._constants.UNARY_OPERATORS) } }, visitor: ["argument"], aliases: ["UnaryLike", "Expression"] }); defineType("UpdateExpression", { builder: ["operator", "argument", "prefix"], fields: { prefix: { default: false }, argument: { validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("Expression") : (0, _utils.assertNodeType)("Identifier", "MemberExpression") }, operator: { validate: (0, _utils.assertOneOf)(..._constants.UPDATE_OPERATORS) } }, visitor: ["argument"], aliases: ["Expression"] }); defineType("VariableDeclaration", { builder: ["kind", "declarations"], visitor: ["declarations"], aliases: ["Statement", "Declaration"], fields: { declare: { validate: (0, _utils.assertValueType)("boolean"), optional: true }, kind: { validate: (0, _utils.assertOneOf)("var", "let", "const") }, declarations: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("VariableDeclarator"))) } }, validate(parent, key, node) { if (!process.env.BABEL_TYPES_8_BREAKING) return; if (!(0, _is.default)("ForXStatement", parent, { left: node })) return; if (node.declarations.length !== 1) { throw new TypeError(`Exactly one VariableDeclarator is required in the VariableDeclaration of a ${parent.type}`); } } }); defineType("VariableDeclarator", { visitor: ["id", "init"], fields: { id: { validate: function () { if (!process.env.BABEL_TYPES_8_BREAKING) { return (0, _utils.assertNodeType)("LVal"); } const normal = (0, _utils.assertNodeType)("Identifier", "ArrayPattern", "ObjectPattern"); const without = (0, _utils.assertNodeType)("Identifier"); return function (node, key, val) { const validator = node.init ? normal : without; validator(node, key, val); }; }() }, definite: { optional: true, validate: (0, _utils.assertValueType)("boolean") }, init: { optional: true, validate: (0, _utils.assertNodeType)("Expression") } } }); defineType("WhileStatement", { visitor: ["test", "body"], aliases: ["Statement", "BlockParent", "Loop", "While", "Scopable"], fields: { test: { validate: (0, _utils.assertNodeType)("Expression") }, body: { validate: (0, _utils.assertNodeType)("Statement") } } }); defineType("WithStatement", { visitor: ["object", "body"], aliases: ["Statement"], fields: { object: { validate: (0, _utils.assertNodeType)("Expression") }, body: { validate: (0, _utils.assertNodeType)("Statement") } } }); defineType("AssignmentPattern", { visitor: ["left", "right", "decorators"], builder: ["left", "right"], aliases: ["Pattern", "PatternLike", "LVal"], fields: Object.assign({}, patternLikeCommon, { left: { validate: (0, _utils.assertNodeType)("Identifier", "ObjectPattern", "ArrayPattern", "MemberExpression", "TSAsExpression", "TSTypeAssertion", "TSNonNullExpression") }, right: { validate: (0, _utils.assertNodeType)("Expression") }, decorators: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))), optional: true } }) }); defineType("ArrayPattern", { visitor: ["elements", "typeAnnotation"], builder: ["elements"], aliases: ["Pattern", "PatternLike", "LVal"], fields: Object.assign({}, patternLikeCommon, { elements: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeOrValueType)("null", "PatternLike"))) }, decorators: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))), optional: true }, optional: { validate: (0, _utils.assertValueType)("boolean"), optional: true } }) }); defineType("ArrowFunctionExpression", { builder: ["params", "body", "async"], visitor: ["params", "body", "returnType", "typeParameters"], aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Expression", "Pureish"], fields: Object.assign({}, functionCommon, functionTypeAnnotationCommon, { expression: { validate: (0, _utils.assertValueType)("boolean") }, body: { validate: (0, _utils.assertNodeType)("BlockStatement", "Expression") }, predicate: { validate: (0, _utils.assertNodeType)("DeclaredPredicate", "InferredPredicate"), optional: true } }) }); defineType("ClassBody", { visitor: ["body"], fields: { body: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ClassMethod", "ClassPrivateMethod", "ClassProperty", "ClassPrivateProperty", "ClassAccessorProperty", "TSDeclareMethod", "TSIndexSignature", "StaticBlock"))) } } }); defineType("ClassExpression", { builder: ["id", "superClass", "body", "decorators"], visitor: ["id", "body", "superClass", "mixins", "typeParameters", "superTypeParameters", "implements", "decorators"], aliases: ["Scopable", "Class", "Expression"], fields: { id: { validate: (0, _utils.assertNodeType)("Identifier"), optional: true }, typeParameters: { validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"), optional: true }, body: { validate: (0, _utils.assertNodeType)("ClassBody") }, superClass: { optional: true, validate: (0, _utils.assertNodeType)("Expression") }, superTypeParameters: { validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"), optional: true }, implements: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSExpressionWithTypeArguments", "ClassImplements"))), optional: true }, decorators: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))), optional: true }, mixins: { validate: (0, _utils.assertNodeType)("InterfaceExtends"), optional: true } } }); defineType("ClassDeclaration", { inherits: "ClassExpression", aliases: ["Scopable", "Class", "Statement", "Declaration"], fields: { id: { validate: (0, _utils.assertNodeType)("Identifier") }, typeParameters: { validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"), optional: true }, body: { validate: (0, _utils.assertNodeType)("ClassBody") }, superClass: { optional: true, validate: (0, _utils.assertNodeType)("Expression") }, superTypeParameters: { validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"), optional: true }, implements: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSExpressionWithTypeArguments", "ClassImplements"))), optional: true }, decorators: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))), optional: true }, mixins: { validate: (0, _utils.assertNodeType)("InterfaceExtends"), optional: true }, declare: { validate: (0, _utils.assertValueType)("boolean"), optional: true }, abstract: { validate: (0, _utils.assertValueType)("boolean"), optional: true } }, validate: function () { const identifier = (0, _utils.assertNodeType)("Identifier"); return function (parent, key, node) { if (!process.env.BABEL_TYPES_8_BREAKING) return; if (!(0, _is.default)("ExportDefaultDeclaration", parent)) { identifier(node, "id", node.id); } }; }() }); defineType("ExportAllDeclaration", { visitor: ["source"], aliases: ["Statement", "Declaration", "ModuleDeclaration", "ExportDeclaration"], fields: { source: { validate: (0, _utils.assertNodeType)("StringLiteral") }, exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("type", "value")), assertions: { optional: true, validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportAttribute"))) } } }); defineType("ExportDefaultDeclaration", { visitor: ["declaration"], aliases: ["Statement", "Declaration", "ModuleDeclaration", "ExportDeclaration"], fields: { declaration: { validate: (0, _utils.assertNodeType)("FunctionDeclaration", "ClassDeclaration", "Expression") }, exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("value")) } }); defineType("ExportNamedDeclaration", { visitor: ["declaration", "specifiers", "source"], aliases: ["Statement", "Declaration", "ModuleDeclaration", "ExportDeclaration"], fields: { declaration: { optional: true, validate: (0, _utils.chain)((0, _utils.assertNodeType)("Declaration"), Object.assign(function (node, key, val) { if (!process.env.BABEL_TYPES_8_BREAKING) return; if (val && node.specifiers.length) { throw new TypeError("Only declaration or specifiers is allowed on ExportNamedDeclaration"); } }, { oneOfNodeTypes: ["Declaration"] }), function (node, key, val) { if (!process.env.BABEL_TYPES_8_BREAKING) return; if (val && node.source) { throw new TypeError("Cannot export a declaration from a source"); } }) }, assertions: { optional: true, validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportAttribute"))) }, specifiers: { default: [], validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)(function () { const sourced = (0, _utils.assertNodeType)("ExportSpecifier", "ExportDefaultSpecifier", "ExportNamespaceSpecifier"); const sourceless = (0, _utils.assertNodeType)("ExportSpecifier"); if (!process.env.BABEL_TYPES_8_BREAKING) return sourced; return function (node, key, val) { const validator = node.source ? sourced : sourceless; validator(node, key, val); }; }())) }, source: { validate: (0, _utils.assertNodeType)("StringLiteral"), optional: true }, exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("type", "value")) } }); defineType("ExportSpecifier", { visitor: ["local", "exported"], aliases: ["ModuleSpecifier"], fields: { local: { validate: (0, _utils.assertNodeType)("Identifier") }, exported: { validate: (0, _utils.assertNodeType)("Identifier", "StringLiteral") }, exportKind: { validate: (0, _utils.assertOneOf)("type", "value"), optional: true } } }); defineType("ForOfStatement", { visitor: ["left", "right", "body"], builder: ["left", "right", "body", "await"], aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop", "ForXStatement"], fields: { left: { validate: function () { if (!process.env.BABEL_TYPES_8_BREAKING) { return (0, _utils.assertNodeType)("VariableDeclaration", "LVal"); } const declaration = (0, _utils.assertNodeType)("VariableDeclaration"); const lval = (0, _utils.assertNodeType)("Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern", "TSAsExpression", "TSTypeAssertion", "TSNonNullExpression"); return function (node, key, val) { if ((0, _is.default)("VariableDeclaration", val)) { declaration(node, key, val); } else { lval(node, key, val); } }; }() }, right: { validate: (0, _utils.assertNodeType)("Expression") }, body: { validate: (0, _utils.assertNodeType)("Statement") }, await: { default: false } } }); defineType("ImportDeclaration", { visitor: ["specifiers", "source"], aliases: ["Statement", "Declaration", "ModuleDeclaration"], fields: { assertions: { optional: true, validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportAttribute"))) }, specifiers: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportSpecifier", "ImportDefaultSpecifier", "ImportNamespaceSpecifier"))) }, source: { validate: (0, _utils.assertNodeType)("StringLiteral") }, importKind: { validate: (0, _utils.assertOneOf)("type", "typeof", "value"), optional: true } } }); defineType("ImportDefaultSpecifier", { visitor: ["local"], aliases: ["ModuleSpecifier"], fields: { local: { validate: (0, _utils.assertNodeType)("Identifier") } } }); defineType("ImportNamespaceSpecifier", { visitor: ["local"], aliases: ["ModuleSpecifier"], fields: { local: { validate: (0, _utils.assertNodeType)("Identifier") } } }); defineType("ImportSpecifier", { visitor: ["local", "imported"], aliases: ["ModuleSpecifier"], fields: { local: { validate: (0, _utils.assertNodeType)("Identifier") }, imported: { validate: (0, _utils.assertNodeType)("Identifier", "StringLiteral") }, importKind: { validate: (0, _utils.assertOneOf)("type", "typeof", "value"), optional: true } } }); defineType("MetaProperty", { visitor: ["meta", "property"], aliases: ["Expression"], fields: { meta: { validate: (0, _utils.chain)((0, _utils.assertNodeType)("Identifier"), Object.assign(function (node, key, val) { if (!process.env.BABEL_TYPES_8_BREAKING) return; let property; switch (val.name) { case "function": property = "sent"; break; case "new": property = "target"; break; case "import": property = "meta"; break; } if (!(0, _is.default)("Identifier", node.property, { name: property })) { throw new TypeError("Unrecognised MetaProperty"); } }, { oneOfNodeTypes: ["Identifier"] })) }, property: { validate: (0, _utils.assertNodeType)("Identifier") } } }); const classMethodOrPropertyCommon = { abstract: { validate: (0, _utils.assertValueType)("boolean"), optional: true }, accessibility: { validate: (0, _utils.assertOneOf)("public", "private", "protected"), optional: true }, static: { default: false }, override: { default: false }, computed: { default: false }, optional: { validate: (0, _utils.assertValueType)("boolean"), optional: true }, key: { validate: (0, _utils.chain)(function () { const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral"); const computed = (0, _utils.assertNodeType)("Expression"); return function (node, key, val) { const validator = node.computed ? computed : normal; validator(node, key, val); }; }(), (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "Expression")) } }; exports.classMethodOrPropertyCommon = classMethodOrPropertyCommon; const classMethodOrDeclareMethodCommon = Object.assign({}, functionCommon, classMethodOrPropertyCommon, { params: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Identifier", "Pattern", "RestElement", "TSParameterProperty"))) }, kind: { validate: (0, _utils.assertOneOf)("get", "set", "method", "constructor"), default: "method" }, access: { validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), (0, _utils.assertOneOf)("public", "private", "protected")), optional: true }, decorators: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))), optional: true } }); exports.classMethodOrDeclareMethodCommon = classMethodOrDeclareMethodCommon; defineType("ClassMethod", { aliases: ["Function", "Scopable", "BlockParent", "FunctionParent", "Method"], builder: ["kind", "key", "params", "body", "computed", "static", "generator", "async"], visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"], fields: Object.assign({}, classMethodOrDeclareMethodCommon, functionTypeAnnotationCommon, { body: { validate: (0, _utils.assertNodeType)("BlockStatement") } }) }); defineType("ObjectPattern", { visitor: ["properties", "typeAnnotation", "decorators"], builder: ["properties"], aliases: ["Pattern", "PatternLike", "LVal"], fields: Object.assign({}, patternLikeCommon, { properties: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("RestElement", "ObjectProperty"))) } }) }); defineType("SpreadElement", { visitor: ["argument"], aliases: ["UnaryLike"], deprecatedAlias: "SpreadProperty", fields: { argument: { validate: (0, _utils.assertNodeType)("Expression") } } }); defineType("Super", { aliases: ["Expression"] }); defineType("TaggedTemplateExpression", { visitor: ["tag", "quasi", "typeParameters"], builder: ["tag", "quasi"], aliases: ["Expression"], fields: { tag: { validate: (0, _utils.assertNodeType)("Expression") }, quasi: { validate: (0, _utils.assertNodeType)("TemplateLiteral") }, typeParameters: { validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"), optional: true } } }); defineType("TemplateElement", { builder: ["value", "tail"], fields: { value: { validate: (0, _utils.assertShape)({ raw: { validate: (0, _utils.assertValueType)("string") }, cooked: { validate: (0, _utils.assertValueType)("string"), optional: true } }) }, tail: { default: false } } }); defineType("TemplateLiteral", { visitor: ["quasis", "expressions"], aliases: ["Expression", "Literal"], fields: { quasis: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TemplateElement"))) }, expressions: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "TSType")), function (node, key, val) { if (node.quasis.length !== val.length + 1) { throw new TypeError(`Number of ${node.type} quasis should be exactly one more than the number of expressions.\nExpected ${val.length + 1} quasis but got ${node.quasis.length}`); } }) } } }); defineType("YieldExpression", { builder: ["argument", "delegate"], visitor: ["argument"], aliases: ["Expression", "Terminatorless"], fields: { delegate: { validate: (0, _utils.chain)((0, _utils.assertValueType)("boolean"), Object.assign(function (node, key, val) { if (!process.env.BABEL_TYPES_8_BREAKING) return; if (val && !node.argument) { throw new TypeError("Property delegate of YieldExpression cannot be true if there is no argument"); } }, { type: "boolean" })), default: false }, argument: { optional: true, validate: (0, _utils.assertNodeType)("Expression") } } }); defineType("AwaitExpression", { builder: ["argument"], visitor: ["argument"], aliases: ["Expression", "Terminatorless"], fields: { argument: { validate: (0, _utils.assertNodeType)("Expression") } } }); defineType("Import", { aliases: ["Expression"] }); defineType("BigIntLiteral", { builder: ["value"], fields: { value: { validate: (0, _utils.assertValueType)("string") } }, aliases: ["Expression", "Pureish", "Literal", "Immutable"] }); defineType("ExportNamespaceSpecifier", { visitor: ["exported"], aliases: ["ModuleSpecifier"], fields: { exported: { validate: (0, _utils.assertNodeType)("Identifier") } } }); defineType("OptionalMemberExpression", { builder: ["object", "property", "computed", "optional"], visitor: ["object", "property"], aliases: ["Expression"], fields: { object: { validate: (0, _utils.assertNodeType)("Expression") }, property: { validate: function () { const normal = (0, _utils.assertNodeType)("Identifier"); const computed = (0, _utils.assertNodeType)("Expression"); const validator = Object.assign(function (node, key, val) { const validator = node.computed ? computed : normal; validator(node, key, val); }, { oneOfNodeTypes: ["Expression", "Identifier"] }); return validator; }() }, computed: { default: false }, optional: { validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertValueType)("boolean") : (0, _utils.chain)((0, _utils.assertValueType)("boolean"), (0, _utils.assertOptionalChainStart)()) } } }); defineType("OptionalCallExpression", { visitor: ["callee", "arguments", "typeParameters", "typeArguments"], builder: ["callee", "arguments", "optional"], aliases: ["Expression"], fields: { callee: { validate: (0, _utils.assertNodeType)("Expression") }, arguments: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement", "JSXNamespacedName", "ArgumentPlaceholder"))) }, optional: { validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertValueType)("boolean") : (0, _utils.chain)((0, _utils.assertValueType)("boolean"), (0, _utils.assertOptionalChainStart)()) }, typeArguments: { validate: (0, _utils.assertNodeType)("TypeParameterInstantiation"), optional: true }, typeParameters: { validate: (0, _utils.assertNodeType)("TSTypeParameterInstantiation"), optional: true } } }); defineType("ClassProperty", { visitor: ["key", "value", "typeAnnotation", "decorators"], builder: ["key", "value", "typeAnnotation", "decorators", "computed", "static"], aliases: ["Property"], fields: Object.assign({}, classMethodOrPropertyCommon, { value: { validate: (0, _utils.assertNodeType)("Expression"), optional: true }, definite: { validate: (0, _utils.assertValueType)("boolean"), optional: true }, typeAnnotation: { validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"), optional: true }, decorators: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))), optional: true }, readonly: { validate: (0, _utils.assertValueType)("boolean"), optional: true }, declare: { validate: (0, _utils.assertValueType)("boolean"), optional: true }, variance: { validate: (0, _utils.assertNodeType)("Variance"), optional: true } }) }); defineType("ClassAccessorProperty", { visitor: ["key", "value", "typeAnnotation", "decorators"], builder: ["key", "value", "typeAnnotation", "decorators", "computed", "static"], aliases: ["Property", "Accessor"], fields: Object.assign({}, classMethodOrPropertyCommon, { key: { validate: (0, _utils.chain)(function () { const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "PrivateName"); const computed = (0, _utils.assertNodeType)("Expression"); return function (node, key, val) { const validator = node.computed ? computed : normal; validator(node, key, val); }; }(), (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "Expression", "PrivateName")) }, value: { validate: (0, _utils.assertNodeType)("Expression"), optional: true }, definite: { validate: (0, _utils.assertValueType)("boolean"), optional: true }, typeAnnotation: { validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"), optional: true }, decorators: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))), optional: true }, readonly: { validate: (0, _utils.assertValueType)("boolean"), optional: true }, declare: { validate: (0, _utils.assertValueType)("boolean"), optional: true }, variance: { validate: (0, _utils.assertNodeType)("Variance"), optional: true } }) }); defineType("ClassPrivateProperty", { visitor: ["key", "value", "decorators", "typeAnnotation"], builder: ["key", "value", "decorators", "static"], aliases: ["Property", "Private"], fields: { key: { validate: (0, _utils.assertNodeType)("PrivateName") }, value: { validate: (0, _utils.assertNodeType)("Expression"), optional: true }, typeAnnotation: { validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"), optional: true }, decorators: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))), optional: true }, readonly: { validate: (0, _utils.assertValueType)("boolean"), optional: true }, definite: { validate: (0, _utils.assertValueType)("boolean"), optional: true }, variance: { validate: (0, _utils.assertNodeType)("Variance"), optional: true } } }); defineType("ClassPrivateMethod", { builder: ["kind", "key", "params", "body", "static"], visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"], aliases: ["Function", "Scopable", "BlockParent", "FunctionParent", "Method", "Private"], fields: Object.assign({}, classMethodOrDeclareMethodCommon, functionTypeAnnotationCommon, { key: { validate: (0, _utils.assertNodeType)("PrivateName") }, body: { validate: (0, _utils.assertNodeType)("BlockStatement") } }) }); defineType("PrivateName", { visitor: ["id"], aliases: ["Private"], fields: { id: { validate: (0, _utils.assertNodeType)("Identifier") } } }); defineType("StaticBlock", { visitor: ["body"], fields: { body: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement"))) } }, aliases: ["Scopable", "BlockParent", "FunctionParent"] }); }).call(this)}).call(this,require('_process')) },{"../constants":107,"../validators/is":145,"../validators/isValidIdentifier":158,"./utils":127,"@babel/helper-validator-identifier":256,"_process":460}],120:[function(require,module,exports){ (function (process){(function (){ "use strict"; var _utils = require("./utils"); (0, _utils.default)("ArgumentPlaceholder", {}); (0, _utils.default)("BindExpression", { visitor: ["object", "callee"], aliases: ["Expression"], fields: !process.env.BABEL_TYPES_8_BREAKING ? { object: { validate: Object.assign(() => {}, { oneOfNodeTypes: ["Expression"] }) }, callee: { validate: Object.assign(() => {}, { oneOfNodeTypes: ["Expression"] }) } } : { object: { validate: (0, _utils.assertNodeType)("Expression") }, callee: { validate: (0, _utils.assertNodeType)("Expression") } } }); (0, _utils.default)("ImportAttribute", { visitor: ["key", "value"], fields: { key: { validate: (0, _utils.assertNodeType)("Identifier", "StringLiteral") }, value: { validate: (0, _utils.assertNodeType)("StringLiteral") } } }); (0, _utils.default)("Decorator", { visitor: ["expression"], fields: { expression: { validate: (0, _utils.assertNodeType)("Expression") } } }); (0, _utils.default)("DoExpression", { visitor: ["body"], builder: ["body", "async"], aliases: ["Expression"], fields: { body: { validate: (0, _utils.assertNodeType)("BlockStatement") }, async: { validate: (0, _utils.assertValueType)("boolean"), default: false } } }); (0, _utils.default)("ExportDefaultSpecifier", { visitor: ["exported"], aliases: ["ModuleSpecifier"], fields: { exported: { validate: (0, _utils.assertNodeType)("Identifier") } } }); (0, _utils.default)("RecordExpression", { visitor: ["properties"], aliases: ["Expression"], fields: { properties: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ObjectProperty", "SpreadElement"))) } } }); (0, _utils.default)("TupleExpression", { fields: { elements: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement"))), default: [] } }, visitor: ["elements"], aliases: ["Expression"] }); (0, _utils.default)("DecimalLiteral", { builder: ["value"], fields: { value: { validate: (0, _utils.assertValueType)("string") } }, aliases: ["Expression", "Pureish", "Literal", "Immutable"] }); (0, _utils.default)("ModuleExpression", { visitor: ["body"], fields: { body: { validate: (0, _utils.assertNodeType)("Program") } }, aliases: ["Expression"] }); (0, _utils.default)("TopicReference", { aliases: ["Expression"] }); (0, _utils.default)("PipelineTopicExpression", { builder: ["expression"], visitor: ["expression"], fields: { expression: { validate: (0, _utils.assertNodeType)("Expression") } }, aliases: ["Expression"] }); (0, _utils.default)("PipelineBareFunction", { builder: ["callee"], visitor: ["callee"], fields: { callee: { validate: (0, _utils.assertNodeType)("Expression") } }, aliases: ["Expression"] }); (0, _utils.default)("PipelinePrimaryTopicReference", { aliases: ["Expression"] }); }).call(this)}).call(this,require('_process')) },{"./utils":127,"_process":460}],121:[function(require,module,exports){ "use strict"; var _utils = require("./utils"); const defineType = (0, _utils.defineAliasedType)("Flow"); const defineInterfaceishType = name => { defineType(name, { builder: ["id", "typeParameters", "extends", "body"], visitor: ["id", "typeParameters", "extends", "mixins", "implements", "body"], aliases: ["FlowDeclaration", "Statement", "Declaration"], fields: { id: (0, _utils.validateType)("Identifier"), typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"), extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")), mixins: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")), implements: (0, _utils.validateOptional)((0, _utils.arrayOfType)("ClassImplements")), body: (0, _utils.validateType)("ObjectTypeAnnotation") } }); }; defineType("AnyTypeAnnotation", { aliases: ["FlowType", "FlowBaseAnnotation"] }); defineType("ArrayTypeAnnotation", { visitor: ["elementType"], aliases: ["FlowType"], fields: { elementType: (0, _utils.validateType)("FlowType") } }); defineType("BooleanTypeAnnotation", { aliases: ["FlowType", "FlowBaseAnnotation"] }); defineType("BooleanLiteralTypeAnnotation", { builder: ["value"], aliases: ["FlowType"], fields: { value: (0, _utils.validate)((0, _utils.assertValueType)("boolean")) } }); defineType("NullLiteralTypeAnnotation", { aliases: ["FlowType", "FlowBaseAnnotation"] }); defineType("ClassImplements", { visitor: ["id", "typeParameters"], fields: { id: (0, _utils.validateType)("Identifier"), typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation") } }); defineInterfaceishType("DeclareClass"); defineType("DeclareFunction", { visitor: ["id"], aliases: ["FlowDeclaration", "Statement", "Declaration"], fields: { id: (0, _utils.validateType)("Identifier"), predicate: (0, _utils.validateOptionalType)("DeclaredPredicate") } }); defineInterfaceishType("DeclareInterface"); defineType("DeclareModule", { builder: ["id", "body", "kind"], visitor: ["id", "body"], aliases: ["FlowDeclaration", "Statement", "Declaration"], fields: { id: (0, _utils.validateType)(["Identifier", "StringLiteral"]), body: (0, _utils.validateType)("BlockStatement"), kind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("CommonJS", "ES")) } }); defineType("DeclareModuleExports", { visitor: ["typeAnnotation"], aliases: ["FlowDeclaration", "Statement", "Declaration"], fields: { typeAnnotation: (0, _utils.validateType)("TypeAnnotation") } }); defineType("DeclareTypeAlias", { visitor: ["id", "typeParameters", "right"], aliases: ["FlowDeclaration", "Statement", "Declaration"], fields: { id: (0, _utils.validateType)("Identifier"), typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"), right: (0, _utils.validateType)("FlowType") } }); defineType("DeclareOpaqueType", { visitor: ["id", "typeParameters", "supertype"], aliases: ["FlowDeclaration", "Statement", "Declaration"], fields: { id: (0, _utils.validateType)("Identifier"), typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"), supertype: (0, _utils.validateOptionalType)("FlowType"), impltype: (0, _utils.validateOptionalType)("FlowType") } }); defineType("DeclareVariable", { visitor: ["id"], aliases: ["FlowDeclaration", "Statement", "Declaration"], fields: { id: (0, _utils.validateType)("Identifier") } }); defineType("DeclareExportDeclaration", { visitor: ["declaration", "specifiers", "source"], aliases: ["FlowDeclaration", "Statement", "Declaration"], fields: { declaration: (0, _utils.validateOptionalType)("Flow"), specifiers: (0, _utils.validateOptional)((0, _utils.arrayOfType)(["ExportSpecifier", "ExportNamespaceSpecifier"])), source: (0, _utils.validateOptionalType)("StringLiteral"), default: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean")) } }); defineType("DeclareExportAllDeclaration", { visitor: ["source"], aliases: ["FlowDeclaration", "Statement", "Declaration"], fields: { source: (0, _utils.validateType)("StringLiteral"), exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("type", "value")) } }); defineType("DeclaredPredicate", { visitor: ["value"], aliases: ["FlowPredicate"], fields: { value: (0, _utils.validateType)("Flow") } }); defineType("ExistsTypeAnnotation", { aliases: ["FlowType"] }); defineType("FunctionTypeAnnotation", { visitor: ["typeParameters", "params", "rest", "returnType"], aliases: ["FlowType"], fields: { typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"), params: (0, _utils.validate)((0, _utils.arrayOfType)("FunctionTypeParam")), rest: (0, _utils.validateOptionalType)("FunctionTypeParam"), this: (0, _utils.validateOptionalType)("FunctionTypeParam"), returnType: (0, _utils.validateType)("FlowType") } }); defineType("FunctionTypeParam", { visitor: ["name", "typeAnnotation"], fields: { name: (0, _utils.validateOptionalType)("Identifier"), typeAnnotation: (0, _utils.validateType)("FlowType"), optional: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean")) } }); defineType("GenericTypeAnnotation", { visitor: ["id", "typeParameters"], aliases: ["FlowType"], fields: { id: (0, _utils.validateType)(["Identifier", "QualifiedTypeIdentifier"]), typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation") } }); defineType("InferredPredicate", { aliases: ["FlowPredicate"] }); defineType("InterfaceExtends", { visitor: ["id", "typeParameters"], fields: { id: (0, _utils.validateType)(["Identifier", "QualifiedTypeIdentifier"]), typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation") } }); defineInterfaceishType("InterfaceDeclaration"); defineType("InterfaceTypeAnnotation", { visitor: ["extends", "body"], aliases: ["FlowType"], fields: { extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")), body: (0, _utils.validateType)("ObjectTypeAnnotation") } }); defineType("IntersectionTypeAnnotation", { visitor: ["types"], aliases: ["FlowType"], fields: { types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType")) } }); defineType("MixedTypeAnnotation", { aliases: ["FlowType", "FlowBaseAnnotation"] }); defineType("EmptyTypeAnnotation", { aliases: ["FlowType", "FlowBaseAnnotation"] }); defineType("NullableTypeAnnotation", { visitor: ["typeAnnotation"], aliases: ["FlowType"], fields: { typeAnnotation: (0, _utils.validateType)("FlowType") } }); defineType("NumberLiteralTypeAnnotation", { builder: ["value"], aliases: ["FlowType"], fields: { value: (0, _utils.validate)((0, _utils.assertValueType)("number")) } }); defineType("NumberTypeAnnotation", { aliases: ["FlowType", "FlowBaseAnnotation"] }); defineType("ObjectTypeAnnotation", { visitor: ["properties", "indexers", "callProperties", "internalSlots"], aliases: ["FlowType"], builder: ["properties", "indexers", "callProperties", "internalSlots", "exact"], fields: { properties: (0, _utils.validate)((0, _utils.arrayOfType)(["ObjectTypeProperty", "ObjectTypeSpreadProperty"])), indexers: { validate: (0, _utils.arrayOfType)("ObjectTypeIndexer"), optional: true, default: [] }, callProperties: { validate: (0, _utils.arrayOfType)("ObjectTypeCallProperty"), optional: true, default: [] }, internalSlots: { validate: (0, _utils.arrayOfType)("ObjectTypeInternalSlot"), optional: true, default: [] }, exact: { validate: (0, _utils.assertValueType)("boolean"), default: false }, inexact: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean")) } }); defineType("ObjectTypeInternalSlot", { visitor: ["id", "value", "optional", "static", "method"], aliases: ["UserWhitespacable"], fields: { id: (0, _utils.validateType)("Identifier"), value: (0, _utils.validateType)("FlowType"), optional: (0, _utils.validate)((0, _utils.assertValueType)("boolean")), static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")), method: (0, _utils.validate)((0, _utils.assertValueType)("boolean")) } }); defineType("ObjectTypeCallProperty", { visitor: ["value"], aliases: ["UserWhitespacable"], fields: { value: (0, _utils.validateType)("FlowType"), static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")) } }); defineType("ObjectTypeIndexer", { visitor: ["id", "key", "value", "variance"], aliases: ["UserWhitespacable"], fields: { id: (0, _utils.validateOptionalType)("Identifier"), key: (0, _utils.validateType)("FlowType"), value: (0, _utils.validateType)("FlowType"), static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")), variance: (0, _utils.validateOptionalType)("Variance") } }); defineType("ObjectTypeProperty", { visitor: ["key", "value", "variance"], aliases: ["UserWhitespacable"], fields: { key: (0, _utils.validateType)(["Identifier", "StringLiteral"]), value: (0, _utils.validateType)("FlowType"), kind: (0, _utils.validate)((0, _utils.assertOneOf)("init", "get", "set")), static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")), proto: (0, _utils.validate)((0, _utils.assertValueType)("boolean")), optional: (0, _utils.validate)((0, _utils.assertValueType)("boolean")), variance: (0, _utils.validateOptionalType)("Variance"), method: (0, _utils.validate)((0, _utils.assertValueType)("boolean")) } }); defineType("ObjectTypeSpreadProperty", { visitor: ["argument"], aliases: ["UserWhitespacable"], fields: { argument: (0, _utils.validateType)("FlowType") } }); defineType("OpaqueType", { visitor: ["id", "typeParameters", "supertype", "impltype"], aliases: ["FlowDeclaration", "Statement", "Declaration"], fields: { id: (0, _utils.validateType)("Identifier"), typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"), supertype: (0, _utils.validateOptionalType)("FlowType"), impltype: (0, _utils.validateType)("FlowType") } }); defineType("QualifiedTypeIdentifier", { visitor: ["id", "qualification"], fields: { id: (0, _utils.validateType)("Identifier"), qualification: (0, _utils.validateType)(["Identifier", "QualifiedTypeIdentifier"]) } }); defineType("StringLiteralTypeAnnotation", { builder: ["value"], aliases: ["FlowType"], fields: { value: (0, _utils.validate)((0, _utils.assertValueType)("string")) } }); defineType("StringTypeAnnotation", { aliases: ["FlowType", "FlowBaseAnnotation"] }); defineType("SymbolTypeAnnotation", { aliases: ["FlowType", "FlowBaseAnnotation"] }); defineType("ThisTypeAnnotation", { aliases: ["FlowType", "FlowBaseAnnotation"] }); defineType("TupleTypeAnnotation", { visitor: ["types"], aliases: ["FlowType"], fields: { types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType")) } }); defineType("TypeofTypeAnnotation", { visitor: ["argument"], aliases: ["FlowType"], fields: { argument: (0, _utils.validateType)("FlowType") } }); defineType("TypeAlias", { visitor: ["id", "typeParameters", "right"], aliases: ["FlowDeclaration", "Statement", "Declaration"], fields: { id: (0, _utils.validateType)("Identifier"), typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"), right: (0, _utils.validateType)("FlowType") } }); defineType("TypeAnnotation", { visitor: ["typeAnnotation"], fields: { typeAnnotation: (0, _utils.validateType)("FlowType") } }); defineType("TypeCastExpression", { visitor: ["expression", "typeAnnotation"], aliases: ["ExpressionWrapper", "Expression"], fields: { expression: (0, _utils.validateType)("Expression"), typeAnnotation: (0, _utils.validateType)("TypeAnnotation") } }); defineType("TypeParameter", { visitor: ["bound", "default", "variance"], fields: { name: (0, _utils.validate)((0, _utils.assertValueType)("string")), bound: (0, _utils.validateOptionalType)("TypeAnnotation"), default: (0, _utils.validateOptionalType)("FlowType"), variance: (0, _utils.validateOptionalType)("Variance") } }); defineType("TypeParameterDeclaration", { visitor: ["params"], fields: { params: (0, _utils.validate)((0, _utils.arrayOfType)("TypeParameter")) } }); defineType("TypeParameterInstantiation", { visitor: ["params"], fields: { params: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType")) } }); defineType("UnionTypeAnnotation", { visitor: ["types"], aliases: ["FlowType"], fields: { types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType")) } }); defineType("Variance", { builder: ["kind"], fields: { kind: (0, _utils.validate)((0, _utils.assertOneOf)("minus", "plus")) } }); defineType("VoidTypeAnnotation", { aliases: ["FlowType", "FlowBaseAnnotation"] }); defineType("EnumDeclaration", { aliases: ["Statement", "Declaration"], visitor: ["id", "body"], fields: { id: (0, _utils.validateType)("Identifier"), body: (0, _utils.validateType)(["EnumBooleanBody", "EnumNumberBody", "EnumStringBody", "EnumSymbolBody"]) } }); defineType("EnumBooleanBody", { aliases: ["EnumBody"], visitor: ["members"], fields: { explicitType: (0, _utils.validate)((0, _utils.assertValueType)("boolean")), members: (0, _utils.validateArrayOfType)("EnumBooleanMember"), hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)("boolean")) } }); defineType("EnumNumberBody", { aliases: ["EnumBody"], visitor: ["members"], fields: { explicitType: (0, _utils.validate)((0, _utils.assertValueType)("boolean")), members: (0, _utils.validateArrayOfType)("EnumNumberMember"), hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)("boolean")) } }); defineType("EnumStringBody", { aliases: ["EnumBody"], visitor: ["members"], fields: { explicitType: (0, _utils.validate)((0, _utils.assertValueType)("boolean")), members: (0, _utils.validateArrayOfType)(["EnumStringMember", "EnumDefaultedMember"]), hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)("boolean")) } }); defineType("EnumSymbolBody", { aliases: ["EnumBody"], visitor: ["members"], fields: { members: (0, _utils.validateArrayOfType)("EnumDefaultedMember"), hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)("boolean")) } }); defineType("EnumBooleanMember", { aliases: ["EnumMember"], visitor: ["id"], fields: { id: (0, _utils.validateType)("Identifier"), init: (0, _utils.validateType)("BooleanLiteral") } }); defineType("EnumNumberMember", { aliases: ["EnumMember"], visitor: ["id", "init"], fields: { id: (0, _utils.validateType)("Identifier"), init: (0, _utils.validateType)("NumericLiteral") } }); defineType("EnumStringMember", { aliases: ["EnumMember"], visitor: ["id", "init"], fields: { id: (0, _utils.validateType)("Identifier"), init: (0, _utils.validateType)("StringLiteral") } }); defineType("EnumDefaultedMember", { aliases: ["EnumMember"], visitor: ["id"], fields: { id: (0, _utils.validateType)("Identifier") } }); defineType("IndexedAccessType", { visitor: ["objectType", "indexType"], aliases: ["FlowType"], fields: { objectType: (0, _utils.validateType)("FlowType"), indexType: (0, _utils.validateType)("FlowType") } }); defineType("OptionalIndexedAccessType", { visitor: ["objectType", "indexType"], aliases: ["FlowType"], fields: { objectType: (0, _utils.validateType)("FlowType"), indexType: (0, _utils.validateType)("FlowType"), optional: (0, _utils.validate)((0, _utils.assertValueType)("boolean")) } }); },{"./utils":127}],122:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); Object.defineProperty(exports, "ALIAS_KEYS", { enumerable: true, get: function () { return _utils.ALIAS_KEYS; } }); Object.defineProperty(exports, "BUILDER_KEYS", { enumerable: true, get: function () { return _utils.BUILDER_KEYS; } }); Object.defineProperty(exports, "DEPRECATED_KEYS", { enumerable: true, get: function () { return _utils.DEPRECATED_KEYS; } }); Object.defineProperty(exports, "FLIPPED_ALIAS_KEYS", { enumerable: true, get: function () { return _utils.FLIPPED_ALIAS_KEYS; } }); Object.defineProperty(exports, "NODE_FIELDS", { enumerable: true, get: function () { return _utils.NODE_FIELDS; } }); Object.defineProperty(exports, "NODE_PARENT_VALIDATIONS", { enumerable: true, get: function () { return _utils.NODE_PARENT_VALIDATIONS; } }); Object.defineProperty(exports, "PLACEHOLDERS", { enumerable: true, get: function () { return _placeholders.PLACEHOLDERS; } }); Object.defineProperty(exports, "PLACEHOLDERS_ALIAS", { enumerable: true, get: function () { return _placeholders.PLACEHOLDERS_ALIAS; } }); Object.defineProperty(exports, "PLACEHOLDERS_FLIPPED_ALIAS", { enumerable: true, get: function () { return _placeholders.PLACEHOLDERS_FLIPPED_ALIAS; } }); exports.TYPES = void 0; Object.defineProperty(exports, "VISITOR_KEYS", { enumerable: true, get: function () { return _utils.VISITOR_KEYS; } }); var _toFastProperties = require("to-fast-properties"); require("./core"); require("./flow"); require("./jsx"); require("./misc"); require("./experimental"); require("./typescript"); var _utils = require("./utils"); var _placeholders = require("./placeholders"); _toFastProperties(_utils.VISITOR_KEYS); _toFastProperties(_utils.ALIAS_KEYS); _toFastProperties(_utils.FLIPPED_ALIAS_KEYS); _toFastProperties(_utils.NODE_FIELDS); _toFastProperties(_utils.BUILDER_KEYS); _toFastProperties(_utils.DEPRECATED_KEYS); _toFastProperties(_placeholders.PLACEHOLDERS_ALIAS); _toFastProperties(_placeholders.PLACEHOLDERS_FLIPPED_ALIAS); const TYPES = [].concat(Object.keys(_utils.VISITOR_KEYS), Object.keys(_utils.FLIPPED_ALIAS_KEYS), Object.keys(_utils.DEPRECATED_KEYS)); exports.TYPES = TYPES; },{"./core":119,"./experimental":120,"./flow":121,"./jsx":123,"./misc":124,"./placeholders":125,"./typescript":126,"./utils":127,"to-fast-properties":540}],123:[function(require,module,exports){ "use strict"; var _utils = require("./utils"); const defineType = (0, _utils.defineAliasedType)("JSX"); defineType("JSXAttribute", { visitor: ["name", "value"], aliases: ["Immutable"], fields: { name: { validate: (0, _utils.assertNodeType)("JSXIdentifier", "JSXNamespacedName") }, value: { optional: true, validate: (0, _utils.assertNodeType)("JSXElement", "JSXFragment", "StringLiteral", "JSXExpressionContainer") } } }); defineType("JSXClosingElement", { visitor: ["name"], aliases: ["Immutable"], fields: { name: { validate: (0, _utils.assertNodeType)("JSXIdentifier", "JSXMemberExpression", "JSXNamespacedName") } } }); defineType("JSXElement", { builder: ["openingElement", "closingElement", "children", "selfClosing"], visitor: ["openingElement", "children", "closingElement"], aliases: ["Immutable", "Expression"], fields: Object.assign({ openingElement: { validate: (0, _utils.assertNodeType)("JSXOpeningElement") }, closingElement: { optional: true, validate: (0, _utils.assertNodeType)("JSXClosingElement") }, children: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("JSXText", "JSXExpressionContainer", "JSXSpreadChild", "JSXElement", "JSXFragment"))) } }, { selfClosing: { validate: (0, _utils.assertValueType)("boolean"), optional: true } }) }); defineType("JSXEmptyExpression", {}); defineType("JSXExpressionContainer", { visitor: ["expression"], aliases: ["Immutable"], fields: { expression: { validate: (0, _utils.assertNodeType)("Expression", "JSXEmptyExpression") } } }); defineType("JSXSpreadChild", { visitor: ["expression"], aliases: ["Immutable"], fields: { expression: { validate: (0, _utils.assertNodeType)("Expression") } } }); defineType("JSXIdentifier", { builder: ["name"], fields: { name: { validate: (0, _utils.assertValueType)("string") } } }); defineType("JSXMemberExpression", { visitor: ["object", "property"], fields: { object: { validate: (0, _utils.assertNodeType)("JSXMemberExpression", "JSXIdentifier") }, property: { validate: (0, _utils.assertNodeType)("JSXIdentifier") } } }); defineType("JSXNamespacedName", { visitor: ["namespace", "name"], fields: { namespace: { validate: (0, _utils.assertNodeType)("JSXIdentifier") }, name: { validate: (0, _utils.assertNodeType)("JSXIdentifier") } } }); defineType("JSXOpeningElement", { builder: ["name", "attributes", "selfClosing"], visitor: ["name", "attributes"], aliases: ["Immutable"], fields: { name: { validate: (0, _utils.assertNodeType)("JSXIdentifier", "JSXMemberExpression", "JSXNamespacedName") }, selfClosing: { default: false }, attributes: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("JSXAttribute", "JSXSpreadAttribute"))) }, typeParameters: { validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"), optional: true } } }); defineType("JSXSpreadAttribute", { visitor: ["argument"], fields: { argument: { validate: (0, _utils.assertNodeType)("Expression") } } }); defineType("JSXText", { aliases: ["Immutable"], builder: ["value"], fields: { value: { validate: (0, _utils.assertValueType)("string") } } }); defineType("JSXFragment", { builder: ["openingFragment", "closingFragment", "children"], visitor: ["openingFragment", "children", "closingFragment"], aliases: ["Immutable", "Expression"], fields: { openingFragment: { validate: (0, _utils.assertNodeType)("JSXOpeningFragment") }, closingFragment: { validate: (0, _utils.assertNodeType)("JSXClosingFragment") }, children: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("JSXText", "JSXExpressionContainer", "JSXSpreadChild", "JSXElement", "JSXFragment"))) } } }); defineType("JSXOpeningFragment", { aliases: ["Immutable"] }); defineType("JSXClosingFragment", { aliases: ["Immutable"] }); },{"./utils":127}],124:[function(require,module,exports){ "use strict"; var _utils = require("./utils"); var _placeholders = require("./placeholders"); const defineType = (0, _utils.defineAliasedType)("Miscellaneous"); { defineType("Noop", { visitor: [] }); } defineType("Placeholder", { visitor: [], builder: ["expectedNode", "name"], fields: { name: { validate: (0, _utils.assertNodeType)("Identifier") }, expectedNode: { validate: (0, _utils.assertOneOf)(..._placeholders.PLACEHOLDERS) } } }); defineType("V8IntrinsicIdentifier", { builder: ["name"], fields: { name: { validate: (0, _utils.assertValueType)("string") } } }); },{"./placeholders":125,"./utils":127}],125:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.PLACEHOLDERS_FLIPPED_ALIAS = exports.PLACEHOLDERS_ALIAS = exports.PLACEHOLDERS = void 0; var _utils = require("./utils"); const PLACEHOLDERS = ["Identifier", "StringLiteral", "Expression", "Statement", "Declaration", "BlockStatement", "ClassBody", "Pattern"]; exports.PLACEHOLDERS = PLACEHOLDERS; const PLACEHOLDERS_ALIAS = { Declaration: ["Statement"], Pattern: ["PatternLike", "LVal"] }; exports.PLACEHOLDERS_ALIAS = PLACEHOLDERS_ALIAS; for (const type of PLACEHOLDERS) { const alias = _utils.ALIAS_KEYS[type]; if (alias != null && alias.length) PLACEHOLDERS_ALIAS[type] = alias; } const PLACEHOLDERS_FLIPPED_ALIAS = {}; exports.PLACEHOLDERS_FLIPPED_ALIAS = PLACEHOLDERS_FLIPPED_ALIAS; Object.keys(PLACEHOLDERS_ALIAS).forEach(type => { PLACEHOLDERS_ALIAS[type].forEach(alias => { if (!Object.hasOwnProperty.call(PLACEHOLDERS_FLIPPED_ALIAS, alias)) { PLACEHOLDERS_FLIPPED_ALIAS[alias] = []; } PLACEHOLDERS_FLIPPED_ALIAS[alias].push(type); }); }); },{"./utils":127}],126:[function(require,module,exports){ "use strict"; var _utils = require("./utils"); var _core = require("./core"); var _is = require("../validators/is"); const defineType = (0, _utils.defineAliasedType)("TypeScript"); const bool = (0, _utils.assertValueType)("boolean"); const tSFunctionTypeAnnotationCommon = { returnType: { validate: (0, _utils.assertNodeType)("TSTypeAnnotation", "Noop"), optional: true }, typeParameters: { validate: (0, _utils.assertNodeType)("TSTypeParameterDeclaration", "Noop"), optional: true } }; defineType("TSParameterProperty", { aliases: ["LVal"], visitor: ["parameter"], fields: { accessibility: { validate: (0, _utils.assertOneOf)("public", "private", "protected"), optional: true }, readonly: { validate: (0, _utils.assertValueType)("boolean"), optional: true }, parameter: { validate: (0, _utils.assertNodeType)("Identifier", "AssignmentPattern") }, override: { validate: (0, _utils.assertValueType)("boolean"), optional: true }, decorators: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))), optional: true } } }); defineType("TSDeclareFunction", { aliases: ["Statement", "Declaration"], visitor: ["id", "typeParameters", "params", "returnType"], fields: Object.assign({}, _core.functionDeclarationCommon, tSFunctionTypeAnnotationCommon) }); defineType("TSDeclareMethod", { visitor: ["decorators", "key", "typeParameters", "params", "returnType"], fields: Object.assign({}, _core.classMethodOrDeclareMethodCommon, tSFunctionTypeAnnotationCommon) }); defineType("TSQualifiedName", { aliases: ["TSEntityName"], visitor: ["left", "right"], fields: { left: (0, _utils.validateType)("TSEntityName"), right: (0, _utils.validateType)("Identifier") } }); const signatureDeclarationCommon = { typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"), ["parameters"]: (0, _utils.validateArrayOfType)(["Identifier", "RestElement"]), ["typeAnnotation"]: (0, _utils.validateOptionalType)("TSTypeAnnotation") }; const callConstructSignatureDeclaration = { aliases: ["TSTypeElement"], visitor: ["typeParameters", "parameters", "typeAnnotation"], fields: signatureDeclarationCommon }; defineType("TSCallSignatureDeclaration", callConstructSignatureDeclaration); defineType("TSConstructSignatureDeclaration", callConstructSignatureDeclaration); const namedTypeElementCommon = { key: (0, _utils.validateType)("Expression"), computed: (0, _utils.validate)(bool), optional: (0, _utils.validateOptional)(bool) }; defineType("TSPropertySignature", { aliases: ["TSTypeElement"], visitor: ["key", "typeAnnotation", "initializer"], fields: Object.assign({}, namedTypeElementCommon, { readonly: (0, _utils.validateOptional)(bool), typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation"), initializer: (0, _utils.validateOptionalType)("Expression"), kind: { validate: (0, _utils.assertOneOf)("get", "set") } }) }); defineType("TSMethodSignature", { aliases: ["TSTypeElement"], visitor: ["key", "typeParameters", "parameters", "typeAnnotation"], fields: Object.assign({}, signatureDeclarationCommon, namedTypeElementCommon, { kind: { validate: (0, _utils.assertOneOf)("method", "get", "set") } }) }); defineType("TSIndexSignature", { aliases: ["TSTypeElement"], visitor: ["parameters", "typeAnnotation"], fields: { readonly: (0, _utils.validateOptional)(bool), static: (0, _utils.validateOptional)(bool), parameters: (0, _utils.validateArrayOfType)("Identifier"), typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation") } }); const tsKeywordTypes = ["TSAnyKeyword", "TSBooleanKeyword", "TSBigIntKeyword", "TSIntrinsicKeyword", "TSNeverKeyword", "TSNullKeyword", "TSNumberKeyword", "TSObjectKeyword", "TSStringKeyword", "TSSymbolKeyword", "TSUndefinedKeyword", "TSUnknownKeyword", "TSVoidKeyword"]; for (const type of tsKeywordTypes) { defineType(type, { aliases: ["TSType", "TSBaseType"], visitor: [], fields: {} }); } defineType("TSThisType", { aliases: ["TSType", "TSBaseType"], visitor: [], fields: {} }); const fnOrCtrBase = { aliases: ["TSType"], visitor: ["typeParameters", "parameters", "typeAnnotation"] }; defineType("TSFunctionType", Object.assign({}, fnOrCtrBase, { fields: signatureDeclarationCommon })); defineType("TSConstructorType", Object.assign({}, fnOrCtrBase, { fields: Object.assign({}, signatureDeclarationCommon, { abstract: (0, _utils.validateOptional)(bool) }) })); defineType("TSTypeReference", { aliases: ["TSType"], visitor: ["typeName", "typeParameters"], fields: { typeName: (0, _utils.validateType)("TSEntityName"), typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation") } }); defineType("TSTypePredicate", { aliases: ["TSType"], visitor: ["parameterName", "typeAnnotation"], builder: ["parameterName", "typeAnnotation", "asserts"], fields: { parameterName: (0, _utils.validateType)(["Identifier", "TSThisType"]), typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation"), asserts: (0, _utils.validateOptional)(bool) } }); defineType("TSTypeQuery", { aliases: ["TSType"], visitor: ["exprName", "typeParameters"], fields: { exprName: (0, _utils.validateType)(["TSEntityName", "TSImportType"]), typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation") } }); defineType("TSTypeLiteral", { aliases: ["TSType"], visitor: ["members"], fields: { members: (0, _utils.validateArrayOfType)("TSTypeElement") } }); defineType("TSArrayType", { aliases: ["TSType"], visitor: ["elementType"], fields: { elementType: (0, _utils.validateType)("TSType") } }); defineType("TSTupleType", { aliases: ["TSType"], visitor: ["elementTypes"], fields: { elementTypes: (0, _utils.validateArrayOfType)(["TSType", "TSNamedTupleMember"]) } }); defineType("TSOptionalType", { aliases: ["TSType"], visitor: ["typeAnnotation"], fields: { typeAnnotation: (0, _utils.validateType)("TSType") } }); defineType("TSRestType", { aliases: ["TSType"], visitor: ["typeAnnotation"], fields: { typeAnnotation: (0, _utils.validateType)("TSType") } }); defineType("TSNamedTupleMember", { visitor: ["label", "elementType"], builder: ["label", "elementType", "optional"], fields: { label: (0, _utils.validateType)("Identifier"), optional: { validate: bool, default: false }, elementType: (0, _utils.validateType)("TSType") } }); const unionOrIntersection = { aliases: ["TSType"], visitor: ["types"], fields: { types: (0, _utils.validateArrayOfType)("TSType") } }; defineType("TSUnionType", unionOrIntersection); defineType("TSIntersectionType", unionOrIntersection); defineType("TSConditionalType", { aliases: ["TSType"], visitor: ["checkType", "extendsType", "trueType", "falseType"], fields: { checkType: (0, _utils.validateType)("TSType"), extendsType: (0, _utils.validateType)("TSType"), trueType: (0, _utils.validateType)("TSType"), falseType: (0, _utils.validateType)("TSType") } }); defineType("TSInferType", { aliases: ["TSType"], visitor: ["typeParameter"], fields: { typeParameter: (0, _utils.validateType)("TSTypeParameter") } }); defineType("TSParenthesizedType", { aliases: ["TSType"], visitor: ["typeAnnotation"], fields: { typeAnnotation: (0, _utils.validateType)("TSType") } }); defineType("TSTypeOperator", { aliases: ["TSType"], visitor: ["typeAnnotation"], fields: { operator: (0, _utils.validate)((0, _utils.assertValueType)("string")), typeAnnotation: (0, _utils.validateType)("TSType") } }); defineType("TSIndexedAccessType", { aliases: ["TSType"], visitor: ["objectType", "indexType"], fields: { objectType: (0, _utils.validateType)("TSType"), indexType: (0, _utils.validateType)("TSType") } }); defineType("TSMappedType", { aliases: ["TSType"], visitor: ["typeParameter", "typeAnnotation", "nameType"], fields: { readonly: (0, _utils.validateOptional)((0, _utils.assertOneOf)(true, false, "+", "-")), typeParameter: (0, _utils.validateType)("TSTypeParameter"), optional: (0, _utils.validateOptional)((0, _utils.assertOneOf)(true, false, "+", "-")), typeAnnotation: (0, _utils.validateOptionalType)("TSType"), nameType: (0, _utils.validateOptionalType)("TSType") } }); defineType("TSLiteralType", { aliases: ["TSType", "TSBaseType"], visitor: ["literal"], fields: { literal: { validate: function () { const unaryExpression = (0, _utils.assertNodeType)("NumericLiteral", "BigIntLiteral"); const unaryOperator = (0, _utils.assertOneOf)("-"); const literal = (0, _utils.assertNodeType)("NumericLiteral", "StringLiteral", "BooleanLiteral", "BigIntLiteral"); function validator(parent, key, node) { if ((0, _is.default)("UnaryExpression", node)) { unaryOperator(node, "operator", node.operator); unaryExpression(node, "argument", node.argument); } else { literal(parent, key, node); } } validator.oneOfNodeTypes = ["NumericLiteral", "StringLiteral", "BooleanLiteral", "BigIntLiteral", "UnaryExpression"]; return validator; }() } } }); defineType("TSExpressionWithTypeArguments", { aliases: ["TSType"], visitor: ["expression", "typeParameters"], fields: { expression: (0, _utils.validateType)("TSEntityName"), typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation") } }); defineType("TSInterfaceDeclaration", { aliases: ["Statement", "Declaration"], visitor: ["id", "typeParameters", "extends", "body"], fields: { declare: (0, _utils.validateOptional)(bool), id: (0, _utils.validateType)("Identifier"), typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"), extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("TSExpressionWithTypeArguments")), body: (0, _utils.validateType)("TSInterfaceBody") } }); defineType("TSInterfaceBody", { visitor: ["body"], fields: { body: (0, _utils.validateArrayOfType)("TSTypeElement") } }); defineType("TSTypeAliasDeclaration", { aliases: ["Statement", "Declaration"], visitor: ["id", "typeParameters", "typeAnnotation"], fields: { declare: (0, _utils.validateOptional)(bool), id: (0, _utils.validateType)("Identifier"), typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"), typeAnnotation: (0, _utils.validateType)("TSType") } }); defineType("TSInstantiationExpression", { aliases: ["Expression"], visitor: ["expression", "typeParameters"], fields: { expression: (0, _utils.validateType)("Expression"), typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation") } }); defineType("TSAsExpression", { aliases: ["Expression", "LVal", "PatternLike"], visitor: ["expression", "typeAnnotation"], fields: { expression: (0, _utils.validateType)("Expression"), typeAnnotation: (0, _utils.validateType)("TSType") } }); defineType("TSTypeAssertion", { aliases: ["Expression", "LVal", "PatternLike"], visitor: ["typeAnnotation", "expression"], fields: { typeAnnotation: (0, _utils.validateType)("TSType"), expression: (0, _utils.validateType)("Expression") } }); defineType("TSEnumDeclaration", { aliases: ["Statement", "Declaration"], visitor: ["id", "members"], fields: { declare: (0, _utils.validateOptional)(bool), const: (0, _utils.validateOptional)(bool), id: (0, _utils.validateType)("Identifier"), members: (0, _utils.validateArrayOfType)("TSEnumMember"), initializer: (0, _utils.validateOptionalType)("Expression") } }); defineType("TSEnumMember", { visitor: ["id", "initializer"], fields: { id: (0, _utils.validateType)(["Identifier", "StringLiteral"]), initializer: (0, _utils.validateOptionalType)("Expression") } }); defineType("TSModuleDeclaration", { aliases: ["Statement", "Declaration"], visitor: ["id", "body"], fields: { declare: (0, _utils.validateOptional)(bool), global: (0, _utils.validateOptional)(bool), id: (0, _utils.validateType)(["Identifier", "StringLiteral"]), body: (0, _utils.validateType)(["TSModuleBlock", "TSModuleDeclaration"]) } }); defineType("TSModuleBlock", { aliases: ["Scopable", "Block", "BlockParent"], visitor: ["body"], fields: { body: (0, _utils.validateArrayOfType)("Statement") } }); defineType("TSImportType", { aliases: ["TSType"], visitor: ["argument", "qualifier", "typeParameters"], fields: { argument: (0, _utils.validateType)("StringLiteral"), qualifier: (0, _utils.validateOptionalType)("TSEntityName"), typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation") } }); defineType("TSImportEqualsDeclaration", { aliases: ["Statement"], visitor: ["id", "moduleReference"], fields: { isExport: (0, _utils.validate)(bool), id: (0, _utils.validateType)("Identifier"), moduleReference: (0, _utils.validateType)(["TSEntityName", "TSExternalModuleReference"]), importKind: { validate: (0, _utils.assertOneOf)("type", "value"), optional: true } } }); defineType("TSExternalModuleReference", { visitor: ["expression"], fields: { expression: (0, _utils.validateType)("StringLiteral") } }); defineType("TSNonNullExpression", { aliases: ["Expression", "LVal", "PatternLike"], visitor: ["expression"], fields: { expression: (0, _utils.validateType)("Expression") } }); defineType("TSExportAssignment", { aliases: ["Statement"], visitor: ["expression"], fields: { expression: (0, _utils.validateType)("Expression") } }); defineType("TSNamespaceExportDeclaration", { aliases: ["Statement"], visitor: ["id"], fields: { id: (0, _utils.validateType)("Identifier") } }); defineType("TSTypeAnnotation", { visitor: ["typeAnnotation"], fields: { typeAnnotation: { validate: (0, _utils.assertNodeType)("TSType") } } }); defineType("TSTypeParameterInstantiation", { visitor: ["params"], fields: { params: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSType"))) } } }); defineType("TSTypeParameterDeclaration", { visitor: ["params"], fields: { params: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSTypeParameter"))) } } }); defineType("TSTypeParameter", { builder: ["constraint", "default", "name"], visitor: ["constraint", "default"], fields: { name: { validate: (0, _utils.assertValueType)("string") }, in: { validate: (0, _utils.assertValueType)("boolean"), optional: true }, out: { validate: (0, _utils.assertValueType)("boolean"), optional: true }, constraint: { validate: (0, _utils.assertNodeType)("TSType"), optional: true }, default: { validate: (0, _utils.assertNodeType)("TSType"), optional: true } } }); },{"../validators/is":145,"./core":119,"./utils":127}],127:[function(require,module,exports){ (function (process){(function (){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.VISITOR_KEYS = exports.NODE_PARENT_VALIDATIONS = exports.NODE_FIELDS = exports.FLIPPED_ALIAS_KEYS = exports.DEPRECATED_KEYS = exports.BUILDER_KEYS = exports.ALIAS_KEYS = void 0; exports.arrayOf = arrayOf; exports.arrayOfType = arrayOfType; exports.assertEach = assertEach; exports.assertNodeOrValueType = assertNodeOrValueType; exports.assertNodeType = assertNodeType; exports.assertOneOf = assertOneOf; exports.assertOptionalChainStart = assertOptionalChainStart; exports.assertShape = assertShape; exports.assertValueType = assertValueType; exports.chain = chain; exports.default = defineType; exports.defineAliasedType = defineAliasedType; exports.typeIs = typeIs; exports.validate = validate; exports.validateArrayOfType = validateArrayOfType; exports.validateOptional = validateOptional; exports.validateOptionalType = validateOptionalType; exports.validateType = validateType; var _is = require("../validators/is"); var _validate = require("../validators/validate"); const VISITOR_KEYS = {}; exports.VISITOR_KEYS = VISITOR_KEYS; const ALIAS_KEYS = {}; exports.ALIAS_KEYS = ALIAS_KEYS; const FLIPPED_ALIAS_KEYS = {}; exports.FLIPPED_ALIAS_KEYS = FLIPPED_ALIAS_KEYS; const NODE_FIELDS = {}; exports.NODE_FIELDS = NODE_FIELDS; const BUILDER_KEYS = {}; exports.BUILDER_KEYS = BUILDER_KEYS; const DEPRECATED_KEYS = {}; exports.DEPRECATED_KEYS = DEPRECATED_KEYS; const NODE_PARENT_VALIDATIONS = {}; exports.NODE_PARENT_VALIDATIONS = NODE_PARENT_VALIDATIONS; function getType(val) { if (Array.isArray(val)) { return "array"; } else if (val === null) { return "null"; } else { return typeof val; } } function validate(validate) { return { validate }; } function typeIs(typeName) { return typeof typeName === "string" ? assertNodeType(typeName) : assertNodeType(...typeName); } function validateType(typeName) { return validate(typeIs(typeName)); } function validateOptional(validate) { return { validate, optional: true }; } function validateOptionalType(typeName) { return { validate: typeIs(typeName), optional: true }; } function arrayOf(elementType) { return chain(assertValueType("array"), assertEach(elementType)); } function arrayOfType(typeName) { return arrayOf(typeIs(typeName)); } function validateArrayOfType(typeName) { return validate(arrayOfType(typeName)); } function assertEach(callback) { function validator(node, key, val) { if (!Array.isArray(val)) return; for (let i = 0; i < val.length; i++) { const subkey = `${key}[${i}]`; const v = val[i]; callback(node, subkey, v); if (process.env.BABEL_TYPES_8_BREAKING) (0, _validate.validateChild)(node, subkey, v); } } validator.each = callback; return validator; } function assertOneOf(...values) { function validate(node, key, val) { if (values.indexOf(val) < 0) { throw new TypeError(`Property ${key} expected value to be one of ${JSON.stringify(values)} but got ${JSON.stringify(val)}`); } } validate.oneOf = values; return validate; } function assertNodeType(...types) { function validate(node, key, val) { for (const type of types) { if ((0, _is.default)(type, val)) { (0, _validate.validateChild)(node, key, val); return; } } throw new TypeError(`Property ${key} of ${node.type} expected node to be of a type ${JSON.stringify(types)} but instead got ${JSON.stringify(val == null ? void 0 : val.type)}`); } validate.oneOfNodeTypes = types; return validate; } function assertNodeOrValueType(...types) { function validate(node, key, val) { for (const type of types) { if (getType(val) === type || (0, _is.default)(type, val)) { (0, _validate.validateChild)(node, key, val); return; } } throw new TypeError(`Property ${key} of ${node.type} expected node to be of a type ${JSON.stringify(types)} but instead got ${JSON.stringify(val == null ? void 0 : val.type)}`); } validate.oneOfNodeOrValueTypes = types; return validate; } function assertValueType(type) { function validate(node, key, val) { const valid = getType(val) === type; if (!valid) { throw new TypeError(`Property ${key} expected type of ${type} but got ${getType(val)}`); } } validate.type = type; return validate; } function assertShape(shape) { function validate(node, key, val) { const errors = []; for (const property of Object.keys(shape)) { try { (0, _validate.validateField)(node, property, val[property], shape[property]); } catch (error) { if (error instanceof TypeError) { errors.push(error.message); continue; } throw error; } } if (errors.length) { throw new TypeError(`Property ${key} of ${node.type} expected to have the following:\n${errors.join("\n")}`); } } validate.shapeOf = shape; return validate; } function assertOptionalChainStart() { function validate(node) { var _current; let current = node; while (node) { const { type } = current; if (type === "OptionalCallExpression") { if (current.optional) return; current = current.callee; continue; } if (type === "OptionalMemberExpression") { if (current.optional) return; current = current.object; continue; } break; } throw new TypeError(`Non-optional ${node.type} must chain from an optional OptionalMemberExpression or OptionalCallExpression. Found chain from ${(_current = current) == null ? void 0 : _current.type}`); } return validate; } function chain(...fns) { function validate(...args) { for (const fn of fns) { fn(...args); } } validate.chainOf = fns; if (fns.length >= 2 && "type" in fns[0] && fns[0].type === "array" && !("each" in fns[1])) { throw new Error(`An assertValueType("array") validator can only be followed by an assertEach(...) validator.`); } return validate; } const validTypeOpts = ["aliases", "builder", "deprecatedAlias", "fields", "inherits", "visitor", "validate"]; const validFieldKeys = ["default", "optional", "validate"]; function defineAliasedType(...aliases) { return (type, opts = {}) => { let defined = opts.aliases; if (!defined) { var _store$opts$inherits$, _defined; if (opts.inherits) defined = (_store$opts$inherits$ = store[opts.inherits].aliases) == null ? void 0 : _store$opts$inherits$.slice(); (_defined = defined) != null ? _defined : defined = []; opts.aliases = defined; } const additional = aliases.filter(a => !defined.includes(a)); defined.unshift(...additional); return defineType(type, opts); }; } function defineType(type, opts = {}) { const inherits = opts.inherits && store[opts.inherits] || {}; let fields = opts.fields; if (!fields) { fields = {}; if (inherits.fields) { const keys = Object.getOwnPropertyNames(inherits.fields); for (const key of keys) { const field = inherits.fields[key]; const def = field.default; if (Array.isArray(def) ? def.length > 0 : def && typeof def === "object") { throw new Error("field defaults can only be primitives or empty arrays currently"); } fields[key] = { default: Array.isArray(def) ? [] : def, optional: field.optional, validate: field.validate }; } } } const visitor = opts.visitor || inherits.visitor || []; const aliases = opts.aliases || inherits.aliases || []; const builder = opts.builder || inherits.builder || opts.visitor || []; for (const k of Object.keys(opts)) { if (validTypeOpts.indexOf(k) === -1) { throw new Error(`Unknown type option "${k}" on ${type}`); } } if (opts.deprecatedAlias) { DEPRECATED_KEYS[opts.deprecatedAlias] = type; } for (const key of visitor.concat(builder)) { fields[key] = fields[key] || {}; } for (const key of Object.keys(fields)) { const field = fields[key]; if (field.default !== undefined && builder.indexOf(key) === -1) { field.optional = true; } if (field.default === undefined) { field.default = null; } else if (!field.validate && field.default != null) { field.validate = assertValueType(getType(field.default)); } for (const k of Object.keys(field)) { if (validFieldKeys.indexOf(k) === -1) { throw new Error(`Unknown field key "${k}" on ${type}.${key}`); } } } VISITOR_KEYS[type] = opts.visitor = visitor; BUILDER_KEYS[type] = opts.builder = builder; NODE_FIELDS[type] = opts.fields = fields; ALIAS_KEYS[type] = opts.aliases = aliases; aliases.forEach(alias => { FLIPPED_ALIAS_KEYS[alias] = FLIPPED_ALIAS_KEYS[alias] || []; FLIPPED_ALIAS_KEYS[alias].push(type); }); if (opts.validate) { NODE_PARENT_VALIDATIONS[type] = opts.validate; } store[type] = opts; } const store = {}; }).call(this)}).call(this,require('_process')) },{"../validators/is":145,"../validators/validate":163,"_process":460}],128:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); var _exportNames = { react: true, assertNode: true, createTypeAnnotationBasedOnTypeof: true, createUnionTypeAnnotation: true, createFlowUnionType: true, createTSUnionType: true, cloneNode: true, clone: true, cloneDeep: true, cloneDeepWithoutLoc: true, cloneWithoutLoc: true, addComment: true, addComments: true, inheritInnerComments: true, inheritLeadingComments: true, inheritsComments: true, inheritTrailingComments: true, removeComments: true, ensureBlock: true, toBindingIdentifierName: true, toBlock: true, toComputedKey: true, toExpression: true, toIdentifier: true, toKeyAlias: true, toSequenceExpression: true, toStatement: true, valueToNode: true, appendToMemberExpression: true, inherits: true, prependToMemberExpression: true, removeProperties: true, removePropertiesDeep: true, removeTypeDuplicates: true, getBindingIdentifiers: true, getOuterBindingIdentifiers: true, traverse: true, traverseFast: true, shallowEqual: true, is: true, isBinding: true, isBlockScoped: true, isImmutable: true, isLet: true, isNode: true, isNodesEquivalent: true, isPlaceholderType: true, isReferenced: true, isScope: true, isSpecifierDefault: true, isType: true, isValidES3Identifier: true, isValidIdentifier: true, isVar: true, matchesPattern: true, validate: true, buildMatchMemberExpression: true }; Object.defineProperty(exports, "addComment", { enumerable: true, get: function () { return _addComment.default; } }); Object.defineProperty(exports, "addComments", { enumerable: true, get: function () { return _addComments.default; } }); Object.defineProperty(exports, "appendToMemberExpression", { enumerable: true, get: function () { return _appendToMemberExpression.default; } }); Object.defineProperty(exports, "assertNode", { enumerable: true, get: function () { return _assertNode.default; } }); Object.defineProperty(exports, "buildMatchMemberExpression", { enumerable: true, get: function () { return _buildMatchMemberExpression.default; } }); Object.defineProperty(exports, "clone", { enumerable: true, get: function () { return _clone.default; } }); Object.defineProperty(exports, "cloneDeep", { enumerable: true, get: function () { return _cloneDeep.default; } }); Object.defineProperty(exports, "cloneDeepWithoutLoc", { enumerable: true, get: function () { return _cloneDeepWithoutLoc.default; } }); Object.defineProperty(exports, "cloneNode", { enumerable: true, get: function () { return _cloneNode.default; } }); Object.defineProperty(exports, "cloneWithoutLoc", { enumerable: true, get: function () { return _cloneWithoutLoc.default; } }); Object.defineProperty(exports, "createFlowUnionType", { enumerable: true, get: function () { return _createFlowUnionType.default; } }); Object.defineProperty(exports, "createTSUnionType", { enumerable: true, get: function () { return _createTSUnionType.default; } }); Object.defineProperty(exports, "createTypeAnnotationBasedOnTypeof", { enumerable: true, get: function () { return _createTypeAnnotationBasedOnTypeof.default; } }); Object.defineProperty(exports, "createUnionTypeAnnotation", { enumerable: true, get: function () { return _createFlowUnionType.default; } }); Object.defineProperty(exports, "ensureBlock", { enumerable: true, get: function () { return _ensureBlock.default; } }); Object.defineProperty(exports, "getBindingIdentifiers", { enumerable: true, get: function () { return _getBindingIdentifiers.default; } }); Object.defineProperty(exports, "getOuterBindingIdentifiers", { enumerable: true, get: function () { return _getOuterBindingIdentifiers.default; } }); Object.defineProperty(exports, "inheritInnerComments", { enumerable: true, get: function () { return _inheritInnerComments.default; } }); Object.defineProperty(exports, "inheritLeadingComments", { enumerable: true, get: function () { return _inheritLeadingComments.default; } }); Object.defineProperty(exports, "inheritTrailingComments", { enumerable: true, get: function () { return _inheritTrailingComments.default; } }); Object.defineProperty(exports, "inherits", { enumerable: true, get: function () { return _inherits.default; } }); Object.defineProperty(exports, "inheritsComments", { enumerable: true, get: function () { return _inheritsComments.default; } }); Object.defineProperty(exports, "is", { enumerable: true, get: function () { return _is.default; } }); Object.defineProperty(exports, "isBinding", { enumerable: true, get: function () { return _isBinding.default; } }); Object.defineProperty(exports, "isBlockScoped", { enumerable: true, get: function () { return _isBlockScoped.default; } }); Object.defineProperty(exports, "isImmutable", { enumerable: true, get: function () { return _isImmutable.default; } }); Object.defineProperty(exports, "isLet", { enumerable: true, get: function () { return _isLet.default; } }); Object.defineProperty(exports, "isNode", { enumerable: true, get: function () { return _isNode.default; } }); Object.defineProperty(exports, "isNodesEquivalent", { enumerable: true, get: function () { return _isNodesEquivalent.default; } }); Object.defineProperty(exports, "isPlaceholderType", { enumerable: true, get: function () { return _isPlaceholderType.default; } }); Object.defineProperty(exports, "isReferenced", { enumerable: true, get: function () { return _isReferenced.default; } }); Object.defineProperty(exports, "isScope", { enumerable: true, get: function () { return _isScope.default; } }); Object.defineProperty(exports, "isSpecifierDefault", { enumerable: true, get: function () { return _isSpecifierDefault.default; } }); Object.defineProperty(exports, "isType", { enumerable: true, get: function () { return _isType.default; } }); Object.defineProperty(exports, "isValidES3Identifier", { enumerable: true, get: function () { return _isValidES3Identifier.default; } }); Object.defineProperty(exports, "isValidIdentifier", { enumerable: true, get: function () { return _isValidIdentifier.default; } }); Object.defineProperty(exports, "isVar", { enumerable: true, get: function () { return _isVar.default; } }); Object.defineProperty(exports, "matchesPattern", { enumerable: true, get: function () { return _matchesPattern.default; } }); Object.defineProperty(exports, "prependToMemberExpression", { enumerable: true, get: function () { return _prependToMemberExpression.default; } }); exports.react = void 0; Object.defineProperty(exports, "removeComments", { enumerable: true, get: function () { return _removeComments.default; } }); Object.defineProperty(exports, "removeProperties", { enumerable: true, get: function () { return _removeProperties.default; } }); Object.defineProperty(exports, "removePropertiesDeep", { enumerable: true, get: function () { return _removePropertiesDeep.default; } }); Object.defineProperty(exports, "removeTypeDuplicates", { enumerable: true, get: function () { return _removeTypeDuplicates.default; } }); Object.defineProperty(exports, "shallowEqual", { enumerable: true, get: function () { return _shallowEqual.default; } }); Object.defineProperty(exports, "toBindingIdentifierName", { enumerable: true, get: function () { return _toBindingIdentifierName.default; } }); Object.defineProperty(exports, "toBlock", { enumerable: true, get: function () { return _toBlock.default; } }); Object.defineProperty(exports, "toComputedKey", { enumerable: true, get: function () { return _toComputedKey.default; } }); Object.defineProperty(exports, "toExpression", { enumerable: true, get: function () { return _toExpression.default; } }); Object.defineProperty(exports, "toIdentifier", { enumerable: true, get: function () { return _toIdentifier.default; } }); Object.defineProperty(exports, "toKeyAlias", { enumerable: true, get: function () { return _toKeyAlias.default; } }); Object.defineProperty(exports, "toSequenceExpression", { enumerable: true, get: function () { return _toSequenceExpression.default; } }); Object.defineProperty(exports, "toStatement", { enumerable: true, get: function () { return _toStatement.default; } }); Object.defineProperty(exports, "traverse", { enumerable: true, get: function () { return _traverse.default; } }); Object.defineProperty(exports, "traverseFast", { enumerable: true, get: function () { return _traverseFast.default; } }); Object.defineProperty(exports, "validate", { enumerable: true, get: function () { return _validate.default; } }); Object.defineProperty(exports, "valueToNode", { enumerable: true, get: function () { return _valueToNode.default; } }); var _isReactComponent = require("./validators/react/isReactComponent"); var _isCompatTag = require("./validators/react/isCompatTag"); var _buildChildren = require("./builders/react/buildChildren"); var _assertNode = require("./asserts/assertNode"); var _generated = require("./asserts/generated"); Object.keys(_generated).forEach(function (key) { if (key === "default" || key === "__esModule") return; if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; if (key in exports && exports[key] === _generated[key]) return; Object.defineProperty(exports, key, { enumerable: true, get: function () { return _generated[key]; } }); }); var _createTypeAnnotationBasedOnTypeof = require("./builders/flow/createTypeAnnotationBasedOnTypeof"); var _createFlowUnionType = require("./builders/flow/createFlowUnionType"); var _createTSUnionType = require("./builders/typescript/createTSUnionType"); var _generated2 = require("./builders/generated"); Object.keys(_generated2).forEach(function (key) { if (key === "default" || key === "__esModule") return; if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; if (key in exports && exports[key] === _generated2[key]) return; Object.defineProperty(exports, key, { enumerable: true, get: function () { return _generated2[key]; } }); }); var _uppercase = require("./builders/generated/uppercase"); Object.keys(_uppercase).forEach(function (key) { if (key === "default" || key === "__esModule") return; if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; if (key in exports && exports[key] === _uppercase[key]) return; Object.defineProperty(exports, key, { enumerable: true, get: function () { return _uppercase[key]; } }); }); var _cloneNode = require("./clone/cloneNode"); var _clone = require("./clone/clone"); var _cloneDeep = require("./clone/cloneDeep"); var _cloneDeepWithoutLoc = require("./clone/cloneDeepWithoutLoc"); var _cloneWithoutLoc = require("./clone/cloneWithoutLoc"); var _addComment = require("./comments/addComment"); var _addComments = require("./comments/addComments"); var _inheritInnerComments = require("./comments/inheritInnerComments"); var _inheritLeadingComments = require("./comments/inheritLeadingComments"); var _inheritsComments = require("./comments/inheritsComments"); var _inheritTrailingComments = require("./comments/inheritTrailingComments"); var _removeComments = require("./comments/removeComments"); var _generated3 = require("./constants/generated"); Object.keys(_generated3).forEach(function (key) { if (key === "default" || key === "__esModule") return; if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; if (key in exports && exports[key] === _generated3[key]) return; Object.defineProperty(exports, key, { enumerable: true, get: function () { return _generated3[key]; } }); }); var _constants = require("./constants"); Object.keys(_constants).forEach(function (key) { if (key === "default" || key === "__esModule") return; if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; if (key in exports && exports[key] === _constants[key]) return; Object.defineProperty(exports, key, { enumerable: true, get: function () { return _constants[key]; } }); }); var _ensureBlock = require("./converters/ensureBlock"); var _toBindingIdentifierName = require("./converters/toBindingIdentifierName"); var _toBlock = require("./converters/toBlock"); var _toComputedKey = require("./converters/toComputedKey"); var _toExpression = require("./converters/toExpression"); var _toIdentifier = require("./converters/toIdentifier"); var _toKeyAlias = require("./converters/toKeyAlias"); var _toSequenceExpression = require("./converters/toSequenceExpression"); var _toStatement = require("./converters/toStatement"); var _valueToNode = require("./converters/valueToNode"); var _definitions = require("./definitions"); Object.keys(_definitions).forEach(function (key) { if (key === "default" || key === "__esModule") return; if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; if (key in exports && exports[key] === _definitions[key]) return; Object.defineProperty(exports, key, { enumerable: true, get: function () { return _definitions[key]; } }); }); var _appendToMemberExpression = require("./modifications/appendToMemberExpression"); var _inherits = require("./modifications/inherits"); var _prependToMemberExpression = require("./modifications/prependToMemberExpression"); var _removeProperties = require("./modifications/removeProperties"); var _removePropertiesDeep = require("./modifications/removePropertiesDeep"); var _removeTypeDuplicates = require("./modifications/flow/removeTypeDuplicates"); var _getBindingIdentifiers = require("./retrievers/getBindingIdentifiers"); var _getOuterBindingIdentifiers = require("./retrievers/getOuterBindingIdentifiers"); var _traverse = require("./traverse/traverse"); Object.keys(_traverse).forEach(function (key) { if (key === "default" || key === "__esModule") return; if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; if (key in exports && exports[key] === _traverse[key]) return; Object.defineProperty(exports, key, { enumerable: true, get: function () { return _traverse[key]; } }); }); var _traverseFast = require("./traverse/traverseFast"); var _shallowEqual = require("./utils/shallowEqual"); var _is = require("./validators/is"); var _isBinding = require("./validators/isBinding"); var _isBlockScoped = require("./validators/isBlockScoped"); var _isImmutable = require("./validators/isImmutable"); var _isLet = require("./validators/isLet"); var _isNode = require("./validators/isNode"); var _isNodesEquivalent = require("./validators/isNodesEquivalent"); var _isPlaceholderType = require("./validators/isPlaceholderType"); var _isReferenced = require("./validators/isReferenced"); var _isScope = require("./validators/isScope"); var _isSpecifierDefault = require("./validators/isSpecifierDefault"); var _isType = require("./validators/isType"); var _isValidES3Identifier = require("./validators/isValidES3Identifier"); var _isValidIdentifier = require("./validators/isValidIdentifier"); var _isVar = require("./validators/isVar"); var _matchesPattern = require("./validators/matchesPattern"); var _validate = require("./validators/validate"); var _buildMatchMemberExpression = require("./validators/buildMatchMemberExpression"); var _generated4 = require("./validators/generated"); Object.keys(_generated4).forEach(function (key) { if (key === "default" || key === "__esModule") return; if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; if (key in exports && exports[key] === _generated4[key]) return; Object.defineProperty(exports, key, { enumerable: true, get: function () { return _generated4[key]; } }); }); var _generated5 = require("./ast-types/generated"); Object.keys(_generated5).forEach(function (key) { if (key === "default" || key === "__esModule") return; if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; if (key in exports && exports[key] === _generated5[key]) return; Object.defineProperty(exports, key, { enumerable: true, get: function () { return _generated5[key]; } }); }); const react = { isReactComponent: _isReactComponent.default, isCompatTag: _isCompatTag.default, buildChildren: _buildChildren.default }; exports.react = react; },{"./asserts/assertNode":84,"./asserts/generated":85,"./ast-types/generated":86,"./builders/flow/createFlowUnionType":87,"./builders/flow/createTypeAnnotationBasedOnTypeof":88,"./builders/generated":89,"./builders/generated/uppercase":90,"./builders/react/buildChildren":91,"./builders/typescript/createTSUnionType":92,"./clone/clone":94,"./clone/cloneDeep":95,"./clone/cloneDeepWithoutLoc":96,"./clone/cloneNode":97,"./clone/cloneWithoutLoc":98,"./comments/addComment":99,"./comments/addComments":100,"./comments/inheritInnerComments":101,"./comments/inheritLeadingComments":102,"./comments/inheritTrailingComments":103,"./comments/inheritsComments":104,"./comments/removeComments":105,"./constants":107,"./constants/generated":106,"./converters/ensureBlock":108,"./converters/toBindingIdentifierName":110,"./converters/toBlock":111,"./converters/toComputedKey":112,"./converters/toExpression":113,"./converters/toIdentifier":114,"./converters/toKeyAlias":115,"./converters/toSequenceExpression":116,"./converters/toStatement":117,"./converters/valueToNode":118,"./definitions":122,"./modifications/appendToMemberExpression":129,"./modifications/flow/removeTypeDuplicates":130,"./modifications/inherits":131,"./modifications/prependToMemberExpression":132,"./modifications/removeProperties":133,"./modifications/removePropertiesDeep":134,"./retrievers/getBindingIdentifiers":136,"./retrievers/getOuterBindingIdentifiers":137,"./traverse/traverse":138,"./traverse/traverseFast":139,"./utils/shallowEqual":142,"./validators/buildMatchMemberExpression":143,"./validators/generated":144,"./validators/is":145,"./validators/isBinding":146,"./validators/isBlockScoped":147,"./validators/isImmutable":148,"./validators/isLet":149,"./validators/isNode":150,"./validators/isNodesEquivalent":151,"./validators/isPlaceholderType":152,"./validators/isReferenced":153,"./validators/isScope":154,"./validators/isSpecifierDefault":155,"./validators/isType":156,"./validators/isValidES3Identifier":157,"./validators/isValidIdentifier":158,"./validators/isVar":159,"./validators/matchesPattern":160,"./validators/react/isCompatTag":161,"./validators/react/isReactComponent":162,"./validators/validate":163}],129:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = appendToMemberExpression; var _generated = require("../builders/generated"); function appendToMemberExpression(member, append, computed = false) { member.object = (0, _generated.memberExpression)(member.object, member.property, member.computed); member.property = append; member.computed = !!computed; return member; } },{"../builders/generated":89}],130:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = removeTypeDuplicates; var _generated = require("../../validators/generated"); function getQualifiedName(node) { return (0, _generated.isIdentifier)(node) ? node.name : `${node.id.name}.${getQualifiedName(node.qualification)}`; } function removeTypeDuplicates(nodes) { const generics = {}; const bases = {}; const typeGroups = new Set(); const types = []; for (let i = 0; i < nodes.length; i++) { const node = nodes[i]; if (!node) continue; if (types.indexOf(node) >= 0) { continue; } if ((0, _generated.isAnyTypeAnnotation)(node)) { return [node]; } if ((0, _generated.isFlowBaseAnnotation)(node)) { bases[node.type] = node; continue; } if ((0, _generated.isUnionTypeAnnotation)(node)) { if (!typeGroups.has(node.types)) { nodes = nodes.concat(node.types); typeGroups.add(node.types); } continue; } if ((0, _generated.isGenericTypeAnnotation)(node)) { const name = getQualifiedName(node.id); if (generics[name]) { let existing = generics[name]; if (existing.typeParameters) { if (node.typeParameters) { existing.typeParameters.params = removeTypeDuplicates(existing.typeParameters.params.concat(node.typeParameters.params)); } } else { existing = node.typeParameters; } } else { generics[name] = node; } continue; } types.push(node); } for (const type of Object.keys(bases)) { types.push(bases[type]); } for (const name of Object.keys(generics)) { types.push(generics[name]); } return types; } },{"../../validators/generated":144}],131:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = inherits; var _constants = require("../constants"); var _inheritsComments = require("../comments/inheritsComments"); function inherits(child, parent) { if (!child || !parent) return child; for (const key of _constants.INHERIT_KEYS.optional) { if (child[key] == null) { child[key] = parent[key]; } } for (const key of Object.keys(parent)) { if (key[0] === "_" && key !== "__clone") { child[key] = parent[key]; } } for (const key of _constants.INHERIT_KEYS.force) { child[key] = parent[key]; } (0, _inheritsComments.default)(child, parent); return child; } },{"../comments/inheritsComments":104,"../constants":107}],132:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = prependToMemberExpression; var _generated = require("../builders/generated"); function prependToMemberExpression(member, prepend) { member.object = (0, _generated.memberExpression)(prepend, member.object); return member; } },{"../builders/generated":89}],133:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = removeProperties; var _constants = require("../constants"); const CLEAR_KEYS = ["tokens", "start", "end", "loc", "raw", "rawValue"]; const CLEAR_KEYS_PLUS_COMMENTS = [..._constants.COMMENT_KEYS, "comments", ...CLEAR_KEYS]; function removeProperties(node, opts = {}) { const map = opts.preserveComments ? CLEAR_KEYS : CLEAR_KEYS_PLUS_COMMENTS; for (const key of map) { if (node[key] != null) node[key] = undefined; } for (const key of Object.keys(node)) { if (key[0] === "_" && node[key] != null) node[key] = undefined; } const symbols = Object.getOwnPropertySymbols(node); for (const sym of symbols) { node[sym] = null; } } },{"../constants":107}],134:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = removePropertiesDeep; var _traverseFast = require("../traverse/traverseFast"); var _removeProperties = require("./removeProperties"); function removePropertiesDeep(tree, opts) { (0, _traverseFast.default)(tree, _removeProperties.default, opts); return tree; } },{"../traverse/traverseFast":139,"./removeProperties":133}],135:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = removeTypeDuplicates; var _generated = require("../../validators/generated"); function removeTypeDuplicates(nodes) { const generics = {}; const bases = {}; const typeGroups = new Set(); const types = []; for (let i = 0; i < nodes.length; i++) { const node = nodes[i]; if (!node) continue; if (types.indexOf(node) >= 0) { continue; } if ((0, _generated.isTSAnyKeyword)(node)) { return [node]; } if ((0, _generated.isTSBaseType)(node)) { bases[node.type] = node; continue; } if ((0, _generated.isTSUnionType)(node)) { if (!typeGroups.has(node.types)) { nodes.push(...node.types); typeGroups.add(node.types); } continue; } types.push(node); } for (const type of Object.keys(bases)) { types.push(bases[type]); } for (const name of Object.keys(generics)) { types.push(generics[name]); } return types; } },{"../../validators/generated":144}],136:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = getBindingIdentifiers; var _generated = require("../validators/generated"); function getBindingIdentifiers(node, duplicates, outerOnly) { const search = [].concat(node); const ids = Object.create(null); while (search.length) { const id = search.shift(); if (!id) continue; const keys = getBindingIdentifiers.keys[id.type]; if ((0, _generated.isIdentifier)(id)) { if (duplicates) { const _ids = ids[id.name] = ids[id.name] || []; _ids.push(id); } else { ids[id.name] = id; } continue; } if ((0, _generated.isExportDeclaration)(id) && !(0, _generated.isExportAllDeclaration)(id)) { if ((0, _generated.isDeclaration)(id.declaration)) { search.push(id.declaration); } continue; } if (outerOnly) { if ((0, _generated.isFunctionDeclaration)(id)) { search.push(id.id); continue; } if ((0, _generated.isFunctionExpression)(id)) { continue; } } if (keys) { for (let i = 0; i < keys.length; i++) { const key = keys[i]; const nodes = id[key]; if (nodes) { Array.isArray(nodes) ? search.push(...nodes) : search.push(nodes); } } } } return ids; } getBindingIdentifiers.keys = { DeclareClass: ["id"], DeclareFunction: ["id"], DeclareModule: ["id"], DeclareVariable: ["id"], DeclareInterface: ["id"], DeclareTypeAlias: ["id"], DeclareOpaqueType: ["id"], InterfaceDeclaration: ["id"], TypeAlias: ["id"], OpaqueType: ["id"], CatchClause: ["param"], LabeledStatement: ["label"], UnaryExpression: ["argument"], AssignmentExpression: ["left"], ImportSpecifier: ["local"], ImportNamespaceSpecifier: ["local"], ImportDefaultSpecifier: ["local"], ImportDeclaration: ["specifiers"], ExportSpecifier: ["exported"], ExportNamespaceSpecifier: ["exported"], ExportDefaultSpecifier: ["exported"], FunctionDeclaration: ["id", "params"], FunctionExpression: ["id", "params"], ArrowFunctionExpression: ["params"], ObjectMethod: ["params"], ClassMethod: ["params"], ClassPrivateMethod: ["params"], ForInStatement: ["left"], ForOfStatement: ["left"], ClassDeclaration: ["id"], ClassExpression: ["id"], RestElement: ["argument"], UpdateExpression: ["argument"], ObjectProperty: ["value"], AssignmentPattern: ["left"], ArrayPattern: ["elements"], ObjectPattern: ["properties"], VariableDeclaration: ["declarations"], VariableDeclarator: ["id"] }; },{"../validators/generated":144}],137:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = void 0; var _getBindingIdentifiers = require("./getBindingIdentifiers"); var _default = getOuterBindingIdentifiers; exports.default = _default; function getOuterBindingIdentifiers(node, duplicates) { return (0, _getBindingIdentifiers.default)(node, duplicates, true); } },{"./getBindingIdentifiers":136}],138:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = traverse; var _definitions = require("../definitions"); function traverse(node, handlers, state) { if (typeof handlers === "function") { handlers = { enter: handlers }; } const { enter, exit } = handlers; traverseSimpleImpl(node, enter, exit, state, []); } function traverseSimpleImpl(node, enter, exit, state, ancestors) { const keys = _definitions.VISITOR_KEYS[node.type]; if (!keys) return; if (enter) enter(node, ancestors, state); for (const key of keys) { const subNode = node[key]; if (Array.isArray(subNode)) { for (let i = 0; i < subNode.length; i++) { const child = subNode[i]; if (!child) continue; ancestors.push({ node, key, index: i }); traverseSimpleImpl(child, enter, exit, state, ancestors); ancestors.pop(); } } else if (subNode) { ancestors.push({ node, key }); traverseSimpleImpl(subNode, enter, exit, state, ancestors); ancestors.pop(); } } if (exit) exit(node, ancestors, state); } },{"../definitions":122}],139:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = traverseFast; var _definitions = require("../definitions"); function traverseFast(node, enter, opts) { if (!node) return; const keys = _definitions.VISITOR_KEYS[node.type]; if (!keys) return; opts = opts || {}; enter(node, opts); for (const key of keys) { const subNode = node[key]; if (Array.isArray(subNode)) { for (const node of subNode) { traverseFast(node, enter, opts); } } else { traverseFast(subNode, enter, opts); } } } },{"../definitions":122}],140:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = inherit; function inherit(key, child, parent) { if (child && parent) { child[key] = Array.from(new Set([].concat(child[key], parent[key]).filter(Boolean))); } } },{}],141:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = cleanJSXElementLiteralChild; var _generated = require("../../builders/generated"); function cleanJSXElementLiteralChild(child, args) { const lines = child.value.split(/\r\n|\n|\r/); let lastNonEmptyLine = 0; for (let i = 0; i < lines.length; i++) { if (lines[i].match(/[^ \t]/)) { lastNonEmptyLine = i; } } let str = ""; for (let i = 0; i < lines.length; i++) { const line = lines[i]; const isFirstLine = i === 0; const isLastLine = i === lines.length - 1; const isLastNonEmptyLine = i === lastNonEmptyLine; let trimmedLine = line.replace(/\t/g, " "); if (!isFirstLine) { trimmedLine = trimmedLine.replace(/^[ ]+/, ""); } if (!isLastLine) { trimmedLine = trimmedLine.replace(/[ ]+$/, ""); } if (trimmedLine) { if (!isLastNonEmptyLine) { trimmedLine += " "; } str += trimmedLine; } } if (str) args.push((0, _generated.stringLiteral)(str)); } },{"../../builders/generated":89}],142:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = shallowEqual; function shallowEqual(actual, expected) { const keys = Object.keys(expected); for (const key of keys) { if (actual[key] !== expected[key]) { return false; } } return true; } },{}],143:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = buildMatchMemberExpression; var _matchesPattern = require("./matchesPattern"); function buildMatchMemberExpression(match, allowPartial) { const parts = match.split("."); return member => (0, _matchesPattern.default)(member, parts, allowPartial); } },{"./matchesPattern":160}],144:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.isAccessor = isAccessor; exports.isAnyTypeAnnotation = isAnyTypeAnnotation; exports.isArgumentPlaceholder = isArgumentPlaceholder; exports.isArrayExpression = isArrayExpression; exports.isArrayPattern = isArrayPattern; exports.isArrayTypeAnnotation = isArrayTypeAnnotation; exports.isArrowFunctionExpression = isArrowFunctionExpression; exports.isAssignmentExpression = isAssignmentExpression; exports.isAssignmentPattern = isAssignmentPattern; exports.isAwaitExpression = isAwaitExpression; exports.isBigIntLiteral = isBigIntLiteral; exports.isBinary = isBinary; exports.isBinaryExpression = isBinaryExpression; exports.isBindExpression = isBindExpression; exports.isBlock = isBlock; exports.isBlockParent = isBlockParent; exports.isBlockStatement = isBlockStatement; exports.isBooleanLiteral = isBooleanLiteral; exports.isBooleanLiteralTypeAnnotation = isBooleanLiteralTypeAnnotation; exports.isBooleanTypeAnnotation = isBooleanTypeAnnotation; exports.isBreakStatement = isBreakStatement; exports.isCallExpression = isCallExpression; exports.isCatchClause = isCatchClause; exports.isClass = isClass; exports.isClassAccessorProperty = isClassAccessorProperty; exports.isClassBody = isClassBody; exports.isClassDeclaration = isClassDeclaration; exports.isClassExpression = isClassExpression; exports.isClassImplements = isClassImplements; exports.isClassMethod = isClassMethod; exports.isClassPrivateMethod = isClassPrivateMethod; exports.isClassPrivateProperty = isClassPrivateProperty; exports.isClassProperty = isClassProperty; exports.isCompletionStatement = isCompletionStatement; exports.isConditional = isConditional; exports.isConditionalExpression = isConditionalExpression; exports.isContinueStatement = isContinueStatement; exports.isDebuggerStatement = isDebuggerStatement; exports.isDecimalLiteral = isDecimalLiteral; exports.isDeclaration = isDeclaration; exports.isDeclareClass = isDeclareClass; exports.isDeclareExportAllDeclaration = isDeclareExportAllDeclaration; exports.isDeclareExportDeclaration = isDeclareExportDeclaration; exports.isDeclareFunction = isDeclareFunction; exports.isDeclareInterface = isDeclareInterface; exports.isDeclareModule = isDeclareModule; exports.isDeclareModuleExports = isDeclareModuleExports; exports.isDeclareOpaqueType = isDeclareOpaqueType; exports.isDeclareTypeAlias = isDeclareTypeAlias; exports.isDeclareVariable = isDeclareVariable; exports.isDeclaredPredicate = isDeclaredPredicate; exports.isDecorator = isDecorator; exports.isDirective = isDirective; exports.isDirectiveLiteral = isDirectiveLiteral; exports.isDoExpression = isDoExpression; exports.isDoWhileStatement = isDoWhileStatement; exports.isEmptyStatement = isEmptyStatement; exports.isEmptyTypeAnnotation = isEmptyTypeAnnotation; exports.isEnumBody = isEnumBody; exports.isEnumBooleanBody = isEnumBooleanBody; exports.isEnumBooleanMember = isEnumBooleanMember; exports.isEnumDeclaration = isEnumDeclaration; exports.isEnumDefaultedMember = isEnumDefaultedMember; exports.isEnumMember = isEnumMember; exports.isEnumNumberBody = isEnumNumberBody; exports.isEnumNumberMember = isEnumNumberMember; exports.isEnumStringBody = isEnumStringBody; exports.isEnumStringMember = isEnumStringMember; exports.isEnumSymbolBody = isEnumSymbolBody; exports.isExistsTypeAnnotation = isExistsTypeAnnotation; exports.isExportAllDeclaration = isExportAllDeclaration; exports.isExportDeclaration = isExportDeclaration; exports.isExportDefaultDeclaration = isExportDefaultDeclaration; exports.isExportDefaultSpecifier = isExportDefaultSpecifier; exports.isExportNamedDeclaration = isExportNamedDeclaration; exports.isExportNamespaceSpecifier = isExportNamespaceSpecifier; exports.isExportSpecifier = isExportSpecifier; exports.isExpression = isExpression; exports.isExpressionStatement = isExpressionStatement; exports.isExpressionWrapper = isExpressionWrapper; exports.isFile = isFile; exports.isFlow = isFlow; exports.isFlowBaseAnnotation = isFlowBaseAnnotation; exports.isFlowDeclaration = isFlowDeclaration; exports.isFlowPredicate = isFlowPredicate; exports.isFlowType = isFlowType; exports.isFor = isFor; exports.isForInStatement = isForInStatement; exports.isForOfStatement = isForOfStatement; exports.isForStatement = isForStatement; exports.isForXStatement = isForXStatement; exports.isFunction = isFunction; exports.isFunctionDeclaration = isFunctionDeclaration; exports.isFunctionExpression = isFunctionExpression; exports.isFunctionParent = isFunctionParent; exports.isFunctionTypeAnnotation = isFunctionTypeAnnotation; exports.isFunctionTypeParam = isFunctionTypeParam; exports.isGenericTypeAnnotation = isGenericTypeAnnotation; exports.isIdentifier = isIdentifier; exports.isIfStatement = isIfStatement; exports.isImmutable = isImmutable; exports.isImport = isImport; exports.isImportAttribute = isImportAttribute; exports.isImportDeclaration = isImportDeclaration; exports.isImportDefaultSpecifier = isImportDefaultSpecifier; exports.isImportNamespaceSpecifier = isImportNamespaceSpecifier; exports.isImportSpecifier = isImportSpecifier; exports.isIndexedAccessType = isIndexedAccessType; exports.isInferredPredicate = isInferredPredicate; exports.isInterfaceDeclaration = isInterfaceDeclaration; exports.isInterfaceExtends = isInterfaceExtends; exports.isInterfaceTypeAnnotation = isInterfaceTypeAnnotation; exports.isInterpreterDirective = isInterpreterDirective; exports.isIntersectionTypeAnnotation = isIntersectionTypeAnnotation; exports.isJSX = isJSX; exports.isJSXAttribute = isJSXAttribute; exports.isJSXClosingElement = isJSXClosingElement; exports.isJSXClosingFragment = isJSXClosingFragment; exports.isJSXElement = isJSXElement; exports.isJSXEmptyExpression = isJSXEmptyExpression; exports.isJSXExpressionContainer = isJSXExpressionContainer; exports.isJSXFragment = isJSXFragment; exports.isJSXIdentifier = isJSXIdentifier; exports.isJSXMemberExpression = isJSXMemberExpression; exports.isJSXNamespacedName = isJSXNamespacedName; exports.isJSXOpeningElement = isJSXOpeningElement; exports.isJSXOpeningFragment = isJSXOpeningFragment; exports.isJSXSpreadAttribute = isJSXSpreadAttribute; exports.isJSXSpreadChild = isJSXSpreadChild; exports.isJSXText = isJSXText; exports.isLVal = isLVal; exports.isLabeledStatement = isLabeledStatement; exports.isLiteral = isLiteral; exports.isLogicalExpression = isLogicalExpression; exports.isLoop = isLoop; exports.isMemberExpression = isMemberExpression; exports.isMetaProperty = isMetaProperty; exports.isMethod = isMethod; exports.isMiscellaneous = isMiscellaneous; exports.isMixedTypeAnnotation = isMixedTypeAnnotation; exports.isModuleDeclaration = isModuleDeclaration; exports.isModuleExpression = isModuleExpression; exports.isModuleSpecifier = isModuleSpecifier; exports.isNewExpression = isNewExpression; exports.isNoop = isNoop; exports.isNullLiteral = isNullLiteral; exports.isNullLiteralTypeAnnotation = isNullLiteralTypeAnnotation; exports.isNullableTypeAnnotation = isNullableTypeAnnotation; exports.isNumberLiteral = isNumberLiteral; exports.isNumberLiteralTypeAnnotation = isNumberLiteralTypeAnnotation; exports.isNumberTypeAnnotation = isNumberTypeAnnotation; exports.isNumericLiteral = isNumericLiteral; exports.isObjectExpression = isObjectExpression; exports.isObjectMember = isObjectMember; exports.isObjectMethod = isObjectMethod; exports.isObjectPattern = isObjectPattern; exports.isObjectProperty = isObjectProperty; exports.isObjectTypeAnnotation = isObjectTypeAnnotation; exports.isObjectTypeCallProperty = isObjectTypeCallProperty; exports.isObjectTypeIndexer = isObjectTypeIndexer; exports.isObjectTypeInternalSlot = isObjectTypeInternalSlot; exports.isObjectTypeProperty = isObjectTypeProperty; exports.isObjectTypeSpreadProperty = isObjectTypeSpreadProperty; exports.isOpaqueType = isOpaqueType; exports.isOptionalCallExpression = isOptionalCallExpression; exports.isOptionalIndexedAccessType = isOptionalIndexedAccessType; exports.isOptionalMemberExpression = isOptionalMemberExpression; exports.isParenthesizedExpression = isParenthesizedExpression; exports.isPattern = isPattern; exports.isPatternLike = isPatternLike; exports.isPipelineBareFunction = isPipelineBareFunction; exports.isPipelinePrimaryTopicReference = isPipelinePrimaryTopicReference; exports.isPipelineTopicExpression = isPipelineTopicExpression; exports.isPlaceholder = isPlaceholder; exports.isPrivate = isPrivate; exports.isPrivateName = isPrivateName; exports.isProgram = isProgram; exports.isProperty = isProperty; exports.isPureish = isPureish; exports.isQualifiedTypeIdentifier = isQualifiedTypeIdentifier; exports.isRecordExpression = isRecordExpression; exports.isRegExpLiteral = isRegExpLiteral; exports.isRegexLiteral = isRegexLiteral; exports.isRestElement = isRestElement; exports.isRestProperty = isRestProperty; exports.isReturnStatement = isReturnStatement; exports.isScopable = isScopable; exports.isSequenceExpression = isSequenceExpression; exports.isSpreadElement = isSpreadElement; exports.isSpreadProperty = isSpreadProperty; exports.isStandardized = isStandardized; exports.isStatement = isStatement; exports.isStaticBlock = isStaticBlock; exports.isStringLiteral = isStringLiteral; exports.isStringLiteralTypeAnnotation = isStringLiteralTypeAnnotation; exports.isStringTypeAnnotation = isStringTypeAnnotation; exports.isSuper = isSuper; exports.isSwitchCase = isSwitchCase; exports.isSwitchStatement = isSwitchStatement; exports.isSymbolTypeAnnotation = isSymbolTypeAnnotation; exports.isTSAnyKeyword = isTSAnyKeyword; exports.isTSArrayType = isTSArrayType; exports.isTSAsExpression = isTSAsExpression; exports.isTSBaseType = isTSBaseType; exports.isTSBigIntKeyword = isTSBigIntKeyword; exports.isTSBooleanKeyword = isTSBooleanKeyword; exports.isTSCallSignatureDeclaration = isTSCallSignatureDeclaration; exports.isTSConditionalType = isTSConditionalType; exports.isTSConstructSignatureDeclaration = isTSConstructSignatureDeclaration; exports.isTSConstructorType = isTSConstructorType; exports.isTSDeclareFunction = isTSDeclareFunction; exports.isTSDeclareMethod = isTSDeclareMethod; exports.isTSEntityName = isTSEntityName; exports.isTSEnumDeclaration = isTSEnumDeclaration; exports.isTSEnumMember = isTSEnumMember; exports.isTSExportAssignment = isTSExportAssignment; exports.isTSExpressionWithTypeArguments = isTSExpressionWithTypeArguments; exports.isTSExternalModuleReference = isTSExternalModuleReference; exports.isTSFunctionType = isTSFunctionType; exports.isTSImportEqualsDeclaration = isTSImportEqualsDeclaration; exports.isTSImportType = isTSImportType; exports.isTSIndexSignature = isTSIndexSignature; exports.isTSIndexedAccessType = isTSIndexedAccessType; exports.isTSInferType = isTSInferType; exports.isTSInstantiationExpression = isTSInstantiationExpression; exports.isTSInterfaceBody = isTSInterfaceBody; exports.isTSInterfaceDeclaration = isTSInterfaceDeclaration; exports.isTSIntersectionType = isTSIntersectionType; exports.isTSIntrinsicKeyword = isTSIntrinsicKeyword; exports.isTSLiteralType = isTSLiteralType; exports.isTSMappedType = isTSMappedType; exports.isTSMethodSignature = isTSMethodSignature; exports.isTSModuleBlock = isTSModuleBlock; exports.isTSModuleDeclaration = isTSModuleDeclaration; exports.isTSNamedTupleMember = isTSNamedTupleMember; exports.isTSNamespaceExportDeclaration = isTSNamespaceExportDeclaration; exports.isTSNeverKeyword = isTSNeverKeyword; exports.isTSNonNullExpression = isTSNonNullExpression; exports.isTSNullKeyword = isTSNullKeyword; exports.isTSNumberKeyword = isTSNumberKeyword; exports.isTSObjectKeyword = isTSObjectKeyword; exports.isTSOptionalType = isTSOptionalType; exports.isTSParameterProperty = isTSParameterProperty; exports.isTSParenthesizedType = isTSParenthesizedType; exports.isTSPropertySignature = isTSPropertySignature; exports.isTSQualifiedName = isTSQualifiedName; exports.isTSRestType = isTSRestType; exports.isTSStringKeyword = isTSStringKeyword; exports.isTSSymbolKeyword = isTSSymbolKeyword; exports.isTSThisType = isTSThisType; exports.isTSTupleType = isTSTupleType; exports.isTSType = isTSType; exports.isTSTypeAliasDeclaration = isTSTypeAliasDeclaration; exports.isTSTypeAnnotation = isTSTypeAnnotation; exports.isTSTypeAssertion = isTSTypeAssertion; exports.isTSTypeElement = isTSTypeElement; exports.isTSTypeLiteral = isTSTypeLiteral; exports.isTSTypeOperator = isTSTypeOperator; exports.isTSTypeParameter = isTSTypeParameter; exports.isTSTypeParameterDeclaration = isTSTypeParameterDeclaration; exports.isTSTypeParameterInstantiation = isTSTypeParameterInstantiation; exports.isTSTypePredicate = isTSTypePredicate; exports.isTSTypeQuery = isTSTypeQuery; exports.isTSTypeReference = isTSTypeReference; exports.isTSUndefinedKeyword = isTSUndefinedKeyword; exports.isTSUnionType = isTSUnionType; exports.isTSUnknownKeyword = isTSUnknownKeyword; exports.isTSVoidKeyword = isTSVoidKeyword; exports.isTaggedTemplateExpression = isTaggedTemplateExpression; exports.isTemplateElement = isTemplateElement; exports.isTemplateLiteral = isTemplateLiteral; exports.isTerminatorless = isTerminatorless; exports.isThisExpression = isThisExpression; exports.isThisTypeAnnotation = isThisTypeAnnotation; exports.isThrowStatement = isThrowStatement; exports.isTopicReference = isTopicReference; exports.isTryStatement = isTryStatement; exports.isTupleExpression = isTupleExpression; exports.isTupleTypeAnnotation = isTupleTypeAnnotation; exports.isTypeAlias = isTypeAlias; exports.isTypeAnnotation = isTypeAnnotation; exports.isTypeCastExpression = isTypeCastExpression; exports.isTypeParameter = isTypeParameter; exports.isTypeParameterDeclaration = isTypeParameterDeclaration; exports.isTypeParameterInstantiation = isTypeParameterInstantiation; exports.isTypeScript = isTypeScript; exports.isTypeofTypeAnnotation = isTypeofTypeAnnotation; exports.isUnaryExpression = isUnaryExpression; exports.isUnaryLike = isUnaryLike; exports.isUnionTypeAnnotation = isUnionTypeAnnotation; exports.isUpdateExpression = isUpdateExpression; exports.isUserWhitespacable = isUserWhitespacable; exports.isV8IntrinsicIdentifier = isV8IntrinsicIdentifier; exports.isVariableDeclaration = isVariableDeclaration; exports.isVariableDeclarator = isVariableDeclarator; exports.isVariance = isVariance; exports.isVoidTypeAnnotation = isVoidTypeAnnotation; exports.isWhile = isWhile; exports.isWhileStatement = isWhileStatement; exports.isWithStatement = isWithStatement; exports.isYieldExpression = isYieldExpression; var _shallowEqual = require("../../utils/shallowEqual"); function isArrayExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ArrayExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isAssignmentExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "AssignmentExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isBinaryExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "BinaryExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isInterpreterDirective(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "InterpreterDirective") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isDirective(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "Directive") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isDirectiveLiteral(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "DirectiveLiteral") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isBlockStatement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "BlockStatement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isBreakStatement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "BreakStatement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isCallExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "CallExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isCatchClause(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "CatchClause") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isConditionalExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ConditionalExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isContinueStatement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ContinueStatement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isDebuggerStatement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "DebuggerStatement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isDoWhileStatement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "DoWhileStatement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isEmptyStatement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "EmptyStatement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isExpressionStatement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ExpressionStatement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isFile(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "File") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isForInStatement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ForInStatement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isForStatement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ForStatement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isFunctionDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "FunctionDeclaration") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isFunctionExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "FunctionExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isIdentifier(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "Identifier") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isIfStatement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "IfStatement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isLabeledStatement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "LabeledStatement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isStringLiteral(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "StringLiteral") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isNumericLiteral(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "NumericLiteral") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isNullLiteral(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "NullLiteral") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isBooleanLiteral(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "BooleanLiteral") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isRegExpLiteral(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "RegExpLiteral") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isLogicalExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "LogicalExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isMemberExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "MemberExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isNewExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "NewExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isProgram(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "Program") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isObjectExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ObjectExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isObjectMethod(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ObjectMethod") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isObjectProperty(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ObjectProperty") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isRestElement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "RestElement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isReturnStatement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ReturnStatement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isSequenceExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "SequenceExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isParenthesizedExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ParenthesizedExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isSwitchCase(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "SwitchCase") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isSwitchStatement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "SwitchStatement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isThisExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ThisExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isThrowStatement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ThrowStatement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTryStatement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TryStatement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isUnaryExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "UnaryExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isUpdateExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "UpdateExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isVariableDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "VariableDeclaration") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isVariableDeclarator(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "VariableDeclarator") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isWhileStatement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "WhileStatement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isWithStatement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "WithStatement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isAssignmentPattern(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "AssignmentPattern") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isArrayPattern(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ArrayPattern") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isArrowFunctionExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ArrowFunctionExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isClassBody(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ClassBody") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isClassExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ClassExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isClassDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ClassDeclaration") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isExportAllDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ExportAllDeclaration") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isExportDefaultDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ExportDefaultDeclaration") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isExportNamedDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ExportNamedDeclaration") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isExportSpecifier(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ExportSpecifier") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isForOfStatement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ForOfStatement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isImportDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ImportDeclaration") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isImportDefaultSpecifier(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ImportDefaultSpecifier") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isImportNamespaceSpecifier(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ImportNamespaceSpecifier") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isImportSpecifier(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ImportSpecifier") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isMetaProperty(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "MetaProperty") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isClassMethod(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ClassMethod") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isObjectPattern(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ObjectPattern") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isSpreadElement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "SpreadElement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isSuper(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "Super") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTaggedTemplateExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TaggedTemplateExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTemplateElement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TemplateElement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTemplateLiteral(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TemplateLiteral") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isYieldExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "YieldExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isAwaitExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "AwaitExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isImport(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "Import") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isBigIntLiteral(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "BigIntLiteral") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isExportNamespaceSpecifier(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ExportNamespaceSpecifier") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isOptionalMemberExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "OptionalMemberExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isOptionalCallExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "OptionalCallExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isClassProperty(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ClassProperty") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isClassAccessorProperty(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ClassAccessorProperty") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isClassPrivateProperty(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ClassPrivateProperty") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isClassPrivateMethod(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ClassPrivateMethod") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isPrivateName(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "PrivateName") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isStaticBlock(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "StaticBlock") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isAnyTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "AnyTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isArrayTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ArrayTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isBooleanTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "BooleanTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isBooleanLiteralTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "BooleanLiteralTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isNullLiteralTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "NullLiteralTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isClassImplements(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ClassImplements") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isDeclareClass(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "DeclareClass") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isDeclareFunction(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "DeclareFunction") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isDeclareInterface(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "DeclareInterface") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isDeclareModule(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "DeclareModule") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isDeclareModuleExports(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "DeclareModuleExports") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isDeclareTypeAlias(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "DeclareTypeAlias") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isDeclareOpaqueType(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "DeclareOpaqueType") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isDeclareVariable(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "DeclareVariable") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isDeclareExportDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "DeclareExportDeclaration") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isDeclareExportAllDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "DeclareExportAllDeclaration") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isDeclaredPredicate(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "DeclaredPredicate") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isExistsTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ExistsTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isFunctionTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "FunctionTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isFunctionTypeParam(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "FunctionTypeParam") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isGenericTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "GenericTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isInferredPredicate(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "InferredPredicate") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isInterfaceExtends(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "InterfaceExtends") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isInterfaceDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "InterfaceDeclaration") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isInterfaceTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "InterfaceTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isIntersectionTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "IntersectionTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isMixedTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "MixedTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isEmptyTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "EmptyTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isNullableTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "NullableTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isNumberLiteralTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "NumberLiteralTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isNumberTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "NumberTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isObjectTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ObjectTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isObjectTypeInternalSlot(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ObjectTypeInternalSlot") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isObjectTypeCallProperty(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ObjectTypeCallProperty") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isObjectTypeIndexer(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ObjectTypeIndexer") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isObjectTypeProperty(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ObjectTypeProperty") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isObjectTypeSpreadProperty(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ObjectTypeSpreadProperty") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isOpaqueType(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "OpaqueType") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isQualifiedTypeIdentifier(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "QualifiedTypeIdentifier") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isStringLiteralTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "StringLiteralTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isStringTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "StringTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isSymbolTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "SymbolTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isThisTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ThisTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTupleTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TupleTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTypeofTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TypeofTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTypeAlias(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TypeAlias") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTypeCastExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TypeCastExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTypeParameter(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TypeParameter") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTypeParameterDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TypeParameterDeclaration") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTypeParameterInstantiation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TypeParameterInstantiation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isUnionTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "UnionTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isVariance(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "Variance") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isVoidTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "VoidTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isEnumDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "EnumDeclaration") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isEnumBooleanBody(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "EnumBooleanBody") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isEnumNumberBody(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "EnumNumberBody") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isEnumStringBody(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "EnumStringBody") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isEnumSymbolBody(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "EnumSymbolBody") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isEnumBooleanMember(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "EnumBooleanMember") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isEnumNumberMember(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "EnumNumberMember") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isEnumStringMember(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "EnumStringMember") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isEnumDefaultedMember(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "EnumDefaultedMember") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isIndexedAccessType(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "IndexedAccessType") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isOptionalIndexedAccessType(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "OptionalIndexedAccessType") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isJSXAttribute(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "JSXAttribute") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isJSXClosingElement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "JSXClosingElement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isJSXElement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "JSXElement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isJSXEmptyExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "JSXEmptyExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isJSXExpressionContainer(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "JSXExpressionContainer") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isJSXSpreadChild(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "JSXSpreadChild") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isJSXIdentifier(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "JSXIdentifier") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isJSXMemberExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "JSXMemberExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isJSXNamespacedName(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "JSXNamespacedName") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isJSXOpeningElement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "JSXOpeningElement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isJSXSpreadAttribute(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "JSXSpreadAttribute") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isJSXText(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "JSXText") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isJSXFragment(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "JSXFragment") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isJSXOpeningFragment(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "JSXOpeningFragment") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isJSXClosingFragment(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "JSXClosingFragment") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isNoop(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "Noop") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isPlaceholder(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "Placeholder") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isV8IntrinsicIdentifier(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "V8IntrinsicIdentifier") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isArgumentPlaceholder(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ArgumentPlaceholder") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isBindExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "BindExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isImportAttribute(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ImportAttribute") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isDecorator(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "Decorator") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isDoExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "DoExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isExportDefaultSpecifier(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ExportDefaultSpecifier") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isRecordExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "RecordExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTupleExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TupleExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isDecimalLiteral(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "DecimalLiteral") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isModuleExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ModuleExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTopicReference(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TopicReference") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isPipelineTopicExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "PipelineTopicExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isPipelineBareFunction(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "PipelineBareFunction") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isPipelinePrimaryTopicReference(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "PipelinePrimaryTopicReference") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSParameterProperty(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSParameterProperty") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSDeclareFunction(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSDeclareFunction") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSDeclareMethod(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSDeclareMethod") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSQualifiedName(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSQualifiedName") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSCallSignatureDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSCallSignatureDeclaration") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSConstructSignatureDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSConstructSignatureDeclaration") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSPropertySignature(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSPropertySignature") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSMethodSignature(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSMethodSignature") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSIndexSignature(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSIndexSignature") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSAnyKeyword(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSAnyKeyword") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSBooleanKeyword(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSBooleanKeyword") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSBigIntKeyword(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSBigIntKeyword") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSIntrinsicKeyword(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSIntrinsicKeyword") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSNeverKeyword(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSNeverKeyword") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSNullKeyword(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSNullKeyword") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSNumberKeyword(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSNumberKeyword") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSObjectKeyword(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSObjectKeyword") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSStringKeyword(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSStringKeyword") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSSymbolKeyword(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSSymbolKeyword") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSUndefinedKeyword(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSUndefinedKeyword") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSUnknownKeyword(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSUnknownKeyword") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSVoidKeyword(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSVoidKeyword") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSThisType(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSThisType") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSFunctionType(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSFunctionType") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSConstructorType(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSConstructorType") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSTypeReference(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSTypeReference") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSTypePredicate(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSTypePredicate") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSTypeQuery(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSTypeQuery") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSTypeLiteral(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSTypeLiteral") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSArrayType(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSArrayType") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSTupleType(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSTupleType") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSOptionalType(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSOptionalType") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSRestType(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSRestType") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSNamedTupleMember(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSNamedTupleMember") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSUnionType(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSUnionType") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSIntersectionType(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSIntersectionType") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSConditionalType(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSConditionalType") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSInferType(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSInferType") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSParenthesizedType(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSParenthesizedType") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSTypeOperator(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSTypeOperator") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSIndexedAccessType(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSIndexedAccessType") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSMappedType(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSMappedType") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSLiteralType(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSLiteralType") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSExpressionWithTypeArguments(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSExpressionWithTypeArguments") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSInterfaceDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSInterfaceDeclaration") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSInterfaceBody(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSInterfaceBody") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSTypeAliasDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSTypeAliasDeclaration") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSInstantiationExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSInstantiationExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSAsExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSAsExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSTypeAssertion(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSTypeAssertion") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSEnumDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSEnumDeclaration") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSEnumMember(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSEnumMember") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSModuleDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSModuleDeclaration") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSModuleBlock(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSModuleBlock") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSImportType(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSImportType") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSImportEqualsDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSImportEqualsDeclaration") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSExternalModuleReference(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSExternalModuleReference") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSNonNullExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSNonNullExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSExportAssignment(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSExportAssignment") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSNamespaceExportDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSNamespaceExportDeclaration") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSTypeParameterInstantiation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSTypeParameterInstantiation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSTypeParameterDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSTypeParameterDeclaration") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSTypeParameter(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSTypeParameter") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isStandardized(node, opts) { if (!node) return false; const nodeType = node.type; if ("ArrayExpression" === nodeType || "AssignmentExpression" === nodeType || "BinaryExpression" === nodeType || "InterpreterDirective" === nodeType || "Directive" === nodeType || "DirectiveLiteral" === nodeType || "BlockStatement" === nodeType || "BreakStatement" === nodeType || "CallExpression" === nodeType || "CatchClause" === nodeType || "ConditionalExpression" === nodeType || "ContinueStatement" === nodeType || "DebuggerStatement" === nodeType || "DoWhileStatement" === nodeType || "EmptyStatement" === nodeType || "ExpressionStatement" === nodeType || "File" === nodeType || "ForInStatement" === nodeType || "ForStatement" === nodeType || "FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "Identifier" === nodeType || "IfStatement" === nodeType || "LabeledStatement" === nodeType || "StringLiteral" === nodeType || "NumericLiteral" === nodeType || "NullLiteral" === nodeType || "BooleanLiteral" === nodeType || "RegExpLiteral" === nodeType || "LogicalExpression" === nodeType || "MemberExpression" === nodeType || "NewExpression" === nodeType || "Program" === nodeType || "ObjectExpression" === nodeType || "ObjectMethod" === nodeType || "ObjectProperty" === nodeType || "RestElement" === nodeType || "ReturnStatement" === nodeType || "SequenceExpression" === nodeType || "ParenthesizedExpression" === nodeType || "SwitchCase" === nodeType || "SwitchStatement" === nodeType || "ThisExpression" === nodeType || "ThrowStatement" === nodeType || "TryStatement" === nodeType || "UnaryExpression" === nodeType || "UpdateExpression" === nodeType || "VariableDeclaration" === nodeType || "VariableDeclarator" === nodeType || "WhileStatement" === nodeType || "WithStatement" === nodeType || "AssignmentPattern" === nodeType || "ArrayPattern" === nodeType || "ArrowFunctionExpression" === nodeType || "ClassBody" === nodeType || "ClassExpression" === nodeType || "ClassDeclaration" === nodeType || "ExportAllDeclaration" === nodeType || "ExportDefaultDeclaration" === nodeType || "ExportNamedDeclaration" === nodeType || "ExportSpecifier" === nodeType || "ForOfStatement" === nodeType || "ImportDeclaration" === nodeType || "ImportDefaultSpecifier" === nodeType || "ImportNamespaceSpecifier" === nodeType || "ImportSpecifier" === nodeType || "MetaProperty" === nodeType || "ClassMethod" === nodeType || "ObjectPattern" === nodeType || "SpreadElement" === nodeType || "Super" === nodeType || "TaggedTemplateExpression" === nodeType || "TemplateElement" === nodeType || "TemplateLiteral" === nodeType || "YieldExpression" === nodeType || "AwaitExpression" === nodeType || "Import" === nodeType || "BigIntLiteral" === nodeType || "ExportNamespaceSpecifier" === nodeType || "OptionalMemberExpression" === nodeType || "OptionalCallExpression" === nodeType || "ClassProperty" === nodeType || "ClassAccessorProperty" === nodeType || "ClassPrivateProperty" === nodeType || "ClassPrivateMethod" === nodeType || "PrivateName" === nodeType || "StaticBlock" === nodeType || nodeType === "Placeholder" && ("Identifier" === node.expectedNode || "StringLiteral" === node.expectedNode || "BlockStatement" === node.expectedNode || "ClassBody" === node.expectedNode)) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isExpression(node, opts) { if (!node) return false; const nodeType = node.type; if ("ArrayExpression" === nodeType || "AssignmentExpression" === nodeType || "BinaryExpression" === nodeType || "CallExpression" === nodeType || "ConditionalExpression" === nodeType || "FunctionExpression" === nodeType || "Identifier" === nodeType || "StringLiteral" === nodeType || "NumericLiteral" === nodeType || "NullLiteral" === nodeType || "BooleanLiteral" === nodeType || "RegExpLiteral" === nodeType || "LogicalExpression" === nodeType || "MemberExpression" === nodeType || "NewExpression" === nodeType || "ObjectExpression" === nodeType || "SequenceExpression" === nodeType || "ParenthesizedExpression" === nodeType || "ThisExpression" === nodeType || "UnaryExpression" === nodeType || "UpdateExpression" === nodeType || "ArrowFunctionExpression" === nodeType || "ClassExpression" === nodeType || "MetaProperty" === nodeType || "Super" === nodeType || "TaggedTemplateExpression" === nodeType || "TemplateLiteral" === nodeType || "YieldExpression" === nodeType || "AwaitExpression" === nodeType || "Import" === nodeType || "BigIntLiteral" === nodeType || "OptionalMemberExpression" === nodeType || "OptionalCallExpression" === nodeType || "TypeCastExpression" === nodeType || "JSXElement" === nodeType || "JSXFragment" === nodeType || "BindExpression" === nodeType || "DoExpression" === nodeType || "RecordExpression" === nodeType || "TupleExpression" === nodeType || "DecimalLiteral" === nodeType || "ModuleExpression" === nodeType || "TopicReference" === nodeType || "PipelineTopicExpression" === nodeType || "PipelineBareFunction" === nodeType || "PipelinePrimaryTopicReference" === nodeType || "TSInstantiationExpression" === nodeType || "TSAsExpression" === nodeType || "TSTypeAssertion" === nodeType || "TSNonNullExpression" === nodeType || nodeType === "Placeholder" && ("Expression" === node.expectedNode || "Identifier" === node.expectedNode || "StringLiteral" === node.expectedNode)) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isBinary(node, opts) { if (!node) return false; const nodeType = node.type; if ("BinaryExpression" === nodeType || "LogicalExpression" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isScopable(node, opts) { if (!node) return false; const nodeType = node.type; if ("BlockStatement" === nodeType || "CatchClause" === nodeType || "DoWhileStatement" === nodeType || "ForInStatement" === nodeType || "ForStatement" === nodeType || "FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "Program" === nodeType || "ObjectMethod" === nodeType || "SwitchStatement" === nodeType || "WhileStatement" === nodeType || "ArrowFunctionExpression" === nodeType || "ClassExpression" === nodeType || "ClassDeclaration" === nodeType || "ForOfStatement" === nodeType || "ClassMethod" === nodeType || "ClassPrivateMethod" === nodeType || "StaticBlock" === nodeType || "TSModuleBlock" === nodeType || nodeType === "Placeholder" && "BlockStatement" === node.expectedNode) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isBlockParent(node, opts) { if (!node) return false; const nodeType = node.type; if ("BlockStatement" === nodeType || "CatchClause" === nodeType || "DoWhileStatement" === nodeType || "ForInStatement" === nodeType || "ForStatement" === nodeType || "FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "Program" === nodeType || "ObjectMethod" === nodeType || "SwitchStatement" === nodeType || "WhileStatement" === nodeType || "ArrowFunctionExpression" === nodeType || "ForOfStatement" === nodeType || "ClassMethod" === nodeType || "ClassPrivateMethod" === nodeType || "StaticBlock" === nodeType || "TSModuleBlock" === nodeType || nodeType === "Placeholder" && "BlockStatement" === node.expectedNode) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isBlock(node, opts) { if (!node) return false; const nodeType = node.type; if ("BlockStatement" === nodeType || "Program" === nodeType || "TSModuleBlock" === nodeType || nodeType === "Placeholder" && "BlockStatement" === node.expectedNode) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isStatement(node, opts) { if (!node) return false; const nodeType = node.type; if ("BlockStatement" === nodeType || "BreakStatement" === nodeType || "ContinueStatement" === nodeType || "DebuggerStatement" === nodeType || "DoWhileStatement" === nodeType || "EmptyStatement" === nodeType || "ExpressionStatement" === nodeType || "ForInStatement" === nodeType || "ForStatement" === nodeType || "FunctionDeclaration" === nodeType || "IfStatement" === nodeType || "LabeledStatement" === nodeType || "ReturnStatement" === nodeType || "SwitchStatement" === nodeType || "ThrowStatement" === nodeType || "TryStatement" === nodeType || "VariableDeclaration" === nodeType || "WhileStatement" === nodeType || "WithStatement" === nodeType || "ClassDeclaration" === nodeType || "ExportAllDeclaration" === nodeType || "ExportDefaultDeclaration" === nodeType || "ExportNamedDeclaration" === nodeType || "ForOfStatement" === nodeType || "ImportDeclaration" === nodeType || "DeclareClass" === nodeType || "DeclareFunction" === nodeType || "DeclareInterface" === nodeType || "DeclareModule" === nodeType || "DeclareModuleExports" === nodeType || "DeclareTypeAlias" === nodeType || "DeclareOpaqueType" === nodeType || "DeclareVariable" === nodeType || "DeclareExportDeclaration" === nodeType || "DeclareExportAllDeclaration" === nodeType || "InterfaceDeclaration" === nodeType || "OpaqueType" === nodeType || "TypeAlias" === nodeType || "EnumDeclaration" === nodeType || "TSDeclareFunction" === nodeType || "TSInterfaceDeclaration" === nodeType || "TSTypeAliasDeclaration" === nodeType || "TSEnumDeclaration" === nodeType || "TSModuleDeclaration" === nodeType || "TSImportEqualsDeclaration" === nodeType || "TSExportAssignment" === nodeType || "TSNamespaceExportDeclaration" === nodeType || nodeType === "Placeholder" && ("Statement" === node.expectedNode || "Declaration" === node.expectedNode || "BlockStatement" === node.expectedNode)) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTerminatorless(node, opts) { if (!node) return false; const nodeType = node.type; if ("BreakStatement" === nodeType || "ContinueStatement" === nodeType || "ReturnStatement" === nodeType || "ThrowStatement" === nodeType || "YieldExpression" === nodeType || "AwaitExpression" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isCompletionStatement(node, opts) { if (!node) return false; const nodeType = node.type; if ("BreakStatement" === nodeType || "ContinueStatement" === nodeType || "ReturnStatement" === nodeType || "ThrowStatement" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isConditional(node, opts) { if (!node) return false; const nodeType = node.type; if ("ConditionalExpression" === nodeType || "IfStatement" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isLoop(node, opts) { if (!node) return false; const nodeType = node.type; if ("DoWhileStatement" === nodeType || "ForInStatement" === nodeType || "ForStatement" === nodeType || "WhileStatement" === nodeType || "ForOfStatement" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isWhile(node, opts) { if (!node) return false; const nodeType = node.type; if ("DoWhileStatement" === nodeType || "WhileStatement" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isExpressionWrapper(node, opts) { if (!node) return false; const nodeType = node.type; if ("ExpressionStatement" === nodeType || "ParenthesizedExpression" === nodeType || "TypeCastExpression" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isFor(node, opts) { if (!node) return false; const nodeType = node.type; if ("ForInStatement" === nodeType || "ForStatement" === nodeType || "ForOfStatement" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isForXStatement(node, opts) { if (!node) return false; const nodeType = node.type; if ("ForInStatement" === nodeType || "ForOfStatement" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isFunction(node, opts) { if (!node) return false; const nodeType = node.type; if ("FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "ObjectMethod" === nodeType || "ArrowFunctionExpression" === nodeType || "ClassMethod" === nodeType || "ClassPrivateMethod" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isFunctionParent(node, opts) { if (!node) return false; const nodeType = node.type; if ("FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "ObjectMethod" === nodeType || "ArrowFunctionExpression" === nodeType || "ClassMethod" === nodeType || "ClassPrivateMethod" === nodeType || "StaticBlock" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isPureish(node, opts) { if (!node) return false; const nodeType = node.type; if ("FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "StringLiteral" === nodeType || "NumericLiteral" === nodeType || "NullLiteral" === nodeType || "BooleanLiteral" === nodeType || "RegExpLiteral" === nodeType || "ArrowFunctionExpression" === nodeType || "BigIntLiteral" === nodeType || "DecimalLiteral" === nodeType || nodeType === "Placeholder" && "StringLiteral" === node.expectedNode) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if ("FunctionDeclaration" === nodeType || "VariableDeclaration" === nodeType || "ClassDeclaration" === nodeType || "ExportAllDeclaration" === nodeType || "ExportDefaultDeclaration" === nodeType || "ExportNamedDeclaration" === nodeType || "ImportDeclaration" === nodeType || "DeclareClass" === nodeType || "DeclareFunction" === nodeType || "DeclareInterface" === nodeType || "DeclareModule" === nodeType || "DeclareModuleExports" === nodeType || "DeclareTypeAlias" === nodeType || "DeclareOpaqueType" === nodeType || "DeclareVariable" === nodeType || "DeclareExportDeclaration" === nodeType || "DeclareExportAllDeclaration" === nodeType || "InterfaceDeclaration" === nodeType || "OpaqueType" === nodeType || "TypeAlias" === nodeType || "EnumDeclaration" === nodeType || "TSDeclareFunction" === nodeType || "TSInterfaceDeclaration" === nodeType || "TSTypeAliasDeclaration" === nodeType || "TSEnumDeclaration" === nodeType || "TSModuleDeclaration" === nodeType || nodeType === "Placeholder" && "Declaration" === node.expectedNode) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isPatternLike(node, opts) { if (!node) return false; const nodeType = node.type; if ("Identifier" === nodeType || "RestElement" === nodeType || "AssignmentPattern" === nodeType || "ArrayPattern" === nodeType || "ObjectPattern" === nodeType || "TSAsExpression" === nodeType || "TSTypeAssertion" === nodeType || "TSNonNullExpression" === nodeType || nodeType === "Placeholder" && ("Pattern" === node.expectedNode || "Identifier" === node.expectedNode)) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isLVal(node, opts) { if (!node) return false; const nodeType = node.type; if ("Identifier" === nodeType || "MemberExpression" === nodeType || "RestElement" === nodeType || "AssignmentPattern" === nodeType || "ArrayPattern" === nodeType || "ObjectPattern" === nodeType || "TSParameterProperty" === nodeType || "TSAsExpression" === nodeType || "TSTypeAssertion" === nodeType || "TSNonNullExpression" === nodeType || nodeType === "Placeholder" && ("Pattern" === node.expectedNode || "Identifier" === node.expectedNode)) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSEntityName(node, opts) { if (!node) return false; const nodeType = node.type; if ("Identifier" === nodeType || "TSQualifiedName" === nodeType || nodeType === "Placeholder" && "Identifier" === node.expectedNode) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isLiteral(node, opts) { if (!node) return false; const nodeType = node.type; if ("StringLiteral" === nodeType || "NumericLiteral" === nodeType || "NullLiteral" === nodeType || "BooleanLiteral" === nodeType || "RegExpLiteral" === nodeType || "TemplateLiteral" === nodeType || "BigIntLiteral" === nodeType || "DecimalLiteral" === nodeType || nodeType === "Placeholder" && "StringLiteral" === node.expectedNode) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isImmutable(node, opts) { if (!node) return false; const nodeType = node.type; if ("StringLiteral" === nodeType || "NumericLiteral" === nodeType || "NullLiteral" === nodeType || "BooleanLiteral" === nodeType || "BigIntLiteral" === nodeType || "JSXAttribute" === nodeType || "JSXClosingElement" === nodeType || "JSXElement" === nodeType || "JSXExpressionContainer" === nodeType || "JSXSpreadChild" === nodeType || "JSXOpeningElement" === nodeType || "JSXText" === nodeType || "JSXFragment" === nodeType || "JSXOpeningFragment" === nodeType || "JSXClosingFragment" === nodeType || "DecimalLiteral" === nodeType || nodeType === "Placeholder" && "StringLiteral" === node.expectedNode) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isUserWhitespacable(node, opts) { if (!node) return false; const nodeType = node.type; if ("ObjectMethod" === nodeType || "ObjectProperty" === nodeType || "ObjectTypeInternalSlot" === nodeType || "ObjectTypeCallProperty" === nodeType || "ObjectTypeIndexer" === nodeType || "ObjectTypeProperty" === nodeType || "ObjectTypeSpreadProperty" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isMethod(node, opts) { if (!node) return false; const nodeType = node.type; if ("ObjectMethod" === nodeType || "ClassMethod" === nodeType || "ClassPrivateMethod" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isObjectMember(node, opts) { if (!node) return false; const nodeType = node.type; if ("ObjectMethod" === nodeType || "ObjectProperty" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isProperty(node, opts) { if (!node) return false; const nodeType = node.type; if ("ObjectProperty" === nodeType || "ClassProperty" === nodeType || "ClassAccessorProperty" === nodeType || "ClassPrivateProperty" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isUnaryLike(node, opts) { if (!node) return false; const nodeType = node.type; if ("UnaryExpression" === nodeType || "SpreadElement" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isPattern(node, opts) { if (!node) return false; const nodeType = node.type; if ("AssignmentPattern" === nodeType || "ArrayPattern" === nodeType || "ObjectPattern" === nodeType || nodeType === "Placeholder" && "Pattern" === node.expectedNode) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isClass(node, opts) { if (!node) return false; const nodeType = node.type; if ("ClassExpression" === nodeType || "ClassDeclaration" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isModuleDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if ("ExportAllDeclaration" === nodeType || "ExportDefaultDeclaration" === nodeType || "ExportNamedDeclaration" === nodeType || "ImportDeclaration" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isExportDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if ("ExportAllDeclaration" === nodeType || "ExportDefaultDeclaration" === nodeType || "ExportNamedDeclaration" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isModuleSpecifier(node, opts) { if (!node) return false; const nodeType = node.type; if ("ExportSpecifier" === nodeType || "ImportDefaultSpecifier" === nodeType || "ImportNamespaceSpecifier" === nodeType || "ImportSpecifier" === nodeType || "ExportNamespaceSpecifier" === nodeType || "ExportDefaultSpecifier" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isAccessor(node, opts) { if (!node) return false; const nodeType = node.type; if ("ClassAccessorProperty" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isPrivate(node, opts) { if (!node) return false; const nodeType = node.type; if ("ClassPrivateProperty" === nodeType || "ClassPrivateMethod" === nodeType || "PrivateName" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isFlow(node, opts) { if (!node) return false; const nodeType = node.type; if ("AnyTypeAnnotation" === nodeType || "ArrayTypeAnnotation" === nodeType || "BooleanTypeAnnotation" === nodeType || "BooleanLiteralTypeAnnotation" === nodeType || "NullLiteralTypeAnnotation" === nodeType || "ClassImplements" === nodeType || "DeclareClass" === nodeType || "DeclareFunction" === nodeType || "DeclareInterface" === nodeType || "DeclareModule" === nodeType || "DeclareModuleExports" === nodeType || "DeclareTypeAlias" === nodeType || "DeclareOpaqueType" === nodeType || "DeclareVariable" === nodeType || "DeclareExportDeclaration" === nodeType || "DeclareExportAllDeclaration" === nodeType || "DeclaredPredicate" === nodeType || "ExistsTypeAnnotation" === nodeType || "FunctionTypeAnnotation" === nodeType || "FunctionTypeParam" === nodeType || "GenericTypeAnnotation" === nodeType || "InferredPredicate" === nodeType || "InterfaceExtends" === nodeType || "InterfaceDeclaration" === nodeType || "InterfaceTypeAnnotation" === nodeType || "IntersectionTypeAnnotation" === nodeType || "MixedTypeAnnotation" === nodeType || "EmptyTypeAnnotation" === nodeType || "NullableTypeAnnotation" === nodeType || "NumberLiteralTypeAnnotation" === nodeType || "NumberTypeAnnotation" === nodeType || "ObjectTypeAnnotation" === nodeType || "ObjectTypeInternalSlot" === nodeType || "ObjectTypeCallProperty" === nodeType || "ObjectTypeIndexer" === nodeType || "ObjectTypeProperty" === nodeType || "ObjectTypeSpreadProperty" === nodeType || "OpaqueType" === nodeType || "QualifiedTypeIdentifier" === nodeType || "StringLiteralTypeAnnotation" === nodeType || "StringTypeAnnotation" === nodeType || "SymbolTypeAnnotation" === nodeType || "ThisTypeAnnotation" === nodeType || "TupleTypeAnnotation" === nodeType || "TypeofTypeAnnotation" === nodeType || "TypeAlias" === nodeType || "TypeAnnotation" === nodeType || "TypeCastExpression" === nodeType || "TypeParameter" === nodeType || "TypeParameterDeclaration" === nodeType || "TypeParameterInstantiation" === nodeType || "UnionTypeAnnotation" === nodeType || "Variance" === nodeType || "VoidTypeAnnotation" === nodeType || "EnumDeclaration" === nodeType || "EnumBooleanBody" === nodeType || "EnumNumberBody" === nodeType || "EnumStringBody" === nodeType || "EnumSymbolBody" === nodeType || "EnumBooleanMember" === nodeType || "EnumNumberMember" === nodeType || "EnumStringMember" === nodeType || "EnumDefaultedMember" === nodeType || "IndexedAccessType" === nodeType || "OptionalIndexedAccessType" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isFlowType(node, opts) { if (!node) return false; const nodeType = node.type; if ("AnyTypeAnnotation" === nodeType || "ArrayTypeAnnotation" === nodeType || "BooleanTypeAnnotation" === nodeType || "BooleanLiteralTypeAnnotation" === nodeType || "NullLiteralTypeAnnotation" === nodeType || "ExistsTypeAnnotation" === nodeType || "FunctionTypeAnnotation" === nodeType || "GenericTypeAnnotation" === nodeType || "InterfaceTypeAnnotation" === nodeType || "IntersectionTypeAnnotation" === nodeType || "MixedTypeAnnotation" === nodeType || "EmptyTypeAnnotation" === nodeType || "NullableTypeAnnotation" === nodeType || "NumberLiteralTypeAnnotation" === nodeType || "NumberTypeAnnotation" === nodeType || "ObjectTypeAnnotation" === nodeType || "StringLiteralTypeAnnotation" === nodeType || "StringTypeAnnotation" === nodeType || "SymbolTypeAnnotation" === nodeType || "ThisTypeAnnotation" === nodeType || "TupleTypeAnnotation" === nodeType || "TypeofTypeAnnotation" === nodeType || "UnionTypeAnnotation" === nodeType || "VoidTypeAnnotation" === nodeType || "IndexedAccessType" === nodeType || "OptionalIndexedAccessType" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isFlowBaseAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if ("AnyTypeAnnotation" === nodeType || "BooleanTypeAnnotation" === nodeType || "NullLiteralTypeAnnotation" === nodeType || "MixedTypeAnnotation" === nodeType || "EmptyTypeAnnotation" === nodeType || "NumberTypeAnnotation" === nodeType || "StringTypeAnnotation" === nodeType || "SymbolTypeAnnotation" === nodeType || "ThisTypeAnnotation" === nodeType || "VoidTypeAnnotation" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isFlowDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if ("DeclareClass" === nodeType || "DeclareFunction" === nodeType || "DeclareInterface" === nodeType || "DeclareModule" === nodeType || "DeclareModuleExports" === nodeType || "DeclareTypeAlias" === nodeType || "DeclareOpaqueType" === nodeType || "DeclareVariable" === nodeType || "DeclareExportDeclaration" === nodeType || "DeclareExportAllDeclaration" === nodeType || "InterfaceDeclaration" === nodeType || "OpaqueType" === nodeType || "TypeAlias" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isFlowPredicate(node, opts) { if (!node) return false; const nodeType = node.type; if ("DeclaredPredicate" === nodeType || "InferredPredicate" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isEnumBody(node, opts) { if (!node) return false; const nodeType = node.type; if ("EnumBooleanBody" === nodeType || "EnumNumberBody" === nodeType || "EnumStringBody" === nodeType || "EnumSymbolBody" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isEnumMember(node, opts) { if (!node) return false; const nodeType = node.type; if ("EnumBooleanMember" === nodeType || "EnumNumberMember" === nodeType || "EnumStringMember" === nodeType || "EnumDefaultedMember" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isJSX(node, opts) { if (!node) return false; const nodeType = node.type; if ("JSXAttribute" === nodeType || "JSXClosingElement" === nodeType || "JSXElement" === nodeType || "JSXEmptyExpression" === nodeType || "JSXExpressionContainer" === nodeType || "JSXSpreadChild" === nodeType || "JSXIdentifier" === nodeType || "JSXMemberExpression" === nodeType || "JSXNamespacedName" === nodeType || "JSXOpeningElement" === nodeType || "JSXSpreadAttribute" === nodeType || "JSXText" === nodeType || "JSXFragment" === nodeType || "JSXOpeningFragment" === nodeType || "JSXClosingFragment" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isMiscellaneous(node, opts) { if (!node) return false; const nodeType = node.type; if ("Noop" === nodeType || "Placeholder" === nodeType || "V8IntrinsicIdentifier" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTypeScript(node, opts) { if (!node) return false; const nodeType = node.type; if ("TSParameterProperty" === nodeType || "TSDeclareFunction" === nodeType || "TSDeclareMethod" === nodeType || "TSQualifiedName" === nodeType || "TSCallSignatureDeclaration" === nodeType || "TSConstructSignatureDeclaration" === nodeType || "TSPropertySignature" === nodeType || "TSMethodSignature" === nodeType || "TSIndexSignature" === nodeType || "TSAnyKeyword" === nodeType || "TSBooleanKeyword" === nodeType || "TSBigIntKeyword" === nodeType || "TSIntrinsicKeyword" === nodeType || "TSNeverKeyword" === nodeType || "TSNullKeyword" === nodeType || "TSNumberKeyword" === nodeType || "TSObjectKeyword" === nodeType || "TSStringKeyword" === nodeType || "TSSymbolKeyword" === nodeType || "TSUndefinedKeyword" === nodeType || "TSUnknownKeyword" === nodeType || "TSVoidKeyword" === nodeType || "TSThisType" === nodeType || "TSFunctionType" === nodeType || "TSConstructorType" === nodeType || "TSTypeReference" === nodeType || "TSTypePredicate" === nodeType || "TSTypeQuery" === nodeType || "TSTypeLiteral" === nodeType || "TSArrayType" === nodeType || "TSTupleType" === nodeType || "TSOptionalType" === nodeType || "TSRestType" === nodeType || "TSNamedTupleMember" === nodeType || "TSUnionType" === nodeType || "TSIntersectionType" === nodeType || "TSConditionalType" === nodeType || "TSInferType" === nodeType || "TSParenthesizedType" === nodeType || "TSTypeOperator" === nodeType || "TSIndexedAccessType" === nodeType || "TSMappedType" === nodeType || "TSLiteralType" === nodeType || "TSExpressionWithTypeArguments" === nodeType || "TSInterfaceDeclaration" === nodeType || "TSInterfaceBody" === nodeType || "TSTypeAliasDeclaration" === nodeType || "TSInstantiationExpression" === nodeType || "TSAsExpression" === nodeType || "TSTypeAssertion" === nodeType || "TSEnumDeclaration" === nodeType || "TSEnumMember" === nodeType || "TSModuleDeclaration" === nodeType || "TSModuleBlock" === nodeType || "TSImportType" === nodeType || "TSImportEqualsDeclaration" === nodeType || "TSExternalModuleReference" === nodeType || "TSNonNullExpression" === nodeType || "TSExportAssignment" === nodeType || "TSNamespaceExportDeclaration" === nodeType || "TSTypeAnnotation" === nodeType || "TSTypeParameterInstantiation" === nodeType || "TSTypeParameterDeclaration" === nodeType || "TSTypeParameter" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSTypeElement(node, opts) { if (!node) return false; const nodeType = node.type; if ("TSCallSignatureDeclaration" === nodeType || "TSConstructSignatureDeclaration" === nodeType || "TSPropertySignature" === nodeType || "TSMethodSignature" === nodeType || "TSIndexSignature" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSType(node, opts) { if (!node) return false; const nodeType = node.type; if ("TSAnyKeyword" === nodeType || "TSBooleanKeyword" === nodeType || "TSBigIntKeyword" === nodeType || "TSIntrinsicKeyword" === nodeType || "TSNeverKeyword" === nodeType || "TSNullKeyword" === nodeType || "TSNumberKeyword" === nodeType || "TSObjectKeyword" === nodeType || "TSStringKeyword" === nodeType || "TSSymbolKeyword" === nodeType || "TSUndefinedKeyword" === nodeType || "TSUnknownKeyword" === nodeType || "TSVoidKeyword" === nodeType || "TSThisType" === nodeType || "TSFunctionType" === nodeType || "TSConstructorType" === nodeType || "TSTypeReference" === nodeType || "TSTypePredicate" === nodeType || "TSTypeQuery" === nodeType || "TSTypeLiteral" === nodeType || "TSArrayType" === nodeType || "TSTupleType" === nodeType || "TSOptionalType" === nodeType || "TSRestType" === nodeType || "TSUnionType" === nodeType || "TSIntersectionType" === nodeType || "TSConditionalType" === nodeType || "TSInferType" === nodeType || "TSParenthesizedType" === nodeType || "TSTypeOperator" === nodeType || "TSIndexedAccessType" === nodeType || "TSMappedType" === nodeType || "TSLiteralType" === nodeType || "TSExpressionWithTypeArguments" === nodeType || "TSImportType" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSBaseType(node, opts) { if (!node) return false; const nodeType = node.type; if ("TSAnyKeyword" === nodeType || "TSBooleanKeyword" === nodeType || "TSBigIntKeyword" === nodeType || "TSIntrinsicKeyword" === nodeType || "TSNeverKeyword" === nodeType || "TSNullKeyword" === nodeType || "TSNumberKeyword" === nodeType || "TSObjectKeyword" === nodeType || "TSStringKeyword" === nodeType || "TSSymbolKeyword" === nodeType || "TSUndefinedKeyword" === nodeType || "TSUnknownKeyword" === nodeType || "TSVoidKeyword" === nodeType || "TSThisType" === nodeType || "TSLiteralType" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isNumberLiteral(node, opts) { console.trace("The node type NumberLiteral has been renamed to NumericLiteral"); if (!node) return false; const nodeType = node.type; if (nodeType === "NumberLiteral") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isRegexLiteral(node, opts) { console.trace("The node type RegexLiteral has been renamed to RegExpLiteral"); if (!node) return false; const nodeType = node.type; if (nodeType === "RegexLiteral") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isRestProperty(node, opts) { console.trace("The node type RestProperty has been renamed to RestElement"); if (!node) return false; const nodeType = node.type; if (nodeType === "RestProperty") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isSpreadProperty(node, opts) { console.trace("The node type SpreadProperty has been renamed to SpreadElement"); if (!node) return false; const nodeType = node.type; if (nodeType === "SpreadProperty") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } },{"../../utils/shallowEqual":142}],145:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = is; var _shallowEqual = require("../utils/shallowEqual"); var _isType = require("./isType"); var _isPlaceholderType = require("./isPlaceholderType"); var _definitions = require("../definitions"); function is(type, node, opts) { if (!node) return false; const matches = (0, _isType.default)(node.type, type); if (!matches) { if (!opts && node.type === "Placeholder" && type in _definitions.FLIPPED_ALIAS_KEYS) { return (0, _isPlaceholderType.default)(node.expectedNode, type); } return false; } if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } },{"../definitions":122,"../utils/shallowEqual":142,"./isPlaceholderType":152,"./isType":156}],146:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = isBinding; var _getBindingIdentifiers = require("../retrievers/getBindingIdentifiers"); function isBinding(node, parent, grandparent) { if (grandparent && node.type === "Identifier" && parent.type === "ObjectProperty" && grandparent.type === "ObjectExpression") { return false; } const keys = _getBindingIdentifiers.default.keys[parent.type]; if (keys) { for (let i = 0; i < keys.length; i++) { const key = keys[i]; const val = parent[key]; if (Array.isArray(val)) { if (val.indexOf(node) >= 0) return true; } else { if (val === node) return true; } } } return false; } },{"../retrievers/getBindingIdentifiers":136}],147:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = isBlockScoped; var _generated = require("./generated"); var _isLet = require("./isLet"); function isBlockScoped(node) { return (0, _generated.isFunctionDeclaration)(node) || (0, _generated.isClassDeclaration)(node) || (0, _isLet.default)(node); } },{"./generated":144,"./isLet":149}],148:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = isImmutable; var _isType = require("./isType"); var _generated = require("./generated"); function isImmutable(node) { if ((0, _isType.default)(node.type, "Immutable")) return true; if ((0, _generated.isIdentifier)(node)) { if (node.name === "undefined") { return true; } else { return false; } } return false; } },{"./generated":144,"./isType":156}],149:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = isLet; var _generated = require("./generated"); var _constants = require("../constants"); function isLet(node) { return (0, _generated.isVariableDeclaration)(node) && (node.kind !== "var" || node[_constants.BLOCK_SCOPED_SYMBOL]); } },{"../constants":107,"./generated":144}],150:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = isNode; var _definitions = require("../definitions"); function isNode(node) { return !!(node && _definitions.VISITOR_KEYS[node.type]); } },{"../definitions":122}],151:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = isNodesEquivalent; var _definitions = require("../definitions"); function isNodesEquivalent(a, b) { if (typeof a !== "object" || typeof b !== "object" || a == null || b == null) { return a === b; } if (a.type !== b.type) { return false; } const fields = Object.keys(_definitions.NODE_FIELDS[a.type] || a.type); const visitorKeys = _definitions.VISITOR_KEYS[a.type]; for (const field of fields) { const val_a = a[field]; const val_b = b[field]; if (typeof val_a !== typeof val_b) { return false; } if (val_a == null && val_b == null) { continue; } else if (val_a == null || val_b == null) { return false; } if (Array.isArray(val_a)) { if (!Array.isArray(val_b)) { return false; } if (val_a.length !== val_b.length) { return false; } for (let i = 0; i < val_a.length; i++) { if (!isNodesEquivalent(val_a[i], val_b[i])) { return false; } } continue; } if (typeof val_a === "object" && !(visitorKeys != null && visitorKeys.includes(field))) { for (const key of Object.keys(val_a)) { if (val_a[key] !== val_b[key]) { return false; } } continue; } if (!isNodesEquivalent(val_a, val_b)) { return false; } } return true; } },{"../definitions":122}],152:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = isPlaceholderType; var _definitions = require("../definitions"); function isPlaceholderType(placeholderType, targetType) { if (placeholderType === targetType) return true; const aliases = _definitions.PLACEHOLDERS_ALIAS[placeholderType]; if (aliases) { for (const alias of aliases) { if (targetType === alias) return true; } } return false; } },{"../definitions":122}],153:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = isReferenced; function isReferenced(node, parent, grandparent) { switch (parent.type) { case "MemberExpression": case "OptionalMemberExpression": if (parent.property === node) { return !!parent.computed; } return parent.object === node; case "JSXMemberExpression": return parent.object === node; case "VariableDeclarator": return parent.init === node; case "ArrowFunctionExpression": return parent.body === node; case "PrivateName": return false; case "ClassMethod": case "ClassPrivateMethod": case "ObjectMethod": if (parent.key === node) { return !!parent.computed; } return false; case "ObjectProperty": if (parent.key === node) { return !!parent.computed; } return !grandparent || grandparent.type !== "ObjectPattern"; case "ClassProperty": case "ClassAccessorProperty": if (parent.key === node) { return !!parent.computed; } return true; case "ClassPrivateProperty": return parent.key !== node; case "ClassDeclaration": case "ClassExpression": return parent.superClass === node; case "AssignmentExpression": return parent.right === node; case "AssignmentPattern": return parent.right === node; case "LabeledStatement": return false; case "CatchClause": return false; case "RestElement": return false; case "BreakStatement": case "ContinueStatement": return false; case "FunctionDeclaration": case "FunctionExpression": return false; case "ExportNamespaceSpecifier": case "ExportDefaultSpecifier": return false; case "ExportSpecifier": if (grandparent != null && grandparent.source) { return false; } return parent.local === node; case "ImportDefaultSpecifier": case "ImportNamespaceSpecifier": case "ImportSpecifier": return false; case "ImportAttribute": return false; case "JSXAttribute": return false; case "ObjectPattern": case "ArrayPattern": return false; case "MetaProperty": return false; case "ObjectTypeProperty": return parent.key !== node; case "TSEnumMember": return parent.id !== node; case "TSPropertySignature": if (parent.key === node) { return !!parent.computed; } return true; } return true; } },{}],154:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = isScope; var _generated = require("./generated"); function isScope(node, parent) { if ((0, _generated.isBlockStatement)(node) && ((0, _generated.isFunction)(parent) || (0, _generated.isCatchClause)(parent))) { return false; } if ((0, _generated.isPattern)(node) && ((0, _generated.isFunction)(parent) || (0, _generated.isCatchClause)(parent))) { return true; } return (0, _generated.isScopable)(node); } },{"./generated":144}],155:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = isSpecifierDefault; var _generated = require("./generated"); function isSpecifierDefault(specifier) { return (0, _generated.isImportDefaultSpecifier)(specifier) || (0, _generated.isIdentifier)(specifier.imported || specifier.exported, { name: "default" }); } },{"./generated":144}],156:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = isType; var _definitions = require("../definitions"); function isType(nodeType, targetType) { if (nodeType === targetType) return true; if (_definitions.ALIAS_KEYS[targetType]) return false; const aliases = _definitions.FLIPPED_ALIAS_KEYS[targetType]; if (aliases) { if (aliases[0] === nodeType) return true; for (const alias of aliases) { if (nodeType === alias) return true; } } return false; } },{"../definitions":122}],157:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = isValidES3Identifier; var _isValidIdentifier = require("./isValidIdentifier"); const RESERVED_WORDS_ES3_ONLY = new Set(["abstract", "boolean", "byte", "char", "double", "enum", "final", "float", "goto", "implements", "int", "interface", "long", "native", "package", "private", "protected", "public", "short", "static", "synchronized", "throws", "transient", "volatile"]); function isValidES3Identifier(name) { return (0, _isValidIdentifier.default)(name) && !RESERVED_WORDS_ES3_ONLY.has(name); } },{"./isValidIdentifier":158}],158:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = isValidIdentifier; var _helperValidatorIdentifier = require("@babel/helper-validator-identifier"); function isValidIdentifier(name, reserved = true) { if (typeof name !== "string") return false; if (reserved) { if ((0, _helperValidatorIdentifier.isKeyword)(name) || (0, _helperValidatorIdentifier.isStrictReservedWord)(name, true)) { return false; } } return (0, _helperValidatorIdentifier.isIdentifierName)(name); } },{"@babel/helper-validator-identifier":256}],159:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = isVar; var _generated = require("./generated"); var _constants = require("../constants"); function isVar(node) { return (0, _generated.isVariableDeclaration)(node, { kind: "var" }) && !node[_constants.BLOCK_SCOPED_SYMBOL]; } },{"../constants":107,"./generated":144}],160:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = matchesPattern; var _generated = require("./generated"); function matchesPattern(member, match, allowPartial) { if (!(0, _generated.isMemberExpression)(member)) return false; const parts = Array.isArray(match) ? match : match.split("."); const nodes = []; let node; for (node = member; (0, _generated.isMemberExpression)(node); node = node.object) { nodes.push(node.property); } nodes.push(node); if (nodes.length < parts.length) return false; if (!allowPartial && nodes.length > parts.length) return false; for (let i = 0, j = nodes.length - 1; i < parts.length; i++, j--) { const node = nodes[j]; let value; if ((0, _generated.isIdentifier)(node)) { value = node.name; } else if ((0, _generated.isStringLiteral)(node)) { value = node.value; } else if ((0, _generated.isThisExpression)(node)) { value = "this"; } else { return false; } if (parts[i] !== value) return false; } return true; } },{"./generated":144}],161:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = isCompatTag; function isCompatTag(tagName) { return !!tagName && /^[a-z]/.test(tagName); } },{}],162:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = void 0; var _buildMatchMemberExpression = require("../buildMatchMemberExpression"); const isReactComponent = (0, _buildMatchMemberExpression.default)("React.Component"); var _default = isReactComponent; exports.default = _default; },{"../buildMatchMemberExpression":143}],163:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = validate; exports.validateChild = validateChild; exports.validateField = validateField; var _definitions = require("../definitions"); function validate(node, key, val) { if (!node) return; const fields = _definitions.NODE_FIELDS[node.type]; if (!fields) return; const field = fields[key]; validateField(node, key, val, field); validateChild(node, key, val); } function validateField(node, key, val, field) { if (!(field != null && field.validate)) return; if (field.optional && val == null) return; field.validate(node, key, val); } function validateChild(node, key, val) { if (val == null) return; const validate = _definitions.NODE_PARENT_VALIDATIONS[val.type]; if (!validate) return; validate(node, key, val); } },{"../definitions":122}],164:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = getModuleName; { const originalGetModuleName = getModuleName; exports.default = getModuleName = function getModuleName(rootOpts, pluginOpts) { var _pluginOpts$moduleId, _pluginOpts$moduleIds, _pluginOpts$getModule, _pluginOpts$moduleRoo; return originalGetModuleName(rootOpts, { moduleId: (_pluginOpts$moduleId = pluginOpts.moduleId) != null ? _pluginOpts$moduleId : rootOpts.moduleId, moduleIds: (_pluginOpts$moduleIds = pluginOpts.moduleIds) != null ? _pluginOpts$moduleIds : rootOpts.moduleIds, getModuleId: (_pluginOpts$getModule = pluginOpts.getModuleId) != null ? _pluginOpts$getModule : rootOpts.getModuleId, moduleRoot: (_pluginOpts$moduleRoo = pluginOpts.moduleRoot) != null ? _pluginOpts$moduleRoo : rootOpts.moduleRoot }); }; } function getModuleName(rootOpts, pluginOpts) { const { filename, filenameRelative = filename, sourceRoot = pluginOpts.moduleRoot } = rootOpts; const { moduleId, moduleIds = !!moduleId, getModuleId, moduleRoot = sourceRoot } = pluginOpts; if (!moduleIds) return null; if (moduleId != null && !getModuleId) { return moduleId; } let moduleName = moduleRoot != null ? moduleRoot + "/" : ""; if (filenameRelative) { const sourceRootReplacer = sourceRoot != null ? new RegExp("^" + sourceRoot + "/?") : ""; moduleName += filenameRelative.replace(sourceRootReplacer, "").replace(/\.(\w*?)$/, ""); } moduleName = moduleName.replace(/\\/g, "/"); if (getModuleId) { return getModuleId(moduleName) || moduleName; } else { return moduleName; } } },{}],165:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.buildNamespaceInitStatements = buildNamespaceInitStatements; exports.ensureStatementsHoisted = ensureStatementsHoisted; Object.defineProperty(exports, "getModuleName", { enumerable: true, get: function () { return _getModuleName.default; } }); Object.defineProperty(exports, "hasExports", { enumerable: true, get: function () { return _normalizeAndLoadMetadata.hasExports; } }); Object.defineProperty(exports, "isModule", { enumerable: true, get: function () { return _helperModuleImports.isModule; } }); Object.defineProperty(exports, "isSideEffectImport", { enumerable: true, get: function () { return _normalizeAndLoadMetadata.isSideEffectImport; } }); exports.rewriteModuleStatementsAndPrepareHeader = rewriteModuleStatementsAndPrepareHeader; Object.defineProperty(exports, "rewriteThis", { enumerable: true, get: function () { return _rewriteThis.default; } }); exports.wrapInterop = wrapInterop; var _assert = require("assert"); var _t = require("@babel/types"); var _template = require("@babel/template"); var _helperModuleImports = require("@babel/helper-module-imports"); var _rewriteThis = require("./rewrite-this"); var _rewriteLiveReferences = require("./rewrite-live-references"); var _normalizeAndLoadMetadata = require("./normalize-and-load-metadata"); var _getModuleName = require("./get-module-name"); const { booleanLiteral, callExpression, cloneNode, directive, directiveLiteral, expressionStatement, identifier, isIdentifier, memberExpression, stringLiteral, valueToNode, variableDeclaration, variableDeclarator } = _t; function rewriteModuleStatementsAndPrepareHeader(path, { loose, exportName, strict, allowTopLevelThis, strictMode, noInterop, importInterop = noInterop ? "none" : "babel", lazy, esNamespaceOnly, filename, constantReexports = loose, enumerableModuleMeta = loose, noIncompleteNsImportDetection }) { (0, _normalizeAndLoadMetadata.validateImportInteropOption)(importInterop); _assert((0, _helperModuleImports.isModule)(path), "Cannot process module statements in a script"); path.node.sourceType = "script"; const meta = (0, _normalizeAndLoadMetadata.default)(path, exportName, { importInterop, initializeReexports: constantReexports, lazy, esNamespaceOnly, filename }); if (!allowTopLevelThis) { (0, _rewriteThis.default)(path); } (0, _rewriteLiveReferences.default)(path, meta); if (strictMode !== false) { const hasStrict = path.node.directives.some(directive => { return directive.value.value === "use strict"; }); if (!hasStrict) { path.unshiftContainer("directives", directive(directiveLiteral("use strict"))); } } const headers = []; if ((0, _normalizeAndLoadMetadata.hasExports)(meta) && !strict) { headers.push(buildESModuleHeader(meta, enumerableModuleMeta)); } const nameList = buildExportNameListDeclaration(path, meta); if (nameList) { meta.exportNameListName = nameList.name; headers.push(nameList.statement); } headers.push(...buildExportInitializationStatements(path, meta, constantReexports, noIncompleteNsImportDetection)); return { meta, headers }; } function ensureStatementsHoisted(statements) { statements.forEach(header => { header._blockHoist = 3; }); } function wrapInterop(programPath, expr, type) { if (type === "none") { return null; } if (type === "node-namespace") { return callExpression(programPath.hub.addHelper("interopRequireWildcard"), [expr, booleanLiteral(true)]); } else if (type === "node-default") { return null; } let helper; if (type === "default") { helper = "interopRequireDefault"; } else if (type === "namespace") { helper = "interopRequireWildcard"; } else { throw new Error(`Unknown interop: ${type}`); } return callExpression(programPath.hub.addHelper(helper), [expr]); } function buildNamespaceInitStatements(metadata, sourceMetadata, constantReexports = false) { const statements = []; let srcNamespace = identifier(sourceMetadata.name); if (sourceMetadata.lazy) srcNamespace = callExpression(srcNamespace, []); for (const localName of sourceMetadata.importsNamespace) { if (localName === sourceMetadata.name) continue; statements.push(_template.default.statement`var NAME = SOURCE;`({ NAME: localName, SOURCE: cloneNode(srcNamespace) })); } if (constantReexports) { statements.push(...buildReexportsFromMeta(metadata, sourceMetadata, true)); } for (const exportName of sourceMetadata.reexportNamespace) { statements.push((sourceMetadata.lazy ? _template.default.statement` Object.defineProperty(EXPORTS, "NAME", { enumerable: true, get: function() { return NAMESPACE; } }); ` : _template.default.statement`EXPORTS.NAME = NAMESPACE;`)({ EXPORTS: metadata.exportName, NAME: exportName, NAMESPACE: cloneNode(srcNamespace) })); } if (sourceMetadata.reexportAll) { const statement = buildNamespaceReexport(metadata, cloneNode(srcNamespace), constantReexports); statement.loc = sourceMetadata.reexportAll.loc; statements.push(statement); } return statements; } const ReexportTemplate = { constant: _template.default.statement`EXPORTS.EXPORT_NAME = NAMESPACE_IMPORT;`, constantComputed: _template.default.statement`EXPORTS["EXPORT_NAME"] = NAMESPACE_IMPORT;`, spec: _template.default.statement` Object.defineProperty(EXPORTS, "EXPORT_NAME", { enumerable: true, get: function() { return NAMESPACE_IMPORT; }, }); ` }; const buildReexportsFromMeta = (meta, metadata, constantReexports) => { const namespace = metadata.lazy ? callExpression(identifier(metadata.name), []) : identifier(metadata.name); const { stringSpecifiers } = meta; return Array.from(metadata.reexports, ([exportName, importName]) => { let NAMESPACE_IMPORT = cloneNode(namespace); if (importName === "default" && metadata.interop === "node-default") {} else if (stringSpecifiers.has(importName)) { NAMESPACE_IMPORT = memberExpression(NAMESPACE_IMPORT, stringLiteral(importName), true); } else { NAMESPACE_IMPORT = memberExpression(NAMESPACE_IMPORT, identifier(importName)); } const astNodes = { EXPORTS: meta.exportName, EXPORT_NAME: exportName, NAMESPACE_IMPORT }; if (constantReexports || isIdentifier(NAMESPACE_IMPORT)) { if (stringSpecifiers.has(exportName)) { return ReexportTemplate.constantComputed(astNodes); } else { return ReexportTemplate.constant(astNodes); } } else { return ReexportTemplate.spec(astNodes); } }); }; function buildESModuleHeader(metadata, enumerableModuleMeta = false) { return (enumerableModuleMeta ? _template.default.statement` EXPORTS.__esModule = true; ` : _template.default.statement` Object.defineProperty(EXPORTS, "__esModule", { value: true, }); `)({ EXPORTS: metadata.exportName }); } function buildNamespaceReexport(metadata, namespace, constantReexports) { return (constantReexports ? _template.default.statement` Object.keys(NAMESPACE).forEach(function(key) { if (key === "default" || key === "__esModule") return; VERIFY_NAME_LIST; if (key in EXPORTS && EXPORTS[key] === NAMESPACE[key]) return; EXPORTS[key] = NAMESPACE[key]; }); ` : _template.default.statement` Object.keys(NAMESPACE).forEach(function(key) { if (key === "default" || key === "__esModule") return; VERIFY_NAME_LIST; if (key in EXPORTS && EXPORTS[key] === NAMESPACE[key]) return; Object.defineProperty(EXPORTS, key, { enumerable: true, get: function() { return NAMESPACE[key]; }, }); }); `)({ NAMESPACE: namespace, EXPORTS: metadata.exportName, VERIFY_NAME_LIST: metadata.exportNameListName ? (0, _template.default)` if (Object.prototype.hasOwnProperty.call(EXPORTS_LIST, key)) return; `({ EXPORTS_LIST: metadata.exportNameListName }) : null }); } function buildExportNameListDeclaration(programPath, metadata) { const exportedVars = Object.create(null); for (const data of metadata.local.values()) { for (const name of data.names) { exportedVars[name] = true; } } let hasReexport = false; for (const data of metadata.source.values()) { for (const exportName of data.reexports.keys()) { exportedVars[exportName] = true; } for (const exportName of data.reexportNamespace) { exportedVars[exportName] = true; } hasReexport = hasReexport || !!data.reexportAll; } if (!hasReexport || Object.keys(exportedVars).length === 0) return null; const name = programPath.scope.generateUidIdentifier("exportNames"); delete exportedVars.default; return { name: name.name, statement: variableDeclaration("var", [variableDeclarator(name, valueToNode(exportedVars))]) }; } function buildExportInitializationStatements(programPath, metadata, constantReexports = false, noIncompleteNsImportDetection = false) { const initStatements = []; for (const [localName, data] of metadata.local) { if (data.kind === "import") {} else if (data.kind === "hoisted") { initStatements.push([data.names[0], buildInitStatement(metadata, data.names, identifier(localName))]); } else if (!noIncompleteNsImportDetection) { for (const exportName of data.names) { initStatements.push([exportName, null]); } } } for (const data of metadata.source.values()) { if (!constantReexports) { const reexportsStatements = buildReexportsFromMeta(metadata, data, false); const reexports = [...data.reexports.keys()]; for (let i = 0; i < reexportsStatements.length; i++) { initStatements.push([reexports[i], reexportsStatements[i]]); } } if (!noIncompleteNsImportDetection) { for (const exportName of data.reexportNamespace) { initStatements.push([exportName, null]); } } } initStatements.sort(([a], [b]) => { if (a < b) return -1; if (b < a) return 1; return 0; }); const results = []; if (noIncompleteNsImportDetection) { for (const [, initStatement] of initStatements) { results.push(initStatement); } } else { const chunkSize = 100; for (let i = 0; i < initStatements.length; i += chunkSize) { let uninitializedExportNames = []; for (let j = 0; j < chunkSize && i + j < initStatements.length; j++) { const [exportName, initStatement] = initStatements[i + j]; if (initStatement !== null) { if (uninitializedExportNames.length > 0) { results.push(buildInitStatement(metadata, uninitializedExportNames, programPath.scope.buildUndefinedNode())); uninitializedExportNames = []; } results.push(initStatement); } else { uninitializedExportNames.push(exportName); } } if (uninitializedExportNames.length > 0) { results.push(buildInitStatement(metadata, uninitializedExportNames, programPath.scope.buildUndefinedNode())); } } } return results; } const InitTemplate = { computed: _template.default.expression`EXPORTS["NAME"] = VALUE`, default: _template.default.expression`EXPORTS.NAME = VALUE` }; function buildInitStatement(metadata, exportNames, initExpr) { const { stringSpecifiers, exportName: EXPORTS } = metadata; return expressionStatement(exportNames.reduce((acc, exportName) => { const params = { EXPORTS, NAME: exportName, VALUE: acc }; if (stringSpecifiers.has(exportName)) { return InitTemplate.computed(params); } else { return InitTemplate.default(params); } }, initExpr)); } },{"./get-module-name":164,"./normalize-and-load-metadata":166,"./rewrite-live-references":167,"./rewrite-this":168,"@babel/helper-module-imports":82,"@babel/template":281,"@babel/types":359,"assert":402}],166:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = normalizeModuleAndLoadMetadata; exports.hasExports = hasExports; exports.isSideEffectImport = isSideEffectImport; exports.validateImportInteropOption = validateImportInteropOption; var _path = require("path"); var _helperValidatorIdentifier = require("@babel/helper-validator-identifier"); var _helperSplitExportDeclaration = require("@babel/helper-split-export-declaration"); function hasExports(metadata) { return metadata.hasExports; } function isSideEffectImport(source) { return source.imports.size === 0 && source.importsNamespace.size === 0 && source.reexports.size === 0 && source.reexportNamespace.size === 0 && !source.reexportAll; } function validateImportInteropOption(importInterop) { if (typeof importInterop !== "function" && importInterop !== "none" && importInterop !== "babel" && importInterop !== "node") { throw new Error(`.importInterop must be one of "none", "babel", "node", or a function returning one of those values (received ${importInterop}).`); } return importInterop; } function resolveImportInterop(importInterop, source, filename) { if (typeof importInterop === "function") { return validateImportInteropOption(importInterop(source, filename)); } return importInterop; } function normalizeModuleAndLoadMetadata(programPath, exportName, { importInterop, initializeReexports = false, lazy = false, esNamespaceOnly = false, filename }) { if (!exportName) { exportName = programPath.scope.generateUidIdentifier("exports").name; } const stringSpecifiers = new Set(); nameAnonymousExports(programPath); const { local, source, hasExports } = getModuleMetadata(programPath, { initializeReexports, lazy }, stringSpecifiers); removeModuleDeclarations(programPath); for (const [, metadata] of source) { if (metadata.importsNamespace.size > 0) { metadata.name = metadata.importsNamespace.values().next().value; } const resolvedInterop = resolveImportInterop(importInterop, metadata.source, filename); if (resolvedInterop === "none") { metadata.interop = "none"; } else if (resolvedInterop === "node" && metadata.interop === "namespace") { metadata.interop = "node-namespace"; } else if (resolvedInterop === "node" && metadata.interop === "default") { metadata.interop = "node-default"; } else if (esNamespaceOnly && metadata.interop === "namespace") { metadata.interop = "default"; } } return { exportName, exportNameListName: null, hasExports, local, source, stringSpecifiers }; } function getExportSpecifierName(path, stringSpecifiers) { if (path.isIdentifier()) { return path.node.name; } else if (path.isStringLiteral()) { const stringValue = path.node.value; if (!(0, _helperValidatorIdentifier.isIdentifierName)(stringValue)) { stringSpecifiers.add(stringValue); } return stringValue; } else { throw new Error(`Expected export specifier to be either Identifier or StringLiteral, got ${path.node.type}`); } } function assertExportSpecifier(path) { if (path.isExportSpecifier()) { return; } else if (path.isExportNamespaceSpecifier()) { throw path.buildCodeFrameError("Export namespace should be first transformed by `@babel/plugin-proposal-export-namespace-from`."); } else { throw path.buildCodeFrameError("Unexpected export specifier type"); } } function getModuleMetadata(programPath, { lazy, initializeReexports }, stringSpecifiers) { const localData = getLocalExportMetadata(programPath, initializeReexports, stringSpecifiers); const sourceData = new Map(); const getData = sourceNode => { const source = sourceNode.value; let data = sourceData.get(source); if (!data) { data = { name: programPath.scope.generateUidIdentifier((0, _path.basename)(source, (0, _path.extname)(source))).name, interop: "none", loc: null, imports: new Map(), importsNamespace: new Set(), reexports: new Map(), reexportNamespace: new Set(), reexportAll: null, lazy: false, source }; sourceData.set(source, data); } return data; }; let hasExports = false; programPath.get("body").forEach(child => { if (child.isImportDeclaration()) { const data = getData(child.node.source); if (!data.loc) data.loc = child.node.loc; child.get("specifiers").forEach(spec => { if (spec.isImportDefaultSpecifier()) { const localName = spec.get("local").node.name; data.imports.set(localName, "default"); const reexport = localData.get(localName); if (reexport) { localData.delete(localName); reexport.names.forEach(name => { data.reexports.set(name, "default"); }); } } else if (spec.isImportNamespaceSpecifier()) { const localName = spec.get("local").node.name; data.importsNamespace.add(localName); const reexport = localData.get(localName); if (reexport) { localData.delete(localName); reexport.names.forEach(name => { data.reexportNamespace.add(name); }); } } else if (spec.isImportSpecifier()) { const importName = getExportSpecifierName(spec.get("imported"), stringSpecifiers); const localName = spec.get("local").node.name; data.imports.set(localName, importName); const reexport = localData.get(localName); if (reexport) { localData.delete(localName); reexport.names.forEach(name => { data.reexports.set(name, importName); }); } } }); } else if (child.isExportAllDeclaration()) { hasExports = true; const data = getData(child.node.source); if (!data.loc) data.loc = child.node.loc; data.reexportAll = { loc: child.node.loc }; } else if (child.isExportNamedDeclaration() && child.node.source) { hasExports = true; const data = getData(child.node.source); if (!data.loc) data.loc = child.node.loc; child.get("specifiers").forEach(spec => { assertExportSpecifier(spec); const importName = getExportSpecifierName(spec.get("local"), stringSpecifiers); const exportName = getExportSpecifierName(spec.get("exported"), stringSpecifiers); data.reexports.set(exportName, importName); if (exportName === "__esModule") { throw spec.get("exported").buildCodeFrameError('Illegal export "__esModule".'); } }); } else if (child.isExportNamedDeclaration() || child.isExportDefaultDeclaration()) { hasExports = true; } }); for (const metadata of sourceData.values()) { let needsDefault = false; let needsNamed = false; if (metadata.importsNamespace.size > 0) { needsDefault = true; needsNamed = true; } if (metadata.reexportAll) { needsNamed = true; } for (const importName of metadata.imports.values()) { if (importName === "default") needsDefault = true;else needsNamed = true; } for (const importName of metadata.reexports.values()) { if (importName === "default") needsDefault = true;else needsNamed = true; } if (needsDefault && needsNamed) { metadata.interop = "namespace"; } else if (needsDefault) { metadata.interop = "default"; } } for (const [source, metadata] of sourceData) { if (lazy !== false && !(isSideEffectImport(metadata) || metadata.reexportAll)) { if (lazy === true) { metadata.lazy = !/\./.test(source); } else if (Array.isArray(lazy)) { metadata.lazy = lazy.indexOf(source) !== -1; } else if (typeof lazy === "function") { metadata.lazy = lazy(source); } else { throw new Error(`.lazy must be a boolean, string array, or function`); } } } return { hasExports, local: localData, source: sourceData }; } function getLocalExportMetadata(programPath, initializeReexports, stringSpecifiers) { const bindingKindLookup = new Map(); programPath.get("body").forEach(child => { let kind; if (child.isImportDeclaration()) { kind = "import"; } else { if (child.isExportDefaultDeclaration()) { child = child.get("declaration"); } if (child.isExportNamedDeclaration()) { if (child.node.declaration) { child = child.get("declaration"); } else if (initializeReexports && child.node.source && child.get("source").isStringLiteral()) { child.get("specifiers").forEach(spec => { assertExportSpecifier(spec); bindingKindLookup.set(spec.get("local").node.name, "block"); }); return; } } if (child.isFunctionDeclaration()) { kind = "hoisted"; } else if (child.isClassDeclaration()) { kind = "block"; } else if (child.isVariableDeclaration({ kind: "var" })) { kind = "var"; } else if (child.isVariableDeclaration()) { kind = "block"; } else { return; } } Object.keys(child.getOuterBindingIdentifiers()).forEach(name => { bindingKindLookup.set(name, kind); }); }); const localMetadata = new Map(); const getLocalMetadata = idPath => { const localName = idPath.node.name; let metadata = localMetadata.get(localName); if (!metadata) { const kind = bindingKindLookup.get(localName); if (kind === undefined) { throw idPath.buildCodeFrameError(`Exporting local "${localName}", which is not declared.`); } metadata = { names: [], kind }; localMetadata.set(localName, metadata); } return metadata; }; programPath.get("body").forEach(child => { if (child.isExportNamedDeclaration() && (initializeReexports || !child.node.source)) { if (child.node.declaration) { const declaration = child.get("declaration"); const ids = declaration.getOuterBindingIdentifierPaths(); Object.keys(ids).forEach(name => { if (name === "__esModule") { throw declaration.buildCodeFrameError('Illegal export "__esModule".'); } getLocalMetadata(ids[name]).names.push(name); }); } else { child.get("specifiers").forEach(spec => { const local = spec.get("local"); const exported = spec.get("exported"); const localMetadata = getLocalMetadata(local); const exportName = getExportSpecifierName(exported, stringSpecifiers); if (exportName === "__esModule") { throw exported.buildCodeFrameError('Illegal export "__esModule".'); } localMetadata.names.push(exportName); }); } } else if (child.isExportDefaultDeclaration()) { const declaration = child.get("declaration"); if (declaration.isFunctionDeclaration() || declaration.isClassDeclaration()) { getLocalMetadata(declaration.get("id")).names.push("default"); } else { throw declaration.buildCodeFrameError("Unexpected default expression export."); } } }); return localMetadata; } function nameAnonymousExports(programPath) { programPath.get("body").forEach(child => { if (!child.isExportDefaultDeclaration()) return; (0, _helperSplitExportDeclaration.default)(child); }); } function removeModuleDeclarations(programPath) { programPath.get("body").forEach(child => { if (child.isImportDeclaration()) { child.remove(); } else if (child.isExportNamedDeclaration()) { if (child.node.declaration) { child.node.declaration._blockHoist = child.node._blockHoist; child.replaceWith(child.node.declaration); } else { child.remove(); } } else if (child.isExportDefaultDeclaration()) { const declaration = child.get("declaration"); if (declaration.isFunctionDeclaration() || declaration.isClassDeclaration()) { declaration._blockHoist = child.node._blockHoist; child.replaceWith(declaration); } else { throw declaration.buildCodeFrameError("Unexpected default expression export."); } } else if (child.isExportAllDeclaration()) { child.remove(); } }); } },{"@babel/helper-split-export-declaration":253,"@babel/helper-validator-identifier":256,"path":459}],167:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = rewriteLiveReferences; var _assert = require("assert"); var _t = require("@babel/types"); var _template = require("@babel/template"); var _helperSimpleAccess = require("@babel/helper-simple-access"); const { assignmentExpression, callExpression, cloneNode, expressionStatement, getOuterBindingIdentifiers, identifier, isMemberExpression, isVariableDeclaration, jsxIdentifier, jsxMemberExpression, memberExpression, numericLiteral, sequenceExpression, stringLiteral, variableDeclaration, variableDeclarator } = _t; function isInType(path) { do { switch (path.parent.type) { case "TSTypeAnnotation": case "TSTypeAliasDeclaration": case "TSTypeReference": case "TypeAnnotation": case "TypeAlias": return true; case "ExportSpecifier": return path.parentPath.parent.exportKind === "type"; default: if (path.parentPath.isStatement() || path.parentPath.isExpression()) { return false; } } } while (path = path.parentPath); } function rewriteLiveReferences(programPath, metadata) { const imported = new Map(); const exported = new Map(); const requeueInParent = path => { programPath.requeue(path); }; for (const [source, data] of metadata.source) { for (const [localName, importName] of data.imports) { imported.set(localName, [source, importName, null]); } for (const localName of data.importsNamespace) { imported.set(localName, [source, null, localName]); } } for (const [local, data] of metadata.local) { let exportMeta = exported.get(local); if (!exportMeta) { exportMeta = []; exported.set(local, exportMeta); } exportMeta.push(...data.names); } const rewriteBindingInitVisitorState = { metadata, requeueInParent, scope: programPath.scope, exported }; programPath.traverse(rewriteBindingInitVisitor, rewriteBindingInitVisitorState); (0, _helperSimpleAccess.default)(programPath, new Set([...Array.from(imported.keys()), ...Array.from(exported.keys())]), false); const rewriteReferencesVisitorState = { seen: new WeakSet(), metadata, requeueInParent, scope: programPath.scope, imported, exported, buildImportReference: ([source, importName, localName], identNode) => { const meta = metadata.source.get(source); if (localName) { if (meta.lazy) { identNode = callExpression(identNode, []); } return identNode; } let namespace = identifier(meta.name); if (meta.lazy) namespace = callExpression(namespace, []); if (importName === "default" && meta.interop === "node-default") { return namespace; } const computed = metadata.stringSpecifiers.has(importName); return memberExpression(namespace, computed ? stringLiteral(importName) : identifier(importName), computed); } }; programPath.traverse(rewriteReferencesVisitor, rewriteReferencesVisitorState); } const rewriteBindingInitVisitor = { Scope(path) { path.skip(); }, ClassDeclaration(path) { const { requeueInParent, exported, metadata } = this; const { id } = path.node; if (!id) throw new Error("Expected class to have a name"); const localName = id.name; const exportNames = exported.get(localName) || []; if (exportNames.length > 0) { const statement = expressionStatement(buildBindingExportAssignmentExpression(metadata, exportNames, identifier(localName), path.scope)); statement._blockHoist = path.node._blockHoist; requeueInParent(path.insertAfter(statement)[0]); } }, VariableDeclaration(path) { const { requeueInParent, exported, metadata } = this; Object.keys(path.getOuterBindingIdentifiers()).forEach(localName => { const exportNames = exported.get(localName) || []; if (exportNames.length > 0) { const statement = expressionStatement(buildBindingExportAssignmentExpression(metadata, exportNames, identifier(localName), path.scope)); statement._blockHoist = path.node._blockHoist; requeueInParent(path.insertAfter(statement)[0]); } }); } }; const buildBindingExportAssignmentExpression = (metadata, exportNames, localExpr, scope) => { const exportsObjectName = metadata.exportName; for (let currentScope = scope; currentScope != null; currentScope = currentScope.parent) { if (currentScope.hasOwnBinding(exportsObjectName)) { currentScope.rename(exportsObjectName); } } return (exportNames || []).reduce((expr, exportName) => { const { stringSpecifiers } = metadata; const computed = stringSpecifiers.has(exportName); return assignmentExpression("=", memberExpression(identifier(exportsObjectName), computed ? stringLiteral(exportName) : identifier(exportName), computed), expr); }, localExpr); }; const buildImportThrow = localName => { return _template.default.expression.ast` (function() { throw new Error('"' + '${localName}' + '" is read-only.'); })() `; }; const rewriteReferencesVisitor = { ReferencedIdentifier(path) { const { seen, buildImportReference, scope, imported, requeueInParent } = this; if (seen.has(path.node)) return; seen.add(path.node); const localName = path.node.name; const importData = imported.get(localName); if (importData) { if (isInType(path)) { throw path.buildCodeFrameError(`Cannot transform the imported binding "${localName}" since it's also used in a type annotation. ` + `Please strip type annotations using @babel/preset-typescript or @babel/preset-flow.`); } const localBinding = path.scope.getBinding(localName); const rootBinding = scope.getBinding(localName); if (rootBinding !== localBinding) return; const ref = buildImportReference(importData, path.node); ref.loc = path.node.loc; if ((path.parentPath.isCallExpression({ callee: path.node }) || path.parentPath.isOptionalCallExpression({ callee: path.node }) || path.parentPath.isTaggedTemplateExpression({ tag: path.node })) && isMemberExpression(ref)) { path.replaceWith(sequenceExpression([numericLiteral(0), ref])); } else if (path.isJSXIdentifier() && isMemberExpression(ref)) { const { object, property } = ref; path.replaceWith(jsxMemberExpression(jsxIdentifier(object.name), jsxIdentifier(property.name))); } else { path.replaceWith(ref); } requeueInParent(path); path.skip(); } }, UpdateExpression(path) { const { scope, seen, imported, exported, requeueInParent, buildImportReference } = this; if (seen.has(path.node)) return; seen.add(path.node); const arg = path.get("argument"); if (arg.isMemberExpression()) return; const update = path.node; if (arg.isIdentifier()) { const localName = arg.node.name; if (scope.getBinding(localName) !== path.scope.getBinding(localName)) { return; } const exportedNames = exported.get(localName); const importData = imported.get(localName); if ((exportedNames == null ? void 0 : exportedNames.length) > 0 || importData) { if (importData) { path.replaceWith(assignmentExpression(update.operator[0] + "=", buildImportReference(importData, arg.node), buildImportThrow(localName))); } else if (update.prefix) { path.replaceWith(buildBindingExportAssignmentExpression(this.metadata, exportedNames, cloneNode(update), path.scope)); } else { const ref = scope.generateDeclaredUidIdentifier(localName); path.replaceWith(sequenceExpression([assignmentExpression("=", cloneNode(ref), cloneNode(update)), buildBindingExportAssignmentExpression(this.metadata, exportedNames, identifier(localName), path.scope), cloneNode(ref)])); } } } requeueInParent(path); path.skip(); }, AssignmentExpression: { exit(path) { const { scope, seen, imported, exported, requeueInParent, buildImportReference } = this; if (seen.has(path.node)) return; seen.add(path.node); const left = path.get("left"); if (left.isMemberExpression()) return; if (left.isIdentifier()) { const localName = left.node.name; if (scope.getBinding(localName) !== path.scope.getBinding(localName)) { return; } const exportedNames = exported.get(localName); const importData = imported.get(localName); if ((exportedNames == null ? void 0 : exportedNames.length) > 0 || importData) { _assert(path.node.operator === "=", "Path was not simplified"); const assignment = path.node; if (importData) { assignment.left = buildImportReference(importData, left.node); assignment.right = sequenceExpression([assignment.right, buildImportThrow(localName)]); } path.replaceWith(buildBindingExportAssignmentExpression(this.metadata, exportedNames, assignment, path.scope)); requeueInParent(path); } } else { const ids = left.getOuterBindingIdentifiers(); const programScopeIds = Object.keys(ids).filter(localName => scope.getBinding(localName) === path.scope.getBinding(localName)); const id = programScopeIds.find(localName => imported.has(localName)); if (id) { path.node.right = sequenceExpression([path.node.right, buildImportThrow(id)]); } const items = []; programScopeIds.forEach(localName => { const exportedNames = exported.get(localName) || []; if (exportedNames.length > 0) { items.push(buildBindingExportAssignmentExpression(this.metadata, exportedNames, identifier(localName), path.scope)); } }); if (items.length > 0) { let node = sequenceExpression(items); if (path.parentPath.isExpressionStatement()) { node = expressionStatement(node); node._blockHoist = path.parentPath.node._blockHoist; } const statement = path.insertAfter(node)[0]; requeueInParent(statement); } } } }, "ForOfStatement|ForInStatement"(path) { const { scope, node } = path; const { left } = node; const { exported, imported, scope: programScope } = this; if (!isVariableDeclaration(left)) { let didTransformExport = false, importConstViolationName; const loopBodyScope = path.get("body").scope; for (const name of Object.keys(getOuterBindingIdentifiers(left))) { if (programScope.getBinding(name) === scope.getBinding(name)) { if (exported.has(name)) { didTransformExport = true; if (loopBodyScope.hasOwnBinding(name)) { loopBodyScope.rename(name); } } if (imported.has(name) && !importConstViolationName) { importConstViolationName = name; } } } if (!didTransformExport && !importConstViolationName) { return; } path.ensureBlock(); const bodyPath = path.get("body"); const newLoopId = scope.generateUidIdentifierBasedOnNode(left); path.get("left").replaceWith(variableDeclaration("let", [variableDeclarator(cloneNode(newLoopId))])); scope.registerDeclaration(path.get("left")); if (didTransformExport) { bodyPath.unshiftContainer("body", expressionStatement(assignmentExpression("=", left, newLoopId))); } if (importConstViolationName) { bodyPath.unshiftContainer("body", expressionStatement(buildImportThrow(importConstViolationName))); } } } }; },{"@babel/helper-simple-access":172,"@babel/template":281,"@babel/types":359,"assert":402}],168:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = rewriteThis; var _helperEnvironmentVisitor = require("@babel/helper-environment-visitor"); var _traverse = require("@babel/traverse"); var _t = require("@babel/types"); const { numericLiteral, unaryExpression } = _t; function rewriteThis(programPath) { (0, _traverse.default)(programPath.node, Object.assign({}, rewriteThisVisitor, { noScope: true })); } const rewriteThisVisitor = _traverse.default.visitors.merge([_helperEnvironmentVisitor.default, { ThisExpression(path) { path.replaceWith(unaryExpression("void", numericLiteral(0), true)); } }]); },{"@babel/helper-environment-visitor":76,"@babel/traverse":290,"@babel/types":359}],169:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = optimiseCallExpression; var _t = require("@babel/types"); const { callExpression, identifier, isIdentifier, isSpreadElement, memberExpression, optionalCallExpression, optionalMemberExpression } = _t; function optimiseCallExpression(callee, thisNode, args, optional) { if (args.length === 1 && isSpreadElement(args[0]) && isIdentifier(args[0].argument, { name: "arguments" })) { if (optional) { return optionalCallExpression(optionalMemberExpression(callee, identifier("apply"), false, true), [thisNode, args[0].argument], false); } return callExpression(memberExpression(callee, identifier("apply")), [thisNode, args[0].argument]); } else { if (optional) { return optionalCallExpression(optionalMemberExpression(callee, identifier("call"), false, true), [thisNode, ...args], false); } return callExpression(memberExpression(callee, identifier("call")), [thisNode, ...args]); } } },{"@babel/types":359}],170:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.declare = declare; exports.declarePreset = void 0; function declare(builder) { return (api, options, dirname) => { var _clonedApi2; let clonedApi; for (const name of Object.keys(apiPolyfills)) { var _clonedApi; if (api[name]) continue; clonedApi = (_clonedApi = clonedApi) != null ? _clonedApi : copyApiObject(api); clonedApi[name] = apiPolyfills[name](clonedApi); } return builder((_clonedApi2 = clonedApi) != null ? _clonedApi2 : api, options || {}, dirname); }; } const declarePreset = declare; exports.declarePreset = declarePreset; const apiPolyfills = { assertVersion: api => range => { throwVersionError(range, api.version); }, targets: () => () => { return {}; }, assumption: () => () => { return undefined; } }; function copyApiObject(api) { let proto = null; if (typeof api.version === "string" && /^7\./.test(api.version)) { proto = Object.getPrototypeOf(api); if (proto && (!has(proto, "version") || !has(proto, "transform") || !has(proto, "template") || !has(proto, "types"))) { proto = null; } } return Object.assign({}, proto, api); } function has(obj, key) { return Object.prototype.hasOwnProperty.call(obj, key); } function throwVersionError(range, version) { if (typeof range === "number") { if (!Number.isInteger(range)) { throw new Error("Expected string or integer value."); } range = `^${range}.0.0-0`; } if (typeof range !== "string") { throw new Error("Expected string or integer value."); } const limit = Error.stackTraceLimit; if (typeof limit === "number" && limit < 25) { Error.stackTraceLimit = 25; } let err; if (version.slice(0, 2) === "7.") { err = new Error(`Requires Babel "^7.0.0-beta.41", but was loaded with "${version}". ` + `You'll need to update your @babel/core version.`); } else { err = new Error(`Requires Babel "${range}", but was loaded with "${version}". ` + `If you are sure you have a compatible version of @babel/core, ` + `it is likely that something in your build process is loading the ` + `wrong version. Inspect the stack trace of this error to look for ` + `the first entry that doesn't mention "@babel/core" or "babel-core" ` + `to see what is calling Babel.`); } if (typeof limit === "number") { Error.stackTraceLimit = limit; } throw Object.assign(err, { code: "BABEL_VERSION_UNSUPPORTED", version, range }); } },{}],171:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = void 0; Object.defineProperty(exports, "environmentVisitor", { enumerable: true, get: function () { return _helperEnvironmentVisitor.default; } }); Object.defineProperty(exports, "skipAllButComputedKey", { enumerable: true, get: function () { return _helperEnvironmentVisitor.skipAllButComputedKey; } }); var _traverse = require("@babel/traverse"); var _helperMemberExpressionToFunctions = require("@babel/helper-member-expression-to-functions"); var _helperOptimiseCallExpression = require("@babel/helper-optimise-call-expression"); var _helperEnvironmentVisitor = require("@babel/helper-environment-visitor"); var _t = require("@babel/types"); const { assignmentExpression, booleanLiteral, callExpression, cloneNode, identifier, memberExpression, sequenceExpression, stringLiteral, thisExpression } = _t; function getPrototypeOfExpression(objectRef, isStatic, file, isPrivateMethod) { objectRef = cloneNode(objectRef); const targetRef = isStatic || isPrivateMethod ? objectRef : memberExpression(objectRef, identifier("prototype")); return callExpression(file.addHelper("getPrototypeOf"), [targetRef]); } const visitor = _traverse.default.visitors.merge([_helperEnvironmentVisitor.default, { Super(path, state) { const { node, parentPath } = path; if (!parentPath.isMemberExpression({ object: node })) return; state.handle(parentPath); } }]); const unshadowSuperBindingVisitor = _traverse.default.visitors.merge([_helperEnvironmentVisitor.default, { Scopable(path, { refName }) { const binding = path.scope.getOwnBinding(refName); if (binding && binding.identifier.name === refName) { path.scope.rename(refName); } } }]); const specHandlers = { memoise(superMember, count) { const { scope, node } = superMember; const { computed, property } = node; if (!computed) { return; } const memo = scope.maybeGenerateMemoised(property); if (!memo) { return; } this.memoiser.set(property, memo, count); }, prop(superMember) { const { computed, property } = superMember.node; if (this.memoiser.has(property)) { return cloneNode(this.memoiser.get(property)); } if (computed) { return cloneNode(property); } return stringLiteral(property.name); }, get(superMember) { return this._get(superMember, this._getThisRefs()); }, _get(superMember, thisRefs) { const proto = getPrototypeOfExpression(this.getObjectRef(), this.isStatic, this.file, this.isPrivateMethod); return callExpression(this.file.addHelper("get"), [thisRefs.memo ? sequenceExpression([thisRefs.memo, proto]) : proto, this.prop(superMember), thisRefs.this]); }, _getThisRefs() { if (!this.isDerivedConstructor) { return { this: thisExpression() }; } const thisRef = this.scope.generateDeclaredUidIdentifier("thisSuper"); return { memo: assignmentExpression("=", thisRef, thisExpression()), this: cloneNode(thisRef) }; }, set(superMember, value) { const thisRefs = this._getThisRefs(); const proto = getPrototypeOfExpression(this.getObjectRef(), this.isStatic, this.file, this.isPrivateMethod); return callExpression(this.file.addHelper("set"), [thisRefs.memo ? sequenceExpression([thisRefs.memo, proto]) : proto, this.prop(superMember), value, thisRefs.this, booleanLiteral(superMember.isInStrictMode())]); }, destructureSet(superMember) { throw superMember.buildCodeFrameError(`Destructuring to a super field is not supported yet.`); }, call(superMember, args) { const thisRefs = this._getThisRefs(); return (0, _helperOptimiseCallExpression.default)(this._get(superMember, thisRefs), cloneNode(thisRefs.this), args, false); }, optionalCall(superMember, args) { const thisRefs = this._getThisRefs(); return (0, _helperOptimiseCallExpression.default)(this._get(superMember, thisRefs), cloneNode(thisRefs.this), args, true); } }; const looseHandlers = Object.assign({}, specHandlers, { prop(superMember) { const { property } = superMember.node; if (this.memoiser.has(property)) { return cloneNode(this.memoiser.get(property)); } return cloneNode(property); }, get(superMember) { const { isStatic, getSuperRef } = this; const { computed } = superMember.node; const prop = this.prop(superMember); let object; if (isStatic) { var _getSuperRef; object = (_getSuperRef = getSuperRef()) != null ? _getSuperRef : memberExpression(identifier("Function"), identifier("prototype")); } else { var _getSuperRef2; object = memberExpression((_getSuperRef2 = getSuperRef()) != null ? _getSuperRef2 : identifier("Object"), identifier("prototype")); } return memberExpression(object, prop, computed); }, set(superMember, value) { const { computed } = superMember.node; const prop = this.prop(superMember); return assignmentExpression("=", memberExpression(thisExpression(), prop, computed), value); }, destructureSet(superMember) { const { computed } = superMember.node; const prop = this.prop(superMember); return memberExpression(thisExpression(), prop, computed); }, call(superMember, args) { return (0, _helperOptimiseCallExpression.default)(this.get(superMember), thisExpression(), args, false); }, optionalCall(superMember, args) { return (0, _helperOptimiseCallExpression.default)(this.get(superMember), thisExpression(), args, true); } }); class ReplaceSupers { constructor(opts) { var _opts$constantSuper; const path = opts.methodPath; this.methodPath = path; this.isDerivedConstructor = path.isClassMethod({ kind: "constructor" }) && !!opts.superRef; this.isStatic = path.isObjectMethod() || path.node.static || (path.isStaticBlock == null ? void 0 : path.isStaticBlock()); this.isPrivateMethod = path.isPrivate() && path.isMethod(); this.file = opts.file; this.constantSuper = (_opts$constantSuper = opts.constantSuper) != null ? _opts$constantSuper : opts.isLoose; this.opts = opts; } getObjectRef() { return cloneNode(this.opts.objectRef || this.opts.getObjectRef()); } getSuperRef() { if (this.opts.superRef) return cloneNode(this.opts.superRef); if (this.opts.getSuperRef) { return cloneNode(this.opts.getSuperRef()); } } replace() { if (this.opts.refToPreserve) { this.methodPath.traverse(unshadowSuperBindingVisitor, { refName: this.opts.refToPreserve.name }); } const handler = this.constantSuper ? looseHandlers : specHandlers; (0, _helperMemberExpressionToFunctions.default)(this.methodPath, visitor, Object.assign({ file: this.file, scope: this.methodPath.scope, isDerivedConstructor: this.isDerivedConstructor, isStatic: this.isStatic, isPrivateMethod: this.isPrivateMethod, getObjectRef: this.getObjectRef.bind(this), getSuperRef: this.getSuperRef.bind(this), boundGet: handler.get }, handler)); } } exports.default = ReplaceSupers; },{"@babel/helper-environment-visitor":76,"@babel/helper-member-expression-to-functions":79,"@babel/helper-optimise-call-expression":169,"@babel/traverse":290,"@babel/types":359}],172:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = simplifyAccess; var _t = require("@babel/types"); const { LOGICAL_OPERATORS, assignmentExpression, binaryExpression, cloneNode, identifier, logicalExpression, numericLiteral, sequenceExpression, unaryExpression } = _t; function simplifyAccess(path, bindingNames, includeUpdateExpression = true) { path.traverse(simpleAssignmentVisitor, { scope: path.scope, bindingNames, seen: new WeakSet(), includeUpdateExpression }); } const simpleAssignmentVisitor = { UpdateExpression: { exit(path) { const { scope, bindingNames, includeUpdateExpression } = this; if (!includeUpdateExpression) { return; } const arg = path.get("argument"); if (!arg.isIdentifier()) return; const localName = arg.node.name; if (!bindingNames.has(localName)) return; if (scope.getBinding(localName) !== path.scope.getBinding(localName)) { return; } if (path.parentPath.isExpressionStatement() && !path.isCompletionRecord()) { const operator = path.node.operator == "++" ? "+=" : "-="; path.replaceWith(assignmentExpression(operator, arg.node, numericLiteral(1))); } else if (path.node.prefix) { path.replaceWith(assignmentExpression("=", identifier(localName), binaryExpression(path.node.operator[0], unaryExpression("+", arg.node), numericLiteral(1)))); } else { const old = path.scope.generateUidIdentifierBasedOnNode(arg.node, "old"); const varName = old.name; path.scope.push({ id: old }); const binary = binaryExpression(path.node.operator[0], identifier(varName), numericLiteral(1)); path.replaceWith(sequenceExpression([assignmentExpression("=", identifier(varName), unaryExpression("+", arg.node)), assignmentExpression("=", cloneNode(arg.node), binary), identifier(varName)])); } } }, AssignmentExpression: { exit(path) { const { scope, seen, bindingNames } = this; if (path.node.operator === "=") return; if (seen.has(path.node)) return; seen.add(path.node); const left = path.get("left"); if (!left.isIdentifier()) return; const localName = left.node.name; if (!bindingNames.has(localName)) return; if (scope.getBinding(localName) !== path.scope.getBinding(localName)) { return; } const operator = path.node.operator.slice(0, -1); if (LOGICAL_OPERATORS.includes(operator)) { path.replaceWith(logicalExpression(operator, path.node.left, assignmentExpression("=", cloneNode(path.node.left), path.node.right))); } else { path.node.right = binaryExpression(operator, cloneNode(path.node.left), path.node.right); path.node.operator = "="; } } } }; },{"@babel/types":217}],173:[function(require,module,exports){ arguments[4][84][0].apply(exports,arguments) },{"../validators/isNode":239,"dup":84}],174:[function(require,module,exports){ arguments[4][85][0].apply(exports,arguments) },{"../../validators/is":234,"dup":85}],175:[function(require,module,exports){ arguments[4][9][0].apply(exports,arguments) },{"dup":9}],176:[function(require,module,exports){ arguments[4][87][0].apply(exports,arguments) },{"../../modifications/flow/removeTypeDuplicates":219,"../generated":178,"dup":87}],177:[function(require,module,exports){ arguments[4][88][0].apply(exports,arguments) },{"../generated":178,"dup":88}],178:[function(require,module,exports){ arguments[4][89][0].apply(exports,arguments) },{"../validateNode":182,"dup":89}],179:[function(require,module,exports){ arguments[4][90][0].apply(exports,arguments) },{"./index":178,"dup":90}],180:[function(require,module,exports){ arguments[4][91][0].apply(exports,arguments) },{"../../utils/react/cleanJSXElementLiteralChild":230,"../../validators/generated":233,"dup":91}],181:[function(require,module,exports){ arguments[4][92][0].apply(exports,arguments) },{"../../modifications/typescript/removeTypeDuplicates":224,"../generated":178,"dup":92}],182:[function(require,module,exports){ arguments[4][93][0].apply(exports,arguments) },{"..":217,"../validators/validate":252,"dup":93}],183:[function(require,module,exports){ arguments[4][94][0].apply(exports,arguments) },{"./cloneNode":186,"dup":94}],184:[function(require,module,exports){ arguments[4][95][0].apply(exports,arguments) },{"./cloneNode":186,"dup":95}],185:[function(require,module,exports){ arguments[4][96][0].apply(exports,arguments) },{"./cloneNode":186,"dup":96}],186:[function(require,module,exports){ arguments[4][97][0].apply(exports,arguments) },{"../definitions":211,"../validators/generated":233,"dup":97}],187:[function(require,module,exports){ arguments[4][98][0].apply(exports,arguments) },{"./cloneNode":186,"dup":98}],188:[function(require,module,exports){ arguments[4][99][0].apply(exports,arguments) },{"./addComments":189,"dup":99}],189:[function(require,module,exports){ arguments[4][100][0].apply(exports,arguments) },{"dup":100}],190:[function(require,module,exports){ arguments[4][101][0].apply(exports,arguments) },{"../utils/inherit":229,"dup":101}],191:[function(require,module,exports){ arguments[4][102][0].apply(exports,arguments) },{"../utils/inherit":229,"dup":102}],192:[function(require,module,exports){ arguments[4][103][0].apply(exports,arguments) },{"../utils/inherit":229,"dup":103}],193:[function(require,module,exports){ arguments[4][104][0].apply(exports,arguments) },{"./inheritInnerComments":190,"./inheritLeadingComments":191,"./inheritTrailingComments":192,"dup":104}],194:[function(require,module,exports){ arguments[4][105][0].apply(exports,arguments) },{"../constants":196,"dup":105}],195:[function(require,module,exports){ arguments[4][106][0].apply(exports,arguments) },{"../../definitions":211,"dup":106}],196:[function(require,module,exports){ arguments[4][107][0].apply(exports,arguments) },{"dup":107}],197:[function(require,module,exports){ arguments[4][108][0].apply(exports,arguments) },{"./toBlock":200,"dup":108}],198:[function(require,module,exports){ arguments[4][109][0].apply(exports,arguments) },{"../builders/generated":178,"../clone/cloneNode":186,"../retrievers/getBindingIdentifiers":225,"../validators/generated":233,"dup":109}],199:[function(require,module,exports){ arguments[4][110][0].apply(exports,arguments) },{"./toIdentifier":203,"dup":110}],200:[function(require,module,exports){ arguments[4][111][0].apply(exports,arguments) },{"../builders/generated":178,"../validators/generated":233,"dup":111}],201:[function(require,module,exports){ arguments[4][112][0].apply(exports,arguments) },{"../builders/generated":178,"../validators/generated":233,"dup":112}],202:[function(require,module,exports){ arguments[4][113][0].apply(exports,arguments) },{"../validators/generated":233,"dup":113}],203:[function(require,module,exports){ arguments[4][114][0].apply(exports,arguments) },{"../validators/isValidIdentifier":247,"@babel/helper-validator-identifier":256,"dup":114}],204:[function(require,module,exports){ arguments[4][115][0].apply(exports,arguments) },{"../clone/cloneNode":186,"../modifications/removePropertiesDeep":223,"../validators/generated":233,"dup":115}],205:[function(require,module,exports){ arguments[4][116][0].apply(exports,arguments) },{"./gatherSequenceExpressions":198,"dup":116}],206:[function(require,module,exports){ arguments[4][117][0].apply(exports,arguments) },{"../builders/generated":178,"../validators/generated":233,"dup":117}],207:[function(require,module,exports){ arguments[4][118][0].apply(exports,arguments) },{"../builders/generated":178,"../validators/isValidIdentifier":247,"dup":118}],208:[function(require,module,exports){ arguments[4][119][0].apply(exports,arguments) },{"../constants":196,"../validators/is":234,"../validators/isValidIdentifier":247,"./utils":216,"@babel/helper-validator-identifier":256,"_process":460,"dup":119}],209:[function(require,module,exports){ arguments[4][120][0].apply(exports,arguments) },{"./utils":216,"_process":460,"dup":120}],210:[function(require,module,exports){ arguments[4][121][0].apply(exports,arguments) },{"./utils":216,"dup":121}],211:[function(require,module,exports){ arguments[4][122][0].apply(exports,arguments) },{"./core":208,"./experimental":209,"./flow":210,"./jsx":212,"./misc":213,"./placeholders":214,"./typescript":215,"./utils":216,"dup":122,"to-fast-properties":540}],212:[function(require,module,exports){ arguments[4][123][0].apply(exports,arguments) },{"./utils":216,"dup":123}],213:[function(require,module,exports){ arguments[4][124][0].apply(exports,arguments) },{"./placeholders":214,"./utils":216,"dup":124}],214:[function(require,module,exports){ arguments[4][125][0].apply(exports,arguments) },{"./utils":216,"dup":125}],215:[function(require,module,exports){ arguments[4][126][0].apply(exports,arguments) },{"../validators/is":234,"./core":208,"./utils":216,"dup":126}],216:[function(require,module,exports){ arguments[4][127][0].apply(exports,arguments) },{"../validators/is":234,"../validators/validate":252,"_process":460,"dup":127}],217:[function(require,module,exports){ arguments[4][128][0].apply(exports,arguments) },{"./asserts/assertNode":173,"./asserts/generated":174,"./ast-types/generated":175,"./builders/flow/createFlowUnionType":176,"./builders/flow/createTypeAnnotationBasedOnTypeof":177,"./builders/generated":178,"./builders/generated/uppercase":179,"./builders/react/buildChildren":180,"./builders/typescript/createTSUnionType":181,"./clone/clone":183,"./clone/cloneDeep":184,"./clone/cloneDeepWithoutLoc":185,"./clone/cloneNode":186,"./clone/cloneWithoutLoc":187,"./comments/addComment":188,"./comments/addComments":189,"./comments/inheritInnerComments":190,"./comments/inheritLeadingComments":191,"./comments/inheritTrailingComments":192,"./comments/inheritsComments":193,"./comments/removeComments":194,"./constants":196,"./constants/generated":195,"./converters/ensureBlock":197,"./converters/toBindingIdentifierName":199,"./converters/toBlock":200,"./converters/toComputedKey":201,"./converters/toExpression":202,"./converters/toIdentifier":203,"./converters/toKeyAlias":204,"./converters/toSequenceExpression":205,"./converters/toStatement":206,"./converters/valueToNode":207,"./definitions":211,"./modifications/appendToMemberExpression":218,"./modifications/flow/removeTypeDuplicates":219,"./modifications/inherits":220,"./modifications/prependToMemberExpression":221,"./modifications/removeProperties":222,"./modifications/removePropertiesDeep":223,"./retrievers/getBindingIdentifiers":225,"./retrievers/getOuterBindingIdentifiers":226,"./traverse/traverse":227,"./traverse/traverseFast":228,"./utils/shallowEqual":231,"./validators/buildMatchMemberExpression":232,"./validators/generated":233,"./validators/is":234,"./validators/isBinding":235,"./validators/isBlockScoped":236,"./validators/isImmutable":237,"./validators/isLet":238,"./validators/isNode":239,"./validators/isNodesEquivalent":240,"./validators/isPlaceholderType":241,"./validators/isReferenced":242,"./validators/isScope":243,"./validators/isSpecifierDefault":244,"./validators/isType":245,"./validators/isValidES3Identifier":246,"./validators/isValidIdentifier":247,"./validators/isVar":248,"./validators/matchesPattern":249,"./validators/react/isCompatTag":250,"./validators/react/isReactComponent":251,"./validators/validate":252,"dup":128}],218:[function(require,module,exports){ arguments[4][129][0].apply(exports,arguments) },{"../builders/generated":178,"dup":129}],219:[function(require,module,exports){ arguments[4][130][0].apply(exports,arguments) },{"../../validators/generated":233,"dup":130}],220:[function(require,module,exports){ arguments[4][131][0].apply(exports,arguments) },{"../comments/inheritsComments":193,"../constants":196,"dup":131}],221:[function(require,module,exports){ arguments[4][132][0].apply(exports,arguments) },{"../builders/generated":178,"dup":132}],222:[function(require,module,exports){ arguments[4][133][0].apply(exports,arguments) },{"../constants":196,"dup":133}],223:[function(require,module,exports){ arguments[4][134][0].apply(exports,arguments) },{"../traverse/traverseFast":228,"./removeProperties":222,"dup":134}],224:[function(require,module,exports){ arguments[4][135][0].apply(exports,arguments) },{"../../validators/generated":233,"dup":135}],225:[function(require,module,exports){ arguments[4][136][0].apply(exports,arguments) },{"../validators/generated":233,"dup":136}],226:[function(require,module,exports){ arguments[4][137][0].apply(exports,arguments) },{"./getBindingIdentifiers":225,"dup":137}],227:[function(require,module,exports){ arguments[4][138][0].apply(exports,arguments) },{"../definitions":211,"dup":138}],228:[function(require,module,exports){ arguments[4][139][0].apply(exports,arguments) },{"../definitions":211,"dup":139}],229:[function(require,module,exports){ arguments[4][140][0].apply(exports,arguments) },{"dup":140}],230:[function(require,module,exports){ arguments[4][141][0].apply(exports,arguments) },{"../../builders/generated":178,"dup":141}],231:[function(require,module,exports){ arguments[4][142][0].apply(exports,arguments) },{"dup":142}],232:[function(require,module,exports){ arguments[4][143][0].apply(exports,arguments) },{"./matchesPattern":249,"dup":143}],233:[function(require,module,exports){ arguments[4][144][0].apply(exports,arguments) },{"../../utils/shallowEqual":231,"dup":144}],234:[function(require,module,exports){ arguments[4][145][0].apply(exports,arguments) },{"../definitions":211,"../utils/shallowEqual":231,"./isPlaceholderType":241,"./isType":245,"dup":145}],235:[function(require,module,exports){ arguments[4][146][0].apply(exports,arguments) },{"../retrievers/getBindingIdentifiers":225,"dup":146}],236:[function(require,module,exports){ arguments[4][147][0].apply(exports,arguments) },{"./generated":233,"./isLet":238,"dup":147}],237:[function(require,module,exports){ arguments[4][148][0].apply(exports,arguments) },{"./generated":233,"./isType":245,"dup":148}],238:[function(require,module,exports){ arguments[4][149][0].apply(exports,arguments) },{"../constants":196,"./generated":233,"dup":149}],239:[function(require,module,exports){ arguments[4][150][0].apply(exports,arguments) },{"../definitions":211,"dup":150}],240:[function(require,module,exports){ arguments[4][151][0].apply(exports,arguments) },{"../definitions":211,"dup":151}],241:[function(require,module,exports){ arguments[4][152][0].apply(exports,arguments) },{"../definitions":211,"dup":152}],242:[function(require,module,exports){ arguments[4][153][0].apply(exports,arguments) },{"dup":153}],243:[function(require,module,exports){ arguments[4][154][0].apply(exports,arguments) },{"./generated":233,"dup":154}],244:[function(require,module,exports){ arguments[4][155][0].apply(exports,arguments) },{"./generated":233,"dup":155}],245:[function(require,module,exports){ arguments[4][156][0].apply(exports,arguments) },{"../definitions":211,"dup":156}],246:[function(require,module,exports){ arguments[4][157][0].apply(exports,arguments) },{"./isValidIdentifier":247,"dup":157}],247:[function(require,module,exports){ arguments[4][158][0].apply(exports,arguments) },{"@babel/helper-validator-identifier":256,"dup":158}],248:[function(require,module,exports){ arguments[4][159][0].apply(exports,arguments) },{"../constants":196,"./generated":233,"dup":159}],249:[function(require,module,exports){ arguments[4][160][0].apply(exports,arguments) },{"./generated":233,"dup":160}],250:[function(require,module,exports){ arguments[4][161][0].apply(exports,arguments) },{"dup":161}],251:[function(require,module,exports){ arguments[4][162][0].apply(exports,arguments) },{"../buildMatchMemberExpression":232,"dup":162}],252:[function(require,module,exports){ arguments[4][163][0].apply(exports,arguments) },{"../definitions":211,"dup":163}],253:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = splitExportDeclaration; var _t = require("@babel/types"); const { cloneNode, exportNamedDeclaration, exportSpecifier, identifier, variableDeclaration, variableDeclarator } = _t; function splitExportDeclaration(exportDeclaration) { if (!exportDeclaration.isExportDeclaration() || exportDeclaration.isExportAllDeclaration()) { throw new Error("Only default and named export declarations can be split."); } if (exportDeclaration.isExportDefaultDeclaration()) { const declaration = exportDeclaration.get("declaration"); const standaloneDeclaration = declaration.isFunctionDeclaration() || declaration.isClassDeclaration(); const scope = declaration.isScope() ? declaration.scope.parent : declaration.scope; let id = declaration.node.id; let needBindingRegistration = false; if (!id) { needBindingRegistration = true; id = scope.generateUidIdentifier("default"); if (standaloneDeclaration || declaration.isFunctionExpression() || declaration.isClassExpression()) { declaration.node.id = cloneNode(id); } } const updatedDeclaration = standaloneDeclaration ? declaration.node : variableDeclaration("var", [variableDeclarator(cloneNode(id), declaration.node)]); const updatedExportDeclaration = exportNamedDeclaration(null, [exportSpecifier(cloneNode(id), identifier("default"))]); exportDeclaration.insertAfter(updatedExportDeclaration); exportDeclaration.replaceWith(updatedDeclaration); if (needBindingRegistration) { scope.registerDeclaration(exportDeclaration); } return exportDeclaration; } else if (exportDeclaration.get("specifiers").length > 0) { throw new Error("It doesn't make sense to split exported specifiers."); } const declaration = exportDeclaration.get("declaration"); const bindingIdentifiers = declaration.getOuterBindingIdentifiers(); const specifiers = Object.keys(bindingIdentifiers).map(name => { return exportSpecifier(identifier(name), identifier(name)); }); const aliasDeclar = exportNamedDeclaration(null, specifiers); exportDeclaration.insertAfter(aliasDeclar); exportDeclaration.replaceWith(declaration.node); return exportDeclaration; } },{"@babel/types":359}],254:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.readCodePoint = readCodePoint; exports.readInt = readInt; exports.readStringContents = readStringContents; var _isDigit = function isDigit(code) { return code >= 48 && code <= 57; }; const forbiddenNumericSeparatorSiblings = { decBinOct: new Set([46, 66, 69, 79, 95, 98, 101, 111]), hex: new Set([46, 88, 95, 120]) }; const isAllowedNumericSeparatorSibling = { bin: ch => ch === 48 || ch === 49, oct: ch => ch >= 48 && ch <= 55, dec: ch => ch >= 48 && ch <= 57, hex: ch => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102 }; function readStringContents(type, input, pos, lineStart, curLine, errors) { const initialPos = pos; const initialLineStart = lineStart; const initialCurLine = curLine; let out = ""; let firstInvalidLoc = null; let chunkStart = pos; const { length } = input; for (;;) { if (pos >= length) { errors.unterminated(initialPos, initialLineStart, initialCurLine); out += input.slice(chunkStart, pos); break; } const ch = input.charCodeAt(pos); if (isStringEnd(type, ch, input, pos)) { out += input.slice(chunkStart, pos); break; } if (ch === 92) { out += input.slice(chunkStart, pos); const res = readEscapedChar(input, pos, lineStart, curLine, type === "template", errors); if (res.ch === null && !firstInvalidLoc) { firstInvalidLoc = { pos, lineStart, curLine }; } else { out += res.ch; } ({ pos, lineStart, curLine } = res); chunkStart = pos; } else if (ch === 8232 || ch === 8233) { ++pos; ++curLine; lineStart = pos; } else if (ch === 10 || ch === 13) { if (type === "template") { out += input.slice(chunkStart, pos) + "\n"; ++pos; if (ch === 13 && input.charCodeAt(pos) === 10) { ++pos; } ++curLine; chunkStart = lineStart = pos; } else { errors.unterminated(initialPos, initialLineStart, initialCurLine); } } else { ++pos; } } return { pos, str: out, firstInvalidLoc, lineStart, curLine, containsInvalid: !!firstInvalidLoc }; } function isStringEnd(type, ch, input, pos) { if (type === "template") { return ch === 96 || ch === 36 && input.charCodeAt(pos + 1) === 123; } return ch === (type === "double" ? 34 : 39); } function readEscapedChar(input, pos, lineStart, curLine, inTemplate, errors) { const throwOnInvalid = !inTemplate; pos++; const res = ch => ({ pos, ch, lineStart, curLine }); const ch = input.charCodeAt(pos++); switch (ch) { case 110: return res("\n"); case 114: return res("\r"); case 120: { let code; ({ code, pos } = readHexChar(input, pos, lineStart, curLine, 2, false, throwOnInvalid, errors)); return res(code === null ? null : String.fromCharCode(code)); } case 117: { let code; ({ code, pos } = readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors)); return res(code === null ? null : String.fromCodePoint(code)); } case 116: return res("\t"); case 98: return res("\b"); case 118: return res("\u000b"); case 102: return res("\f"); case 13: if (input.charCodeAt(pos) === 10) { ++pos; } case 10: lineStart = pos; ++curLine; case 8232: case 8233: return res(""); case 56: case 57: if (inTemplate) { return res(null); } else { errors.strictNumericEscape(pos - 1, lineStart, curLine); } default: if (ch >= 48 && ch <= 55) { const startPos = pos - 1; const match = input.slice(startPos, pos + 2).match(/^[0-7]+/); let octalStr = match[0]; let octal = parseInt(octalStr, 8); if (octal > 255) { octalStr = octalStr.slice(0, -1); octal = parseInt(octalStr, 8); } pos += octalStr.length - 1; const next = input.charCodeAt(pos); if (octalStr !== "0" || next === 56 || next === 57) { if (inTemplate) { return res(null); } else { errors.strictNumericEscape(startPos, lineStart, curLine); } } return res(String.fromCharCode(octal)); } return res(String.fromCharCode(ch)); } } function readHexChar(input, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors) { const initialPos = pos; let n; ({ n, pos } = readInt(input, pos, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid)); if (n === null) { if (throwOnInvalid) { errors.invalidEscapeSequence(initialPos, lineStart, curLine); } else { pos = initialPos - 1; } } return { code: n, pos }; } function readInt(input, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) { const start = pos; const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings.hex : forbiddenNumericSeparatorSiblings.decBinOct; const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling.hex : radix === 10 ? isAllowedNumericSeparatorSibling.dec : radix === 8 ? isAllowedNumericSeparatorSibling.oct : isAllowedNumericSeparatorSibling.bin; let invalid = false; let total = 0; for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) { const code = input.charCodeAt(pos); let val; if (code === 95 && allowNumSeparator !== "bail") { const prev = input.charCodeAt(pos - 1); const next = input.charCodeAt(pos + 1); if (!allowNumSeparator) { if (bailOnError) return { n: null, pos }; errors.numericSeparatorInEscapeSequence(pos, lineStart, curLine); } else if (Number.isNaN(next) || !isAllowedSibling(next) || forbiddenSiblings.has(prev) || forbiddenSiblings.has(next)) { if (bailOnError) return { n: null, pos }; errors.unexpectedNumericSeparator(pos, lineStart, curLine); } ++pos; continue; } if (code >= 97) { val = code - 97 + 10; } else if (code >= 65) { val = code - 65 + 10; } else if (_isDigit(code)) { val = code - 48; } else { val = Infinity; } if (val >= radix) { if (val <= 9 && bailOnError) { return { n: null, pos }; } else if (val <= 9 && errors.invalidDigit(pos, lineStart, curLine, radix)) { val = 0; } else if (forceLen) { val = 0; invalid = true; } else { break; } } ++pos; total = total * radix + val; } if (pos === start || len != null && pos - start !== len || invalid) { return { n: null, pos }; } return { n: total, pos }; } function readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors) { const ch = input.charCodeAt(pos); let code; if (ch === 123) { ++pos; ({ code, pos } = readHexChar(input, pos, lineStart, curLine, input.indexOf("}", pos) - pos, true, throwOnInvalid, errors)); ++pos; if (code !== null && code > 0x10ffff) { if (throwOnInvalid) { errors.invalidCodePoint(pos, lineStart, curLine); } else { return { code: null, pos }; } } } else { ({ code, pos } = readHexChar(input, pos, lineStart, curLine, 4, false, throwOnInvalid, errors)); } return { code, pos }; } },{}],255:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.isIdentifierChar = isIdentifierChar; exports.isIdentifierName = isIdentifierName; exports.isIdentifierStart = isIdentifierStart; let nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u05d0-\u05ea\u05ef-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u0860-\u086a\u0870-\u0887\u0889-\u088e\u08a0-\u08c9\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u09fc\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0af9\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c5d\u0c60\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cdd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d04-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u1711\u171f-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1878\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4c\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5\u1cf6\u1cfa\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u3400-\u4dbf\u4e00-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7ca\ua7d0\ua7d1\ua7d3\ua7d5-\ua7d9\ua7f2-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\ua8fe\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab69\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc"; let nonASCIIidentifierChars = "\u200c\u200d\xb7\u0300-\u036f\u0387\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u0898-\u089f\u08ca-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u09fe\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0afa-\u0aff\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c00-\u0c04\u0c3c\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0cf3\u0d00-\u0d03\u0d3b\u0d3c\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d81-\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ece\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1369-\u1371\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u180f-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19d0-\u19da\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1ab0-\u1abd\u1abf-\u1ace\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1dc0-\u1dff\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\ua620-\ua629\ua66f\ua674-\ua67d\ua69e\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua82c\ua880\ua881\ua8b4-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f1\ua8ff-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\ua9e5\ua9f0-\ua9f9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f"; const nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]"); const nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]"); nonASCIIidentifierStartChars = nonASCIIidentifierChars = null; const astralIdentifierStartCodes = [0, 11, 2, 25, 2, 18, 2, 1, 2, 14, 3, 13, 35, 122, 70, 52, 268, 28, 4, 48, 48, 31, 14, 29, 6, 37, 11, 29, 3, 35, 5, 7, 2, 4, 43, 157, 19, 35, 5, 35, 5, 39, 9, 51, 13, 10, 2, 14, 2, 6, 2, 1, 2, 10, 2, 14, 2, 6, 2, 1, 68, 310, 10, 21, 11, 7, 25, 5, 2, 41, 2, 8, 70, 5, 3, 0, 2, 43, 2, 1, 4, 0, 3, 22, 11, 22, 10, 30, 66, 18, 2, 1, 11, 21, 11, 25, 71, 55, 7, 1, 65, 0, 16, 3, 2, 2, 2, 28, 43, 28, 4, 28, 36, 7, 2, 27, 28, 53, 11, 21, 11, 18, 14, 17, 111, 72, 56, 50, 14, 50, 14, 35, 349, 41, 7, 1, 79, 28, 11, 0, 9, 21, 43, 17, 47, 20, 28, 22, 13, 52, 58, 1, 3, 0, 14, 44, 33, 24, 27, 35, 30, 0, 3, 0, 9, 34, 4, 0, 13, 47, 15, 3, 22, 0, 2, 0, 36, 17, 2, 24, 20, 1, 64, 6, 2, 0, 2, 3, 2, 14, 2, 9, 8, 46, 39, 7, 3, 1, 3, 21, 2, 6, 2, 1, 2, 4, 4, 0, 19, 0, 13, 4, 159, 52, 19, 3, 21, 2, 31, 47, 21, 1, 2, 0, 185, 46, 42, 3, 37, 47, 21, 0, 60, 42, 14, 0, 72, 26, 38, 6, 186, 43, 117, 63, 32, 7, 3, 0, 3, 7, 2, 1, 2, 23, 16, 0, 2, 0, 95, 7, 3, 38, 17, 0, 2, 0, 29, 0, 11, 39, 8, 0, 22, 0, 12, 45, 20, 0, 19, 72, 264, 8, 2, 36, 18, 0, 50, 29, 113, 6, 2, 1, 2, 37, 22, 0, 26, 5, 2, 1, 2, 31, 15, 0, 328, 18, 16, 0, 2, 12, 2, 33, 125, 0, 80, 921, 103, 110, 18, 195, 2637, 96, 16, 1071, 18, 5, 4026, 582, 8634, 568, 8, 30, 18, 78, 18, 29, 19, 47, 17, 3, 32, 20, 6, 18, 689, 63, 129, 74, 6, 0, 67, 12, 65, 1, 2, 0, 29, 6135, 9, 1237, 43, 8, 8936, 3, 2, 6, 2, 1, 2, 290, 16, 0, 30, 2, 3, 0, 15, 3, 9, 395, 2309, 106, 6, 12, 4, 8, 8, 9, 5991, 84, 2, 70, 2, 1, 3, 0, 3, 1, 3, 3, 2, 11, 2, 0, 2, 6, 2, 64, 2, 3, 3, 7, 2, 6, 2, 27, 2, 3, 2, 4, 2, 0, 4, 6, 2, 339, 3, 24, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 7, 1845, 30, 7, 5, 262, 61, 147, 44, 11, 6, 17, 0, 322, 29, 19, 43, 485, 27, 757, 6, 2, 3, 2, 1, 2, 14, 2, 196, 60, 67, 8, 0, 1205, 3, 2, 26, 2, 1, 2, 0, 3, 0, 2, 9, 2, 3, 2, 0, 2, 0, 7, 0, 5, 0, 2, 0, 2, 0, 2, 2, 2, 1, 2, 0, 3, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 3, 3, 2, 6, 2, 3, 2, 3, 2, 0, 2, 9, 2, 16, 6, 2, 2, 4, 2, 16, 4421, 42719, 33, 4153, 7, 221, 3, 5761, 15, 7472, 3104, 541, 1507, 4938, 6, 4191]; const astralIdentifierCodes = [509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 574, 3, 9, 9, 370, 1, 81, 2, 71, 10, 50, 3, 123, 2, 54, 14, 32, 10, 3, 1, 11, 3, 46, 10, 8, 0, 46, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13, 2, 49, 13, 9, 3, 2, 11, 83, 11, 7, 0, 3, 0, 158, 11, 6, 9, 7, 3, 56, 1, 2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 193, 17, 10, 9, 5, 0, 82, 19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9, 84, 14, 5, 9, 243, 14, 166, 9, 71, 5, 2, 1, 3, 3, 2, 0, 2, 1, 13, 9, 120, 6, 3, 6, 4, 0, 29, 9, 41, 6, 2, 3, 9, 0, 10, 10, 47, 15, 406, 7, 2, 7, 17, 9, 57, 21, 2, 13, 123, 5, 4, 0, 2, 1, 2, 6, 2, 0, 9, 9, 49, 4, 2, 1, 2, 4, 9, 9, 330, 3, 10, 1, 2, 0, 49, 6, 4, 4, 14, 9, 5351, 0, 7, 14, 13835, 9, 87, 9, 39, 4, 60, 6, 26, 9, 1014, 0, 2, 54, 8, 3, 82, 0, 12, 1, 19628, 1, 4706, 45, 3, 22, 543, 4, 4, 5, 9, 7, 3, 6, 31, 3, 149, 2, 1418, 49, 513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 1361, 6, 2, 16, 3, 6, 2, 1, 2, 4, 101, 0, 161, 6, 10, 9, 357, 0, 62, 13, 499, 13, 983, 6, 110, 6, 6, 9, 4759, 9, 787719, 239]; function isInAstralSet(code, set) { let pos = 0x10000; for (let i = 0, length = set.length; i < length; i += 2) { pos += set[i]; if (pos > code) return false; pos += set[i + 1]; if (pos >= code) return true; } return false; } function isIdentifierStart(code) { if (code < 65) return code === 36; if (code <= 90) return true; if (code < 97) return code === 95; if (code <= 122) return true; if (code <= 0xffff) { return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code)); } return isInAstralSet(code, astralIdentifierStartCodes); } function isIdentifierChar(code) { if (code < 48) return code === 36; if (code < 58) return true; if (code < 65) return false; if (code <= 90) return true; if (code < 97) return code === 95; if (code <= 122) return true; if (code <= 0xffff) { return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code)); } return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes); } function isIdentifierName(name) { let isFirst = true; for (let i = 0; i < name.length; i++) { let cp = name.charCodeAt(i); if ((cp & 0xfc00) === 0xd800 && i + 1 < name.length) { const trail = name.charCodeAt(++i); if ((trail & 0xfc00) === 0xdc00) { cp = 0x10000 + ((cp & 0x3ff) << 10) + (trail & 0x3ff); } } if (isFirst) { isFirst = false; if (!isIdentifierStart(cp)) { return false; } } else if (!isIdentifierChar(cp)) { return false; } } return !isFirst; } },{}],256:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); Object.defineProperty(exports, "isIdentifierChar", { enumerable: true, get: function () { return _identifier.isIdentifierChar; } }); Object.defineProperty(exports, "isIdentifierName", { enumerable: true, get: function () { return _identifier.isIdentifierName; } }); Object.defineProperty(exports, "isIdentifierStart", { enumerable: true, get: function () { return _identifier.isIdentifierStart; } }); Object.defineProperty(exports, "isKeyword", { enumerable: true, get: function () { return _keyword.isKeyword; } }); Object.defineProperty(exports, "isReservedWord", { enumerable: true, get: function () { return _keyword.isReservedWord; } }); Object.defineProperty(exports, "isStrictBindOnlyReservedWord", { enumerable: true, get: function () { return _keyword.isStrictBindOnlyReservedWord; } }); Object.defineProperty(exports, "isStrictBindReservedWord", { enumerable: true, get: function () { return _keyword.isStrictBindReservedWord; } }); Object.defineProperty(exports, "isStrictReservedWord", { enumerable: true, get: function () { return _keyword.isStrictReservedWord; } }); var _identifier = require("./identifier"); var _keyword = require("./keyword"); },{"./identifier":255,"./keyword":257}],257:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.isKeyword = isKeyword; exports.isReservedWord = isReservedWord; exports.isStrictBindOnlyReservedWord = isStrictBindOnlyReservedWord; exports.isStrictBindReservedWord = isStrictBindReservedWord; exports.isStrictReservedWord = isStrictReservedWord; const reservedWords = { keyword: ["break", "case", "catch", "continue", "debugger", "default", "do", "else", "finally", "for", "function", "if", "return", "switch", "throw", "try", "var", "const", "while", "with", "new", "this", "super", "class", "extends", "export", "import", "null", "true", "false", "in", "instanceof", "typeof", "void", "delete"], strict: ["implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"], strictBind: ["eval", "arguments"] }; const keywords = new Set(reservedWords.keyword); const reservedWordsStrictSet = new Set(reservedWords.strict); const reservedWordsStrictBindSet = new Set(reservedWords.strictBind); function isReservedWord(word, inModule) { return inModule && word === "await" || word === "enum"; } function isStrictReservedWord(word, inModule) { return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word); } function isStrictBindOnlyReservedWord(word) { return reservedWordsStrictBindSet.has(word); } function isStrictBindReservedWord(word, inModule) { return isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word); } function isKeyword(word) { return keywords.has(word); } },{}],258:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.findSuggestion = findSuggestion; const { min } = Math; function levenshtein(a, b) { let t = [], u = [], i, j; const m = a.length, n = b.length; if (!m) { return n; } if (!n) { return m; } for (j = 0; j <= n; j++) { t[j] = j; } for (i = 1; i <= m; i++) { for (u = [i], j = 1; j <= n; j++) { u[j] = a[i - 1] === b[j - 1] ? t[j - 1] : min(t[j - 1], t[j], u[j - 1]) + 1; } t = u; } return u[n]; } function findSuggestion(str, arr) { const distances = arr.map(el => levenshtein(el, str)); return arr[distances.indexOf(min(...distances))]; } },{}],259:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); Object.defineProperty(exports, "OptionValidator", { enumerable: true, get: function () { return _validator.OptionValidator; } }); Object.defineProperty(exports, "findSuggestion", { enumerable: true, get: function () { return _findSuggestion.findSuggestion; } }); var _validator = require("./validator"); var _findSuggestion = require("./find-suggestion"); },{"./find-suggestion":258,"./validator":260}],260:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.OptionValidator = void 0; var _findSuggestion = require("./find-suggestion"); class OptionValidator { constructor(descriptor) { this.descriptor = descriptor; } validateTopLevelOptions(options, TopLevelOptionShape) { const validOptionNames = Object.keys(TopLevelOptionShape); for (const option of Object.keys(options)) { if (!validOptionNames.includes(option)) { throw new Error(this.formatMessage(`'${option}' is not a valid top-level option. - Did you mean '${(0, _findSuggestion.findSuggestion)(option, validOptionNames)}'?`)); } } } validateBooleanOption(name, value, defaultValue) { if (value === undefined) { return defaultValue; } else { this.invariant(typeof value === "boolean", `'${name}' option must be a boolean.`); } return value; } validateStringOption(name, value, defaultValue) { if (value === undefined) { return defaultValue; } else { this.invariant(typeof value === "string", `'${name}' option must be a string.`); } return value; } invariant(condition, message) { if (!condition) { throw new Error(this.formatMessage(message)); } } formatMessage(message) { return `${this.descriptor}: ${message}`; } } exports.OptionValidator = OptionValidator; },{"./find-suggestion":258}],261:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = wrapFunction; var _helperFunctionName = require("@babel/helper-function-name"); var _template = require("@babel/template"); var _t = require("@babel/types"); const { blockStatement, callExpression, functionExpression, isAssignmentPattern, isFunctionDeclaration, isRestElement, returnStatement } = _t; const buildAnonymousExpressionWrapper = _template.default.expression(` (function () { var REF = FUNCTION; return function NAME(PARAMS) { return REF.apply(this, arguments); }; })() `); const buildNamedExpressionWrapper = _template.default.expression(` (function () { var REF = FUNCTION; function NAME(PARAMS) { return REF.apply(this, arguments); } return NAME; })() `); const buildDeclarationWrapper = _template.default.statements(` function NAME(PARAMS) { return REF.apply(this, arguments); } function REF() { REF = FUNCTION; return REF.apply(this, arguments); } `); function classOrObjectMethod(path, callId) { const node = path.node; const body = node.body; const container = functionExpression(null, [], blockStatement(body.body), true); body.body = [returnStatement(callExpression(callExpression(callId, [container]), []))]; node.async = false; node.generator = false; path.get("body.body.0.argument.callee.arguments.0").unwrapFunctionEnvironment(); } function plainFunction(path, callId, noNewArrows, ignoreFunctionLength) { let functionId = null; let node; if (path.isArrowFunctionExpression()) { { var _path$arrowFunctionTo; path = (_path$arrowFunctionTo = path.arrowFunctionToExpression({ noNewArrows })) != null ? _path$arrowFunctionTo : path; } node = path.node; } else { node = path.node; } const isDeclaration = isFunctionDeclaration(node); functionId = node.id; node.id = null; node.type = "FunctionExpression"; const built = callExpression(callId, [node]); const params = []; for (const param of node.params) { if (isAssignmentPattern(param) || isRestElement(param)) { break; } params.push(path.scope.generateUidIdentifier("x")); } const wrapperArgs = { NAME: functionId || null, REF: path.scope.generateUidIdentifier(functionId ? functionId.name : "ref"), FUNCTION: built, PARAMS: params }; if (isDeclaration) { const container = buildDeclarationWrapper(wrapperArgs); path.replaceWith(container[0]); path.insertAfter(container[1]); } else { let container; if (functionId) { container = buildNamedExpressionWrapper(wrapperArgs); } else { container = buildAnonymousExpressionWrapper(wrapperArgs); const returnFn = container.callee.body.body[1].argument; (0, _helperFunctionName.default)({ node: returnFn, parent: path.parent, scope: path.scope }); functionId = returnFn.id; } if (functionId || !ignoreFunctionLength && params.length) { path.replaceWith(container); } else { path.replaceWith(built); } } } function wrapFunction(path, callId, noNewArrows = true, ignoreFunctionLength = false) { if (path.isMethod()) { classOrObjectMethod(path, callId); } else { plainFunction(path, callId, noNewArrows, ignoreFunctionLength); } } },{"@babel/helper-function-name":77,"@babel/template":281,"@babel/types":359}],262:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.wrapRegExp = exports.typeof = exports.objectSpread2 = exports.jsx = void 0; var _template = require("@babel/template"); const jsx = { minVersion: "7.0.0-beta.0", ast: () => _template.default.program.ast('\nvar REACT_ELEMENT_TYPE;\nexport default function _createRawReactElement(type, props, key, children) {\n if (!REACT_ELEMENT_TYPE) {\n REACT_ELEMENT_TYPE =\n (typeof Symbol === "function" &&\n \n Symbol["for"] &&\n Symbol["for"]("react.element")) ||\n 0xeac7;\n }\n var defaultProps = type && type.defaultProps;\n var childrenLength = arguments.length - 3;\n if (!props && childrenLength !== 0) {\n \n \n props = { children: void 0 };\n }\n if (childrenLength === 1) {\n props.children = children;\n } else if (childrenLength > 1) {\n var childArray = new Array(childrenLength);\n for (var i = 0; i < childrenLength; i++) {\n childArray[i] = arguments[i + 3];\n }\n props.children = childArray;\n }\n if (props && defaultProps) {\n for (var propName in defaultProps) {\n if (props[propName] === void 0) {\n props[propName] = defaultProps[propName];\n }\n }\n } else if (!props) {\n props = defaultProps || {};\n }\n return {\n $$typeof: REACT_ELEMENT_TYPE,\n type: type,\n key: key === undefined ? null : "" + key,\n ref: null,\n props: props,\n _owner: null,\n };\n}\n') }; exports.jsx = jsx; const objectSpread2 = { minVersion: "7.5.0", ast: () => _template.default.program.ast('\nimport defineProperty from "defineProperty";\nfunction ownKeys(object, enumerableOnly) {\n var keys = Object.keys(object);\n if (Object.getOwnPropertySymbols) {\n var symbols = Object.getOwnPropertySymbols(object);\n if (enumerableOnly) {\n symbols = symbols.filter(function (sym) {\n return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n });\n }\n keys.push.apply(keys, symbols);\n }\n return keys;\n}\nexport default function _objectSpread2(target) {\n for (var i = 1; i < arguments.length; i++) {\n var source = arguments[i] != null ? arguments[i] : {};\n if (i % 2) {\n ownKeys(Object(source), true).forEach(function (key) {\n defineProperty(target, key, source[key]);\n });\n } else if (Object.getOwnPropertyDescriptors) {\n Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n } else {\n ownKeys(Object(source)).forEach(function (key) {\n Object.defineProperty(\n target,\n key,\n Object.getOwnPropertyDescriptor(source, key)\n );\n });\n }\n }\n return target;\n}\n') }; exports.objectSpread2 = objectSpread2; const _typeof = { minVersion: "7.0.0-beta.0", ast: () => _template.default.program.ast('\nexport default function _typeof(obj) {\n "@babel/helpers - typeof";\n if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {\n _typeof = function (obj) {\n return typeof obj;\n };\n } else {\n _typeof = function (obj) {\n return obj &&\n typeof Symbol === "function" &&\n obj.constructor === Symbol &&\n obj !== Symbol.prototype\n ? "symbol"\n : typeof obj;\n };\n }\n return _typeof(obj);\n}\n') }; exports.typeof = _typeof; const wrapRegExp = { minVersion: "7.2.6", ast: () => _template.default.program.ast('\nimport setPrototypeOf from "setPrototypeOf";\nimport inherits from "inherits";\nexport default function _wrapRegExp() {\n _wrapRegExp = function (re, groups) {\n return new BabelRegExp(re, undefined, groups);\n };\n var _super = RegExp.prototype;\n var _groups = new WeakMap();\n function BabelRegExp(re, flags, groups) {\n var _this = new RegExp(re, flags);\n \n _groups.set(_this, groups || _groups.get(re));\n return setPrototypeOf(_this, BabelRegExp.prototype);\n }\n inherits(BabelRegExp, RegExp);\n BabelRegExp.prototype.exec = function (str) {\n var result = _super.exec.call(this, str);\n if (result) result.groups = buildGroups(result, this);\n return result;\n };\n BabelRegExp.prototype[Symbol.replace] = function (str, substitution) {\n if (typeof substitution === "string") {\n var groups = _groups.get(this);\n return _super[Symbol.replace].call(\n this,\n str,\n substitution.replace(/\\$<([^>]+)>/g, function (_, name) {\n return "$" + groups[name];\n })\n );\n } else if (typeof substitution === "function") {\n var _this = this;\n return _super[Symbol.replace].call(this, str, function () {\n var args = arguments;\n \n if (typeof args[args.length - 1] !== "object") {\n args = [].slice.call(args);\n args.push(buildGroups(args, _this));\n }\n return substitution.apply(this, args);\n });\n } else {\n return _super[Symbol.replace].call(this, str, substitution);\n }\n };\n function buildGroups(result, re) {\n \n \n var g = _groups.get(re);\n return Object.keys(g).reduce(function (groups, name) {\n groups[name] = result[g[name]];\n return groups;\n }, Object.create(null));\n }\n return _wrapRegExp.apply(this, arguments);\n}\n') }; exports.wrapRegExp = wrapRegExp; },{"@babel/template":281}],263:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = void 0; var _template = require("@babel/template"); var generated = require("./helpers-generated"); const helpers = Object.assign({ __proto__: null }, generated); var _default = helpers; exports.default = _default; const helper = minVersion => tpl => ({ minVersion, ast: () => _template.default.program.ast(tpl) }); helpers.asyncIterator = helper("7.0.0-beta.0")` export default function _asyncIterator(iterable) { var method; if (typeof Symbol !== "undefined") { if (Symbol.asyncIterator) method = iterable[Symbol.asyncIterator]; if (method == null && Symbol.iterator) method = iterable[Symbol.iterator]; } if (method == null) method = iterable["@@asyncIterator"]; if (method == null) method = iterable["@@iterator"] if (method == null) throw new TypeError("Object is not async iterable"); return method.call(iterable); } `; helpers.AwaitValue = helper("7.0.0-beta.0")` export default function _AwaitValue(value) { this.wrapped = value; } `; helpers.AsyncGenerator = helper("7.0.0-beta.0")` import AwaitValue from "AwaitValue"; export default function AsyncGenerator(gen) { var front, back; function send(key, arg) { return new Promise(function (resolve, reject) { var request = { key: key, arg: arg, resolve: resolve, reject: reject, next: null, }; if (back) { back = back.next = request; } else { front = back = request; resume(key, arg); } }); } function resume(key, arg) { try { var result = gen[key](arg) var value = result.value; var wrappedAwait = value instanceof AwaitValue; Promise.resolve(wrappedAwait ? value.wrapped : value).then( function (arg) { if (wrappedAwait) { resume(key === "return" ? "return" : "next", arg); return } settle(result.done ? "return" : "normal", arg); }, function (err) { resume("throw", err); }); } catch (err) { settle("throw", err); } } function settle(type, value) { switch (type) { case "return": front.resolve({ value: value, done: true }); break; case "throw": front.reject(value); break; default: front.resolve({ value: value, done: false }); break; } front = front.next; if (front) { resume(front.key, front.arg); } else { back = null; } } this._invoke = send; // Hide "return" method if generator return is not supported if (typeof gen.return !== "function") { this.return = undefined; } } AsyncGenerator.prototype[typeof Symbol === "function" && Symbol.asyncIterator || "@@asyncIterator"] = function () { return this; }; AsyncGenerator.prototype.next = function (arg) { return this._invoke("next", arg); }; AsyncGenerator.prototype.throw = function (arg) { return this._invoke("throw", arg); }; AsyncGenerator.prototype.return = function (arg) { return this._invoke("return", arg); }; `; helpers.wrapAsyncGenerator = helper("7.0.0-beta.0")` import AsyncGenerator from "AsyncGenerator"; export default function _wrapAsyncGenerator(fn) { return function () { return new AsyncGenerator(fn.apply(this, arguments)); }; } `; helpers.awaitAsyncGenerator = helper("7.0.0-beta.0")` import AwaitValue from "AwaitValue"; export default function _awaitAsyncGenerator(value) { return new AwaitValue(value); } `; helpers.asyncGeneratorDelegate = helper("7.0.0-beta.0")` export default function _asyncGeneratorDelegate(inner, awaitWrap) { var iter = {}, waiting = false; function pump(key, value) { waiting = true; value = new Promise(function (resolve) { resolve(inner[key](value)); }); return { done: false, value: awaitWrap(value) }; }; iter[typeof Symbol !== "undefined" && Symbol.iterator || "@@iterator"] = function () { return this; }; iter.next = function (value) { if (waiting) { waiting = false; return value; } return pump("next", value); }; if (typeof inner.throw === "function") { iter.throw = function (value) { if (waiting) { waiting = false; throw value; } return pump("throw", value); }; } if (typeof inner.return === "function") { iter.return = function (value) { if (waiting) { waiting = false; return value; } return pump("return", value); }; } return iter; } `; helpers.asyncToGenerator = helper("7.0.0-beta.0")` function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } } export default function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; } `; helpers.classCallCheck = helper("7.0.0-beta.0")` export default function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } `; helpers.createClass = helper("7.0.0-beta.0")` function _defineProperties(target, props) { for (var i = 0; i < props.length; i ++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } export default function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } `; helpers.defineEnumerableProperties = helper("7.0.0-beta.0")` export default function _defineEnumerableProperties(obj, descs) { for (var key in descs) { var desc = descs[key]; desc.configurable = desc.enumerable = true; if ("value" in desc) desc.writable = true; Object.defineProperty(obj, key, desc); } // Symbols are not enumerated over by for-in loops. If native // Symbols are available, fetch all of the descs object's own // symbol properties and define them on our target object too. if (Object.getOwnPropertySymbols) { var objectSymbols = Object.getOwnPropertySymbols(descs); for (var i = 0; i < objectSymbols.length; i++) { var sym = objectSymbols[i]; var desc = descs[sym]; desc.configurable = desc.enumerable = true; if ("value" in desc) desc.writable = true; Object.defineProperty(obj, sym, desc); } } return obj; } `; helpers.defaults = helper("7.0.0-beta.0")` export default function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } `; helpers.defineProperty = helper("7.0.0-beta.0")` export default function _defineProperty(obj, key, value) { // Shortcircuit the slow defineProperty path when possible. // We are trying to avoid issues where setters defined on the // prototype cause side effects under the fast path of simple // assignment. By checking for existence of the property with // the in operator, we can optimize most of this overhead away. if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } `; helpers.extends = helper("7.0.0-beta.0")` export default function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); } `; helpers.objectSpread = helper("7.0.0-beta.0")` import defineProperty from "defineProperty"; export default function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = (arguments[i] != null) ? Object(arguments[i]) : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function(key) { defineProperty(target, key, source[key]); }); } return target; } `; helpers.inherits = helper("7.0.0-beta.0")` import setPrototypeOf from "setPrototypeOf"; export default function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) setPrototypeOf(subClass, superClass); } `; helpers.inheritsLoose = helper("7.0.0-beta.0")` import setPrototypeOf from "setPrototypeOf"; export default function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; setPrototypeOf(subClass, superClass); } `; helpers.getPrototypeOf = helper("7.0.0-beta.0")` export default function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } `; helpers.setPrototypeOf = helper("7.0.0-beta.0")` export default function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } `; helpers.isNativeReflectConstruct = helper("7.9.0")` export default function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; // core-js@3 if (Reflect.construct.sham) return false; // Proxy can't be polyfilled. Every browser implemented // proxies before or at the same time as Reflect.construct, // so if they support Proxy they also support Reflect.construct. if (typeof Proxy === "function") return true; // Since Reflect.construct can't be properly polyfilled, some // implementations (e.g. core-js@2) don't set the correct internal slots. // Those polyfills don't allow us to subclass built-ins, so we need to // use our fallback implementation. try { // If the internal slots aren't set, this throws an error similar to // TypeError: this is not a Boolean object. Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {})); return true; } catch (e) { return false; } } `; helpers.construct = helper("7.0.0-beta.0")` import setPrototypeOf from "setPrototypeOf"; import isNativeReflectConstruct from "isNativeReflectConstruct"; export default function _construct(Parent, args, Class) { if (isNativeReflectConstruct()) { _construct = Reflect.construct; } else { // NOTE: If Parent !== Class, the correct __proto__ is set *after* // calling the constructor. _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) setPrototypeOf(instance, Class.prototype); return instance; }; } // Avoid issues with Class being present but undefined when it wasn't // present in the original call. return _construct.apply(null, arguments); } `; helpers.isNativeFunction = helper("7.0.0-beta.0")` export default function _isNativeFunction(fn) { // Note: This function returns "true" for core-js functions. return Function.toString.call(fn).indexOf("[native code]") !== -1; } `; helpers.wrapNativeSuper = helper("7.0.0-beta.0")` import getPrototypeOf from "getPrototypeOf"; import setPrototypeOf from "setPrototypeOf"; import isNativeFunction from "isNativeFunction"; import construct from "construct"; export default function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return construct(Class, arguments, getPrototypeOf(this).constructor) } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true, } }); return setPrototypeOf(Wrapper, Class); } return _wrapNativeSuper(Class) } `; helpers.instanceof = helper("7.0.0-beta.0")` export default function _instanceof(left, right) { if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) { return !!right[Symbol.hasInstance](left); } else { return left instanceof right; } } `; helpers.interopRequireDefault = helper("7.0.0-beta.0")` export default function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } `; helpers.interopRequireWildcard = helper("7.14.0")` function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } export default function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || (typeof obj !== "object" && typeof obj !== "function")) { return { default: obj } } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; } `; helpers.newArrowCheck = helper("7.0.0-beta.0")` export default function _newArrowCheck(innerThis, boundThis) { if (innerThis !== boundThis) { throw new TypeError("Cannot instantiate an arrow function"); } } `; helpers.objectDestructuringEmpty = helper("7.0.0-beta.0")` export default function _objectDestructuringEmpty(obj) { if (obj == null) throw new TypeError("Cannot destructure undefined"); } `; helpers.objectWithoutPropertiesLoose = helper("7.0.0-beta.0")` export default function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } `; helpers.objectWithoutProperties = helper("7.0.0-beta.0")` import objectWithoutPropertiesLoose from "objectWithoutPropertiesLoose"; export default function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } `; helpers.assertThisInitialized = helper("7.0.0-beta.0")` export default function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } `; helpers.possibleConstructorReturn = helper("7.0.0-beta.0")` import assertThisInitialized from "assertThisInitialized"; export default function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return assertThisInitialized(self); } `; helpers.createSuper = helper("7.9.0")` import getPrototypeOf from "getPrototypeOf"; import isNativeReflectConstruct from "isNativeReflectConstruct"; import possibleConstructorReturn from "possibleConstructorReturn"; export default function _createSuper(Derived) { var hasNativeReflectConstruct = isNativeReflectConstruct(); return function _createSuperInternal() { var Super = getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { // NOTE: This doesn't work if this.__proto__.constructor has been modified. var NewTarget = getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return possibleConstructorReturn(this, result); } } `; helpers.superPropBase = helper("7.0.0-beta.0")` import getPrototypeOf from "getPrototypeOf"; export default function _superPropBase(object, property) { // Yes, this throws if object is null to being with, that's on purpose. while (!Object.prototype.hasOwnProperty.call(object, property)) { object = getPrototypeOf(object); if (object === null) break; } return object; } `; helpers.get = helper("7.0.0-beta.0")` import superPropBase from "superPropBase"; export default function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); } `; helpers.set = helper("7.0.0-beta.0")` import superPropBase from "superPropBase"; import defineProperty from "defineProperty"; function set(target, property, value, receiver) { if (typeof Reflect !== "undefined" && Reflect.set) { set = Reflect.set; } else { set = function set(target, property, value, receiver) { var base = superPropBase(target, property); var desc; if (base) { desc = Object.getOwnPropertyDescriptor(base, property); if (desc.set) { desc.set.call(receiver, value); return true; } else if (!desc.writable) { // Both getter and non-writable fall into this. return false; } } // Without a super that defines the property, spec boils down to // "define on receiver" for some reason. desc = Object.getOwnPropertyDescriptor(receiver, property); if (desc) { if (!desc.writable) { // Setter, getter, and non-writable fall into this. return false; } desc.value = value; Object.defineProperty(receiver, property, desc); } else { // Avoid setters that may be defined on Sub's prototype, but not on // the instance. defineProperty(receiver, property, value); } return true; }; } return set(target, property, value, receiver); } export default function _set(target, property, value, receiver, isStrict) { var s = set(target, property, value, receiver || target); if (!s && isStrict) { throw new Error('failed to set property'); } return value; } `; helpers.taggedTemplateLiteral = helper("7.0.0-beta.0")` export default function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); } `; helpers.taggedTemplateLiteralLoose = helper("7.0.0-beta.0")` export default function _taggedTemplateLiteralLoose(strings, raw) { if (!raw) { raw = strings.slice(0); } strings.raw = raw; return strings; } `; helpers.readOnlyError = helper("7.0.0-beta.0")` export default function _readOnlyError(name) { throw new TypeError("\\"" + name + "\\" is read-only"); } `; helpers.writeOnlyError = helper("7.12.13")` export default function _writeOnlyError(name) { throw new TypeError("\\"" + name + "\\" is write-only"); } `; helpers.classNameTDZError = helper("7.0.0-beta.0")` export default function _classNameTDZError(name) { throw new Error("Class \\"" + name + "\\" cannot be referenced in computed property keys."); } `; helpers.temporalUndefined = helper("7.0.0-beta.0")` // This function isn't mean to be called, but to be used as a reference. // We can't use a normal object because it isn't hoisted. export default function _temporalUndefined() {} `; helpers.tdz = helper("7.5.5")` export default function _tdzError(name) { throw new ReferenceError(name + " is not defined - temporal dead zone"); } `; helpers.temporalRef = helper("7.0.0-beta.0")` import undef from "temporalUndefined"; import err from "tdz"; export default function _temporalRef(val, name) { return val === undef ? err(name) : val; } `; helpers.slicedToArray = helper("7.0.0-beta.0")` import arrayWithHoles from "arrayWithHoles"; import iterableToArrayLimit from "iterableToArrayLimit"; import unsupportedIterableToArray from "unsupportedIterableToArray"; import nonIterableRest from "nonIterableRest"; export default function _slicedToArray(arr, i) { return ( arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest() ); } `; helpers.slicedToArrayLoose = helper("7.0.0-beta.0")` import arrayWithHoles from "arrayWithHoles"; import iterableToArrayLimitLoose from "iterableToArrayLimitLoose"; import unsupportedIterableToArray from "unsupportedIterableToArray"; import nonIterableRest from "nonIterableRest"; export default function _slicedToArrayLoose(arr, i) { return ( arrayWithHoles(arr) || iterableToArrayLimitLoose(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest() ); } `; helpers.toArray = helper("7.0.0-beta.0")` import arrayWithHoles from "arrayWithHoles"; import iterableToArray from "iterableToArray"; import unsupportedIterableToArray from "unsupportedIterableToArray"; import nonIterableRest from "nonIterableRest"; export default function _toArray(arr) { return ( arrayWithHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableRest() ); } `; helpers.toConsumableArray = helper("7.0.0-beta.0")` import arrayWithoutHoles from "arrayWithoutHoles"; import iterableToArray from "iterableToArray"; import unsupportedIterableToArray from "unsupportedIterableToArray"; import nonIterableSpread from "nonIterableSpread"; export default function _toConsumableArray(arr) { return ( arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread() ); } `; helpers.arrayWithoutHoles = helper("7.0.0-beta.0")` import arrayLikeToArray from "arrayLikeToArray"; export default function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return arrayLikeToArray(arr); } `; helpers.arrayWithHoles = helper("7.0.0-beta.0")` export default function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; } `; helpers.maybeArrayLike = helper("7.9.0")` import arrayLikeToArray from "arrayLikeToArray"; export default function _maybeArrayLike(next, arr, i) { if (arr && !Array.isArray(arr) && typeof arr.length === "number") { var len = arr.length; return arrayLikeToArray(arr, i !== void 0 && i < len ? i : len); } return next(arr, i); } `; helpers.iterableToArray = helper("7.0.0-beta.0")` export default function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); } `; helpers.iterableToArrayLimit = helper("7.0.0-beta.0")` export default function _iterableToArrayLimit(arr, i) { // this is an expanded form of \`for...of\` that properly supports abrupt completions of // iterators etc. variable names have been minimised to reduce the size of this massive // helper. sometimes spec compliance is annoying :( // // _n = _iteratorNormalCompletion // _d = _didIteratorError // _e = _iteratorError // _i = _iterator // _s = _step var _i = arr == null ? null : (typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]); if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } `; helpers.iterableToArrayLimitLoose = helper("7.0.0-beta.0")` export default function _iterableToArrayLimitLoose(arr, i) { var _i = arr && (typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]); if (_i == null) return; var _arr = []; for (_i = _i.call(arr), _step; !(_step = _i.next()).done;) { _arr.push(_step.value); if (i && _arr.length === i) break; } return _arr; } `; helpers.unsupportedIterableToArray = helper("7.9.0")` import arrayLikeToArray from "arrayLikeToArray"; export default function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen); } `; helpers.arrayLikeToArray = helper("7.9.0")` export default function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; } `; helpers.nonIterableSpread = helper("7.0.0-beta.0")` export default function _nonIterableSpread() { throw new TypeError( "Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method." ); } `; helpers.nonIterableRest = helper("7.0.0-beta.0")` export default function _nonIterableRest() { throw new TypeError( "Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method." ); } `; helpers.createForOfIteratorHelper = helper("7.9.0")` import unsupportedIterableToArray from "unsupportedIterableToArray"; // s: start (create the iterator) // n: next // e: error (called whenever something throws) // f: finish (always called at the end) export default function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { // Fallback for engines without symbol support if ( Array.isArray(o) || (it = unsupportedIterableToArray(o)) || (allowArrayLike && o && typeof o.length === "number") ) { if (it) o = it; var i = 0; var F = function(){}; return { s: F, n: function() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function(e) { throw e; }, f: F, }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function() { it = it.call(o); }, n: function() { var step = it.next(); normalCompletion = step.done; return step; }, e: function(e) { didErr = true; err = e; }, f: function() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; } `; helpers.createForOfIteratorHelperLoose = helper("7.9.0")` import unsupportedIterableToArray from "unsupportedIterableToArray"; export default function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (it) return (it = it.call(o)).next.bind(it); // Fallback for engines without symbol support if ( Array.isArray(o) || (it = unsupportedIterableToArray(o)) || (allowArrayLike && o && typeof o.length === "number") ) { if (it) o = it; var i = 0; return function() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; } } throw new TypeError("Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } `; helpers.skipFirstGeneratorNext = helper("7.0.0-beta.0")` export default function _skipFirstGeneratorNext(fn) { return function () { var it = fn.apply(this, arguments); it.next(); return it; } } `; helpers.toPrimitive = helper("7.1.5")` export default function _toPrimitive( input, hint /*: "default" | "string" | "number" | void */ ) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } `; helpers.toPropertyKey = helper("7.1.5")` import toPrimitive from "toPrimitive"; export default function _toPropertyKey(arg) { var key = toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); } `; helpers.initializerWarningHelper = helper("7.0.0-beta.0")` export default function _initializerWarningHelper(descriptor, context){ throw new Error( 'Decorating class property failed. Please ensure that ' + 'proposal-class-properties is enabled and runs after the decorators transform.' ); } `; helpers.initializerDefineProperty = helper("7.0.0-beta.0")` export default function _initializerDefineProperty(target, property, descriptor, context){ if (!descriptor) return; Object.defineProperty(target, property, { enumerable: descriptor.enumerable, configurable: descriptor.configurable, writable: descriptor.writable, value: descriptor.initializer ? descriptor.initializer.call(context) : void 0, }); } `; helpers.applyDecoratedDescriptor = helper("7.0.0-beta.0")` export default function _applyDecoratedDescriptor(target, property, decorators, descriptor, context){ var desc = {}; Object.keys(descriptor).forEach(function(key){ desc[key] = descriptor[key]; }); desc.enumerable = !!desc.enumerable; desc.configurable = !!desc.configurable; if ('value' in desc || desc.initializer){ desc.writable = true; } desc = decorators.slice().reverse().reduce(function(desc, decorator){ return decorator(target, property, desc) || desc; }, desc); if (context && desc.initializer !== void 0){ desc.value = desc.initializer ? desc.initializer.call(context) : void 0; desc.initializer = undefined; } if (desc.initializer === void 0){ Object.defineProperty(target, property, desc); desc = null; } return desc; } `; helpers.classPrivateFieldLooseKey = helper("7.0.0-beta.0")` var id = 0; export default function _classPrivateFieldKey(name) { return "__private_" + (id++) + "_" + name; } `; helpers.classPrivateFieldLooseBase = helper("7.0.0-beta.0")` export default function _classPrivateFieldBase(receiver, privateKey) { if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) { throw new TypeError("attempted to use private field on non-instance"); } return receiver; } `; helpers.classPrivateFieldGet = helper("7.0.0-beta.0")` import classApplyDescriptorGet from "classApplyDescriptorGet"; import classExtractFieldDescriptor from "classExtractFieldDescriptor"; export default function _classPrivateFieldGet(receiver, privateMap) { var descriptor = classExtractFieldDescriptor(receiver, privateMap, "get"); return classApplyDescriptorGet(receiver, descriptor); } `; helpers.classPrivateFieldSet = helper("7.0.0-beta.0")` import classApplyDescriptorSet from "classApplyDescriptorSet"; import classExtractFieldDescriptor from "classExtractFieldDescriptor"; export default function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = classExtractFieldDescriptor(receiver, privateMap, "set"); classApplyDescriptorSet(receiver, descriptor, value); return value; } `; helpers.classPrivateFieldDestructureSet = helper("7.4.4")` import classApplyDescriptorDestructureSet from "classApplyDescriptorDestructureSet"; import classExtractFieldDescriptor from "classExtractFieldDescriptor"; export default function _classPrivateFieldDestructureSet(receiver, privateMap) { var descriptor = classExtractFieldDescriptor(receiver, privateMap, "set"); return classApplyDescriptorDestructureSet(receiver, descriptor); } `; helpers.classExtractFieldDescriptor = helper("7.13.10")` export default function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); } `; helpers.classStaticPrivateFieldSpecGet = helper("7.0.2")` import classApplyDescriptorGet from "classApplyDescriptorGet"; import classCheckPrivateStaticAccess from "classCheckPrivateStaticAccess"; import classCheckPrivateStaticFieldDescriptor from "classCheckPrivateStaticFieldDescriptor"; export default function _classStaticPrivateFieldSpecGet(receiver, classConstructor, descriptor) { classCheckPrivateStaticAccess(receiver, classConstructor); classCheckPrivateStaticFieldDescriptor(descriptor, "get"); return classApplyDescriptorGet(receiver, descriptor); } `; helpers.classStaticPrivateFieldSpecSet = helper("7.0.2")` import classApplyDescriptorSet from "classApplyDescriptorSet"; import classCheckPrivateStaticAccess from "classCheckPrivateStaticAccess"; import classCheckPrivateStaticFieldDescriptor from "classCheckPrivateStaticFieldDescriptor"; export default function _classStaticPrivateFieldSpecSet(receiver, classConstructor, descriptor, value) { classCheckPrivateStaticAccess(receiver, classConstructor); classCheckPrivateStaticFieldDescriptor(descriptor, "set"); classApplyDescriptorSet(receiver, descriptor, value); return value; } `; helpers.classStaticPrivateMethodGet = helper("7.3.2")` import classCheckPrivateStaticAccess from "classCheckPrivateStaticAccess"; export default function _classStaticPrivateMethodGet(receiver, classConstructor, method) { classCheckPrivateStaticAccess(receiver, classConstructor); return method; } `; helpers.classStaticPrivateMethodSet = helper("7.3.2")` export default function _classStaticPrivateMethodSet() { throw new TypeError("attempted to set read only static private field"); } `; helpers.classApplyDescriptorGet = helper("7.13.10")` export default function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; } `; helpers.classApplyDescriptorSet = helper("7.13.10")` export default function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { // This should only throw in strict mode, but class bodies are // always strict and private fields can only be used inside // class bodies. throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } } `; helpers.classApplyDescriptorDestructureSet = helper("7.13.10")` export default function _classApplyDescriptorDestructureSet(receiver, descriptor) { if (descriptor.set) { if (!("__destrObj" in descriptor)) { descriptor.__destrObj = { set value(v) { descriptor.set.call(receiver, v) }, }; } return descriptor.__destrObj; } else { if (!descriptor.writable) { // This should only throw in strict mode, but class bodies are // always strict and private fields can only be used inside // class bodies. throw new TypeError("attempted to set read only private field"); } return descriptor; } } `; helpers.classStaticPrivateFieldDestructureSet = helper("7.13.10")` import classApplyDescriptorDestructureSet from "classApplyDescriptorDestructureSet"; import classCheckPrivateStaticAccess from "classCheckPrivateStaticAccess"; import classCheckPrivateStaticFieldDescriptor from "classCheckPrivateStaticFieldDescriptor"; export default function _classStaticPrivateFieldDestructureSet(receiver, classConstructor, descriptor) { classCheckPrivateStaticAccess(receiver, classConstructor); classCheckPrivateStaticFieldDescriptor(descriptor, "set"); return classApplyDescriptorDestructureSet(receiver, descriptor); } `; helpers.classCheckPrivateStaticAccess = helper("7.13.10")` export default function _classCheckPrivateStaticAccess(receiver, classConstructor) { if (receiver !== classConstructor) { throw new TypeError("Private static access of wrong provenance"); } } `; helpers.classCheckPrivateStaticFieldDescriptor = helper("7.13.10")` export default function _classCheckPrivateStaticFieldDescriptor(descriptor, action) { if (descriptor === undefined) { throw new TypeError("attempted to " + action + " private static field before its declaration"); } } `; helpers.decorate = helper("7.1.5")` import toArray from "toArray"; import toPropertyKey from "toPropertyKey"; // These comments are stripped by @babel/template /*:: type PropertyDescriptor = | { value: any, writable: boolean, configurable: boolean, enumerable: boolean, } | { get?: () => any, set?: (v: any) => void, configurable: boolean, enumerable: boolean, }; type FieldDescriptor ={ writable: boolean, configurable: boolean, enumerable: boolean, }; type Placement = "static" | "prototype" | "own"; type Key = string | symbol; // PrivateName is not supported yet. type ElementDescriptor = | { kind: "method", key: Key, placement: Placement, descriptor: PropertyDescriptor } | { kind: "field", key: Key, placement: Placement, descriptor: FieldDescriptor, initializer?: () => any, }; // This is exposed to the user code type ElementObjectInput = ElementDescriptor & { [@@toStringTag]?: "Descriptor" }; // This is exposed to the user code type ElementObjectOutput = ElementDescriptor & { [@@toStringTag]?: "Descriptor" extras?: ElementDescriptor[], finisher?: ClassFinisher, }; // This is exposed to the user code type ClassObject = { [@@toStringTag]?: "Descriptor", kind: "class", elements: ElementDescriptor[], }; type ElementDecorator = (descriptor: ElementObjectInput) => ?ElementObjectOutput; type ClassDecorator = (descriptor: ClassObject) => ?ClassObject; type ClassFinisher = (cl: Class) => Class; // Only used by Babel in the transform output, not part of the spec. type ElementDefinition = | { kind: "method", value: any, key: Key, static?: boolean, decorators?: ElementDecorator[], } | { kind: "field", value: () => any, key: Key, static?: boolean, decorators?: ElementDecorator[], }; declare function ClassFactory(initialize: (instance: C) => void): { F: Class, d: ElementDefinition[] } */ /*:: // Various combinations with/without extras and with one or many finishers type ElementFinisherExtras = { element: ElementDescriptor, finisher?: ClassFinisher, extras?: ElementDescriptor[], }; type ElementFinishersExtras = { element: ElementDescriptor, finishers: ClassFinisher[], extras: ElementDescriptor[], }; type ElementsFinisher = { elements: ElementDescriptor[], finisher?: ClassFinisher, }; type ElementsFinishers = { elements: ElementDescriptor[], finishers: ClassFinisher[], }; */ /*:: type Placements = { static: Key[], prototype: Key[], own: Key[], }; */ // ClassDefinitionEvaluation (Steps 26-*) export default function _decorate( decorators /*: ClassDecorator[] */, factory /*: ClassFactory */, superClass /*: ?Class<*> */, mixins /*: ?Array */, ) /*: Class<*> */ { var api = _getDecoratorsApi(); if (mixins) { for (var i = 0; i < mixins.length; i++) { api = mixins[i](api); } } var r = factory(function initialize(O) { api.initializeInstanceElements(O, decorated.elements); }, superClass); var decorated = api.decorateClass( _coalesceClassElements(r.d.map(_createElementDescriptor)), decorators, ); api.initializeClassElements(r.F, decorated.elements); return api.runClassFinishers(r.F, decorated.finishers); } function _getDecoratorsApi() { _getDecoratorsApi = function() { return api; }; var api = { elementsDefinitionOrder: [["method"], ["field"]], // InitializeInstanceElements initializeInstanceElements: function( /*::*/ O /*: C */, elements /*: ElementDescriptor[] */, ) { ["method", "field"].forEach(function(kind) { elements.forEach(function(element /*: ElementDescriptor */) { if (element.kind === kind && element.placement === "own") { this.defineClassElement(O, element); } }, this); }, this); }, // InitializeClassElements initializeClassElements: function( /*::*/ F /*: Class */, elements /*: ElementDescriptor[] */, ) { var proto = F.prototype; ["method", "field"].forEach(function(kind) { elements.forEach(function(element /*: ElementDescriptor */) { var placement = element.placement; if ( element.kind === kind && (placement === "static" || placement === "prototype") ) { var receiver = placement === "static" ? F : proto; this.defineClassElement(receiver, element); } }, this); }, this); }, // DefineClassElement defineClassElement: function( /*::*/ receiver /*: C | Class */, element /*: ElementDescriptor */, ) { var descriptor /*: PropertyDescriptor */ = element.descriptor; if (element.kind === "field") { var initializer = element.initializer; descriptor = { enumerable: descriptor.enumerable, writable: descriptor.writable, configurable: descriptor.configurable, value: initializer === void 0 ? void 0 : initializer.call(receiver), }; } Object.defineProperty(receiver, element.key, descriptor); }, // DecorateClass decorateClass: function( elements /*: ElementDescriptor[] */, decorators /*: ClassDecorator[] */, ) /*: ElementsFinishers */ { var newElements /*: ElementDescriptor[] */ = []; var finishers /*: ClassFinisher[] */ = []; var placements /*: Placements */ = { static: [], prototype: [], own: [], }; elements.forEach(function(element /*: ElementDescriptor */) { this.addElementPlacement(element, placements); }, this); elements.forEach(function(element /*: ElementDescriptor */) { if (!_hasDecorators(element)) return newElements.push(element); var elementFinishersExtras /*: ElementFinishersExtras */ = this.decorateElement( element, placements, ); newElements.push(elementFinishersExtras.element); newElements.push.apply(newElements, elementFinishersExtras.extras); finishers.push.apply(finishers, elementFinishersExtras.finishers); }, this); if (!decorators) { return { elements: newElements, finishers: finishers }; } var result /*: ElementsFinishers */ = this.decorateConstructor( newElements, decorators, ); finishers.push.apply(finishers, result.finishers); result.finishers = finishers; return result; }, // AddElementPlacement addElementPlacement: function( element /*: ElementDescriptor */, placements /*: Placements */, silent /*: boolean */, ) { var keys = placements[element.placement]; if (!silent && keys.indexOf(element.key) !== -1) { throw new TypeError("Duplicated element (" + element.key + ")"); } keys.push(element.key); }, // DecorateElement decorateElement: function( element /*: ElementDescriptor */, placements /*: Placements */, ) /*: ElementFinishersExtras */ { var extras /*: ElementDescriptor[] */ = []; var finishers /*: ClassFinisher[] */ = []; for ( var decorators = element.decorators, i = decorators.length - 1; i >= 0; i-- ) { // (inlined) RemoveElementPlacement var keys = placements[element.placement]; keys.splice(keys.indexOf(element.key), 1); var elementObject /*: ElementObjectInput */ = this.fromElementDescriptor( element, ); var elementFinisherExtras /*: ElementFinisherExtras */ = this.toElementFinisherExtras( (0, decorators[i])(elementObject) /*: ElementObjectOutput */ || elementObject, ); element = elementFinisherExtras.element; this.addElementPlacement(element, placements); if (elementFinisherExtras.finisher) { finishers.push(elementFinisherExtras.finisher); } var newExtras /*: ElementDescriptor[] | void */ = elementFinisherExtras.extras; if (newExtras) { for (var j = 0; j < newExtras.length; j++) { this.addElementPlacement(newExtras[j], placements); } extras.push.apply(extras, newExtras); } } return { element: element, finishers: finishers, extras: extras }; }, // DecorateConstructor decorateConstructor: function( elements /*: ElementDescriptor[] */, decorators /*: ClassDecorator[] */, ) /*: ElementsFinishers */ { var finishers /*: ClassFinisher[] */ = []; for (var i = decorators.length - 1; i >= 0; i--) { var obj /*: ClassObject */ = this.fromClassDescriptor(elements); var elementsAndFinisher /*: ElementsFinisher */ = this.toClassDescriptor( (0, decorators[i])(obj) /*: ClassObject */ || obj, ); if (elementsAndFinisher.finisher !== undefined) { finishers.push(elementsAndFinisher.finisher); } if (elementsAndFinisher.elements !== undefined) { elements = elementsAndFinisher.elements; for (var j = 0; j < elements.length - 1; j++) { for (var k = j + 1; k < elements.length; k++) { if ( elements[j].key === elements[k].key && elements[j].placement === elements[k].placement ) { throw new TypeError( "Duplicated element (" + elements[j].key + ")", ); } } } } } return { elements: elements, finishers: finishers }; }, // FromElementDescriptor fromElementDescriptor: function( element /*: ElementDescriptor */, ) /*: ElementObject */ { var obj /*: ElementObject */ = { kind: element.kind, key: element.key, placement: element.placement, descriptor: element.descriptor, }; var desc = { value: "Descriptor", configurable: true, }; Object.defineProperty(obj, Symbol.toStringTag, desc); if (element.kind === "field") obj.initializer = element.initializer; return obj; }, // ToElementDescriptors toElementDescriptors: function( elementObjects /*: ElementObject[] */, ) /*: ElementDescriptor[] */ { if (elementObjects === undefined) return; return toArray(elementObjects).map(function(elementObject) { var element = this.toElementDescriptor(elementObject); this.disallowProperty(elementObject, "finisher", "An element descriptor"); this.disallowProperty(elementObject, "extras", "An element descriptor"); return element; }, this); }, // ToElementDescriptor toElementDescriptor: function( elementObject /*: ElementObject */, ) /*: ElementDescriptor */ { var kind = String(elementObject.kind); if (kind !== "method" && kind !== "field") { throw new TypeError( 'An element descriptor\\'s .kind property must be either "method" or' + ' "field", but a decorator created an element descriptor with' + ' .kind "' + kind + '"', ); } var key = toPropertyKey(elementObject.key); var placement = String(elementObject.placement); if ( placement !== "static" && placement !== "prototype" && placement !== "own" ) { throw new TypeError( 'An element descriptor\\'s .placement property must be one of "static",' + ' "prototype" or "own", but a decorator created an element descriptor' + ' with .placement "' + placement + '"', ); } var descriptor /*: PropertyDescriptor */ = elementObject.descriptor; this.disallowProperty(elementObject, "elements", "An element descriptor"); var element /*: ElementDescriptor */ = { kind: kind, key: key, placement: placement, descriptor: Object.assign({}, descriptor), }; if (kind !== "field") { this.disallowProperty(elementObject, "initializer", "A method descriptor"); } else { this.disallowProperty( descriptor, "get", "The property descriptor of a field descriptor", ); this.disallowProperty( descriptor, "set", "The property descriptor of a field descriptor", ); this.disallowProperty( descriptor, "value", "The property descriptor of a field descriptor", ); element.initializer = elementObject.initializer; } return element; }, toElementFinisherExtras: function( elementObject /*: ElementObject */, ) /*: ElementFinisherExtras */ { var element /*: ElementDescriptor */ = this.toElementDescriptor( elementObject, ); var finisher /*: ClassFinisher */ = _optionalCallableProperty( elementObject, "finisher", ); var extras /*: ElementDescriptors[] */ = this.toElementDescriptors( elementObject.extras, ); return { element: element, finisher: finisher, extras: extras }; }, // FromClassDescriptor fromClassDescriptor: function( elements /*: ElementDescriptor[] */, ) /*: ClassObject */ { var obj = { kind: "class", elements: elements.map(this.fromElementDescriptor, this), }; var desc = { value: "Descriptor", configurable: true }; Object.defineProperty(obj, Symbol.toStringTag, desc); return obj; }, // ToClassDescriptor toClassDescriptor: function( obj /*: ClassObject */, ) /*: ElementsFinisher */ { var kind = String(obj.kind); if (kind !== "class") { throw new TypeError( 'A class descriptor\\'s .kind property must be "class", but a decorator' + ' created a class descriptor with .kind "' + kind + '"', ); } this.disallowProperty(obj, "key", "A class descriptor"); this.disallowProperty(obj, "placement", "A class descriptor"); this.disallowProperty(obj, "descriptor", "A class descriptor"); this.disallowProperty(obj, "initializer", "A class descriptor"); this.disallowProperty(obj, "extras", "A class descriptor"); var finisher = _optionalCallableProperty(obj, "finisher"); var elements = this.toElementDescriptors(obj.elements); return { elements: elements, finisher: finisher }; }, // RunClassFinishers runClassFinishers: function( constructor /*: Class<*> */, finishers /*: ClassFinisher[] */, ) /*: Class<*> */ { for (var i = 0; i < finishers.length; i++) { var newConstructor /*: ?Class<*> */ = (0, finishers[i])(constructor); if (newConstructor !== undefined) { // NOTE: This should check if IsConstructor(newConstructor) is false. if (typeof newConstructor !== "function") { throw new TypeError("Finishers must return a constructor."); } constructor = newConstructor; } } return constructor; }, disallowProperty: function(obj, name, objectType) { if (obj[name] !== undefined) { throw new TypeError(objectType + " can't have a ." + name + " property."); } } }; return api; } // ClassElementEvaluation function _createElementDescriptor( def /*: ElementDefinition */, ) /*: ElementDescriptor */ { var key = toPropertyKey(def.key); var descriptor /*: PropertyDescriptor */; if (def.kind === "method") { descriptor = { value: def.value, writable: true, configurable: true, enumerable: false, }; } else if (def.kind === "get") { descriptor = { get: def.value, configurable: true, enumerable: false }; } else if (def.kind === "set") { descriptor = { set: def.value, configurable: true, enumerable: false }; } else if (def.kind === "field") { descriptor = { configurable: true, writable: true, enumerable: true }; } var element /*: ElementDescriptor */ = { kind: def.kind === "field" ? "field" : "method", key: key, placement: def.static ? "static" : def.kind === "field" ? "own" : "prototype", descriptor: descriptor, }; if (def.decorators) element.decorators = def.decorators; if (def.kind === "field") element.initializer = def.value; return element; } // CoalesceGetterSetter function _coalesceGetterSetter( element /*: ElementDescriptor */, other /*: ElementDescriptor */, ) { if (element.descriptor.get !== undefined) { other.descriptor.get = element.descriptor.get; } else { other.descriptor.set = element.descriptor.set; } } // CoalesceClassElements function _coalesceClassElements( elements /*: ElementDescriptor[] */, ) /*: ElementDescriptor[] */ { var newElements /*: ElementDescriptor[] */ = []; var isSameElement = function( other /*: ElementDescriptor */, ) /*: boolean */ { return ( other.kind === "method" && other.key === element.key && other.placement === element.placement ); }; for (var i = 0; i < elements.length; i++) { var element /*: ElementDescriptor */ = elements[i]; var other /*: ElementDescriptor */; if ( element.kind === "method" && (other = newElements.find(isSameElement)) ) { if ( _isDataDescriptor(element.descriptor) || _isDataDescriptor(other.descriptor) ) { if (_hasDecorators(element) || _hasDecorators(other)) { throw new ReferenceError( "Duplicated methods (" + element.key + ") can't be decorated.", ); } other.descriptor = element.descriptor; } else { if (_hasDecorators(element)) { if (_hasDecorators(other)) { throw new ReferenceError( "Decorators can't be placed on different accessors with for " + "the same property (" + element.key + ").", ); } other.decorators = element.decorators; } _coalesceGetterSetter(element, other); } } else { newElements.push(element); } } return newElements; } function _hasDecorators(element /*: ElementDescriptor */) /*: boolean */ { return element.decorators && element.decorators.length; } function _isDataDescriptor(desc /*: PropertyDescriptor */) /*: boolean */ { return ( desc !== undefined && !(desc.value === undefined && desc.writable === undefined) ); } function _optionalCallableProperty /*::*/( obj /*: T */, name /*: $Keys */, ) /*: ?Function */ { var value = obj[name]; if (value !== undefined && typeof value !== "function") { throw new TypeError("Expected '" + name + "' to be a function"); } return value; } `; helpers.classPrivateMethodGet = helper("7.1.6")` export default function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; } `; { helpers.classPrivateMethodSet = helper("7.1.6")` export default function _classPrivateMethodSet() { throw new TypeError("attempted to reassign private method"); } `; } },{"./helpers-generated":262,"@babel/template":281}],264:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.get = get; exports.minVersion = minVersion; exports.getDependencies = getDependencies; exports.ensure = ensure; exports.default = exports.list = void 0; var _traverse = require("@babel/traverse"); var t = require("@babel/types"); var _helpers = require("./helpers"); function makePath(path) { const parts = []; for (; path.parentPath; path = path.parentPath) { parts.push(path.key); if (path.inList) parts.push(path.listKey); } return parts.reverse().join("."); } let fileClass = undefined; function getHelperMetadata(file) { const globals = new Set(); const localBindingNames = new Set(); const dependencies = new Map(); let exportName; let exportPath; const exportBindingAssignments = []; const importPaths = []; const importBindingsReferences = []; const dependencyVisitor = { ImportDeclaration(child) { const name = child.node.source.value; if (!_helpers.default[name]) { throw child.buildCodeFrameError(`Unknown helper ${name}`); } if (child.get("specifiers").length !== 1 || !child.get("specifiers.0").isImportDefaultSpecifier()) { throw child.buildCodeFrameError("Helpers can only import a default value"); } const bindingIdentifier = child.node.specifiers[0].local; dependencies.set(bindingIdentifier, name); importPaths.push(makePath(child)); }, ExportDefaultDeclaration(child) { const decl = child.get("declaration"); if (decl.isFunctionDeclaration()) { if (!decl.node.id) { throw decl.buildCodeFrameError("Helpers should give names to their exported func declaration"); } exportName = decl.node.id.name; } exportPath = makePath(child); }, ExportAllDeclaration(child) { throw child.buildCodeFrameError("Helpers can only export default"); }, ExportNamedDeclaration(child) { throw child.buildCodeFrameError("Helpers can only export default"); }, Statement(child) { if (child.isModuleDeclaration()) return; child.skip(); } }; const referenceVisitor = { Program(path) { const bindings = path.scope.getAllBindings(); Object.keys(bindings).forEach(name => { if (name === exportName) return; if (dependencies.has(bindings[name].identifier)) return; localBindingNames.add(name); }); }, ReferencedIdentifier(child) { const name = child.node.name; const binding = child.scope.getBinding(name, true); if (!binding) { globals.add(name); } else if (dependencies.has(binding.identifier)) { importBindingsReferences.push(makePath(child)); } }, AssignmentExpression(child) { const left = child.get("left"); if (!(exportName in left.getBindingIdentifiers())) return; if (!left.isIdentifier()) { throw left.buildCodeFrameError("Only simple assignments to exports are allowed in helpers"); } const binding = child.scope.getBinding(exportName); if (binding != null && binding.scope.path.isProgram()) { exportBindingAssignments.push(makePath(child)); } } }; (0, _traverse.default)(file.ast, dependencyVisitor, file.scope); (0, _traverse.default)(file.ast, referenceVisitor, file.scope); if (!exportPath) throw new Error("Helpers must default-export something."); exportBindingAssignments.reverse(); return { globals: Array.from(globals), localBindingNames: Array.from(localBindingNames), dependencies, exportBindingAssignments, exportPath, exportName, importBindingsReferences, importPaths }; } function permuteHelperAST(file, metadata, id, localBindings, getDependency) { if (localBindings && !id) { throw new Error("Unexpected local bindings for module-based helpers."); } if (!id) return; const { localBindingNames, dependencies, exportBindingAssignments, exportPath, exportName, importBindingsReferences, importPaths } = metadata; const dependenciesRefs = {}; dependencies.forEach((name, id) => { dependenciesRefs[id.name] = typeof getDependency === "function" && getDependency(name) || id; }); const toRename = {}; const bindings = new Set(localBindings || []); localBindingNames.forEach(name => { let newName = name; while (bindings.has(newName)) newName = "_" + newName; if (newName !== name) toRename[name] = newName; }); if (id.type === "Identifier" && exportName !== id.name) { toRename[exportName] = id.name; } const visitor = { Program(path) { const exp = path.get(exportPath); const imps = importPaths.map(p => path.get(p)); const impsBindingRefs = importBindingsReferences.map(p => path.get(p)); const decl = exp.get("declaration"); if (id.type === "Identifier") { if (decl.isFunctionDeclaration()) { exp.replaceWith(decl); } else { exp.replaceWith(t.variableDeclaration("var", [t.variableDeclarator(id, decl.node)])); } } else if (id.type === "MemberExpression") { if (decl.isFunctionDeclaration()) { exportBindingAssignments.forEach(assignPath => { const assign = path.get(assignPath); assign.replaceWith(t.assignmentExpression("=", id, assign.node)); }); exp.replaceWith(decl); path.pushContainer("body", t.expressionStatement(t.assignmentExpression("=", id, t.identifier(exportName)))); } else { exp.replaceWith(t.expressionStatement(t.assignmentExpression("=", id, decl.node))); } } else { throw new Error("Unexpected helper format."); } Object.keys(toRename).forEach(name => { path.scope.rename(name, toRename[name]); }); for (const path of imps) path.remove(); for (const path of impsBindingRefs) { const node = t.cloneNode(dependenciesRefs[path.node.name]); path.replaceWith(node); } path.stop(); } }; (0, _traverse.default)(file.ast, visitor, file.scope); } const helperData = Object.create(null); function loadHelper(name) { if (!helperData[name]) { const helper = _helpers.default[name]; if (!helper) { throw Object.assign(new ReferenceError(`Unknown helper ${name}`), { code: "BABEL_HELPER_UNKNOWN", helper: name }); } const fn = () => { const file = { ast: t.file(helper.ast()) }; if (fileClass) { return new fileClass({ filename: `babel-helper://${name}` }, file); } return file; }; const metadata = getHelperMetadata(fn()); helperData[name] = { build(getDependency, id, localBindings) { const file = fn(); permuteHelperAST(file, metadata, id, localBindings, getDependency); return { nodes: file.ast.program.body, globals: metadata.globals }; }, minVersion() { return helper.minVersion; }, dependencies: metadata.dependencies }; } return helperData[name]; } function get(name, getDependency, id, localBindings) { return loadHelper(name).build(getDependency, id, localBindings); } function minVersion(name) { return loadHelper(name).minVersion(); } function getDependencies(name) { return Array.from(loadHelper(name).dependencies.values()); } function ensure(name, newFileClass) { if (!fileClass) { fileClass = newFileClass; } loadHelper(name); } const list = Object.keys(_helpers.default).map(name => name.replace(/^_/, "")).filter(name => name !== "__esModule"); exports.list = list; var _default = get; exports.default = _default; },{"./helpers":263,"@babel/traverse":290,"@babel/types":359}],265:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = highlight; exports.getChalk = getChalk; exports.shouldHighlight = shouldHighlight; var _jsTokens = require("js-tokens"); var _helperValidatorIdentifier = require("@babel/helper-validator-identifier"); var _chalk = require("chalk"); const sometimesKeywords = new Set(["as", "async", "from", "get", "of", "set"]); function getDefs(chalk) { return { keyword: chalk.cyan, capitalized: chalk.yellow, jsxIdentifier: chalk.yellow, punctuator: chalk.yellow, number: chalk.magenta, string: chalk.green, regex: chalk.magenta, comment: chalk.grey, invalid: chalk.white.bgRed.bold }; } const NEWLINE = /\r\n|[\n\r\u2028\u2029]/; const BRACKET = /^[()[\]{}]$/; let tokenize; { const JSX_TAG = /^[a-z][\w-]*$/i; const getTokenType = function (token, offset, text) { if (token.type === "name") { if ((0, _helperValidatorIdentifier.isKeyword)(token.value) || (0, _helperValidatorIdentifier.isStrictReservedWord)(token.value, true) || sometimesKeywords.has(token.value)) { return "keyword"; } if (JSX_TAG.test(token.value) && (text[offset - 1] === "<" || text.slice(offset - 2, offset) == " colorize(str)).join("\n"); } else { highlighted += value; } } return highlighted; } function shouldHighlight(options) { return !!_chalk.supportsColor || options.forceColor; } function getChalk(options) { return options.forceColor ? new _chalk.constructor({ enabled: true, level: 1 }) : _chalk; } function highlight(code, options = {}) { if (code !== "" && shouldHighlight(options)) { const chalk = getChalk(options); const defs = getDefs(chalk); return highlightTokens(defs, code); } else { return code; } } },{"@babel/helper-validator-identifier":256,"chalk":423,"js-tokens":452}],266:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, '__esModule', { value: true }); function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } class Position { constructor(line, col, index) { this.line = void 0; this.column = void 0; this.index = void 0; this.line = line; this.column = col; this.index = index; } } class SourceLocation { constructor(start, end) { this.start = void 0; this.end = void 0; this.filename = void 0; this.identifierName = void 0; this.start = start; this.end = end; } } function createPositionWithColumnOffset(position, columnOffset) { const { line, column, index } = position; return new Position(line, column + columnOffset, index + columnOffset); } var ParseErrorCode = { SyntaxError: "BABEL_PARSER_SYNTAX_ERROR", SourceTypeModuleError: "BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED" }; const reflect = (keys, last = keys.length - 1) => ({ get() { return keys.reduce((object, key) => object[key], this); }, set(value) { keys.reduce((item, key, i) => i === last ? item[key] = value : item[key], this); } }); const instantiate = (constructor, properties, descriptors) => Object.keys(descriptors).map(key => [key, descriptors[key]]).filter(([, descriptor]) => !!descriptor).map(([key, descriptor]) => [key, typeof descriptor === "function" ? { value: descriptor, enumerable: false } : typeof descriptor.reflect === "string" ? Object.assign({}, descriptor, reflect(descriptor.reflect.split("."))) : descriptor]).reduce((instance, [key, descriptor]) => Object.defineProperty(instance, key, Object.assign({ configurable: true }, descriptor)), Object.assign(new constructor(), properties)); var ModuleErrors = { ImportMetaOutsideModule: { message: `import.meta may appear only with 'sourceType: "module"'`, code: ParseErrorCode.SourceTypeModuleError }, ImportOutsideModule: { message: `'import' and 'export' may appear only with 'sourceType: "module"'`, code: ParseErrorCode.SourceTypeModuleError } }; const NodeDescriptions = { ArrayPattern: "array destructuring pattern", AssignmentExpression: "assignment expression", AssignmentPattern: "assignment expression", ArrowFunctionExpression: "arrow function expression", ConditionalExpression: "conditional expression", CatchClause: "catch clause", ForOfStatement: "for-of statement", ForInStatement: "for-in statement", ForStatement: "for-loop", FormalParameters: "function parameter list", Identifier: "identifier", ImportSpecifier: "import specifier", ImportDefaultSpecifier: "import default specifier", ImportNamespaceSpecifier: "import namespace specifier", ObjectPattern: "object destructuring pattern", ParenthesizedExpression: "parenthesized expression", RestElement: "rest element", UpdateExpression: { true: "prefix operation", false: "postfix operation" }, VariableDeclarator: "variable declaration", YieldExpression: "yield expression" }; const toNodeDescription = ({ type, prefix }) => type === "UpdateExpression" ? NodeDescriptions.UpdateExpression[String(prefix)] : NodeDescriptions[type]; var StandardErrors = { AccessorIsGenerator: ({ kind }) => `A ${kind}ter cannot be a generator.`, ArgumentsInClass: "'arguments' is only allowed in functions and class methods.", AsyncFunctionInSingleStatementContext: "Async functions can only be declared at the top level or inside a block.", AwaitBindingIdentifier: "Can not use 'await' as identifier inside an async function.", AwaitBindingIdentifierInStaticBlock: "Can not use 'await' as identifier inside a static block.", AwaitExpressionFormalParameter: "'await' is not allowed in async function parameters.", AwaitNotInAsyncContext: "'await' is only allowed within async functions and at the top levels of modules.", AwaitNotInAsyncFunction: "'await' is only allowed within async functions.", BadGetterArity: "A 'get' accesor must not have any formal parameters.", BadSetterArity: "A 'set' accesor must have exactly one formal parameter.", BadSetterRestParameter: "A 'set' accesor function argument must not be a rest parameter.", ConstructorClassField: "Classes may not have a field named 'constructor'.", ConstructorClassPrivateField: "Classes may not have a private field named '#constructor'.", ConstructorIsAccessor: "Class constructor may not be an accessor.", ConstructorIsAsync: "Constructor can't be an async function.", ConstructorIsGenerator: "Constructor can't be a generator.", DeclarationMissingInitializer: ({ kind }) => `Missing initializer in ${kind} declaration.`, DecoratorArgumentsOutsideParentheses: "Decorator arguments must be moved inside parentheses: use '@(decorator(args))' instead of '@(decorator)(args)'.", DecoratorBeforeExport: "Decorators must be placed *before* the 'export' keyword. You can set the 'decoratorsBeforeExport' option to false to use the 'export @decorator class {}' syntax.", DecoratorConstructor: "Decorators can't be used with a constructor. Did you mean '@dec class { ... }'?", DecoratorExportClass: "Using the export keyword between a decorator and a class is not allowed. Please use `export @dec class` instead.", DecoratorSemicolon: "Decorators must not be followed by a semicolon.", DecoratorStaticBlock: "Decorators can't be used with a static block.", DeletePrivateField: "Deleting a private field is not allowed.", DestructureNamedImport: "ES2015 named imports do not destructure. Use another statement for destructuring after the import.", DuplicateConstructor: "Duplicate constructor in the same class.", DuplicateDefaultExport: "Only one default export allowed per module.", DuplicateExport: ({ exportName }) => `\`${exportName}\` has already been exported. Exported identifiers must be unique.`, DuplicateProto: "Redefinition of __proto__ property.", DuplicateRegExpFlags: "Duplicate regular expression flag.", ElementAfterRest: "Rest element must be last element.", EscapedCharNotAnIdentifier: "Invalid Unicode escape.", ExportBindingIsString: ({ localName, exportName }) => `A string literal cannot be used as an exported binding without \`from\`.\n- Did you mean \`export { '${localName}' as '${exportName}' } from 'some-module'\`?`, ExportDefaultFromAsIdentifier: "'from' is not allowed as an identifier after 'export default'.", ForInOfLoopInitializer: ({ type }) => `'${type === "ForInStatement" ? "for-in" : "for-of"}' loop variable declaration may not have an initializer.`, ForOfAsync: "The left-hand side of a for-of loop may not be 'async'.", ForOfLet: "The left-hand side of a for-of loop may not start with 'let'.", GeneratorInSingleStatementContext: "Generators can only be declared at the top level or inside a block.", IllegalBreakContinue: ({ type }) => `Unsyntactic ${type === "BreakStatement" ? "break" : "continue"}.`, IllegalLanguageModeDirective: "Illegal 'use strict' directive in function with non-simple parameter list.", IllegalReturn: "'return' outside of function.", ImportBindingIsString: ({ importName }) => `A string literal cannot be used as an imported binding.\n- Did you mean \`import { "${importName}" as foo }\`?`, ImportCallArgumentTrailingComma: "Trailing comma is disallowed inside import(...) arguments.", ImportCallArity: ({ maxArgumentCount }) => `\`import()\` requires exactly ${maxArgumentCount === 1 ? "one argument" : "one or two arguments"}.`, ImportCallNotNewExpression: "Cannot use new with import(...).", ImportCallSpreadArgument: "`...` is not allowed in `import()`.", ImportJSONBindingNotDefault: "A JSON module can only be imported with `default`.", IncompatibleRegExpUVFlags: "The 'u' and 'v' regular expression flags cannot be enabled at the same time.", InvalidBigIntLiteral: "Invalid BigIntLiteral.", InvalidCodePoint: "Code point out of bounds.", InvalidCoverInitializedName: "Invalid shorthand property initializer.", InvalidDecimal: "Invalid decimal.", InvalidDigit: ({ radix }) => `Expected number in radix ${radix}.`, InvalidEscapeSequence: "Bad character escape sequence.", InvalidEscapeSequenceTemplate: "Invalid escape sequence in template.", InvalidEscapedReservedWord: ({ reservedWord }) => `Escape sequence in keyword ${reservedWord}.`, InvalidIdentifier: ({ identifierName }) => `Invalid identifier ${identifierName}.`, InvalidLhs: ({ ancestor }) => `Invalid left-hand side in ${toNodeDescription(ancestor)}.`, InvalidLhsBinding: ({ ancestor }) => `Binding invalid left-hand side in ${toNodeDescription(ancestor)}.`, InvalidNumber: "Invalid number.", InvalidOrMissingExponent: "Floating-point numbers require a valid exponent after the 'e'.", InvalidOrUnexpectedToken: ({ unexpected }) => `Unexpected character '${unexpected}'.`, InvalidParenthesizedAssignment: "Invalid parenthesized assignment pattern.", InvalidPrivateFieldResolution: ({ identifierName }) => `Private name #${identifierName} is not defined.`, InvalidPropertyBindingPattern: "Binding member expression.", InvalidRecordProperty: "Only properties and spread elements are allowed in record definitions.", InvalidRestAssignmentPattern: "Invalid rest operator's argument.", LabelRedeclaration: ({ labelName }) => `Label '${labelName}' is already declared.`, LetInLexicalBinding: "'let' is not allowed to be used as a name in 'let' or 'const' declarations.", LineTerminatorBeforeArrow: "No line break is allowed before '=>'.", MalformedRegExpFlags: "Invalid regular expression flag.", MissingClassName: "A class name is required.", MissingEqInAssignment: "Only '=' operator can be used for specifying default value.", MissingSemicolon: "Missing semicolon.", MissingPlugin: ({ missingPlugin }) => `This experimental syntax requires enabling the parser plugin: ${missingPlugin.map(name => JSON.stringify(name)).join(", ")}.`, MissingOneOfPlugins: ({ missingPlugin }) => `This experimental syntax requires enabling one of the following parser plugin(s): ${missingPlugin.map(name => JSON.stringify(name)).join(", ")}.`, MissingUnicodeEscape: "Expecting Unicode escape sequence \\uXXXX.", MixingCoalesceWithLogical: "Nullish coalescing operator(??) requires parens when mixing with logical operators.", ModuleAttributeDifferentFromType: "The only accepted module attribute is `type`.", ModuleAttributeInvalidValue: "Only string literals are allowed as module attribute values.", ModuleAttributesWithDuplicateKeys: ({ key }) => `Duplicate key "${key}" is not allowed in module attributes.`, ModuleExportNameHasLoneSurrogate: ({ surrogateCharCode }) => `An export name cannot include a lone surrogate, found '\\u${surrogateCharCode.toString(16)}'.`, ModuleExportUndefined: ({ localName }) => `Export '${localName}' is not defined.`, MultipleDefaultsInSwitch: "Multiple default clauses.", NewlineAfterThrow: "Illegal newline after throw.", NoCatchOrFinally: "Missing catch or finally clause.", NumberIdentifier: "Identifier directly after number.", NumericSeparatorInEscapeSequence: "Numeric separators are not allowed inside unicode escape sequences or hex escape sequences.", ObsoleteAwaitStar: "'await*' has been removed from the async functions proposal. Use Promise.all() instead.", OptionalChainingNoNew: "Constructors in/after an Optional Chain are not allowed.", OptionalChainingNoTemplate: "Tagged Template Literals are not allowed in optionalChain.", OverrideOnConstructor: "'override' modifier cannot appear on a constructor declaration.", ParamDupe: "Argument name clash.", PatternHasAccessor: "Object pattern can't contain getter or setter.", PatternHasMethod: "Object pattern can't contain methods.", PrivateInExpectedIn: ({ identifierName }) => `Private names are only allowed in property accesses (\`obj.#${identifierName}\`) or in \`in\` expressions (\`#${identifierName} in obj\`).`, PrivateNameRedeclaration: ({ identifierName }) => `Duplicate private name #${identifierName}.`, RecordExpressionBarIncorrectEndSyntaxType: "Record expressions ending with '|}' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.", RecordExpressionBarIncorrectStartSyntaxType: "Record expressions starting with '{|' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.", RecordExpressionHashIncorrectStartSyntaxType: "Record expressions starting with '#{' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'hash'.", RecordNoProto: "'__proto__' is not allowed in Record expressions.", RestTrailingComma: "Unexpected trailing comma after rest element.", SloppyFunction: "In non-strict mode code, functions can only be declared at top level, inside a block, or as the body of an if statement.", StaticPrototype: "Classes may not have static property named prototype.", SuperNotAllowed: "`super()` is only valid inside a class constructor of a subclass. Maybe a typo in the method name ('constructor') or not extending another class?", SuperPrivateField: "Private fields can't be accessed on super.", TrailingDecorator: "Decorators must be attached to a class element.", TupleExpressionBarIncorrectEndSyntaxType: "Tuple expressions ending with '|]' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.", TupleExpressionBarIncorrectStartSyntaxType: "Tuple expressions starting with '[|' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.", TupleExpressionHashIncorrectStartSyntaxType: "Tuple expressions starting with '#[' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'hash'.", UnexpectedArgumentPlaceholder: "Unexpected argument placeholder.", UnexpectedAwaitAfterPipelineBody: 'Unexpected "await" after pipeline body; await must have parentheses in minimal proposal.', UnexpectedDigitAfterHash: "Unexpected digit after hash token.", UnexpectedImportExport: "'import' and 'export' may only appear at the top level.", UnexpectedKeyword: ({ keyword }) => `Unexpected keyword '${keyword}'.`, UnexpectedLeadingDecorator: "Leading decorators must be attached to a class declaration.", UnexpectedLexicalDeclaration: "Lexical declaration cannot appear in a single-statement context.", UnexpectedNewTarget: "`new.target` can only be used in functions or class properties.", UnexpectedNumericSeparator: "A numeric separator is only allowed between two digits.", UnexpectedPrivateField: "Unexpected private name.", UnexpectedReservedWord: ({ reservedWord }) => `Unexpected reserved word '${reservedWord}'.`, UnexpectedSuper: "'super' is only allowed in object methods and classes.", UnexpectedToken: ({ expected, unexpected }) => `Unexpected token${unexpected ? ` '${unexpected}'.` : ""}${expected ? `, expected "${expected}"` : ""}`, UnexpectedTokenUnaryExponentiation: "Illegal expression. Wrap left hand side or entire exponentiation in parentheses.", UnsupportedBind: "Binding should be performed on object property.", UnsupportedDecoratorExport: "A decorated export must export a class declaration.", UnsupportedDefaultExport: "Only expressions, functions or classes are allowed as the `default` export.", UnsupportedImport: "`import` can only be used in `import()` or `import.meta`.", UnsupportedMetaProperty: ({ target, onlyValidPropertyName }) => `The only valid meta property for ${target} is ${target}.${onlyValidPropertyName}.`, UnsupportedParameterDecorator: "Decorators cannot be used to decorate parameters.", UnsupportedPropertyDecorator: "Decorators cannot be used to decorate object literal properties.", UnsupportedSuper: "'super' can only be used with function calls (i.e. super()) or in property accesses (i.e. super.prop or super[prop]).", UnterminatedComment: "Unterminated comment.", UnterminatedRegExp: "Unterminated regular expression.", UnterminatedString: "Unterminated string constant.", UnterminatedTemplate: "Unterminated template.", VarRedeclaration: ({ identifierName }) => `Identifier '${identifierName}' has already been declared.`, YieldBindingIdentifier: "Can not use 'yield' as identifier inside a generator.", YieldInParameter: "Yield expression is not allowed in formal parameters.", ZeroDigitNumericSeparator: "Numeric separator can not be used after leading 0." }; var StrictModeErrors = { StrictDelete: "Deleting local variable in strict mode.", StrictEvalArguments: ({ referenceName }) => `Assigning to '${referenceName}' in strict mode.`, StrictEvalArgumentsBinding: ({ bindingName }) => `Binding '${bindingName}' in strict mode.`, StrictFunction: "In strict mode code, functions can only be declared at top level or inside a block.", StrictNumericEscape: "The only valid numeric escape in strict mode is '\\0'.", StrictOctalLiteral: "Legacy octal literals are not allowed in strict mode.", StrictWith: "'with' in strict mode." }; const UnparenthesizedPipeBodyDescriptions = new Set(["ArrowFunctionExpression", "AssignmentExpression", "ConditionalExpression", "YieldExpression"]); var PipelineOperatorErrors = { PipeBodyIsTighter: "Unexpected yield after pipeline body; any yield expression acting as Hack-style pipe body must be parenthesized due to its loose operator precedence.", PipeTopicRequiresHackPipes: 'Topic reference is used, but the pipelineOperator plugin was not passed a "proposal": "hack" or "smart" option.', PipeTopicUnbound: "Topic reference is unbound; it must be inside a pipe body.", PipeTopicUnconfiguredToken: ({ token }) => `Invalid topic token ${token}. In order to use ${token} as a topic reference, the pipelineOperator plugin must be configured with { "proposal": "hack", "topicToken": "${token}" }.`, PipeTopicUnused: "Hack-style pipe body does not contain a topic reference; Hack-style pipes must use topic at least once.", PipeUnparenthesizedBody: ({ type }) => `Hack-style pipe body cannot be an unparenthesized ${toNodeDescription({ type })}; please wrap it in parentheses.`, PipelineBodyNoArrow: 'Unexpected arrow "=>" after pipeline body; arrow function in pipeline body must be parenthesized.', PipelineBodySequenceExpression: "Pipeline body may not be a comma-separated sequence expression.", PipelineHeadSequenceExpression: "Pipeline head should not be a comma-separated sequence expression.", PipelineTopicUnused: "Pipeline is in topic style but does not use topic reference.", PrimaryTopicNotAllowed: "Topic reference was used in a lexical context without topic binding.", PrimaryTopicRequiresSmartPipeline: 'Topic reference is used, but the pipelineOperator plugin was not passed a "proposal": "hack" or "smart" option.' }; const _excluded$1 = ["toMessage"], _excluded2$1 = ["message"]; function toParseErrorConstructor(_ref) { let { toMessage } = _ref, properties = _objectWithoutPropertiesLoose(_ref, _excluded$1); return function constructor({ loc, details }) { return instantiate(SyntaxError, Object.assign({}, properties, { loc }), { clone(overrides = {}) { const loc = overrides.loc || {}; return constructor({ loc: new Position("line" in loc ? loc.line : this.loc.line, "column" in loc ? loc.column : this.loc.column, "index" in loc ? loc.index : this.loc.index), details: Object.assign({}, this.details, overrides.details) }); }, details: { value: details, enumerable: false }, message: { get() { return `${toMessage(this.details)} (${this.loc.line}:${this.loc.column})`; }, set(value) { Object.defineProperty(this, "message", { value }); } }, pos: { reflect: "loc.index", enumerable: true }, missingPlugin: "missingPlugin" in details && { reflect: "details.missingPlugin", enumerable: true } }); }; } function ParseErrorEnum(argument, syntaxPlugin) { if (Array.isArray(argument)) { return parseErrorTemplates => ParseErrorEnum(parseErrorTemplates, argument[0]); } const ParseErrorConstructors = {}; for (const reasonCode of Object.keys(argument)) { const template = argument[reasonCode]; const _ref2 = typeof template === "string" ? { message: () => template } : typeof template === "function" ? { message: template } : template, { message } = _ref2, rest = _objectWithoutPropertiesLoose(_ref2, _excluded2$1); const toMessage = typeof message === "string" ? () => message : message; ParseErrorConstructors[reasonCode] = toParseErrorConstructor(Object.assign({ code: ParseErrorCode.SyntaxError, reasonCode, toMessage }, syntaxPlugin ? { syntaxPlugin } : {}, rest)); } return ParseErrorConstructors; } const Errors = Object.assign({}, ParseErrorEnum(ModuleErrors), ParseErrorEnum(StandardErrors), ParseErrorEnum(StrictModeErrors), ParseErrorEnum`pipelineOperator`(PipelineOperatorErrors)); const { defineProperty } = Object; const toUnenumerable = (object, key) => defineProperty(object, key, { enumerable: false, value: object[key] }); function toESTreeLocation(node) { node.loc.start && toUnenumerable(node.loc.start, "index"); node.loc.end && toUnenumerable(node.loc.end, "index"); return node; } var estree = (superClass => class ESTreeParserMixin extends superClass { parse() { const file = toESTreeLocation(super.parse()); if (this.options.tokens) { file.tokens = file.tokens.map(toESTreeLocation); } return file; } parseRegExpLiteral({ pattern, flags }) { let regex = null; try { regex = new RegExp(pattern, flags); } catch (e) {} const node = this.estreeParseLiteral(regex); node.regex = { pattern, flags }; return node; } parseBigIntLiteral(value) { let bigInt; try { bigInt = BigInt(value); } catch (_unused) { bigInt = null; } const node = this.estreeParseLiteral(bigInt); node.bigint = String(node.value || value); return node; } parseDecimalLiteral(value) { const decimal = null; const node = this.estreeParseLiteral(decimal); node.decimal = String(node.value || value); return node; } estreeParseLiteral(value) { return this.parseLiteral(value, "Literal"); } parseStringLiteral(value) { return this.estreeParseLiteral(value); } parseNumericLiteral(value) { return this.estreeParseLiteral(value); } parseNullLiteral() { return this.estreeParseLiteral(null); } parseBooleanLiteral(value) { return this.estreeParseLiteral(value); } directiveToStmt(directive) { const expression = directive.value; delete directive.value; expression.type = "Literal"; expression.raw = expression.extra.raw; expression.value = expression.extra.expressionValue; const stmt = directive; stmt.type = "ExpressionStatement"; stmt.expression = expression; stmt.directive = expression.extra.rawValue; delete expression.extra; return stmt; } initFunction(node, isAsync) { super.initFunction(node, isAsync); node.expression = false; } checkDeclaration(node) { if (node != null && this.isObjectProperty(node)) { this.checkDeclaration(node.value); } else { super.checkDeclaration(node); } } getObjectOrClassMethodParams(method) { return method.value.params; } isValidDirective(stmt) { var _stmt$expression$extr; return stmt.type === "ExpressionStatement" && stmt.expression.type === "Literal" && typeof stmt.expression.value === "string" && !((_stmt$expression$extr = stmt.expression.extra) != null && _stmt$expression$extr.parenthesized); } parseBlockBody(node, allowDirectives, topLevel, end, afterBlockParse) { super.parseBlockBody(node, allowDirectives, topLevel, end, afterBlockParse); const directiveStatements = node.directives.map(d => this.directiveToStmt(d)); node.body = directiveStatements.concat(node.body); delete node.directives; } pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) { this.parseMethod(method, isGenerator, isAsync, isConstructor, allowsDirectSuper, "ClassMethod", true); if (method.typeParameters) { method.value.typeParameters = method.typeParameters; delete method.typeParameters; } classBody.body.push(method); } parsePrivateName() { const node = super.parsePrivateName(); { if (!this.getPluginOption("estree", "classFeatures")) { return node; } } return this.convertPrivateNameToPrivateIdentifier(node); } convertPrivateNameToPrivateIdentifier(node) { const name = super.getPrivateNameSV(node); node = node; delete node.id; node.name = name; node.type = "PrivateIdentifier"; return node; } isPrivateName(node) { { if (!this.getPluginOption("estree", "classFeatures")) { return super.isPrivateName(node); } } return node.type === "PrivateIdentifier"; } getPrivateNameSV(node) { { if (!this.getPluginOption("estree", "classFeatures")) { return super.getPrivateNameSV(node); } } return node.name; } parseLiteral(value, type) { const node = super.parseLiteral(value, type); node.raw = node.extra.raw; delete node.extra; return node; } parseFunctionBody(node, allowExpression, isMethod = false) { super.parseFunctionBody(node, allowExpression, isMethod); node.expression = node.body.type !== "BlockStatement"; } parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope = false) { let funcNode = this.startNode(); funcNode.kind = node.kind; funcNode = super.parseMethod(funcNode, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope); funcNode.type = "FunctionExpression"; delete funcNode.kind; node.value = funcNode; if (type === "ClassPrivateMethod") { node.computed = false; } return this.finishNode(node, "MethodDefinition"); } parseClassProperty(...args) { const propertyNode = super.parseClassProperty(...args); { if (!this.getPluginOption("estree", "classFeatures")) { return propertyNode; } } propertyNode.type = "PropertyDefinition"; return propertyNode; } parseClassPrivateProperty(...args) { const propertyNode = super.parseClassPrivateProperty(...args); { if (!this.getPluginOption("estree", "classFeatures")) { return propertyNode; } } propertyNode.type = "PropertyDefinition"; propertyNode.computed = false; return propertyNode; } parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor) { const node = super.parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor); if (node) { node.type = "Property"; if (node.kind === "method") { node.kind = "init"; } node.shorthand = false; } return node; } parseObjectProperty(prop, startPos, startLoc, isPattern, refExpressionErrors) { const node = super.parseObjectProperty(prop, startPos, startLoc, isPattern, refExpressionErrors); if (node) { node.kind = "init"; node.type = "Property"; } return node; } isValidLVal(type, isUnparenthesizedInAssign, binding) { return type === "Property" ? "value" : super.isValidLVal(type, isUnparenthesizedInAssign, binding); } isAssignable(node, isBinding) { if (node != null && this.isObjectProperty(node)) { return this.isAssignable(node.value, isBinding); } return super.isAssignable(node, isBinding); } toAssignable(node, isLHS = false) { if (node != null && this.isObjectProperty(node)) { const { key, value } = node; if (this.isPrivateName(key)) { this.classScope.usePrivateName(this.getPrivateNameSV(key), key.loc.start); } this.toAssignable(value, isLHS); } else { super.toAssignable(node, isLHS); } } toAssignableObjectExpressionProp(prop, isLast, isLHS) { if (prop.kind === "get" || prop.kind === "set") { this.raise(Errors.PatternHasAccessor, { at: prop.key }); } else if (prop.method) { this.raise(Errors.PatternHasMethod, { at: prop.key }); } else { super.toAssignableObjectExpressionProp(prop, isLast, isLHS); } } finishCallExpression(unfinished, optional) { const node = super.finishCallExpression(unfinished, optional); if (node.callee.type === "Import") { node.type = "ImportExpression"; node.source = node.arguments[0]; if (this.hasPlugin("importAssertions")) { var _node$arguments$; node.attributes = (_node$arguments$ = node.arguments[1]) != null ? _node$arguments$ : null; } delete node.arguments; delete node.callee; } return node; } toReferencedArguments(node) { if (node.type === "ImportExpression") { return; } super.toReferencedArguments(node); } parseExport(unfinished) { const node = super.parseExport(unfinished); switch (node.type) { case "ExportAllDeclaration": node.exported = null; break; case "ExportNamedDeclaration": if (node.specifiers.length === 1 && node.specifiers[0].type === "ExportNamespaceSpecifier") { node.type = "ExportAllDeclaration"; node.exported = node.specifiers[0].exported; delete node.specifiers; } break; } return node; } parseSubscript(base, startPos, startLoc, noCalls, state) { const node = super.parseSubscript(base, startPos, startLoc, noCalls, state); if (state.optionalChainMember) { if (node.type === "OptionalMemberExpression" || node.type === "OptionalCallExpression") { node.type = node.type.substring(8); } if (state.stop) { const chain = this.startNodeAtNode(node); chain.expression = node; return this.finishNode(chain, "ChainExpression"); } } else if (node.type === "MemberExpression" || node.type === "CallExpression") { node.optional = false; } return node; } hasPropertyAsPrivateName(node) { if (node.type === "ChainExpression") { node = node.expression; } return super.hasPropertyAsPrivateName(node); } isOptionalChain(node) { return node.type === "ChainExpression"; } isObjectProperty(node) { return node.type === "Property" && node.kind === "init" && !node.method; } isObjectMethod(node) { return node.method || node.kind === "get" || node.kind === "set"; } finishNodeAt(node, type, endLoc) { return toESTreeLocation(super.finishNodeAt(node, type, endLoc)); } resetStartLocation(node, start, startLoc) { super.resetStartLocation(node, start, startLoc); toESTreeLocation(node); } resetEndLocation(node, endLoc = this.state.lastTokEndLoc) { super.resetEndLocation(node, endLoc); toESTreeLocation(node); } }); class TokContext { constructor(token, preserveSpace) { this.token = void 0; this.preserveSpace = void 0; this.token = token; this.preserveSpace = !!preserveSpace; } } const types = { brace: new TokContext("{"), j_oTag: new TokContext("...", true) }; { types.template = new TokContext("`", true); } const beforeExpr = true; const startsExpr = true; const isLoop = true; const isAssign = true; const prefix = true; const postfix = true; class ExportedTokenType { constructor(label, conf = {}) { this.label = void 0; this.keyword = void 0; this.beforeExpr = void 0; this.startsExpr = void 0; this.rightAssociative = void 0; this.isLoop = void 0; this.isAssign = void 0; this.prefix = void 0; this.postfix = void 0; this.binop = void 0; this.label = label; this.keyword = conf.keyword; this.beforeExpr = !!conf.beforeExpr; this.startsExpr = !!conf.startsExpr; this.rightAssociative = !!conf.rightAssociative; this.isLoop = !!conf.isLoop; this.isAssign = !!conf.isAssign; this.prefix = !!conf.prefix; this.postfix = !!conf.postfix; this.binop = conf.binop != null ? conf.binop : null; { this.updateContext = null; } } } const keywords$1 = new Map(); function createKeyword(name, options = {}) { options.keyword = name; const token = createToken(name, options); keywords$1.set(name, token); return token; } function createBinop(name, binop) { return createToken(name, { beforeExpr, binop }); } let tokenTypeCounter = -1; const tokenTypes = []; const tokenLabels = []; const tokenBinops = []; const tokenBeforeExprs = []; const tokenStartsExprs = []; const tokenPrefixes = []; function createToken(name, options = {}) { var _options$binop, _options$beforeExpr, _options$startsExpr, _options$prefix; ++tokenTypeCounter; tokenLabels.push(name); tokenBinops.push((_options$binop = options.binop) != null ? _options$binop : -1); tokenBeforeExprs.push((_options$beforeExpr = options.beforeExpr) != null ? _options$beforeExpr : false); tokenStartsExprs.push((_options$startsExpr = options.startsExpr) != null ? _options$startsExpr : false); tokenPrefixes.push((_options$prefix = options.prefix) != null ? _options$prefix : false); tokenTypes.push(new ExportedTokenType(name, options)); return tokenTypeCounter; } function createKeywordLike(name, options = {}) { var _options$binop2, _options$beforeExpr2, _options$startsExpr2, _options$prefix2; ++tokenTypeCounter; keywords$1.set(name, tokenTypeCounter); tokenLabels.push(name); tokenBinops.push((_options$binop2 = options.binop) != null ? _options$binop2 : -1); tokenBeforeExprs.push((_options$beforeExpr2 = options.beforeExpr) != null ? _options$beforeExpr2 : false); tokenStartsExprs.push((_options$startsExpr2 = options.startsExpr) != null ? _options$startsExpr2 : false); tokenPrefixes.push((_options$prefix2 = options.prefix) != null ? _options$prefix2 : false); tokenTypes.push(new ExportedTokenType("name", options)); return tokenTypeCounter; } const tt = { bracketL: createToken("[", { beforeExpr, startsExpr }), bracketHashL: createToken("#[", { beforeExpr, startsExpr }), bracketBarL: createToken("[|", { beforeExpr, startsExpr }), bracketR: createToken("]"), bracketBarR: createToken("|]"), braceL: createToken("{", { beforeExpr, startsExpr }), braceBarL: createToken("{|", { beforeExpr, startsExpr }), braceHashL: createToken("#{", { beforeExpr, startsExpr }), braceR: createToken("}"), braceBarR: createToken("|}"), parenL: createToken("(", { beforeExpr, startsExpr }), parenR: createToken(")"), comma: createToken(",", { beforeExpr }), semi: createToken(";", { beforeExpr }), colon: createToken(":", { beforeExpr }), doubleColon: createToken("::", { beforeExpr }), dot: createToken("."), question: createToken("?", { beforeExpr }), questionDot: createToken("?."), arrow: createToken("=>", { beforeExpr }), template: createToken("template"), ellipsis: createToken("...", { beforeExpr }), backQuote: createToken("`", { startsExpr }), dollarBraceL: createToken("${", { beforeExpr, startsExpr }), templateTail: createToken("...`", { startsExpr }), templateNonTail: createToken("...${", { beforeExpr, startsExpr }), at: createToken("@"), hash: createToken("#", { startsExpr }), interpreterDirective: createToken("#!..."), eq: createToken("=", { beforeExpr, isAssign }), assign: createToken("_=", { beforeExpr, isAssign }), slashAssign: createToken("_=", { beforeExpr, isAssign }), xorAssign: createToken("_=", { beforeExpr, isAssign }), moduloAssign: createToken("_=", { beforeExpr, isAssign }), incDec: createToken("++/--", { prefix, postfix, startsExpr }), bang: createToken("!", { beforeExpr, prefix, startsExpr }), tilde: createToken("~", { beforeExpr, prefix, startsExpr }), doubleCaret: createToken("^^", { startsExpr }), doubleAt: createToken("@@", { startsExpr }), pipeline: createBinop("|>", 0), nullishCoalescing: createBinop("??", 1), logicalOR: createBinop("||", 1), logicalAND: createBinop("&&", 2), bitwiseOR: createBinop("|", 3), bitwiseXOR: createBinop("^", 4), bitwiseAND: createBinop("&", 5), equality: createBinop("==/!=/===/!==", 6), lt: createBinop("/<=/>=", 7), gt: createBinop("/<=/>=", 7), relational: createBinop("/<=/>=", 7), bitShift: createBinop("<>/>>>", 8), bitShiftL: createBinop("<>/>>>", 8), bitShiftR: createBinop("<>/>>>", 8), plusMin: createToken("+/-", { beforeExpr, binop: 9, prefix, startsExpr }), modulo: createToken("%", { binop: 10, startsExpr }), star: createToken("*", { binop: 10 }), slash: createBinop("/", 10), exponent: createToken("**", { beforeExpr, binop: 11, rightAssociative: true }), _in: createKeyword("in", { beforeExpr, binop: 7 }), _instanceof: createKeyword("instanceof", { beforeExpr, binop: 7 }), _break: createKeyword("break"), _case: createKeyword("case", { beforeExpr }), _catch: createKeyword("catch"), _continue: createKeyword("continue"), _debugger: createKeyword("debugger"), _default: createKeyword("default", { beforeExpr }), _else: createKeyword("else", { beforeExpr }), _finally: createKeyword("finally"), _function: createKeyword("function", { startsExpr }), _if: createKeyword("if"), _return: createKeyword("return", { beforeExpr }), _switch: createKeyword("switch"), _throw: createKeyword("throw", { beforeExpr, prefix, startsExpr }), _try: createKeyword("try"), _var: createKeyword("var"), _const: createKeyword("const"), _with: createKeyword("with"), _new: createKeyword("new", { beforeExpr, startsExpr }), _this: createKeyword("this", { startsExpr }), _super: createKeyword("super", { startsExpr }), _class: createKeyword("class", { startsExpr }), _extends: createKeyword("extends", { beforeExpr }), _export: createKeyword("export"), _import: createKeyword("import", { startsExpr }), _null: createKeyword("null", { startsExpr }), _true: createKeyword("true", { startsExpr }), _false: createKeyword("false", { startsExpr }), _typeof: createKeyword("typeof", { beforeExpr, prefix, startsExpr }), _void: createKeyword("void", { beforeExpr, prefix, startsExpr }), _delete: createKeyword("delete", { beforeExpr, prefix, startsExpr }), _do: createKeyword("do", { isLoop, beforeExpr }), _for: createKeyword("for", { isLoop }), _while: createKeyword("while", { isLoop }), _as: createKeywordLike("as", { startsExpr }), _assert: createKeywordLike("assert", { startsExpr }), _async: createKeywordLike("async", { startsExpr }), _await: createKeywordLike("await", { startsExpr }), _from: createKeywordLike("from", { startsExpr }), _get: createKeywordLike("get", { startsExpr }), _let: createKeywordLike("let", { startsExpr }), _meta: createKeywordLike("meta", { startsExpr }), _of: createKeywordLike("of", { startsExpr }), _sent: createKeywordLike("sent", { startsExpr }), _set: createKeywordLike("set", { startsExpr }), _static: createKeywordLike("static", { startsExpr }), _yield: createKeywordLike("yield", { startsExpr }), _asserts: createKeywordLike("asserts", { startsExpr }), _checks: createKeywordLike("checks", { startsExpr }), _exports: createKeywordLike("exports", { startsExpr }), _global: createKeywordLike("global", { startsExpr }), _implements: createKeywordLike("implements", { startsExpr }), _intrinsic: createKeywordLike("intrinsic", { startsExpr }), _infer: createKeywordLike("infer", { startsExpr }), _is: createKeywordLike("is", { startsExpr }), _mixins: createKeywordLike("mixins", { startsExpr }), _proto: createKeywordLike("proto", { startsExpr }), _require: createKeywordLike("require", { startsExpr }), _keyof: createKeywordLike("keyof", { startsExpr }), _readonly: createKeywordLike("readonly", { startsExpr }), _unique: createKeywordLike("unique", { startsExpr }), _abstract: createKeywordLike("abstract", { startsExpr }), _declare: createKeywordLike("declare", { startsExpr }), _enum: createKeywordLike("enum", { startsExpr }), _module: createKeywordLike("module", { startsExpr }), _namespace: createKeywordLike("namespace", { startsExpr }), _interface: createKeywordLike("interface", { startsExpr }), _type: createKeywordLike("type", { startsExpr }), _opaque: createKeywordLike("opaque", { startsExpr }), name: createToken("name", { startsExpr }), string: createToken("string", { startsExpr }), num: createToken("num", { startsExpr }), bigint: createToken("bigint", { startsExpr }), decimal: createToken("decimal", { startsExpr }), regexp: createToken("regexp", { startsExpr }), privateName: createToken("#name", { startsExpr }), eof: createToken("eof"), jsxName: createToken("jsxName"), jsxText: createToken("jsxText", { beforeExpr: true }), jsxTagStart: createToken("jsxTagStart", { startsExpr: true }), jsxTagEnd: createToken("jsxTagEnd"), placeholder: createToken("%%", { startsExpr: true }) }; function tokenIsIdentifier(token) { return token >= 93 && token <= 128; } function tokenKeywordOrIdentifierIsKeyword(token) { return token <= 92; } function tokenIsKeywordOrIdentifier(token) { return token >= 58 && token <= 128; } function tokenIsLiteralPropertyName(token) { return token >= 58 && token <= 132; } function tokenComesBeforeExpression(token) { return tokenBeforeExprs[token]; } function tokenCanStartExpression(token) { return tokenStartsExprs[token]; } function tokenIsAssignment(token) { return token >= 29 && token <= 33; } function tokenIsFlowInterfaceOrTypeOrOpaque(token) { return token >= 125 && token <= 127; } function tokenIsLoop(token) { return token >= 90 && token <= 92; } function tokenIsKeyword(token) { return token >= 58 && token <= 92; } function tokenIsOperator(token) { return token >= 39 && token <= 59; } function tokenIsPostfix(token) { return token === 34; } function tokenIsPrefix(token) { return tokenPrefixes[token]; } function tokenIsTSTypeOperator(token) { return token >= 117 && token <= 119; } function tokenIsTSDeclarationStart(token) { return token >= 120 && token <= 126; } function tokenLabelName(token) { return tokenLabels[token]; } function tokenOperatorPrecedence(token) { return tokenBinops[token]; } function tokenIsRightAssociative(token) { return token === 57; } function tokenIsTemplate(token) { return token >= 24 && token <= 25; } function getExportedToken(token) { return tokenTypes[token]; } { tokenTypes[8].updateContext = context => { context.pop(); }; tokenTypes[5].updateContext = tokenTypes[7].updateContext = tokenTypes[23].updateContext = context => { context.push(types.brace); }; tokenTypes[22].updateContext = context => { if (context[context.length - 1] === types.template) { context.pop(); } else { context.push(types.template); } }; tokenTypes[138].updateContext = context => { context.push(types.j_expr, types.j_oTag); }; } let nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u05d0-\u05ea\u05ef-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u0860-\u086a\u0870-\u0887\u0889-\u088e\u08a0-\u08c9\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u09fc\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0af9\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c5d\u0c60\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cdd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d04-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u1711\u171f-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1878\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4c\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5\u1cf6\u1cfa\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u3400-\u4dbf\u4e00-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7ca\ua7d0\ua7d1\ua7d3\ua7d5-\ua7d9\ua7f2-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\ua8fe\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab69\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc"; let nonASCIIidentifierChars = "\u200c\u200d\xb7\u0300-\u036f\u0387\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u0898-\u089f\u08ca-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u09fe\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0afa-\u0aff\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c00-\u0c04\u0c3c\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0cf3\u0d00-\u0d03\u0d3b\u0d3c\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d81-\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ece\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1369-\u1371\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u180f-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19d0-\u19da\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1ab0-\u1abd\u1abf-\u1ace\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1dc0-\u1dff\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\ua620-\ua629\ua66f\ua674-\ua67d\ua69e\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua82c\ua880\ua881\ua8b4-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f1\ua8ff-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\ua9e5\ua9f0-\ua9f9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f"; const nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]"); const nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]"); nonASCIIidentifierStartChars = nonASCIIidentifierChars = null; const astralIdentifierStartCodes = [0, 11, 2, 25, 2, 18, 2, 1, 2, 14, 3, 13, 35, 122, 70, 52, 268, 28, 4, 48, 48, 31, 14, 29, 6, 37, 11, 29, 3, 35, 5, 7, 2, 4, 43, 157, 19, 35, 5, 35, 5, 39, 9, 51, 13, 10, 2, 14, 2, 6, 2, 1, 2, 10, 2, 14, 2, 6, 2, 1, 68, 310, 10, 21, 11, 7, 25, 5, 2, 41, 2, 8, 70, 5, 3, 0, 2, 43, 2, 1, 4, 0, 3, 22, 11, 22, 10, 30, 66, 18, 2, 1, 11, 21, 11, 25, 71, 55, 7, 1, 65, 0, 16, 3, 2, 2, 2, 28, 43, 28, 4, 28, 36, 7, 2, 27, 28, 53, 11, 21, 11, 18, 14, 17, 111, 72, 56, 50, 14, 50, 14, 35, 349, 41, 7, 1, 79, 28, 11, 0, 9, 21, 43, 17, 47, 20, 28, 22, 13, 52, 58, 1, 3, 0, 14, 44, 33, 24, 27, 35, 30, 0, 3, 0, 9, 34, 4, 0, 13, 47, 15, 3, 22, 0, 2, 0, 36, 17, 2, 24, 20, 1, 64, 6, 2, 0, 2, 3, 2, 14, 2, 9, 8, 46, 39, 7, 3, 1, 3, 21, 2, 6, 2, 1, 2, 4, 4, 0, 19, 0, 13, 4, 159, 52, 19, 3, 21, 2, 31, 47, 21, 1, 2, 0, 185, 46, 42, 3, 37, 47, 21, 0, 60, 42, 14, 0, 72, 26, 38, 6, 186, 43, 117, 63, 32, 7, 3, 0, 3, 7, 2, 1, 2, 23, 16, 0, 2, 0, 95, 7, 3, 38, 17, 0, 2, 0, 29, 0, 11, 39, 8, 0, 22, 0, 12, 45, 20, 0, 19, 72, 264, 8, 2, 36, 18, 0, 50, 29, 113, 6, 2, 1, 2, 37, 22, 0, 26, 5, 2, 1, 2, 31, 15, 0, 328, 18, 16, 0, 2, 12, 2, 33, 125, 0, 80, 921, 103, 110, 18, 195, 2637, 96, 16, 1071, 18, 5, 4026, 582, 8634, 568, 8, 30, 18, 78, 18, 29, 19, 47, 17, 3, 32, 20, 6, 18, 689, 63, 129, 74, 6, 0, 67, 12, 65, 1, 2, 0, 29, 6135, 9, 1237, 43, 8, 8936, 3, 2, 6, 2, 1, 2, 290, 16, 0, 30, 2, 3, 0, 15, 3, 9, 395, 2309, 106, 6, 12, 4, 8, 8, 9, 5991, 84, 2, 70, 2, 1, 3, 0, 3, 1, 3, 3, 2, 11, 2, 0, 2, 6, 2, 64, 2, 3, 3, 7, 2, 6, 2, 27, 2, 3, 2, 4, 2, 0, 4, 6, 2, 339, 3, 24, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 7, 1845, 30, 7, 5, 262, 61, 147, 44, 11, 6, 17, 0, 322, 29, 19, 43, 485, 27, 757, 6, 2, 3, 2, 1, 2, 14, 2, 196, 60, 67, 8, 0, 1205, 3, 2, 26, 2, 1, 2, 0, 3, 0, 2, 9, 2, 3, 2, 0, 2, 0, 7, 0, 5, 0, 2, 0, 2, 0, 2, 2, 2, 1, 2, 0, 3, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 3, 3, 2, 6, 2, 3, 2, 3, 2, 0, 2, 9, 2, 16, 6, 2, 2, 4, 2, 16, 4421, 42719, 33, 4153, 7, 221, 3, 5761, 15, 7472, 3104, 541, 1507, 4938, 6, 4191]; const astralIdentifierCodes = [509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 574, 3, 9, 9, 370, 1, 81, 2, 71, 10, 50, 3, 123, 2, 54, 14, 32, 10, 3, 1, 11, 3, 46, 10, 8, 0, 46, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13, 2, 49, 13, 9, 3, 2, 11, 83, 11, 7, 0, 3, 0, 158, 11, 6, 9, 7, 3, 56, 1, 2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 193, 17, 10, 9, 5, 0, 82, 19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9, 84, 14, 5, 9, 243, 14, 166, 9, 71, 5, 2, 1, 3, 3, 2, 0, 2, 1, 13, 9, 120, 6, 3, 6, 4, 0, 29, 9, 41, 6, 2, 3, 9, 0, 10, 10, 47, 15, 406, 7, 2, 7, 17, 9, 57, 21, 2, 13, 123, 5, 4, 0, 2, 1, 2, 6, 2, 0, 9, 9, 49, 4, 2, 1, 2, 4, 9, 9, 330, 3, 10, 1, 2, 0, 49, 6, 4, 4, 14, 9, 5351, 0, 7, 14, 13835, 9, 87, 9, 39, 4, 60, 6, 26, 9, 1014, 0, 2, 54, 8, 3, 82, 0, 12, 1, 19628, 1, 4706, 45, 3, 22, 543, 4, 4, 5, 9, 7, 3, 6, 31, 3, 149, 2, 1418, 49, 513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 1361, 6, 2, 16, 3, 6, 2, 1, 2, 4, 101, 0, 161, 6, 10, 9, 357, 0, 62, 13, 499, 13, 983, 6, 110, 6, 6, 9, 4759, 9, 787719, 239]; function isInAstralSet(code, set) { let pos = 0x10000; for (let i = 0, length = set.length; i < length; i += 2) { pos += set[i]; if (pos > code) return false; pos += set[i + 1]; if (pos >= code) return true; } return false; } function isIdentifierStart(code) { if (code < 65) return code === 36; if (code <= 90) return true; if (code < 97) return code === 95; if (code <= 122) return true; if (code <= 0xffff) { return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code)); } return isInAstralSet(code, astralIdentifierStartCodes); } function isIdentifierChar(code) { if (code < 48) return code === 36; if (code < 58) return true; if (code < 65) return false; if (code <= 90) return true; if (code < 97) return code === 95; if (code <= 122) return true; if (code <= 0xffff) { return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code)); } return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes); } const reservedWords = { keyword: ["break", "case", "catch", "continue", "debugger", "default", "do", "else", "finally", "for", "function", "if", "return", "switch", "throw", "try", "var", "const", "while", "with", "new", "this", "super", "class", "extends", "export", "import", "null", "true", "false", "in", "instanceof", "typeof", "void", "delete"], strict: ["implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"], strictBind: ["eval", "arguments"] }; const keywords = new Set(reservedWords.keyword); const reservedWordsStrictSet = new Set(reservedWords.strict); const reservedWordsStrictBindSet = new Set(reservedWords.strictBind); function isReservedWord(word, inModule) { return inModule && word === "await" || word === "enum"; } function isStrictReservedWord(word, inModule) { return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word); } function isStrictBindOnlyReservedWord(word) { return reservedWordsStrictBindSet.has(word); } function isStrictBindReservedWord(word, inModule) { return isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word); } function isKeyword(word) { return keywords.has(word); } function isIteratorStart(current, next, next2) { return current === 64 && next === 64 && isIdentifierStart(next2); } const reservedWordLikeSet = new Set(["break", "case", "catch", "continue", "debugger", "default", "do", "else", "finally", "for", "function", "if", "return", "switch", "throw", "try", "var", "const", "while", "with", "new", "this", "super", "class", "extends", "export", "import", "null", "true", "false", "in", "instanceof", "typeof", "void", "delete", "implements", "interface", "let", "package", "private", "protected", "public", "static", "yield", "eval", "arguments", "enum", "await"]); function canBeReservedWord(word) { return reservedWordLikeSet.has(word); } const SCOPE_OTHER = 0b000000000, SCOPE_PROGRAM = 0b000000001, SCOPE_FUNCTION = 0b000000010, SCOPE_ARROW = 0b000000100, SCOPE_SIMPLE_CATCH = 0b000001000, SCOPE_SUPER = 0b000010000, SCOPE_DIRECT_SUPER = 0b000100000, SCOPE_CLASS = 0b001000000, SCOPE_STATIC_BLOCK = 0b010000000, SCOPE_TS_MODULE = 0b100000000, SCOPE_VAR = SCOPE_PROGRAM | SCOPE_FUNCTION | SCOPE_TS_MODULE; const BIND_KIND_VALUE = 0b000000000001, BIND_KIND_TYPE = 0b000000000010, BIND_SCOPE_VAR = 0b000000000100, BIND_SCOPE_LEXICAL = 0b000000001000, BIND_SCOPE_FUNCTION = 0b000000010000, BIND_FLAGS_NONE = 0b0000001000000, BIND_FLAGS_CLASS = 0b0000010000000, BIND_FLAGS_TS_ENUM = 0b0000100000000, BIND_FLAGS_TS_CONST_ENUM = 0b0001000000000, BIND_FLAGS_TS_EXPORT_ONLY = 0b0010000000000, BIND_FLAGS_FLOW_DECLARE_FN = 0b0100000000000, BIND_FLAGS_TS_IMPORT = 0b1000000000000; const BIND_CLASS = BIND_KIND_VALUE | BIND_KIND_TYPE | BIND_SCOPE_LEXICAL | BIND_FLAGS_CLASS, BIND_LEXICAL = BIND_KIND_VALUE | 0 | BIND_SCOPE_LEXICAL | 0, BIND_VAR = BIND_KIND_VALUE | 0 | BIND_SCOPE_VAR | 0, BIND_FUNCTION = BIND_KIND_VALUE | 0 | BIND_SCOPE_FUNCTION | 0, BIND_TS_INTERFACE = 0 | BIND_KIND_TYPE | 0 | BIND_FLAGS_CLASS, BIND_TS_TYPE = 0 | BIND_KIND_TYPE | 0 | 0, BIND_TS_ENUM = BIND_KIND_VALUE | BIND_KIND_TYPE | BIND_SCOPE_LEXICAL | BIND_FLAGS_TS_ENUM, BIND_TS_AMBIENT = 0 | 0 | 0 | BIND_FLAGS_TS_EXPORT_ONLY, BIND_NONE = 0 | 0 | 0 | BIND_FLAGS_NONE, BIND_OUTSIDE = BIND_KIND_VALUE | 0 | 0 | BIND_FLAGS_NONE, BIND_TS_CONST_ENUM = BIND_TS_ENUM | BIND_FLAGS_TS_CONST_ENUM, BIND_TS_NAMESPACE = 0 | 0 | 0 | BIND_FLAGS_TS_EXPORT_ONLY, BIND_TS_TYPE_IMPORT = 0 | BIND_KIND_TYPE | 0 | BIND_FLAGS_TS_IMPORT, BIND_FLOW_DECLARE_FN = BIND_FLAGS_FLOW_DECLARE_FN; const CLASS_ELEMENT_FLAG_STATIC = 0b100, CLASS_ELEMENT_KIND_GETTER = 0b010, CLASS_ELEMENT_KIND_SETTER = 0b001, CLASS_ELEMENT_KIND_ACCESSOR = CLASS_ELEMENT_KIND_GETTER | CLASS_ELEMENT_KIND_SETTER; const CLASS_ELEMENT_STATIC_GETTER = CLASS_ELEMENT_KIND_GETTER | CLASS_ELEMENT_FLAG_STATIC, CLASS_ELEMENT_STATIC_SETTER = CLASS_ELEMENT_KIND_SETTER | CLASS_ELEMENT_FLAG_STATIC, CLASS_ELEMENT_INSTANCE_GETTER = CLASS_ELEMENT_KIND_GETTER, CLASS_ELEMENT_INSTANCE_SETTER = CLASS_ELEMENT_KIND_SETTER, CLASS_ELEMENT_OTHER = 0; class Scope { constructor(flags) { this.var = new Set(); this.lexical = new Set(); this.functions = new Set(); this.flags = flags; } } class ScopeHandler { constructor(parser, inModule) { this.parser = void 0; this.scopeStack = []; this.inModule = void 0; this.undefinedExports = new Map(); this.parser = parser; this.inModule = inModule; } get inFunction() { return (this.currentVarScopeFlags() & SCOPE_FUNCTION) > 0; } get allowSuper() { return (this.currentThisScopeFlags() & SCOPE_SUPER) > 0; } get allowDirectSuper() { return (this.currentThisScopeFlags() & SCOPE_DIRECT_SUPER) > 0; } get inClass() { return (this.currentThisScopeFlags() & SCOPE_CLASS) > 0; } get inClassAndNotInNonArrowFunction() { const flags = this.currentThisScopeFlags(); return (flags & SCOPE_CLASS) > 0 && (flags & SCOPE_FUNCTION) === 0; } get inStaticBlock() { for (let i = this.scopeStack.length - 1;; i--) { const { flags } = this.scopeStack[i]; if (flags & SCOPE_STATIC_BLOCK) { return true; } if (flags & (SCOPE_VAR | SCOPE_CLASS)) { return false; } } } get inNonArrowFunction() { return (this.currentThisScopeFlags() & SCOPE_FUNCTION) > 0; } get treatFunctionsAsVar() { return this.treatFunctionsAsVarInScope(this.currentScope()); } createScope(flags) { return new Scope(flags); } enter(flags) { this.scopeStack.push(this.createScope(flags)); } exit() { const scope = this.scopeStack.pop(); return scope.flags; } treatFunctionsAsVarInScope(scope) { return !!(scope.flags & (SCOPE_FUNCTION | SCOPE_STATIC_BLOCK) || !this.parser.inModule && scope.flags & SCOPE_PROGRAM); } declareName(name, bindingType, loc) { let scope = this.currentScope(); if (bindingType & BIND_SCOPE_LEXICAL || bindingType & BIND_SCOPE_FUNCTION) { this.checkRedeclarationInScope(scope, name, bindingType, loc); if (bindingType & BIND_SCOPE_FUNCTION) { scope.functions.add(name); } else { scope.lexical.add(name); } if (bindingType & BIND_SCOPE_LEXICAL) { this.maybeExportDefined(scope, name); } } else if (bindingType & BIND_SCOPE_VAR) { for (let i = this.scopeStack.length - 1; i >= 0; --i) { scope = this.scopeStack[i]; this.checkRedeclarationInScope(scope, name, bindingType, loc); scope.var.add(name); this.maybeExportDefined(scope, name); if (scope.flags & SCOPE_VAR) break; } } if (this.parser.inModule && scope.flags & SCOPE_PROGRAM) { this.undefinedExports.delete(name); } } maybeExportDefined(scope, name) { if (this.parser.inModule && scope.flags & SCOPE_PROGRAM) { this.undefinedExports.delete(name); } } checkRedeclarationInScope(scope, name, bindingType, loc) { if (this.isRedeclaredInScope(scope, name, bindingType)) { this.parser.raise(Errors.VarRedeclaration, { at: loc, identifierName: name }); } } isRedeclaredInScope(scope, name, bindingType) { if (!(bindingType & BIND_KIND_VALUE)) return false; if (bindingType & BIND_SCOPE_LEXICAL) { return scope.lexical.has(name) || scope.functions.has(name) || scope.var.has(name); } if (bindingType & BIND_SCOPE_FUNCTION) { return scope.lexical.has(name) || !this.treatFunctionsAsVarInScope(scope) && scope.var.has(name); } return scope.lexical.has(name) && !(scope.flags & SCOPE_SIMPLE_CATCH && scope.lexical.values().next().value === name) || !this.treatFunctionsAsVarInScope(scope) && scope.functions.has(name); } checkLocalExport(id) { const { name } = id; const topLevelScope = this.scopeStack[0]; if (!topLevelScope.lexical.has(name) && !topLevelScope.var.has(name) && !topLevelScope.functions.has(name)) { this.undefinedExports.set(name, id.loc.start); } } currentScope() { return this.scopeStack[this.scopeStack.length - 1]; } currentVarScopeFlags() { for (let i = this.scopeStack.length - 1;; i--) { const { flags } = this.scopeStack[i]; if (flags & SCOPE_VAR) { return flags; } } } currentThisScopeFlags() { for (let i = this.scopeStack.length - 1;; i--) { const { flags } = this.scopeStack[i]; if (flags & (SCOPE_VAR | SCOPE_CLASS) && !(flags & SCOPE_ARROW)) { return flags; } } } } class FlowScope extends Scope { constructor(...args) { super(...args); this.declareFunctions = new Set(); } } class FlowScopeHandler extends ScopeHandler { createScope(flags) { return new FlowScope(flags); } declareName(name, bindingType, loc) { const scope = this.currentScope(); if (bindingType & BIND_FLAGS_FLOW_DECLARE_FN) { this.checkRedeclarationInScope(scope, name, bindingType, loc); this.maybeExportDefined(scope, name); scope.declareFunctions.add(name); return; } super.declareName(name, bindingType, loc); } isRedeclaredInScope(scope, name, bindingType) { if (super.isRedeclaredInScope(scope, name, bindingType)) return true; if (bindingType & BIND_FLAGS_FLOW_DECLARE_FN) { return !scope.declareFunctions.has(name) && (scope.lexical.has(name) || scope.functions.has(name)); } return false; } checkLocalExport(id) { if (!this.scopeStack[0].declareFunctions.has(id.name)) { super.checkLocalExport(id); } } } class BaseParser { constructor() { this.sawUnambiguousESM = false; this.ambiguousScriptDifferentAst = false; } hasPlugin(pluginConfig) { if (typeof pluginConfig === "string") { return this.plugins.has(pluginConfig); } else { const [pluginName, pluginOptions] = pluginConfig; if (!this.hasPlugin(pluginName)) { return false; } const actualOptions = this.plugins.get(pluginName); for (const key of Object.keys(pluginOptions)) { if ((actualOptions == null ? void 0 : actualOptions[key]) !== pluginOptions[key]) { return false; } } return true; } } getPluginOption(plugin, name) { var _this$plugins$get; return (_this$plugins$get = this.plugins.get(plugin)) == null ? void 0 : _this$plugins$get[name]; } } function setTrailingComments(node, comments) { if (node.trailingComments === undefined) { node.trailingComments = comments; } else { node.trailingComments.unshift(...comments); } } function setLeadingComments(node, comments) { if (node.leadingComments === undefined) { node.leadingComments = comments; } else { node.leadingComments.unshift(...comments); } } function setInnerComments(node, comments) { if (node.innerComments === undefined) { node.innerComments = comments; } else { node.innerComments.unshift(...comments); } } function adjustInnerComments(node, elements, commentWS) { let lastElement = null; let i = elements.length; while (lastElement === null && i > 0) { lastElement = elements[--i]; } if (lastElement === null || lastElement.start > commentWS.start) { setInnerComments(node, commentWS.comments); } else { setTrailingComments(lastElement, commentWS.comments); } } class CommentsParser extends BaseParser { addComment(comment) { if (this.filename) comment.loc.filename = this.filename; this.state.comments.push(comment); } processComment(node) { const { commentStack } = this.state; const commentStackLength = commentStack.length; if (commentStackLength === 0) return; let i = commentStackLength - 1; const lastCommentWS = commentStack[i]; if (lastCommentWS.start === node.end) { lastCommentWS.leadingNode = node; i--; } const { start: nodeStart } = node; for (; i >= 0; i--) { const commentWS = commentStack[i]; const commentEnd = commentWS.end; if (commentEnd > nodeStart) { commentWS.containingNode = node; this.finalizeComment(commentWS); commentStack.splice(i, 1); } else { if (commentEnd === nodeStart) { commentWS.trailingNode = node; } break; } } } finalizeComment(commentWS) { const { comments } = commentWS; if (commentWS.leadingNode !== null || commentWS.trailingNode !== null) { if (commentWS.leadingNode !== null) { setTrailingComments(commentWS.leadingNode, comments); } if (commentWS.trailingNode !== null) { setLeadingComments(commentWS.trailingNode, comments); } } else { const { containingNode: node, start: commentStart } = commentWS; if (this.input.charCodeAt(commentStart - 1) === 44) { switch (node.type) { case "ObjectExpression": case "ObjectPattern": case "RecordExpression": adjustInnerComments(node, node.properties, commentWS); break; case "CallExpression": case "OptionalCallExpression": adjustInnerComments(node, node.arguments, commentWS); break; case "FunctionDeclaration": case "FunctionExpression": case "ArrowFunctionExpression": case "ObjectMethod": case "ClassMethod": case "ClassPrivateMethod": adjustInnerComments(node, node.params, commentWS); break; case "ArrayExpression": case "ArrayPattern": case "TupleExpression": adjustInnerComments(node, node.elements, commentWS); break; case "ExportNamedDeclaration": case "ImportDeclaration": adjustInnerComments(node, node.specifiers, commentWS); break; default: { setInnerComments(node, comments); } } } else { setInnerComments(node, comments); } } } finalizeRemainingComments() { const { commentStack } = this.state; for (let i = commentStack.length - 1; i >= 0; i--) { this.finalizeComment(commentStack[i]); } this.state.commentStack = []; } resetPreviousNodeTrailingComments(node) { const { commentStack } = this.state; const { length } = commentStack; if (length === 0) return; const commentWS = commentStack[length - 1]; if (commentWS.leadingNode === node) { commentWS.leadingNode = null; } } takeSurroundingComments(node, start, end) { const { commentStack } = this.state; const commentStackLength = commentStack.length; if (commentStackLength === 0) return; let i = commentStackLength - 1; for (; i >= 0; i--) { const commentWS = commentStack[i]; const commentEnd = commentWS.end; const commentStart = commentWS.start; if (commentStart === end) { commentWS.leadingNode = node; } else if (commentEnd === start) { commentWS.trailingNode = node; } else if (commentEnd < start) { break; } } } } const lineBreak = /\r\n?|[\n\u2028\u2029]/; const lineBreakG = new RegExp(lineBreak.source, "g"); function isNewLine(code) { switch (code) { case 10: case 13: case 8232: case 8233: return true; default: return false; } } const skipWhiteSpace = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g; const skipWhiteSpaceInLine = /(?:[^\S\n\r\u2028\u2029]|\/\/.*|\/\*.*?\*\/)*/y; const skipWhiteSpaceToLineBreak = new RegExp("(?=(" + skipWhiteSpaceInLine.source + "))\\1" + /(?=[\n\r\u2028\u2029]|\/\*(?!.*?\*\/)|$)/.source, "y"); function isWhitespace(code) { switch (code) { case 0x0009: case 0x000b: case 0x000c: case 32: case 160: case 5760: case 0x2000: case 0x2001: case 0x2002: case 0x2003: case 0x2004: case 0x2005: case 0x2006: case 0x2007: case 0x2008: case 0x2009: case 0x200a: case 0x202f: case 0x205f: case 0x3000: case 0xfeff: return true; default: return false; } } class State { constructor() { this.strict = void 0; this.curLine = void 0; this.lineStart = void 0; this.startLoc = void 0; this.endLoc = void 0; this.errors = []; this.potentialArrowAt = -1; this.noArrowAt = []; this.noArrowParamsConversionAt = []; this.maybeInArrowParameters = false; this.inType = false; this.noAnonFunctionType = false; this.hasFlowComment = false; this.isAmbientContext = false; this.inAbstractClass = false; this.inDisallowConditionalTypesContext = false; this.topicContext = { maxNumOfResolvableTopics: 0, maxTopicIndex: null }; this.soloAwait = false; this.inFSharpPipelineDirectBody = false; this.labels = []; this.decoratorStack = [[]]; this.comments = []; this.commentStack = []; this.pos = 0; this.type = 135; this.value = null; this.start = 0; this.end = 0; this.lastTokEndLoc = null; this.lastTokStartLoc = null; this.lastTokStart = 0; this.context = [types.brace]; this.canStartJSXElement = true; this.containsEsc = false; this.firstInvalidTemplateEscapePos = null; this.strictErrors = new Map(); this.tokensLength = 0; } init({ strictMode, sourceType, startLine, startColumn }) { this.strict = strictMode === false ? false : strictMode === true ? true : sourceType === "module"; this.curLine = startLine; this.lineStart = -startColumn; this.startLoc = this.endLoc = new Position(startLine, startColumn, 0); } curPosition() { return new Position(this.curLine, this.pos - this.lineStart, this.pos); } clone(skipArrays) { const state = new State(); const keys = Object.keys(this); for (let i = 0, length = keys.length; i < length; i++) { const key = keys[i]; let val = this[key]; if (!skipArrays && Array.isArray(val)) { val = val.slice(); } state[key] = val; } return state; } } var _isDigit = function isDigit(code) { return code >= 48 && code <= 57; }; const forbiddenNumericSeparatorSiblings = { decBinOct: new Set([46, 66, 69, 79, 95, 98, 101, 111]), hex: new Set([46, 88, 95, 120]) }; const isAllowedNumericSeparatorSibling = { bin: ch => ch === 48 || ch === 49, oct: ch => ch >= 48 && ch <= 55, dec: ch => ch >= 48 && ch <= 57, hex: ch => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102 }; function readStringContents(type, input, pos, lineStart, curLine, errors) { const initialPos = pos; const initialLineStart = lineStart; const initialCurLine = curLine; let out = ""; let firstInvalidLoc = null; let chunkStart = pos; const { length } = input; for (;;) { if (pos >= length) { errors.unterminated(initialPos, initialLineStart, initialCurLine); out += input.slice(chunkStart, pos); break; } const ch = input.charCodeAt(pos); if (isStringEnd(type, ch, input, pos)) { out += input.slice(chunkStart, pos); break; } if (ch === 92) { out += input.slice(chunkStart, pos); const res = readEscapedChar(input, pos, lineStart, curLine, type === "template", errors); if (res.ch === null && !firstInvalidLoc) { firstInvalidLoc = { pos, lineStart, curLine }; } else { out += res.ch; } ({ pos, lineStart, curLine } = res); chunkStart = pos; } else if (ch === 8232 || ch === 8233) { ++pos; ++curLine; lineStart = pos; } else if (ch === 10 || ch === 13) { if (type === "template") { out += input.slice(chunkStart, pos) + "\n"; ++pos; if (ch === 13 && input.charCodeAt(pos) === 10) { ++pos; } ++curLine; chunkStart = lineStart = pos; } else { errors.unterminated(initialPos, initialLineStart, initialCurLine); } } else { ++pos; } } return { pos, str: out, firstInvalidLoc, lineStart, curLine, containsInvalid: !!firstInvalidLoc }; } function isStringEnd(type, ch, input, pos) { if (type === "template") { return ch === 96 || ch === 36 && input.charCodeAt(pos + 1) === 123; } return ch === (type === "double" ? 34 : 39); } function readEscapedChar(input, pos, lineStart, curLine, inTemplate, errors) { const throwOnInvalid = !inTemplate; pos++; const res = ch => ({ pos, ch, lineStart, curLine }); const ch = input.charCodeAt(pos++); switch (ch) { case 110: return res("\n"); case 114: return res("\r"); case 120: { let code; ({ code, pos } = readHexChar(input, pos, lineStart, curLine, 2, false, throwOnInvalid, errors)); return res(code === null ? null : String.fromCharCode(code)); } case 117: { let code; ({ code, pos } = readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors)); return res(code === null ? null : String.fromCodePoint(code)); } case 116: return res("\t"); case 98: return res("\b"); case 118: return res("\u000b"); case 102: return res("\f"); case 13: if (input.charCodeAt(pos) === 10) { ++pos; } case 10: lineStart = pos; ++curLine; case 8232: case 8233: return res(""); case 56: case 57: if (inTemplate) { return res(null); } else { errors.strictNumericEscape(pos - 1, lineStart, curLine); } default: if (ch >= 48 && ch <= 55) { const startPos = pos - 1; const match = input.slice(startPos, pos + 2).match(/^[0-7]+/); let octalStr = match[0]; let octal = parseInt(octalStr, 8); if (octal > 255) { octalStr = octalStr.slice(0, -1); octal = parseInt(octalStr, 8); } pos += octalStr.length - 1; const next = input.charCodeAt(pos); if (octalStr !== "0" || next === 56 || next === 57) { if (inTemplate) { return res(null); } else { errors.strictNumericEscape(startPos, lineStart, curLine); } } return res(String.fromCharCode(octal)); } return res(String.fromCharCode(ch)); } } function readHexChar(input, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors) { const initialPos = pos; let n; ({ n, pos } = readInt(input, pos, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid)); if (n === null) { if (throwOnInvalid) { errors.invalidEscapeSequence(initialPos, lineStart, curLine); } else { pos = initialPos - 1; } } return { code: n, pos }; } function readInt(input, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) { const start = pos; const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings.hex : forbiddenNumericSeparatorSiblings.decBinOct; const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling.hex : radix === 10 ? isAllowedNumericSeparatorSibling.dec : radix === 8 ? isAllowedNumericSeparatorSibling.oct : isAllowedNumericSeparatorSibling.bin; let invalid = false; let total = 0; for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) { const code = input.charCodeAt(pos); let val; if (code === 95 && allowNumSeparator !== "bail") { const prev = input.charCodeAt(pos - 1); const next = input.charCodeAt(pos + 1); if (!allowNumSeparator) { if (bailOnError) return { n: null, pos }; errors.numericSeparatorInEscapeSequence(pos, lineStart, curLine); } else if (Number.isNaN(next) || !isAllowedSibling(next) || forbiddenSiblings.has(prev) || forbiddenSiblings.has(next)) { if (bailOnError) return { n: null, pos }; errors.unexpectedNumericSeparator(pos, lineStart, curLine); } ++pos; continue; } if (code >= 97) { val = code - 97 + 10; } else if (code >= 65) { val = code - 65 + 10; } else if (_isDigit(code)) { val = code - 48; } else { val = Infinity; } if (val >= radix) { if (val <= 9 && bailOnError) { return { n: null, pos }; } else if (val <= 9 && errors.invalidDigit(pos, lineStart, curLine, radix)) { val = 0; } else if (forceLen) { val = 0; invalid = true; } else { break; } } ++pos; total = total * radix + val; } if (pos === start || len != null && pos - start !== len || invalid) { return { n: null, pos }; } return { n: total, pos }; } function readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors) { const ch = input.charCodeAt(pos); let code; if (ch === 123) { ++pos; ({ code, pos } = readHexChar(input, pos, lineStart, curLine, input.indexOf("}", pos) - pos, true, throwOnInvalid, errors)); ++pos; if (code !== null && code > 0x10ffff) { if (throwOnInvalid) { errors.invalidCodePoint(pos, lineStart, curLine); } else { return { code: null, pos }; } } } else { ({ code, pos } = readHexChar(input, pos, lineStart, curLine, 4, false, throwOnInvalid, errors)); } return { code, pos }; } const _excluded = ["at"], _excluded2 = ["at"]; function buildPosition(pos, lineStart, curLine) { return new Position(curLine, pos - lineStart, pos); } const VALID_REGEX_FLAGS = new Set([103, 109, 115, 105, 121, 117, 100, 118]); class Token { constructor(state) { this.type = state.type; this.value = state.value; this.start = state.start; this.end = state.end; this.loc = new SourceLocation(state.startLoc, state.endLoc); } } class Tokenizer extends CommentsParser { constructor(options, input) { super(); this.isLookahead = void 0; this.tokens = []; this.errorHandlers_readInt = { invalidDigit: (pos, lineStart, curLine, radix) => { if (!this.options.errorRecovery) return false; this.raise(Errors.InvalidDigit, { at: buildPosition(pos, lineStart, curLine), radix }); return true; }, numericSeparatorInEscapeSequence: this.errorBuilder(Errors.NumericSeparatorInEscapeSequence), unexpectedNumericSeparator: this.errorBuilder(Errors.UnexpectedNumericSeparator) }; this.errorHandlers_readCodePoint = Object.assign({}, this.errorHandlers_readInt, { invalidEscapeSequence: this.errorBuilder(Errors.InvalidEscapeSequence), invalidCodePoint: this.errorBuilder(Errors.InvalidCodePoint) }); this.errorHandlers_readStringContents_string = Object.assign({}, this.errorHandlers_readCodePoint, { strictNumericEscape: (pos, lineStart, curLine) => { this.recordStrictModeErrors(Errors.StrictNumericEscape, { at: buildPosition(pos, lineStart, curLine) }); }, unterminated: (pos, lineStart, curLine) => { throw this.raise(Errors.UnterminatedString, { at: buildPosition(pos - 1, lineStart, curLine) }); } }); this.errorHandlers_readStringContents_template = Object.assign({}, this.errorHandlers_readCodePoint, { strictNumericEscape: this.errorBuilder(Errors.StrictNumericEscape), unterminated: (pos, lineStart, curLine) => { throw this.raise(Errors.UnterminatedTemplate, { at: buildPosition(pos, lineStart, curLine) }); } }); this.state = new State(); this.state.init(options); this.input = input; this.length = input.length; this.isLookahead = false; } pushToken(token) { this.tokens.length = this.state.tokensLength; this.tokens.push(token); ++this.state.tokensLength; } next() { this.checkKeywordEscapes(); if (this.options.tokens) { this.pushToken(new Token(this.state)); } this.state.lastTokStart = this.state.start; this.state.lastTokEndLoc = this.state.endLoc; this.state.lastTokStartLoc = this.state.startLoc; this.nextToken(); } eat(type) { if (this.match(type)) { this.next(); return true; } else { return false; } } match(type) { return this.state.type === type; } createLookaheadState(state) { return { pos: state.pos, value: null, type: state.type, start: state.start, end: state.end, context: [this.curContext()], inType: state.inType, startLoc: state.startLoc, lastTokEndLoc: state.lastTokEndLoc, curLine: state.curLine, lineStart: state.lineStart, curPosition: state.curPosition }; } lookahead() { const old = this.state; this.state = this.createLookaheadState(old); this.isLookahead = true; this.nextToken(); this.isLookahead = false; const curr = this.state; this.state = old; return curr; } nextTokenStart() { return this.nextTokenStartSince(this.state.pos); } nextTokenStartSince(pos) { skipWhiteSpace.lastIndex = pos; return skipWhiteSpace.test(this.input) ? skipWhiteSpace.lastIndex : pos; } lookaheadCharCode() { return this.input.charCodeAt(this.nextTokenStart()); } codePointAtPos(pos) { let cp = this.input.charCodeAt(pos); if ((cp & 0xfc00) === 0xd800 && ++pos < this.input.length) { const trail = this.input.charCodeAt(pos); if ((trail & 0xfc00) === 0xdc00) { cp = 0x10000 + ((cp & 0x3ff) << 10) + (trail & 0x3ff); } } return cp; } setStrict(strict) { this.state.strict = strict; if (strict) { this.state.strictErrors.forEach(([toParseError, at]) => this.raise(toParseError, { at })); this.state.strictErrors.clear(); } } curContext() { return this.state.context[this.state.context.length - 1]; } nextToken() { this.skipSpace(); this.state.start = this.state.pos; if (!this.isLookahead) this.state.startLoc = this.state.curPosition(); if (this.state.pos >= this.length) { this.finishToken(135); return; } this.getTokenFromCode(this.codePointAtPos(this.state.pos)); } skipBlockComment() { let startLoc; if (!this.isLookahead) startLoc = this.state.curPosition(); const start = this.state.pos; const end = this.input.indexOf("*/", start + 2); if (end === -1) { throw this.raise(Errors.UnterminatedComment, { at: this.state.curPosition() }); } this.state.pos = end + 2; lineBreakG.lastIndex = start + 2; while (lineBreakG.test(this.input) && lineBreakG.lastIndex <= end) { ++this.state.curLine; this.state.lineStart = lineBreakG.lastIndex; } if (this.isLookahead) return; const comment = { type: "CommentBlock", value: this.input.slice(start + 2, end), start, end: end + 2, loc: new SourceLocation(startLoc, this.state.curPosition()) }; if (this.options.tokens) this.pushToken(comment); return comment; } skipLineComment(startSkip) { const start = this.state.pos; let startLoc; if (!this.isLookahead) startLoc = this.state.curPosition(); let ch = this.input.charCodeAt(this.state.pos += startSkip); if (this.state.pos < this.length) { while (!isNewLine(ch) && ++this.state.pos < this.length) { ch = this.input.charCodeAt(this.state.pos); } } if (this.isLookahead) return; const end = this.state.pos; const value = this.input.slice(start + startSkip, end); const comment = { type: "CommentLine", value, start, end, loc: new SourceLocation(startLoc, this.state.curPosition()) }; if (this.options.tokens) this.pushToken(comment); return comment; } skipSpace() { const spaceStart = this.state.pos; const comments = []; loop: while (this.state.pos < this.length) { const ch = this.input.charCodeAt(this.state.pos); switch (ch) { case 32: case 160: case 9: ++this.state.pos; break; case 13: if (this.input.charCodeAt(this.state.pos + 1) === 10) { ++this.state.pos; } case 10: case 8232: case 8233: ++this.state.pos; ++this.state.curLine; this.state.lineStart = this.state.pos; break; case 47: switch (this.input.charCodeAt(this.state.pos + 1)) { case 42: { const comment = this.skipBlockComment(); if (comment !== undefined) { this.addComment(comment); if (this.options.attachComment) comments.push(comment); } break; } case 47: { const comment = this.skipLineComment(2); if (comment !== undefined) { this.addComment(comment); if (this.options.attachComment) comments.push(comment); } break; } default: break loop; } break; default: if (isWhitespace(ch)) { ++this.state.pos; } else if (ch === 45 && !this.inModule) { const pos = this.state.pos; if (this.input.charCodeAt(pos + 1) === 45 && this.input.charCodeAt(pos + 2) === 62 && (spaceStart === 0 || this.state.lineStart > spaceStart)) { const comment = this.skipLineComment(3); if (comment !== undefined) { this.addComment(comment); if (this.options.attachComment) comments.push(comment); } } else { break loop; } } else if (ch === 60 && !this.inModule) { const pos = this.state.pos; if (this.input.charCodeAt(pos + 1) === 33 && this.input.charCodeAt(pos + 2) === 45 && this.input.charCodeAt(pos + 3) === 45) { const comment = this.skipLineComment(4); if (comment !== undefined) { this.addComment(comment); if (this.options.attachComment) comments.push(comment); } } else { break loop; } } else { break loop; } } } if (comments.length > 0) { const end = this.state.pos; const commentWhitespace = { start: spaceStart, end, comments, leadingNode: null, trailingNode: null, containingNode: null }; this.state.commentStack.push(commentWhitespace); } } finishToken(type, val) { this.state.end = this.state.pos; this.state.endLoc = this.state.curPosition(); const prevType = this.state.type; this.state.type = type; this.state.value = val; if (!this.isLookahead) { this.updateContext(prevType); } } replaceToken(type) { this.state.type = type; this.updateContext(); } readToken_numberSign() { if (this.state.pos === 0 && this.readToken_interpreter()) { return; } const nextPos = this.state.pos + 1; const next = this.codePointAtPos(nextPos); if (next >= 48 && next <= 57) { throw this.raise(Errors.UnexpectedDigitAfterHash, { at: this.state.curPosition() }); } if (next === 123 || next === 91 && this.hasPlugin("recordAndTuple")) { this.expectPlugin("recordAndTuple"); if (this.getPluginOption("recordAndTuple", "syntaxType") === "bar") { throw this.raise(next === 123 ? Errors.RecordExpressionHashIncorrectStartSyntaxType : Errors.TupleExpressionHashIncorrectStartSyntaxType, { at: this.state.curPosition() }); } this.state.pos += 2; if (next === 123) { this.finishToken(7); } else { this.finishToken(1); } } else if (isIdentifierStart(next)) { ++this.state.pos; this.finishToken(134, this.readWord1(next)); } else if (next === 92) { ++this.state.pos; this.finishToken(134, this.readWord1()); } else { this.finishOp(27, 1); } } readToken_dot() { const next = this.input.charCodeAt(this.state.pos + 1); if (next >= 48 && next <= 57) { this.readNumber(true); return; } if (next === 46 && this.input.charCodeAt(this.state.pos + 2) === 46) { this.state.pos += 3; this.finishToken(21); } else { ++this.state.pos; this.finishToken(16); } } readToken_slash() { const next = this.input.charCodeAt(this.state.pos + 1); if (next === 61) { this.finishOp(31, 2); } else { this.finishOp(56, 1); } } readToken_interpreter() { if (this.state.pos !== 0 || this.length < 2) return false; let ch = this.input.charCodeAt(this.state.pos + 1); if (ch !== 33) return false; const start = this.state.pos; this.state.pos += 1; while (!isNewLine(ch) && ++this.state.pos < this.length) { ch = this.input.charCodeAt(this.state.pos); } const value = this.input.slice(start + 2, this.state.pos); this.finishToken(28, value); return true; } readToken_mult_modulo(code) { let type = code === 42 ? 55 : 54; let width = 1; let next = this.input.charCodeAt(this.state.pos + 1); if (code === 42 && next === 42) { width++; next = this.input.charCodeAt(this.state.pos + 2); type = 57; } if (next === 61 && !this.state.inType) { width++; type = code === 37 ? 33 : 30; } this.finishOp(type, width); } readToken_pipe_amp(code) { const next = this.input.charCodeAt(this.state.pos + 1); if (next === code) { if (this.input.charCodeAt(this.state.pos + 2) === 61) { this.finishOp(30, 3); } else { this.finishOp(code === 124 ? 41 : 42, 2); } return; } if (code === 124) { if (next === 62) { this.finishOp(39, 2); return; } if (this.hasPlugin("recordAndTuple") && next === 125) { if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") { throw this.raise(Errors.RecordExpressionBarIncorrectEndSyntaxType, { at: this.state.curPosition() }); } this.state.pos += 2; this.finishToken(9); return; } if (this.hasPlugin("recordAndTuple") && next === 93) { if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") { throw this.raise(Errors.TupleExpressionBarIncorrectEndSyntaxType, { at: this.state.curPosition() }); } this.state.pos += 2; this.finishToken(4); return; } } if (next === 61) { this.finishOp(30, 2); return; } this.finishOp(code === 124 ? 43 : 45, 1); } readToken_caret() { const next = this.input.charCodeAt(this.state.pos + 1); if (next === 61 && !this.state.inType) { this.finishOp(32, 2); } else if (next === 94 && this.hasPlugin(["pipelineOperator", { proposal: "hack", topicToken: "^^" }])) { this.finishOp(37, 2); const lookaheadCh = this.input.codePointAt(this.state.pos); if (lookaheadCh === 94) { throw this.unexpected(); } } else { this.finishOp(44, 1); } } readToken_atSign() { const next = this.input.charCodeAt(this.state.pos + 1); if (next === 64 && this.hasPlugin(["pipelineOperator", { proposal: "hack", topicToken: "@@" }])) { this.finishOp(38, 2); } else { this.finishOp(26, 1); } } readToken_plus_min(code) { const next = this.input.charCodeAt(this.state.pos + 1); if (next === code) { this.finishOp(34, 2); return; } if (next === 61) { this.finishOp(30, 2); } else { this.finishOp(53, 1); } } readToken_lt() { const { pos } = this.state; const next = this.input.charCodeAt(pos + 1); if (next === 60) { if (this.input.charCodeAt(pos + 2) === 61) { this.finishOp(30, 3); return; } this.finishOp(51, 2); return; } if (next === 61) { this.finishOp(49, 2); return; } this.finishOp(47, 1); } readToken_gt() { const { pos } = this.state; const next = this.input.charCodeAt(pos + 1); if (next === 62) { const size = this.input.charCodeAt(pos + 2) === 62 ? 3 : 2; if (this.input.charCodeAt(pos + size) === 61) { this.finishOp(30, size + 1); return; } this.finishOp(52, size); return; } if (next === 61) { this.finishOp(49, 2); return; } this.finishOp(48, 1); } readToken_eq_excl(code) { const next = this.input.charCodeAt(this.state.pos + 1); if (next === 61) { this.finishOp(46, this.input.charCodeAt(this.state.pos + 2) === 61 ? 3 : 2); return; } if (code === 61 && next === 62) { this.state.pos += 2; this.finishToken(19); return; } this.finishOp(code === 61 ? 29 : 35, 1); } readToken_question() { const next = this.input.charCodeAt(this.state.pos + 1); const next2 = this.input.charCodeAt(this.state.pos + 2); if (next === 63) { if (next2 === 61) { this.finishOp(30, 3); } else { this.finishOp(40, 2); } } else if (next === 46 && !(next2 >= 48 && next2 <= 57)) { this.state.pos += 2; this.finishToken(18); } else { ++this.state.pos; this.finishToken(17); } } getTokenFromCode(code) { switch (code) { case 46: this.readToken_dot(); return; case 40: ++this.state.pos; this.finishToken(10); return; case 41: ++this.state.pos; this.finishToken(11); return; case 59: ++this.state.pos; this.finishToken(13); return; case 44: ++this.state.pos; this.finishToken(12); return; case 91: if (this.hasPlugin("recordAndTuple") && this.input.charCodeAt(this.state.pos + 1) === 124) { if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") { throw this.raise(Errors.TupleExpressionBarIncorrectStartSyntaxType, { at: this.state.curPosition() }); } this.state.pos += 2; this.finishToken(2); } else { ++this.state.pos; this.finishToken(0); } return; case 93: ++this.state.pos; this.finishToken(3); return; case 123: if (this.hasPlugin("recordAndTuple") && this.input.charCodeAt(this.state.pos + 1) === 124) { if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") { throw this.raise(Errors.RecordExpressionBarIncorrectStartSyntaxType, { at: this.state.curPosition() }); } this.state.pos += 2; this.finishToken(6); } else { ++this.state.pos; this.finishToken(5); } return; case 125: ++this.state.pos; this.finishToken(8); return; case 58: if (this.hasPlugin("functionBind") && this.input.charCodeAt(this.state.pos + 1) === 58) { this.finishOp(15, 2); } else { ++this.state.pos; this.finishToken(14); } return; case 63: this.readToken_question(); return; case 96: this.readTemplateToken(); return; case 48: { const next = this.input.charCodeAt(this.state.pos + 1); if (next === 120 || next === 88) { this.readRadixNumber(16); return; } if (next === 111 || next === 79) { this.readRadixNumber(8); return; } if (next === 98 || next === 66) { this.readRadixNumber(2); return; } } case 49: case 50: case 51: case 52: case 53: case 54: case 55: case 56: case 57: this.readNumber(false); return; case 34: case 39: this.readString(code); return; case 47: this.readToken_slash(); return; case 37: case 42: this.readToken_mult_modulo(code); return; case 124: case 38: this.readToken_pipe_amp(code); return; case 94: this.readToken_caret(); return; case 43: case 45: this.readToken_plus_min(code); return; case 60: this.readToken_lt(); return; case 62: this.readToken_gt(); return; case 61: case 33: this.readToken_eq_excl(code); return; case 126: this.finishOp(36, 1); return; case 64: this.readToken_atSign(); return; case 35: this.readToken_numberSign(); return; case 92: this.readWord(); return; default: if (isIdentifierStart(code)) { this.readWord(code); return; } } throw this.raise(Errors.InvalidOrUnexpectedToken, { at: this.state.curPosition(), unexpected: String.fromCodePoint(code) }); } finishOp(type, size) { const str = this.input.slice(this.state.pos, this.state.pos + size); this.state.pos += size; this.finishToken(type, str); } readRegexp() { const startLoc = this.state.startLoc; const start = this.state.start + 1; let escaped, inClass; let { pos } = this.state; for (;; ++pos) { if (pos >= this.length) { throw this.raise(Errors.UnterminatedRegExp, { at: createPositionWithColumnOffset(startLoc, 1) }); } const ch = this.input.charCodeAt(pos); if (isNewLine(ch)) { throw this.raise(Errors.UnterminatedRegExp, { at: createPositionWithColumnOffset(startLoc, 1) }); } if (escaped) { escaped = false; } else { if (ch === 91) { inClass = true; } else if (ch === 93 && inClass) { inClass = false; } else if (ch === 47 && !inClass) { break; } escaped = ch === 92; } } const content = this.input.slice(start, pos); ++pos; let mods = ""; const nextPos = () => createPositionWithColumnOffset(startLoc, pos + 2 - start); while (pos < this.length) { const cp = this.codePointAtPos(pos); const char = String.fromCharCode(cp); if (VALID_REGEX_FLAGS.has(cp)) { if (cp === 118) { this.expectPlugin("regexpUnicodeSets", nextPos()); if (mods.includes("u")) { this.raise(Errors.IncompatibleRegExpUVFlags, { at: nextPos() }); } } else if (cp === 117) { if (mods.includes("v")) { this.raise(Errors.IncompatibleRegExpUVFlags, { at: nextPos() }); } } if (mods.includes(char)) { this.raise(Errors.DuplicateRegExpFlags, { at: nextPos() }); } } else if (isIdentifierChar(cp) || cp === 92) { this.raise(Errors.MalformedRegExpFlags, { at: nextPos() }); } else { break; } ++pos; mods += char; } this.state.pos = pos; this.finishToken(133, { pattern: content, flags: mods }); } readInt(radix, len, forceLen = false, allowNumSeparator = true) { const { n, pos } = readInt(this.input, this.state.pos, this.state.lineStart, this.state.curLine, radix, len, forceLen, allowNumSeparator, this.errorHandlers_readInt, false); this.state.pos = pos; return n; } readRadixNumber(radix) { const startLoc = this.state.curPosition(); let isBigInt = false; this.state.pos += 2; const val = this.readInt(radix); if (val == null) { this.raise(Errors.InvalidDigit, { at: createPositionWithColumnOffset(startLoc, 2), radix }); } const next = this.input.charCodeAt(this.state.pos); if (next === 110) { ++this.state.pos; isBigInt = true; } else if (next === 109) { throw this.raise(Errors.InvalidDecimal, { at: startLoc }); } if (isIdentifierStart(this.codePointAtPos(this.state.pos))) { throw this.raise(Errors.NumberIdentifier, { at: this.state.curPosition() }); } if (isBigInt) { const str = this.input.slice(startLoc.index, this.state.pos).replace(/[_n]/g, ""); this.finishToken(131, str); return; } this.finishToken(130, val); } readNumber(startsWithDot) { const start = this.state.pos; const startLoc = this.state.curPosition(); let isFloat = false; let isBigInt = false; let isDecimal = false; let hasExponent = false; let isOctal = false; if (!startsWithDot && this.readInt(10) === null) { this.raise(Errors.InvalidNumber, { at: this.state.curPosition() }); } const hasLeadingZero = this.state.pos - start >= 2 && this.input.charCodeAt(start) === 48; if (hasLeadingZero) { const integer = this.input.slice(start, this.state.pos); this.recordStrictModeErrors(Errors.StrictOctalLiteral, { at: startLoc }); if (!this.state.strict) { const underscorePos = integer.indexOf("_"); if (underscorePos > 0) { this.raise(Errors.ZeroDigitNumericSeparator, { at: createPositionWithColumnOffset(startLoc, underscorePos) }); } } isOctal = hasLeadingZero && !/[89]/.test(integer); } let next = this.input.charCodeAt(this.state.pos); if (next === 46 && !isOctal) { ++this.state.pos; this.readInt(10); isFloat = true; next = this.input.charCodeAt(this.state.pos); } if ((next === 69 || next === 101) && !isOctal) { next = this.input.charCodeAt(++this.state.pos); if (next === 43 || next === 45) { ++this.state.pos; } if (this.readInt(10) === null) { this.raise(Errors.InvalidOrMissingExponent, { at: startLoc }); } isFloat = true; hasExponent = true; next = this.input.charCodeAt(this.state.pos); } if (next === 110) { if (isFloat || hasLeadingZero) { this.raise(Errors.InvalidBigIntLiteral, { at: startLoc }); } ++this.state.pos; isBigInt = true; } if (next === 109) { this.expectPlugin("decimal", this.state.curPosition()); if (hasExponent || hasLeadingZero) { this.raise(Errors.InvalidDecimal, { at: startLoc }); } ++this.state.pos; isDecimal = true; } if (isIdentifierStart(this.codePointAtPos(this.state.pos))) { throw this.raise(Errors.NumberIdentifier, { at: this.state.curPosition() }); } const str = this.input.slice(start, this.state.pos).replace(/[_mn]/g, ""); if (isBigInt) { this.finishToken(131, str); return; } if (isDecimal) { this.finishToken(132, str); return; } const val = isOctal ? parseInt(str, 8) : parseFloat(str); this.finishToken(130, val); } readCodePoint(throwOnInvalid) { const { code, pos } = readCodePoint(this.input, this.state.pos, this.state.lineStart, this.state.curLine, throwOnInvalid, this.errorHandlers_readCodePoint); this.state.pos = pos; return code; } readString(quote) { const { str, pos, curLine, lineStart } = readStringContents(quote === 34 ? "double" : "single", this.input, this.state.pos + 1, this.state.lineStart, this.state.curLine, this.errorHandlers_readStringContents_string); this.state.pos = pos + 1; this.state.lineStart = lineStart; this.state.curLine = curLine; this.finishToken(129, str); } readTemplateContinuation() { if (!this.match(8)) { this.unexpected(null, 8); } this.state.pos--; this.readTemplateToken(); } readTemplateToken() { const opening = this.input[this.state.pos]; const { str, firstInvalidLoc, pos, curLine, lineStart } = readStringContents("template", this.input, this.state.pos + 1, this.state.lineStart, this.state.curLine, this.errorHandlers_readStringContents_template); this.state.pos = pos + 1; this.state.lineStart = lineStart; this.state.curLine = curLine; if (firstInvalidLoc) { this.state.firstInvalidTemplateEscapePos = new Position(firstInvalidLoc.curLine, firstInvalidLoc.pos - firstInvalidLoc.lineStart, firstInvalidLoc.pos); } if (this.input.codePointAt(pos) === 96) { this.finishToken(24, firstInvalidLoc ? null : opening + str + "`"); } else { this.state.pos++; this.finishToken(25, firstInvalidLoc ? null : opening + str + "${"); } } recordStrictModeErrors(toParseError, { at }) { const index = at.index; if (this.state.strict && !this.state.strictErrors.has(index)) { this.raise(toParseError, { at }); } else { this.state.strictErrors.set(index, [toParseError, at]); } } readWord1(firstCode) { this.state.containsEsc = false; let word = ""; const start = this.state.pos; let chunkStart = this.state.pos; if (firstCode !== undefined) { this.state.pos += firstCode <= 0xffff ? 1 : 2; } while (this.state.pos < this.length) { const ch = this.codePointAtPos(this.state.pos); if (isIdentifierChar(ch)) { this.state.pos += ch <= 0xffff ? 1 : 2; } else if (ch === 92) { this.state.containsEsc = true; word += this.input.slice(chunkStart, this.state.pos); const escStart = this.state.curPosition(); const identifierCheck = this.state.pos === start ? isIdentifierStart : isIdentifierChar; if (this.input.charCodeAt(++this.state.pos) !== 117) { this.raise(Errors.MissingUnicodeEscape, { at: this.state.curPosition() }); chunkStart = this.state.pos - 1; continue; } ++this.state.pos; const esc = this.readCodePoint(true); if (esc !== null) { if (!identifierCheck(esc)) { this.raise(Errors.EscapedCharNotAnIdentifier, { at: escStart }); } word += String.fromCodePoint(esc); } chunkStart = this.state.pos; } else { break; } } return word + this.input.slice(chunkStart, this.state.pos); } readWord(firstCode) { const word = this.readWord1(firstCode); const type = keywords$1.get(word); if (type !== undefined) { this.finishToken(type, tokenLabelName(type)); } else { this.finishToken(128, word); } } checkKeywordEscapes() { const { type } = this.state; if (tokenIsKeyword(type) && this.state.containsEsc) { this.raise(Errors.InvalidEscapedReservedWord, { at: this.state.startLoc, reservedWord: tokenLabelName(type) }); } } raise(toParseError, raiseProperties) { const { at } = raiseProperties, details = _objectWithoutPropertiesLoose(raiseProperties, _excluded); const loc = at instanceof Position ? at : at.loc.start; const error = toParseError({ loc, details }); if (!this.options.errorRecovery) throw error; if (!this.isLookahead) this.state.errors.push(error); return error; } raiseOverwrite(toParseError, raiseProperties) { const { at } = raiseProperties, details = _objectWithoutPropertiesLoose(raiseProperties, _excluded2); const loc = at instanceof Position ? at : at.loc.start; const pos = loc.index; const errors = this.state.errors; for (let i = errors.length - 1; i >= 0; i--) { const error = errors[i]; if (error.loc.index === pos) { return errors[i] = toParseError({ loc, details }); } if (error.loc.index < pos) break; } return this.raise(toParseError, raiseProperties); } updateContext(prevType) {} unexpected(loc, type) { throw this.raise(Errors.UnexpectedToken, { expected: type ? tokenLabelName(type) : null, at: loc != null ? loc : this.state.startLoc }); } expectPlugin(pluginName, loc) { if (this.hasPlugin(pluginName)) { return true; } throw this.raise(Errors.MissingPlugin, { at: loc != null ? loc : this.state.startLoc, missingPlugin: [pluginName] }); } expectOnePlugin(pluginNames) { if (!pluginNames.some(name => this.hasPlugin(name))) { throw this.raise(Errors.MissingOneOfPlugins, { at: this.state.startLoc, missingPlugin: pluginNames }); } } errorBuilder(error) { return (pos, lineStart, curLine) => { this.raise(error, { at: buildPosition(pos, lineStart, curLine) }); }; } } class ClassScope { constructor() { this.privateNames = new Set(); this.loneAccessors = new Map(); this.undefinedPrivateNames = new Map(); } } class ClassScopeHandler { constructor(parser) { this.parser = void 0; this.stack = []; this.undefinedPrivateNames = new Map(); this.parser = parser; } current() { return this.stack[this.stack.length - 1]; } enter() { this.stack.push(new ClassScope()); } exit() { const oldClassScope = this.stack.pop(); const current = this.current(); for (const [name, loc] of Array.from(oldClassScope.undefinedPrivateNames)) { if (current) { if (!current.undefinedPrivateNames.has(name)) { current.undefinedPrivateNames.set(name, loc); } } else { this.parser.raise(Errors.InvalidPrivateFieldResolution, { at: loc, identifierName: name }); } } } declarePrivateName(name, elementType, loc) { const { privateNames, loneAccessors, undefinedPrivateNames } = this.current(); let redefined = privateNames.has(name); if (elementType & CLASS_ELEMENT_KIND_ACCESSOR) { const accessor = redefined && loneAccessors.get(name); if (accessor) { const oldStatic = accessor & CLASS_ELEMENT_FLAG_STATIC; const newStatic = elementType & CLASS_ELEMENT_FLAG_STATIC; const oldKind = accessor & CLASS_ELEMENT_KIND_ACCESSOR; const newKind = elementType & CLASS_ELEMENT_KIND_ACCESSOR; redefined = oldKind === newKind || oldStatic !== newStatic; if (!redefined) loneAccessors.delete(name); } else if (!redefined) { loneAccessors.set(name, elementType); } } if (redefined) { this.parser.raise(Errors.PrivateNameRedeclaration, { at: loc, identifierName: name }); } privateNames.add(name); undefinedPrivateNames.delete(name); } usePrivateName(name, loc) { let classScope; for (classScope of this.stack) { if (classScope.privateNames.has(name)) return; } if (classScope) { classScope.undefinedPrivateNames.set(name, loc); } else { this.parser.raise(Errors.InvalidPrivateFieldResolution, { at: loc, identifierName: name }); } } } const kExpression = 0, kMaybeArrowParameterDeclaration = 1, kMaybeAsyncArrowParameterDeclaration = 2, kParameterDeclaration = 3; class ExpressionScope { constructor(type = kExpression) { this.type = void 0; this.type = type; } canBeArrowParameterDeclaration() { return this.type === kMaybeAsyncArrowParameterDeclaration || this.type === kMaybeArrowParameterDeclaration; } isCertainlyParameterDeclaration() { return this.type === kParameterDeclaration; } } class ArrowHeadParsingScope extends ExpressionScope { constructor(type) { super(type); this.declarationErrors = new Map(); } recordDeclarationError(ParsingErrorClass, { at }) { const index = at.index; this.declarationErrors.set(index, [ParsingErrorClass, at]); } clearDeclarationError(index) { this.declarationErrors.delete(index); } iterateErrors(iterator) { this.declarationErrors.forEach(iterator); } } class ExpressionScopeHandler { constructor(parser) { this.parser = void 0; this.stack = [new ExpressionScope()]; this.parser = parser; } enter(scope) { this.stack.push(scope); } exit() { this.stack.pop(); } recordParameterInitializerError(toParseError, { at: node }) { const origin = { at: node.loc.start }; const { stack } = this; let i = stack.length - 1; let scope = stack[i]; while (!scope.isCertainlyParameterDeclaration()) { if (scope.canBeArrowParameterDeclaration()) { scope.recordDeclarationError(toParseError, origin); } else { return; } scope = stack[--i]; } this.parser.raise(toParseError, origin); } recordArrowParemeterBindingError(error, { at: node }) { const { stack } = this; const scope = stack[stack.length - 1]; const origin = { at: node.loc.start }; if (scope.isCertainlyParameterDeclaration()) { this.parser.raise(error, origin); } else if (scope.canBeArrowParameterDeclaration()) { scope.recordDeclarationError(error, origin); } else { return; } } recordAsyncArrowParametersError({ at }) { const { stack } = this; let i = stack.length - 1; let scope = stack[i]; while (scope.canBeArrowParameterDeclaration()) { if (scope.type === kMaybeAsyncArrowParameterDeclaration) { scope.recordDeclarationError(Errors.AwaitBindingIdentifier, { at }); } scope = stack[--i]; } } validateAsPattern() { const { stack } = this; const currentScope = stack[stack.length - 1]; if (!currentScope.canBeArrowParameterDeclaration()) return; currentScope.iterateErrors(([toParseError, loc]) => { this.parser.raise(toParseError, { at: loc }); let i = stack.length - 2; let scope = stack[i]; while (scope.canBeArrowParameterDeclaration()) { scope.clearDeclarationError(loc.index); scope = stack[--i]; } }); } } function newParameterDeclarationScope() { return new ExpressionScope(kParameterDeclaration); } function newArrowHeadScope() { return new ArrowHeadParsingScope(kMaybeArrowParameterDeclaration); } function newAsyncArrowScope() { return new ArrowHeadParsingScope(kMaybeAsyncArrowParameterDeclaration); } function newExpressionScope() { return new ExpressionScope(); } const PARAM = 0b0000, PARAM_YIELD = 0b0001, PARAM_AWAIT = 0b0010, PARAM_RETURN = 0b0100, PARAM_IN = 0b1000; class ProductionParameterHandler { constructor() { this.stacks = []; } enter(flags) { this.stacks.push(flags); } exit() { this.stacks.pop(); } currentFlags() { return this.stacks[this.stacks.length - 1]; } get hasAwait() { return (this.currentFlags() & PARAM_AWAIT) > 0; } get hasYield() { return (this.currentFlags() & PARAM_YIELD) > 0; } get hasReturn() { return (this.currentFlags() & PARAM_RETURN) > 0; } get hasIn() { return (this.currentFlags() & PARAM_IN) > 0; } } function functionFlags(isAsync, isGenerator) { return (isAsync ? PARAM_AWAIT : 0) | (isGenerator ? PARAM_YIELD : 0); } class UtilParser extends Tokenizer { addExtra(node, key, value, enumerable = true) { if (!node) return; const extra = node.extra = node.extra || {}; if (enumerable) { extra[key] = value; } else { Object.defineProperty(extra, key, { enumerable, value }); } } isContextual(token) { return this.state.type === token && !this.state.containsEsc; } isUnparsedContextual(nameStart, name) { const nameEnd = nameStart + name.length; if (this.input.slice(nameStart, nameEnd) === name) { const nextCh = this.input.charCodeAt(nameEnd); return !(isIdentifierChar(nextCh) || (nextCh & 0xfc00) === 0xd800); } return false; } isLookaheadContextual(name) { const next = this.nextTokenStart(); return this.isUnparsedContextual(next, name); } eatContextual(token) { if (this.isContextual(token)) { this.next(); return true; } return false; } expectContextual(token, toParseError) { if (!this.eatContextual(token)) { if (toParseError != null) { throw this.raise(toParseError, { at: this.state.startLoc }); } throw this.unexpected(null, token); } } canInsertSemicolon() { return this.match(135) || this.match(8) || this.hasPrecedingLineBreak(); } hasPrecedingLineBreak() { return lineBreak.test(this.input.slice(this.state.lastTokEndLoc.index, this.state.start)); } hasFollowingLineBreak() { skipWhiteSpaceToLineBreak.lastIndex = this.state.end; return skipWhiteSpaceToLineBreak.test(this.input); } isLineTerminator() { return this.eat(13) || this.canInsertSemicolon(); } semicolon(allowAsi = true) { if (allowAsi ? this.isLineTerminator() : this.eat(13)) return; this.raise(Errors.MissingSemicolon, { at: this.state.lastTokEndLoc }); } expect(type, loc) { this.eat(type) || this.unexpected(loc, type); } tryParse(fn, oldState = this.state.clone()) { const abortSignal = { node: null }; try { const node = fn((node = null) => { abortSignal.node = node; throw abortSignal; }); if (this.state.errors.length > oldState.errors.length) { const failState = this.state; this.state = oldState; this.state.tokensLength = failState.tokensLength; return { node, error: failState.errors[oldState.errors.length], thrown: false, aborted: false, failState }; } return { node, error: null, thrown: false, aborted: false, failState: null }; } catch (error) { const failState = this.state; this.state = oldState; if (error instanceof SyntaxError) { return { node: null, error, thrown: true, aborted: false, failState }; } if (error === abortSignal) { return { node: abortSignal.node, error: null, thrown: false, aborted: true, failState }; } throw error; } } checkExpressionErrors(refExpressionErrors, andThrow) { if (!refExpressionErrors) return false; const { shorthandAssignLoc, doubleProtoLoc, privateKeyLoc, optionalParametersLoc } = refExpressionErrors; const hasErrors = !!shorthandAssignLoc || !!doubleProtoLoc || !!optionalParametersLoc || !!privateKeyLoc; if (!andThrow) { return hasErrors; } if (shorthandAssignLoc != null) { this.raise(Errors.InvalidCoverInitializedName, { at: shorthandAssignLoc }); } if (doubleProtoLoc != null) { this.raise(Errors.DuplicateProto, { at: doubleProtoLoc }); } if (privateKeyLoc != null) { this.raise(Errors.UnexpectedPrivateField, { at: privateKeyLoc }); } if (optionalParametersLoc != null) { this.unexpected(optionalParametersLoc); } } isLiteralPropertyName() { return tokenIsLiteralPropertyName(this.state.type); } isPrivateName(node) { return node.type === "PrivateName"; } getPrivateNameSV(node) { return node.id.name; } hasPropertyAsPrivateName(node) { return (node.type === "MemberExpression" || node.type === "OptionalMemberExpression") && this.isPrivateName(node.property); } isOptionalChain(node) { return node.type === "OptionalMemberExpression" || node.type === "OptionalCallExpression"; } isObjectProperty(node) { return node.type === "ObjectProperty"; } isObjectMethod(node) { return node.type === "ObjectMethod"; } initializeScopes(inModule = this.options.sourceType === "module") { const oldLabels = this.state.labels; this.state.labels = []; const oldExportedIdentifiers = this.exportedIdentifiers; this.exportedIdentifiers = new Set(); const oldInModule = this.inModule; this.inModule = inModule; const oldScope = this.scope; const ScopeHandler = this.getScopeHandler(); this.scope = new ScopeHandler(this, inModule); const oldProdParam = this.prodParam; this.prodParam = new ProductionParameterHandler(); const oldClassScope = this.classScope; this.classScope = new ClassScopeHandler(this); const oldExpressionScope = this.expressionScope; this.expressionScope = new ExpressionScopeHandler(this); return () => { this.state.labels = oldLabels; this.exportedIdentifiers = oldExportedIdentifiers; this.inModule = oldInModule; this.scope = oldScope; this.prodParam = oldProdParam; this.classScope = oldClassScope; this.expressionScope = oldExpressionScope; }; } enterInitialScopes() { let paramFlags = PARAM; if (this.inModule) { paramFlags |= PARAM_AWAIT; } this.scope.enter(SCOPE_PROGRAM); this.prodParam.enter(paramFlags); } checkDestructuringPrivate(refExpressionErrors) { const { privateKeyLoc } = refExpressionErrors; if (privateKeyLoc !== null) { this.expectPlugin("destructuringPrivate", privateKeyLoc); } } } class ExpressionErrors { constructor() { this.shorthandAssignLoc = null; this.doubleProtoLoc = null; this.privateKeyLoc = null; this.optionalParametersLoc = null; } } class Node { constructor(parser, pos, loc) { this.type = ""; this.start = pos; this.end = 0; this.loc = new SourceLocation(loc); if (parser != null && parser.options.ranges) this.range = [pos, 0]; if (parser != null && parser.filename) this.loc.filename = parser.filename; } } const NodePrototype = Node.prototype; { NodePrototype.__clone = function () { const newNode = new Node(undefined, this.start, this.loc.start); const keys = Object.keys(this); for (let i = 0, length = keys.length; i < length; i++) { const key = keys[i]; if (key !== "leadingComments" && key !== "trailingComments" && key !== "innerComments") { newNode[key] = this[key]; } } return newNode; }; } function clonePlaceholder(node) { return cloneIdentifier(node); } function cloneIdentifier(node) { const { type, start, end, loc, range, extra, name } = node; const cloned = Object.create(NodePrototype); cloned.type = type; cloned.start = start; cloned.end = end; cloned.loc = loc; cloned.range = range; cloned.extra = extra; cloned.name = name; if (type === "Placeholder") { cloned.expectedNode = node.expectedNode; } return cloned; } function cloneStringLiteral(node) { const { type, start, end, loc, range, extra } = node; if (type === "Placeholder") { return clonePlaceholder(node); } const cloned = Object.create(NodePrototype); cloned.type = type; cloned.start = start; cloned.end = end; cloned.loc = loc; cloned.range = range; if (node.raw !== undefined) { cloned.raw = node.raw; } else { cloned.extra = extra; } cloned.value = node.value; return cloned; } class NodeUtils extends UtilParser { startNode() { return new Node(this, this.state.start, this.state.startLoc); } startNodeAt(pos, loc) { return new Node(this, pos, loc); } startNodeAtNode(type) { return this.startNodeAt(type.start, type.loc.start); } finishNode(node, type) { return this.finishNodeAt(node, type, this.state.lastTokEndLoc); } finishNodeAt(node, type, endLoc) { node.type = type; node.end = endLoc.index; node.loc.end = endLoc; if (this.options.ranges) node.range[1] = endLoc.index; if (this.options.attachComment) this.processComment(node); return node; } resetStartLocation(node, start, startLoc) { node.start = start; node.loc.start = startLoc; if (this.options.ranges) node.range[0] = start; } resetEndLocation(node, endLoc = this.state.lastTokEndLoc) { node.end = endLoc.index; node.loc.end = endLoc; if (this.options.ranges) node.range[1] = endLoc.index; } resetStartLocationFromNode(node, locationNode) { this.resetStartLocation(node, locationNode.start, locationNode.loc.start); } } const reservedTypes = new Set(["_", "any", "bool", "boolean", "empty", "extends", "false", "interface", "mixed", "null", "number", "static", "string", "true", "typeof", "void"]); const FlowErrors = ParseErrorEnum`flow`({ AmbiguousConditionalArrow: "Ambiguous expression: wrap the arrow functions in parentheses to disambiguate.", AmbiguousDeclareModuleKind: "Found both `declare module.exports` and `declare export` in the same module. Modules can only have 1 since they are either an ES module or they are a CommonJS module.", AssignReservedType: ({ reservedType }) => `Cannot overwrite reserved type ${reservedType}.`, DeclareClassElement: "The `declare` modifier can only appear on class fields.", DeclareClassFieldInitializer: "Initializers are not allowed in fields with the `declare` modifier.", DuplicateDeclareModuleExports: "Duplicate `declare module.exports` statement.", EnumBooleanMemberNotInitialized: ({ memberName, enumName }) => `Boolean enum members need to be initialized. Use either \`${memberName} = true,\` or \`${memberName} = false,\` in enum \`${enumName}\`.`, EnumDuplicateMemberName: ({ memberName, enumName }) => `Enum member names need to be unique, but the name \`${memberName}\` has already been used before in enum \`${enumName}\`.`, EnumInconsistentMemberValues: ({ enumName }) => `Enum \`${enumName}\` has inconsistent member initializers. Either use no initializers, or consistently use literals (either booleans, numbers, or strings) for all member initializers.`, EnumInvalidExplicitType: ({ invalidEnumType, enumName }) => `Enum type \`${invalidEnumType}\` is not valid. Use one of \`boolean\`, \`number\`, \`string\`, or \`symbol\` in enum \`${enumName}\`.`, EnumInvalidExplicitTypeUnknownSupplied: ({ enumName }) => `Supplied enum type is not valid. Use one of \`boolean\`, \`number\`, \`string\`, or \`symbol\` in enum \`${enumName}\`.`, EnumInvalidMemberInitializerPrimaryType: ({ enumName, memberName, explicitType }) => `Enum \`${enumName}\` has type \`${explicitType}\`, so the initializer of \`${memberName}\` needs to be a ${explicitType} literal.`, EnumInvalidMemberInitializerSymbolType: ({ enumName, memberName }) => `Symbol enum members cannot be initialized. Use \`${memberName},\` in enum \`${enumName}\`.`, EnumInvalidMemberInitializerUnknownType: ({ enumName, memberName }) => `The enum member initializer for \`${memberName}\` needs to be a literal (either a boolean, number, or string) in enum \`${enumName}\`.`, EnumInvalidMemberName: ({ enumName, memberName, suggestion }) => `Enum member names cannot start with lowercase 'a' through 'z'. Instead of using \`${memberName}\`, consider using \`${suggestion}\`, in enum \`${enumName}\`.`, EnumNumberMemberNotInitialized: ({ enumName, memberName }) => `Number enum members need to be initialized, e.g. \`${memberName} = 1\` in enum \`${enumName}\`.`, EnumStringMemberInconsistentlyInitailized: ({ enumName }) => `String enum members need to consistently either all use initializers, or use no initializers, in enum \`${enumName}\`.`, GetterMayNotHaveThisParam: "A getter cannot have a `this` parameter.", ImportTypeShorthandOnlyInPureImport: "The `type` and `typeof` keywords on named imports can only be used on regular `import` statements. It cannot be used with `import type` or `import typeof` statements.", InexactInsideExact: "Explicit inexact syntax cannot appear inside an explicit exact object type.", InexactInsideNonObject: "Explicit inexact syntax cannot appear in class or interface definitions.", InexactVariance: "Explicit inexact syntax cannot have variance.", InvalidNonTypeImportInDeclareModule: "Imports within a `declare module` body must always be `import type` or `import typeof`.", MissingTypeParamDefault: "Type parameter declaration needs a default, since a preceding type parameter declaration has a default.", NestedDeclareModule: "`declare module` cannot be used inside another `declare module`.", NestedFlowComment: "Cannot have a flow comment inside another flow comment.", PatternIsOptional: Object.assign({ message: "A binding pattern parameter cannot be optional in an implementation signature." }, { reasonCode: "OptionalBindingPattern" }), SetterMayNotHaveThisParam: "A setter cannot have a `this` parameter.", SpreadVariance: "Spread properties cannot have variance.", ThisParamAnnotationRequired: "A type annotation is required for the `this` parameter.", ThisParamBannedInConstructor: "Constructors cannot have a `this` parameter; constructors don't bind `this` like other functions.", ThisParamMayNotBeOptional: "The `this` parameter cannot be optional.", ThisParamMustBeFirst: "The `this` parameter must be the first function parameter.", ThisParamNoDefault: "The `this` parameter may not have a default value.", TypeBeforeInitializer: "Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`.", TypeCastInPattern: "The type cast expression is expected to be wrapped with parenthesis.", UnexpectedExplicitInexactInObject: "Explicit inexact syntax must appear at the end of an inexact object.", UnexpectedReservedType: ({ reservedType }) => `Unexpected reserved type ${reservedType}.`, UnexpectedReservedUnderscore: "`_` is only allowed as a type argument to call or new.", UnexpectedSpaceBetweenModuloChecks: "Spaces between `%` and `checks` are not allowed here.", UnexpectedSpreadType: "Spread operator cannot appear in class or interface definitions.", UnexpectedSubtractionOperand: 'Unexpected token, expected "number" or "bigint".', UnexpectedTokenAfterTypeParameter: "Expected an arrow function after this type parameter declaration.", UnexpectedTypeParameterBeforeAsyncArrowFunction: "Type parameters must come after the async keyword, e.g. instead of ` async () => {}`, use `async () => {}`.", UnsupportedDeclareExportKind: ({ unsupportedExportKind, suggestion }) => `\`declare export ${unsupportedExportKind}\` is not supported. Use \`${suggestion}\` instead.`, UnsupportedStatementInDeclareModule: "Only declares and type imports are allowed inside declare module.", UnterminatedFlowComment: "Unterminated flow-comment." }); function isEsModuleType(bodyElement) { return bodyElement.type === "DeclareExportAllDeclaration" || bodyElement.type === "DeclareExportDeclaration" && (!bodyElement.declaration || bodyElement.declaration.type !== "TypeAlias" && bodyElement.declaration.type !== "InterfaceDeclaration"); } function hasTypeImportKind(node) { return node.importKind === "type" || node.importKind === "typeof"; } function isMaybeDefaultImport(type) { return tokenIsKeywordOrIdentifier(type) && type !== 97; } const exportSuggestions = { const: "declare export var", let: "declare export var", type: "export type", interface: "export interface" }; function partition(list, test) { const list1 = []; const list2 = []; for (let i = 0; i < list.length; i++) { (test(list[i], i, list) ? list1 : list2).push(list[i]); } return [list1, list2]; } const FLOW_PRAGMA_REGEX = /\*?\s*@((?:no)?flow)\b/; var flow = (superClass => class FlowParserMixin extends superClass { constructor(...args) { super(...args); this.flowPragma = undefined; } getScopeHandler() { return FlowScopeHandler; } shouldParseTypes() { return this.getPluginOption("flow", "all") || this.flowPragma === "flow"; } shouldParseEnums() { return !!this.getPluginOption("flow", "enums"); } finishToken(type, val) { if (type !== 129 && type !== 13 && type !== 28) { if (this.flowPragma === undefined) { this.flowPragma = null; } } return super.finishToken(type, val); } addComment(comment) { if (this.flowPragma === undefined) { const matches = FLOW_PRAGMA_REGEX.exec(comment.value); if (!matches) ; else if (matches[1] === "flow") { this.flowPragma = "flow"; } else if (matches[1] === "noflow") { this.flowPragma = "noflow"; } else { throw new Error("Unexpected flow pragma"); } } return super.addComment(comment); } flowParseTypeInitialiser(tok) { const oldInType = this.state.inType; this.state.inType = true; this.expect(tok || 14); const type = this.flowParseType(); this.state.inType = oldInType; return type; } flowParsePredicate() { const node = this.startNode(); const moduloLoc = this.state.startLoc; this.next(); this.expectContextual(107); if (this.state.lastTokStart > moduloLoc.index + 1) { this.raise(FlowErrors.UnexpectedSpaceBetweenModuloChecks, { at: moduloLoc }); } if (this.eat(10)) { node.value = super.parseExpression(); this.expect(11); return this.finishNode(node, "DeclaredPredicate"); } else { return this.finishNode(node, "InferredPredicate"); } } flowParseTypeAndPredicateInitialiser() { const oldInType = this.state.inType; this.state.inType = true; this.expect(14); let type = null; let predicate = null; if (this.match(54)) { this.state.inType = oldInType; predicate = this.flowParsePredicate(); } else { type = this.flowParseType(); this.state.inType = oldInType; if (this.match(54)) { predicate = this.flowParsePredicate(); } } return [type, predicate]; } flowParseDeclareClass(node) { this.next(); this.flowParseInterfaceish(node, true); return this.finishNode(node, "DeclareClass"); } flowParseDeclareFunction(node) { this.next(); const id = node.id = this.parseIdentifier(); const typeNode = this.startNode(); const typeContainer = this.startNode(); if (this.match(47)) { typeNode.typeParameters = this.flowParseTypeParameterDeclaration(); } else { typeNode.typeParameters = null; } this.expect(10); const tmp = this.flowParseFunctionTypeParams(); typeNode.params = tmp.params; typeNode.rest = tmp.rest; typeNode.this = tmp._this; this.expect(11); [typeNode.returnType, node.predicate] = this.flowParseTypeAndPredicateInitialiser(); typeContainer.typeAnnotation = this.finishNode(typeNode, "FunctionTypeAnnotation"); id.typeAnnotation = this.finishNode(typeContainer, "TypeAnnotation"); this.resetEndLocation(id); this.semicolon(); this.scope.declareName(node.id.name, BIND_FLOW_DECLARE_FN, node.id.loc.start); return this.finishNode(node, "DeclareFunction"); } flowParseDeclare(node, insideModule) { if (this.match(80)) { return this.flowParseDeclareClass(node); } else if (this.match(68)) { return this.flowParseDeclareFunction(node); } else if (this.match(74)) { return this.flowParseDeclareVariable(node); } else if (this.eatContextual(123)) { if (this.match(16)) { return this.flowParseDeclareModuleExports(node); } else { if (insideModule) { this.raise(FlowErrors.NestedDeclareModule, { at: this.state.lastTokStartLoc }); } return this.flowParseDeclareModule(node); } } else if (this.isContextual(126)) { return this.flowParseDeclareTypeAlias(node); } else if (this.isContextual(127)) { return this.flowParseDeclareOpaqueType(node); } else if (this.isContextual(125)) { return this.flowParseDeclareInterface(node); } else if (this.match(82)) { return this.flowParseDeclareExportDeclaration(node, insideModule); } else { throw this.unexpected(); } } flowParseDeclareVariable(node) { this.next(); node.id = this.flowParseTypeAnnotatableIdentifier(true); this.scope.declareName(node.id.name, BIND_VAR, node.id.loc.start); this.semicolon(); return this.finishNode(node, "DeclareVariable"); } flowParseDeclareModule(node) { this.scope.enter(SCOPE_OTHER); if (this.match(129)) { node.id = super.parseExprAtom(); } else { node.id = this.parseIdentifier(); } const bodyNode = node.body = this.startNode(); const body = bodyNode.body = []; this.expect(5); while (!this.match(8)) { let bodyNode = this.startNode(); if (this.match(83)) { this.next(); if (!this.isContextual(126) && !this.match(87)) { this.raise(FlowErrors.InvalidNonTypeImportInDeclareModule, { at: this.state.lastTokStartLoc }); } super.parseImport(bodyNode); } else { this.expectContextual(121, FlowErrors.UnsupportedStatementInDeclareModule); bodyNode = this.flowParseDeclare(bodyNode, true); } body.push(bodyNode); } this.scope.exit(); this.expect(8); this.finishNode(bodyNode, "BlockStatement"); let kind = null; let hasModuleExport = false; body.forEach(bodyElement => { if (isEsModuleType(bodyElement)) { if (kind === "CommonJS") { this.raise(FlowErrors.AmbiguousDeclareModuleKind, { at: bodyElement }); } kind = "ES"; } else if (bodyElement.type === "DeclareModuleExports") { if (hasModuleExport) { this.raise(FlowErrors.DuplicateDeclareModuleExports, { at: bodyElement }); } if (kind === "ES") { this.raise(FlowErrors.AmbiguousDeclareModuleKind, { at: bodyElement }); } kind = "CommonJS"; hasModuleExport = true; } }); node.kind = kind || "CommonJS"; return this.finishNode(node, "DeclareModule"); } flowParseDeclareExportDeclaration(node, insideModule) { this.expect(82); if (this.eat(65)) { if (this.match(68) || this.match(80)) { node.declaration = this.flowParseDeclare(this.startNode()); } else { node.declaration = this.flowParseType(); this.semicolon(); } node.default = true; return this.finishNode(node, "DeclareExportDeclaration"); } else { if (this.match(75) || this.isLet() || (this.isContextual(126) || this.isContextual(125)) && !insideModule) { const label = this.state.value; throw this.raise(FlowErrors.UnsupportedDeclareExportKind, { at: this.state.startLoc, unsupportedExportKind: label, suggestion: exportSuggestions[label] }); } if (this.match(74) || this.match(68) || this.match(80) || this.isContextual(127)) { node.declaration = this.flowParseDeclare(this.startNode()); node.default = false; return this.finishNode(node, "DeclareExportDeclaration"); } else if (this.match(55) || this.match(5) || this.isContextual(125) || this.isContextual(126) || this.isContextual(127)) { node = this.parseExport(node); if (node.type === "ExportNamedDeclaration") { node.type = "ExportDeclaration"; node.default = false; delete node.exportKind; } node.type = "Declare" + node.type; return node; } } throw this.unexpected(); } flowParseDeclareModuleExports(node) { this.next(); this.expectContextual(108); node.typeAnnotation = this.flowParseTypeAnnotation(); this.semicolon(); return this.finishNode(node, "DeclareModuleExports"); } flowParseDeclareTypeAlias(node) { this.next(); const finished = this.flowParseTypeAlias(node); finished.type = "DeclareTypeAlias"; return finished; } flowParseDeclareOpaqueType(node) { this.next(); const finished = this.flowParseOpaqueType(node, true); finished.type = "DeclareOpaqueType"; return finished; } flowParseDeclareInterface(node) { this.next(); this.flowParseInterfaceish(node); return this.finishNode(node, "DeclareInterface"); } flowParseInterfaceish(node, isClass = false) { node.id = this.flowParseRestrictedIdentifier(!isClass, true); this.scope.declareName(node.id.name, isClass ? BIND_FUNCTION : BIND_LEXICAL, node.id.loc.start); if (this.match(47)) { node.typeParameters = this.flowParseTypeParameterDeclaration(); } else { node.typeParameters = null; } node.extends = []; node.implements = []; node.mixins = []; if (this.eat(81)) { do { node.extends.push(this.flowParseInterfaceExtends()); } while (!isClass && this.eat(12)); } if (this.isContextual(114)) { this.next(); do { node.mixins.push(this.flowParseInterfaceExtends()); } while (this.eat(12)); } if (this.isContextual(110)) { this.next(); do { node.implements.push(this.flowParseInterfaceExtends()); } while (this.eat(12)); } node.body = this.flowParseObjectType({ allowStatic: isClass, allowExact: false, allowSpread: false, allowProto: isClass, allowInexact: false }); } flowParseInterfaceExtends() { const node = this.startNode(); node.id = this.flowParseQualifiedTypeIdentifier(); if (this.match(47)) { node.typeParameters = this.flowParseTypeParameterInstantiation(); } else { node.typeParameters = null; } return this.finishNode(node, "InterfaceExtends"); } flowParseInterface(node) { this.flowParseInterfaceish(node); return this.finishNode(node, "InterfaceDeclaration"); } checkNotUnderscore(word) { if (word === "_") { this.raise(FlowErrors.UnexpectedReservedUnderscore, { at: this.state.startLoc }); } } checkReservedType(word, startLoc, declaration) { if (!reservedTypes.has(word)) return; this.raise(declaration ? FlowErrors.AssignReservedType : FlowErrors.UnexpectedReservedType, { at: startLoc, reservedType: word }); } flowParseRestrictedIdentifier(liberal, declaration) { this.checkReservedType(this.state.value, this.state.startLoc, declaration); return this.parseIdentifier(liberal); } flowParseTypeAlias(node) { node.id = this.flowParseRestrictedIdentifier(false, true); this.scope.declareName(node.id.name, BIND_LEXICAL, node.id.loc.start); if (this.match(47)) { node.typeParameters = this.flowParseTypeParameterDeclaration(); } else { node.typeParameters = null; } node.right = this.flowParseTypeInitialiser(29); this.semicolon(); return this.finishNode(node, "TypeAlias"); } flowParseOpaqueType(node, declare) { this.expectContextual(126); node.id = this.flowParseRestrictedIdentifier(true, true); this.scope.declareName(node.id.name, BIND_LEXICAL, node.id.loc.start); if (this.match(47)) { node.typeParameters = this.flowParseTypeParameterDeclaration(); } else { node.typeParameters = null; } node.supertype = null; if (this.match(14)) { node.supertype = this.flowParseTypeInitialiser(14); } node.impltype = null; if (!declare) { node.impltype = this.flowParseTypeInitialiser(29); } this.semicolon(); return this.finishNode(node, "OpaqueType"); } flowParseTypeParameter(requireDefault = false) { const nodeStartLoc = this.state.startLoc; const node = this.startNode(); const variance = this.flowParseVariance(); const ident = this.flowParseTypeAnnotatableIdentifier(); node.name = ident.name; node.variance = variance; node.bound = ident.typeAnnotation; if (this.match(29)) { this.eat(29); node.default = this.flowParseType(); } else { if (requireDefault) { this.raise(FlowErrors.MissingTypeParamDefault, { at: nodeStartLoc }); } } return this.finishNode(node, "TypeParameter"); } flowParseTypeParameterDeclaration() { const oldInType = this.state.inType; const node = this.startNode(); node.params = []; this.state.inType = true; if (this.match(47) || this.match(138)) { this.next(); } else { this.unexpected(); } let defaultRequired = false; do { const typeParameter = this.flowParseTypeParameter(defaultRequired); node.params.push(typeParameter); if (typeParameter.default) { defaultRequired = true; } if (!this.match(48)) { this.expect(12); } } while (!this.match(48)); this.expect(48); this.state.inType = oldInType; return this.finishNode(node, "TypeParameterDeclaration"); } flowParseTypeParameterInstantiation() { const node = this.startNode(); const oldInType = this.state.inType; node.params = []; this.state.inType = true; this.expect(47); const oldNoAnonFunctionType = this.state.noAnonFunctionType; this.state.noAnonFunctionType = false; while (!this.match(48)) { node.params.push(this.flowParseType()); if (!this.match(48)) { this.expect(12); } } this.state.noAnonFunctionType = oldNoAnonFunctionType; this.expect(48); this.state.inType = oldInType; return this.finishNode(node, "TypeParameterInstantiation"); } flowParseTypeParameterInstantiationCallOrNew() { const node = this.startNode(); const oldInType = this.state.inType; node.params = []; this.state.inType = true; this.expect(47); while (!this.match(48)) { node.params.push(this.flowParseTypeOrImplicitInstantiation()); if (!this.match(48)) { this.expect(12); } } this.expect(48); this.state.inType = oldInType; return this.finishNode(node, "TypeParameterInstantiation"); } flowParseInterfaceType() { const node = this.startNode(); this.expectContextual(125); node.extends = []; if (this.eat(81)) { do { node.extends.push(this.flowParseInterfaceExtends()); } while (this.eat(12)); } node.body = this.flowParseObjectType({ allowStatic: false, allowExact: false, allowSpread: false, allowProto: false, allowInexact: false }); return this.finishNode(node, "InterfaceTypeAnnotation"); } flowParseObjectPropertyKey() { return this.match(130) || this.match(129) ? super.parseExprAtom() : this.parseIdentifier(true); } flowParseObjectTypeIndexer(node, isStatic, variance) { node.static = isStatic; if (this.lookahead().type === 14) { node.id = this.flowParseObjectPropertyKey(); node.key = this.flowParseTypeInitialiser(); } else { node.id = null; node.key = this.flowParseType(); } this.expect(3); node.value = this.flowParseTypeInitialiser(); node.variance = variance; return this.finishNode(node, "ObjectTypeIndexer"); } flowParseObjectTypeInternalSlot(node, isStatic) { node.static = isStatic; node.id = this.flowParseObjectPropertyKey(); this.expect(3); this.expect(3); if (this.match(47) || this.match(10)) { node.method = true; node.optional = false; node.value = this.flowParseObjectTypeMethodish(this.startNodeAt(node.start, node.loc.start)); } else { node.method = false; if (this.eat(17)) { node.optional = true; } node.value = this.flowParseTypeInitialiser(); } return this.finishNode(node, "ObjectTypeInternalSlot"); } flowParseObjectTypeMethodish(node) { node.params = []; node.rest = null; node.typeParameters = null; node.this = null; if (this.match(47)) { node.typeParameters = this.flowParseTypeParameterDeclaration(); } this.expect(10); if (this.match(78)) { node.this = this.flowParseFunctionTypeParam(true); node.this.name = null; if (!this.match(11)) { this.expect(12); } } while (!this.match(11) && !this.match(21)) { node.params.push(this.flowParseFunctionTypeParam(false)); if (!this.match(11)) { this.expect(12); } } if (this.eat(21)) { node.rest = this.flowParseFunctionTypeParam(false); } this.expect(11); node.returnType = this.flowParseTypeInitialiser(); return this.finishNode(node, "FunctionTypeAnnotation"); } flowParseObjectTypeCallProperty(node, isStatic) { const valueNode = this.startNode(); node.static = isStatic; node.value = this.flowParseObjectTypeMethodish(valueNode); return this.finishNode(node, "ObjectTypeCallProperty"); } flowParseObjectType({ allowStatic, allowExact, allowSpread, allowProto, allowInexact }) { const oldInType = this.state.inType; this.state.inType = true; const nodeStart = this.startNode(); nodeStart.callProperties = []; nodeStart.properties = []; nodeStart.indexers = []; nodeStart.internalSlots = []; let endDelim; let exact; let inexact = false; if (allowExact && this.match(6)) { this.expect(6); endDelim = 9; exact = true; } else { this.expect(5); endDelim = 8; exact = false; } nodeStart.exact = exact; while (!this.match(endDelim)) { let isStatic = false; let protoStartLoc = null; let inexactStartLoc = null; const node = this.startNode(); if (allowProto && this.isContextual(115)) { const lookahead = this.lookahead(); if (lookahead.type !== 14 && lookahead.type !== 17) { this.next(); protoStartLoc = this.state.startLoc; allowStatic = false; } } if (allowStatic && this.isContextual(104)) { const lookahead = this.lookahead(); if (lookahead.type !== 14 && lookahead.type !== 17) { this.next(); isStatic = true; } } const variance = this.flowParseVariance(); if (this.eat(0)) { if (protoStartLoc != null) { this.unexpected(protoStartLoc); } if (this.eat(0)) { if (variance) { this.unexpected(variance.loc.start); } nodeStart.internalSlots.push(this.flowParseObjectTypeInternalSlot(node, isStatic)); } else { nodeStart.indexers.push(this.flowParseObjectTypeIndexer(node, isStatic, variance)); } } else if (this.match(10) || this.match(47)) { if (protoStartLoc != null) { this.unexpected(protoStartLoc); } if (variance) { this.unexpected(variance.loc.start); } nodeStart.callProperties.push(this.flowParseObjectTypeCallProperty(node, isStatic)); } else { let kind = "init"; if (this.isContextual(98) || this.isContextual(103)) { const lookahead = this.lookahead(); if (tokenIsLiteralPropertyName(lookahead.type)) { kind = this.state.value; this.next(); } } const propOrInexact = this.flowParseObjectTypeProperty(node, isStatic, protoStartLoc, variance, kind, allowSpread, allowInexact != null ? allowInexact : !exact); if (propOrInexact === null) { inexact = true; inexactStartLoc = this.state.lastTokStartLoc; } else { nodeStart.properties.push(propOrInexact); } } this.flowObjectTypeSemicolon(); if (inexactStartLoc && !this.match(8) && !this.match(9)) { this.raise(FlowErrors.UnexpectedExplicitInexactInObject, { at: inexactStartLoc }); } } this.expect(endDelim); if (allowSpread) { nodeStart.inexact = inexact; } const out = this.finishNode(nodeStart, "ObjectTypeAnnotation"); this.state.inType = oldInType; return out; } flowParseObjectTypeProperty(node, isStatic, protoStartLoc, variance, kind, allowSpread, allowInexact) { if (this.eat(21)) { const isInexactToken = this.match(12) || this.match(13) || this.match(8) || this.match(9); if (isInexactToken) { if (!allowSpread) { this.raise(FlowErrors.InexactInsideNonObject, { at: this.state.lastTokStartLoc }); } else if (!allowInexact) { this.raise(FlowErrors.InexactInsideExact, { at: this.state.lastTokStartLoc }); } if (variance) { this.raise(FlowErrors.InexactVariance, { at: variance }); } return null; } if (!allowSpread) { this.raise(FlowErrors.UnexpectedSpreadType, { at: this.state.lastTokStartLoc }); } if (protoStartLoc != null) { this.unexpected(protoStartLoc); } if (variance) { this.raise(FlowErrors.SpreadVariance, { at: variance }); } node.argument = this.flowParseType(); return this.finishNode(node, "ObjectTypeSpreadProperty"); } else { node.key = this.flowParseObjectPropertyKey(); node.static = isStatic; node.proto = protoStartLoc != null; node.kind = kind; let optional = false; if (this.match(47) || this.match(10)) { node.method = true; if (protoStartLoc != null) { this.unexpected(protoStartLoc); } if (variance) { this.unexpected(variance.loc.start); } node.value = this.flowParseObjectTypeMethodish(this.startNodeAt(node.start, node.loc.start)); if (kind === "get" || kind === "set") { this.flowCheckGetterSetterParams(node); } if (!allowSpread && node.key.name === "constructor" && node.value.this) { this.raise(FlowErrors.ThisParamBannedInConstructor, { at: node.value.this }); } } else { if (kind !== "init") this.unexpected(); node.method = false; if (this.eat(17)) { optional = true; } node.value = this.flowParseTypeInitialiser(); node.variance = variance; } node.optional = optional; return this.finishNode(node, "ObjectTypeProperty"); } } flowCheckGetterSetterParams(property) { const paramCount = property.kind === "get" ? 0 : 1; const length = property.value.params.length + (property.value.rest ? 1 : 0); if (property.value.this) { this.raise(property.kind === "get" ? FlowErrors.GetterMayNotHaveThisParam : FlowErrors.SetterMayNotHaveThisParam, { at: property.value.this }); } if (length !== paramCount) { this.raise(property.kind === "get" ? Errors.BadGetterArity : Errors.BadSetterArity, { at: property }); } if (property.kind === "set" && property.value.rest) { this.raise(Errors.BadSetterRestParameter, { at: property }); } } flowObjectTypeSemicolon() { if (!this.eat(13) && !this.eat(12) && !this.match(8) && !this.match(9)) { this.unexpected(); } } flowParseQualifiedTypeIdentifier(startPos, startLoc, id) { startPos = startPos || this.state.start; startLoc = startLoc || this.state.startLoc; let node = id || this.flowParseRestrictedIdentifier(true); while (this.eat(16)) { const node2 = this.startNodeAt(startPos, startLoc); node2.qualification = node; node2.id = this.flowParseRestrictedIdentifier(true); node = this.finishNode(node2, "QualifiedTypeIdentifier"); } return node; } flowParseGenericType(startPos, startLoc, id) { const node = this.startNodeAt(startPos, startLoc); node.typeParameters = null; node.id = this.flowParseQualifiedTypeIdentifier(startPos, startLoc, id); if (this.match(47)) { node.typeParameters = this.flowParseTypeParameterInstantiation(); } return this.finishNode(node, "GenericTypeAnnotation"); } flowParseTypeofType() { const node = this.startNode(); this.expect(87); node.argument = this.flowParsePrimaryType(); return this.finishNode(node, "TypeofTypeAnnotation"); } flowParseTupleType() { const node = this.startNode(); node.types = []; this.expect(0); while (this.state.pos < this.length && !this.match(3)) { node.types.push(this.flowParseType()); if (this.match(3)) break; this.expect(12); } this.expect(3); return this.finishNode(node, "TupleTypeAnnotation"); } flowParseFunctionTypeParam(first) { let name = null; let optional = false; let typeAnnotation = null; const node = this.startNode(); const lh = this.lookahead(); const isThis = this.state.type === 78; if (lh.type === 14 || lh.type === 17) { if (isThis && !first) { this.raise(FlowErrors.ThisParamMustBeFirst, { at: node }); } name = this.parseIdentifier(isThis); if (this.eat(17)) { optional = true; if (isThis) { this.raise(FlowErrors.ThisParamMayNotBeOptional, { at: node }); } } typeAnnotation = this.flowParseTypeInitialiser(); } else { typeAnnotation = this.flowParseType(); } node.name = name; node.optional = optional; node.typeAnnotation = typeAnnotation; return this.finishNode(node, "FunctionTypeParam"); } reinterpretTypeAsFunctionTypeParam(type) { const node = this.startNodeAt(type.start, type.loc.start); node.name = null; node.optional = false; node.typeAnnotation = type; return this.finishNode(node, "FunctionTypeParam"); } flowParseFunctionTypeParams(params = []) { let rest = null; let _this = null; if (this.match(78)) { _this = this.flowParseFunctionTypeParam(true); _this.name = null; if (!this.match(11)) { this.expect(12); } } while (!this.match(11) && !this.match(21)) { params.push(this.flowParseFunctionTypeParam(false)); if (!this.match(11)) { this.expect(12); } } if (this.eat(21)) { rest = this.flowParseFunctionTypeParam(false); } return { params, rest, _this }; } flowIdentToTypeAnnotation(startPos, startLoc, node, id) { switch (id.name) { case "any": return this.finishNode(node, "AnyTypeAnnotation"); case "bool": case "boolean": return this.finishNode(node, "BooleanTypeAnnotation"); case "mixed": return this.finishNode(node, "MixedTypeAnnotation"); case "empty": return this.finishNode(node, "EmptyTypeAnnotation"); case "number": return this.finishNode(node, "NumberTypeAnnotation"); case "string": return this.finishNode(node, "StringTypeAnnotation"); case "symbol": return this.finishNode(node, "SymbolTypeAnnotation"); default: this.checkNotUnderscore(id.name); return this.flowParseGenericType(startPos, startLoc, id); } } flowParsePrimaryType() { const startPos = this.state.start; const startLoc = this.state.startLoc; const node = this.startNode(); let tmp; let type; let isGroupedType = false; const oldNoAnonFunctionType = this.state.noAnonFunctionType; switch (this.state.type) { case 5: return this.flowParseObjectType({ allowStatic: false, allowExact: false, allowSpread: true, allowProto: false, allowInexact: true }); case 6: return this.flowParseObjectType({ allowStatic: false, allowExact: true, allowSpread: true, allowProto: false, allowInexact: false }); case 0: this.state.noAnonFunctionType = false; type = this.flowParseTupleType(); this.state.noAnonFunctionType = oldNoAnonFunctionType; return type; case 47: node.typeParameters = this.flowParseTypeParameterDeclaration(); this.expect(10); tmp = this.flowParseFunctionTypeParams(); node.params = tmp.params; node.rest = tmp.rest; node.this = tmp._this; this.expect(11); this.expect(19); node.returnType = this.flowParseType(); return this.finishNode(node, "FunctionTypeAnnotation"); case 10: this.next(); if (!this.match(11) && !this.match(21)) { if (tokenIsIdentifier(this.state.type) || this.match(78)) { const token = this.lookahead().type; isGroupedType = token !== 17 && token !== 14; } else { isGroupedType = true; } } if (isGroupedType) { this.state.noAnonFunctionType = false; type = this.flowParseType(); this.state.noAnonFunctionType = oldNoAnonFunctionType; if (this.state.noAnonFunctionType || !(this.match(12) || this.match(11) && this.lookahead().type === 19)) { this.expect(11); return type; } else { this.eat(12); } } if (type) { tmp = this.flowParseFunctionTypeParams([this.reinterpretTypeAsFunctionTypeParam(type)]); } else { tmp = this.flowParseFunctionTypeParams(); } node.params = tmp.params; node.rest = tmp.rest; node.this = tmp._this; this.expect(11); this.expect(19); node.returnType = this.flowParseType(); node.typeParameters = null; return this.finishNode(node, "FunctionTypeAnnotation"); case 129: return this.parseLiteral(this.state.value, "StringLiteralTypeAnnotation"); case 85: case 86: node.value = this.match(85); this.next(); return this.finishNode(node, "BooleanLiteralTypeAnnotation"); case 53: if (this.state.value === "-") { this.next(); if (this.match(130)) { return this.parseLiteralAtNode(-this.state.value, "NumberLiteralTypeAnnotation", node); } if (this.match(131)) { return this.parseLiteralAtNode(-this.state.value, "BigIntLiteralTypeAnnotation", node); } throw this.raise(FlowErrors.UnexpectedSubtractionOperand, { at: this.state.startLoc }); } throw this.unexpected(); case 130: return this.parseLiteral(this.state.value, "NumberLiteralTypeAnnotation"); case 131: return this.parseLiteral(this.state.value, "BigIntLiteralTypeAnnotation"); case 88: this.next(); return this.finishNode(node, "VoidTypeAnnotation"); case 84: this.next(); return this.finishNode(node, "NullLiteralTypeAnnotation"); case 78: this.next(); return this.finishNode(node, "ThisTypeAnnotation"); case 55: this.next(); return this.finishNode(node, "ExistsTypeAnnotation"); case 87: return this.flowParseTypeofType(); default: if (tokenIsKeyword(this.state.type)) { const label = tokenLabelName(this.state.type); this.next(); return super.createIdentifier(node, label); } else if (tokenIsIdentifier(this.state.type)) { if (this.isContextual(125)) { return this.flowParseInterfaceType(); } return this.flowIdentToTypeAnnotation(startPos, startLoc, node, this.parseIdentifier()); } } throw this.unexpected(); } flowParsePostfixType() { const startPos = this.state.start; const startLoc = this.state.startLoc; let type = this.flowParsePrimaryType(); let seenOptionalIndexedAccess = false; while ((this.match(0) || this.match(18)) && !this.canInsertSemicolon()) { const node = this.startNodeAt(startPos, startLoc); const optional = this.eat(18); seenOptionalIndexedAccess = seenOptionalIndexedAccess || optional; this.expect(0); if (!optional && this.match(3)) { node.elementType = type; this.next(); type = this.finishNode(node, "ArrayTypeAnnotation"); } else { node.objectType = type; node.indexType = this.flowParseType(); this.expect(3); if (seenOptionalIndexedAccess) { node.optional = optional; type = this.finishNode(node, "OptionalIndexedAccessType"); } else { type = this.finishNode(node, "IndexedAccessType"); } } } return type; } flowParsePrefixType() { const node = this.startNode(); if (this.eat(17)) { node.typeAnnotation = this.flowParsePrefixType(); return this.finishNode(node, "NullableTypeAnnotation"); } else { return this.flowParsePostfixType(); } } flowParseAnonFunctionWithoutParens() { const param = this.flowParsePrefixType(); if (!this.state.noAnonFunctionType && this.eat(19)) { const node = this.startNodeAt(param.start, param.loc.start); node.params = [this.reinterpretTypeAsFunctionTypeParam(param)]; node.rest = null; node.this = null; node.returnType = this.flowParseType(); node.typeParameters = null; return this.finishNode(node, "FunctionTypeAnnotation"); } return param; } flowParseIntersectionType() { const node = this.startNode(); this.eat(45); const type = this.flowParseAnonFunctionWithoutParens(); node.types = [type]; while (this.eat(45)) { node.types.push(this.flowParseAnonFunctionWithoutParens()); } return node.types.length === 1 ? type : this.finishNode(node, "IntersectionTypeAnnotation"); } flowParseUnionType() { const node = this.startNode(); this.eat(43); const type = this.flowParseIntersectionType(); node.types = [type]; while (this.eat(43)) { node.types.push(this.flowParseIntersectionType()); } return node.types.length === 1 ? type : this.finishNode(node, "UnionTypeAnnotation"); } flowParseType() { const oldInType = this.state.inType; this.state.inType = true; const type = this.flowParseUnionType(); this.state.inType = oldInType; return type; } flowParseTypeOrImplicitInstantiation() { if (this.state.type === 128 && this.state.value === "_") { const startPos = this.state.start; const startLoc = this.state.startLoc; const node = this.parseIdentifier(); return this.flowParseGenericType(startPos, startLoc, node); } else { return this.flowParseType(); } } flowParseTypeAnnotation() { const node = this.startNode(); node.typeAnnotation = this.flowParseTypeInitialiser(); return this.finishNode(node, "TypeAnnotation"); } flowParseTypeAnnotatableIdentifier(allowPrimitiveOverride) { const ident = allowPrimitiveOverride ? this.parseIdentifier() : this.flowParseRestrictedIdentifier(); if (this.match(14)) { ident.typeAnnotation = this.flowParseTypeAnnotation(); this.resetEndLocation(ident); } return ident; } typeCastToParameter(node) { node.expression.typeAnnotation = node.typeAnnotation; this.resetEndLocation(node.expression, node.typeAnnotation.loc.end); return node.expression; } flowParseVariance() { let variance = null; if (this.match(53)) { variance = this.startNode(); if (this.state.value === "+") { variance.kind = "plus"; } else { variance.kind = "minus"; } this.next(); return this.finishNode(variance, "Variance"); } return variance; } parseFunctionBody(node, allowExpressionBody, isMethod = false) { if (allowExpressionBody) { return this.forwardNoArrowParamsConversionAt(node, () => super.parseFunctionBody(node, true, isMethod)); } return super.parseFunctionBody(node, false, isMethod); } parseFunctionBodyAndFinish(node, type, isMethod = false) { if (this.match(14)) { const typeNode = this.startNode(); [typeNode.typeAnnotation, node.predicate] = this.flowParseTypeAndPredicateInitialiser(); node.returnType = typeNode.typeAnnotation ? this.finishNode(typeNode, "TypeAnnotation") : null; } return super.parseFunctionBodyAndFinish(node, type, isMethod); } parseStatement(context, topLevel) { if (this.state.strict && this.isContextual(125)) { const lookahead = this.lookahead(); if (tokenIsKeywordOrIdentifier(lookahead.type)) { const node = this.startNode(); this.next(); return this.flowParseInterface(node); } } else if (this.shouldParseEnums() && this.isContextual(122)) { const node = this.startNode(); this.next(); return this.flowParseEnumDeclaration(node); } const stmt = super.parseStatement(context, topLevel); if (this.flowPragma === undefined && !this.isValidDirective(stmt)) { this.flowPragma = null; } return stmt; } parseExpressionStatement(node, expr) { if (expr.type === "Identifier") { if (expr.name === "declare") { if (this.match(80) || tokenIsIdentifier(this.state.type) || this.match(68) || this.match(74) || this.match(82)) { return this.flowParseDeclare(node); } } else if (tokenIsIdentifier(this.state.type)) { if (expr.name === "interface") { return this.flowParseInterface(node); } else if (expr.name === "type") { return this.flowParseTypeAlias(node); } else if (expr.name === "opaque") { return this.flowParseOpaqueType(node, false); } } } return super.parseExpressionStatement(node, expr); } shouldParseExportDeclaration() { const { type } = this.state; if (tokenIsFlowInterfaceOrTypeOrOpaque(type) || this.shouldParseEnums() && type === 122) { return !this.state.containsEsc; } return super.shouldParseExportDeclaration(); } isExportDefaultSpecifier() { const { type } = this.state; if (tokenIsFlowInterfaceOrTypeOrOpaque(type) || this.shouldParseEnums() && type === 122) { return this.state.containsEsc; } return super.isExportDefaultSpecifier(); } parseExportDefaultExpression() { if (this.shouldParseEnums() && this.isContextual(122)) { const node = this.startNode(); this.next(); return this.flowParseEnumDeclaration(node); } return super.parseExportDefaultExpression(); } parseConditional(expr, startPos, startLoc, refExpressionErrors) { if (!this.match(17)) return expr; if (this.state.maybeInArrowParameters) { const nextCh = this.lookaheadCharCode(); if (nextCh === 44 || nextCh === 61 || nextCh === 58 || nextCh === 41) { this.setOptionalParametersError(refExpressionErrors); return expr; } } this.expect(17); const state = this.state.clone(); const originalNoArrowAt = this.state.noArrowAt; const node = this.startNodeAt(startPos, startLoc); let { consequent, failed } = this.tryParseConditionalConsequent(); let [valid, invalid] = this.getArrowLikeExpressions(consequent); if (failed || invalid.length > 0) { const noArrowAt = [...originalNoArrowAt]; if (invalid.length > 0) { this.state = state; this.state.noArrowAt = noArrowAt; for (let i = 0; i < invalid.length; i++) { noArrowAt.push(invalid[i].start); } ({ consequent, failed } = this.tryParseConditionalConsequent()); [valid, invalid] = this.getArrowLikeExpressions(consequent); } if (failed && valid.length > 1) { this.raise(FlowErrors.AmbiguousConditionalArrow, { at: state.startLoc }); } if (failed && valid.length === 1) { this.state = state; noArrowAt.push(valid[0].start); this.state.noArrowAt = noArrowAt; ({ consequent, failed } = this.tryParseConditionalConsequent()); } } this.getArrowLikeExpressions(consequent, true); this.state.noArrowAt = originalNoArrowAt; this.expect(14); node.test = expr; node.consequent = consequent; node.alternate = this.forwardNoArrowParamsConversionAt(node, () => this.parseMaybeAssign(undefined, undefined)); return this.finishNode(node, "ConditionalExpression"); } tryParseConditionalConsequent() { this.state.noArrowParamsConversionAt.push(this.state.start); const consequent = this.parseMaybeAssignAllowIn(); const failed = !this.match(14); this.state.noArrowParamsConversionAt.pop(); return { consequent, failed }; } getArrowLikeExpressions(node, disallowInvalid) { const stack = [node]; const arrows = []; while (stack.length !== 0) { const node = stack.pop(); if (node.type === "ArrowFunctionExpression") { if (node.typeParameters || !node.returnType) { this.finishArrowValidation(node); } else { arrows.push(node); } stack.push(node.body); } else if (node.type === "ConditionalExpression") { stack.push(node.consequent); stack.push(node.alternate); } } if (disallowInvalid) { arrows.forEach(node => this.finishArrowValidation(node)); return [arrows, []]; } return partition(arrows, node => node.params.every(param => this.isAssignable(param, true))); } finishArrowValidation(node) { var _node$extra; this.toAssignableList(node.params, (_node$extra = node.extra) == null ? void 0 : _node$extra.trailingCommaLoc, false); this.scope.enter(SCOPE_FUNCTION | SCOPE_ARROW); super.checkParams(node, false, true); this.scope.exit(); } forwardNoArrowParamsConversionAt(node, parse) { let result; if (this.state.noArrowParamsConversionAt.indexOf(node.start) !== -1) { this.state.noArrowParamsConversionAt.push(this.state.start); result = parse(); this.state.noArrowParamsConversionAt.pop(); } else { result = parse(); } return result; } parseParenItem(node, startPos, startLoc) { node = super.parseParenItem(node, startPos, startLoc); if (this.eat(17)) { node.optional = true; this.resetEndLocation(node); } if (this.match(14)) { const typeCastNode = this.startNodeAt(startPos, startLoc); typeCastNode.expression = node; typeCastNode.typeAnnotation = this.flowParseTypeAnnotation(); return this.finishNode(typeCastNode, "TypeCastExpression"); } return node; } assertModuleNodeAllowed(node) { if (node.type === "ImportDeclaration" && (node.importKind === "type" || node.importKind === "typeof") || node.type === "ExportNamedDeclaration" && node.exportKind === "type" || node.type === "ExportAllDeclaration" && node.exportKind === "type") { return; } super.assertModuleNodeAllowed(node); } parseExport(node) { const decl = super.parseExport(node); if (decl.type === "ExportNamedDeclaration" || decl.type === "ExportAllDeclaration") { decl.exportKind = decl.exportKind || "value"; } return decl; } parseExportDeclaration(node) { if (this.isContextual(126)) { node.exportKind = "type"; const declarationNode = this.startNode(); this.next(); if (this.match(5)) { node.specifiers = this.parseExportSpecifiers(true); super.parseExportFrom(node); return null; } else { return this.flowParseTypeAlias(declarationNode); } } else if (this.isContextual(127)) { node.exportKind = "type"; const declarationNode = this.startNode(); this.next(); return this.flowParseOpaqueType(declarationNode, false); } else if (this.isContextual(125)) { node.exportKind = "type"; const declarationNode = this.startNode(); this.next(); return this.flowParseInterface(declarationNode); } else if (this.shouldParseEnums() && this.isContextual(122)) { node.exportKind = "value"; const declarationNode = this.startNode(); this.next(); return this.flowParseEnumDeclaration(declarationNode); } else { return super.parseExportDeclaration(node); } } eatExportStar(node) { if (super.eatExportStar(node)) return true; if (this.isContextual(126) && this.lookahead().type === 55) { node.exportKind = "type"; this.next(); this.next(); return true; } return false; } maybeParseExportNamespaceSpecifier(node) { const { startLoc } = this.state; const hasNamespace = super.maybeParseExportNamespaceSpecifier(node); if (hasNamespace && node.exportKind === "type") { this.unexpected(startLoc); } return hasNamespace; } parseClassId(node, isStatement, optionalId) { super.parseClassId(node, isStatement, optionalId); if (this.match(47)) { node.typeParameters = this.flowParseTypeParameterDeclaration(); } } parseClassMember(classBody, member, state) { const { startLoc } = this.state; if (this.isContextual(121)) { if (super.parseClassMemberFromModifier(classBody, member)) { return; } member.declare = true; } super.parseClassMember(classBody, member, state); if (member.declare) { if (member.type !== "ClassProperty" && member.type !== "ClassPrivateProperty" && member.type !== "PropertyDefinition") { this.raise(FlowErrors.DeclareClassElement, { at: startLoc }); } else if (member.value) { this.raise(FlowErrors.DeclareClassFieldInitializer, { at: member.value }); } } } isIterator(word) { return word === "iterator" || word === "asyncIterator"; } readIterator() { const word = super.readWord1(); const fullWord = "@@" + word; if (!this.isIterator(word) || !this.state.inType) { this.raise(Errors.InvalidIdentifier, { at: this.state.curPosition(), identifierName: fullWord }); } this.finishToken(128, fullWord); } getTokenFromCode(code) { const next = this.input.charCodeAt(this.state.pos + 1); if (code === 123 && next === 124) { return this.finishOp(6, 2); } else if (this.state.inType && (code === 62 || code === 60)) { return this.finishOp(code === 62 ? 48 : 47, 1); } else if (this.state.inType && code === 63) { if (next === 46) { return this.finishOp(18, 2); } return this.finishOp(17, 1); } else if (isIteratorStart(code, next, this.input.charCodeAt(this.state.pos + 2))) { this.state.pos += 2; return this.readIterator(); } else { return super.getTokenFromCode(code); } } isAssignable(node, isBinding) { if (node.type === "TypeCastExpression") { return this.isAssignable(node.expression, isBinding); } else { return super.isAssignable(node, isBinding); } } toAssignable(node, isLHS = false) { if (!isLHS && node.type === "AssignmentExpression" && node.left.type === "TypeCastExpression") { node.left = this.typeCastToParameter(node.left); } super.toAssignable(node, isLHS); } toAssignableList(exprList, trailingCommaLoc, isLHS) { for (let i = 0; i < exprList.length; i++) { const expr = exprList[i]; if ((expr == null ? void 0 : expr.type) === "TypeCastExpression") { exprList[i] = this.typeCastToParameter(expr); } } super.toAssignableList(exprList, trailingCommaLoc, isLHS); } toReferencedList(exprList, isParenthesizedExpr) { for (let i = 0; i < exprList.length; i++) { var _expr$extra; const expr = exprList[i]; if (expr && expr.type === "TypeCastExpression" && !((_expr$extra = expr.extra) != null && _expr$extra.parenthesized) && (exprList.length > 1 || !isParenthesizedExpr)) { this.raise(FlowErrors.TypeCastInPattern, { at: expr.typeAnnotation }); } } return exprList; } parseArrayLike(close, canBePattern, isTuple, refExpressionErrors) { const node = super.parseArrayLike(close, canBePattern, isTuple, refExpressionErrors); if (canBePattern && !this.state.maybeInArrowParameters) { this.toReferencedList(node.elements); } return node; } isValidLVal(type, isParenthesized, binding) { return type === "TypeCastExpression" || super.isValidLVal(type, isParenthesized, binding); } parseClassProperty(node) { if (this.match(14)) { node.typeAnnotation = this.flowParseTypeAnnotation(); } return super.parseClassProperty(node); } parseClassPrivateProperty(node) { if (this.match(14)) { node.typeAnnotation = this.flowParseTypeAnnotation(); } return super.parseClassPrivateProperty(node); } isClassMethod() { return this.match(47) || super.isClassMethod(); } isClassProperty() { return this.match(14) || super.isClassProperty(); } isNonstaticConstructor(method) { return !this.match(14) && super.isNonstaticConstructor(method); } pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) { if (method.variance) { this.unexpected(method.variance.loc.start); } delete method.variance; if (this.match(47)) { method.typeParameters = this.flowParseTypeParameterDeclaration(); } super.pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper); if (method.params && isConstructor) { const params = method.params; if (params.length > 0 && this.isThisParam(params[0])) { this.raise(FlowErrors.ThisParamBannedInConstructor, { at: method }); } } else if (method.type === "MethodDefinition" && isConstructor && method.value.params) { const params = method.value.params; if (params.length > 0 && this.isThisParam(params[0])) { this.raise(FlowErrors.ThisParamBannedInConstructor, { at: method }); } } } pushClassPrivateMethod(classBody, method, isGenerator, isAsync) { if (method.variance) { this.unexpected(method.variance.loc.start); } delete method.variance; if (this.match(47)) { method.typeParameters = this.flowParseTypeParameterDeclaration(); } super.pushClassPrivateMethod(classBody, method, isGenerator, isAsync); } parseClassSuper(node) { super.parseClassSuper(node); if (node.superClass && this.match(47)) { node.superTypeParameters = this.flowParseTypeParameterInstantiation(); } if (this.isContextual(110)) { this.next(); const implemented = node.implements = []; do { const node = this.startNode(); node.id = this.flowParseRestrictedIdentifier(true); if (this.match(47)) { node.typeParameters = this.flowParseTypeParameterInstantiation(); } else { node.typeParameters = null; } implemented.push(this.finishNode(node, "ClassImplements")); } while (this.eat(12)); } } checkGetterSetterParams(method) { super.checkGetterSetterParams(method); const params = this.getObjectOrClassMethodParams(method); if (params.length > 0) { const param = params[0]; if (this.isThisParam(param) && method.kind === "get") { this.raise(FlowErrors.GetterMayNotHaveThisParam, { at: param }); } else if (this.isThisParam(param)) { this.raise(FlowErrors.SetterMayNotHaveThisParam, { at: param }); } } } parsePropertyNamePrefixOperator(node) { node.variance = this.flowParseVariance(); } parseObjPropValue(prop, startPos, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors) { if (prop.variance) { this.unexpected(prop.variance.loc.start); } delete prop.variance; let typeParameters; if (this.match(47) && !isAccessor) { typeParameters = this.flowParseTypeParameterDeclaration(); if (!this.match(10)) this.unexpected(); } const result = super.parseObjPropValue(prop, startPos, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors); if (typeParameters) { (result.value || result).typeParameters = typeParameters; } return result; } parseAssignableListItemTypes(param) { if (this.eat(17)) { if (param.type !== "Identifier") { this.raise(FlowErrors.PatternIsOptional, { at: param }); } if (this.isThisParam(param)) { this.raise(FlowErrors.ThisParamMayNotBeOptional, { at: param }); } param.optional = true; } if (this.match(14)) { param.typeAnnotation = this.flowParseTypeAnnotation(); } else if (this.isThisParam(param)) { this.raise(FlowErrors.ThisParamAnnotationRequired, { at: param }); } if (this.match(29) && this.isThisParam(param)) { this.raise(FlowErrors.ThisParamNoDefault, { at: param }); } this.resetEndLocation(param); return param; } parseMaybeDefault(startPos, startLoc, left) { const node = super.parseMaybeDefault(startPos, startLoc, left); if (node.type === "AssignmentPattern" && node.typeAnnotation && node.right.start < node.typeAnnotation.start) { this.raise(FlowErrors.TypeBeforeInitializer, { at: node.typeAnnotation }); } return node; } shouldParseDefaultImport(node) { if (!hasTypeImportKind(node)) { return super.shouldParseDefaultImport(node); } return isMaybeDefaultImport(this.state.type); } parseImportSpecifierLocal(node, specifier, type) { specifier.local = hasTypeImportKind(node) ? this.flowParseRestrictedIdentifier(true, true) : this.parseIdentifier(); node.specifiers.push(this.finishImportSpecifier(specifier, type)); } maybeParseDefaultImportSpecifier(node) { node.importKind = "value"; let kind = null; if (this.match(87)) { kind = "typeof"; } else if (this.isContextual(126)) { kind = "type"; } if (kind) { const lh = this.lookahead(); const { type } = lh; if (kind === "type" && type === 55) { this.unexpected(null, lh.type); } if (isMaybeDefaultImport(type) || type === 5 || type === 55) { this.next(); node.importKind = kind; } } return super.maybeParseDefaultImportSpecifier(node); } parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, bindingType) { const firstIdent = specifier.imported; let specifierTypeKind = null; if (firstIdent.type === "Identifier") { if (firstIdent.name === "type") { specifierTypeKind = "type"; } else if (firstIdent.name === "typeof") { specifierTypeKind = "typeof"; } } let isBinding = false; if (this.isContextual(93) && !this.isLookaheadContextual("as")) { const as_ident = this.parseIdentifier(true); if (specifierTypeKind !== null && !tokenIsKeywordOrIdentifier(this.state.type)) { specifier.imported = as_ident; specifier.importKind = specifierTypeKind; specifier.local = cloneIdentifier(as_ident); } else { specifier.imported = firstIdent; specifier.importKind = null; specifier.local = this.parseIdentifier(); } } else { if (specifierTypeKind !== null && tokenIsKeywordOrIdentifier(this.state.type)) { specifier.imported = this.parseIdentifier(true); specifier.importKind = specifierTypeKind; } else { if (importedIsString) { throw this.raise(Errors.ImportBindingIsString, { at: specifier, importName: firstIdent.value }); } specifier.imported = firstIdent; specifier.importKind = null; } if (this.eatContextual(93)) { specifier.local = this.parseIdentifier(); } else { isBinding = true; specifier.local = cloneIdentifier(specifier.imported); } } const specifierIsTypeImport = hasTypeImportKind(specifier); if (isInTypeOnlyImport && specifierIsTypeImport) { this.raise(FlowErrors.ImportTypeShorthandOnlyInPureImport, { at: specifier }); } if (isInTypeOnlyImport || specifierIsTypeImport) { this.checkReservedType(specifier.local.name, specifier.local.loc.start, true); } if (isBinding && !isInTypeOnlyImport && !specifierIsTypeImport) { this.checkReservedWord(specifier.local.name, specifier.loc.start, true, true); } return this.finishImportSpecifier(specifier, "ImportSpecifier"); } parseBindingAtom() { switch (this.state.type) { case 78: return this.parseIdentifier(true); default: return super.parseBindingAtom(); } } parseFunctionParams(node, allowModifiers) { const kind = node.kind; if (kind !== "get" && kind !== "set" && this.match(47)) { node.typeParameters = this.flowParseTypeParameterDeclaration(); } super.parseFunctionParams(node, allowModifiers); } parseVarId(decl, kind) { super.parseVarId(decl, kind); if (this.match(14)) { decl.id.typeAnnotation = this.flowParseTypeAnnotation(); this.resetEndLocation(decl.id); } } parseAsyncArrowFromCallExpression(node, call) { if (this.match(14)) { const oldNoAnonFunctionType = this.state.noAnonFunctionType; this.state.noAnonFunctionType = true; node.returnType = this.flowParseTypeAnnotation(); this.state.noAnonFunctionType = oldNoAnonFunctionType; } return super.parseAsyncArrowFromCallExpression(node, call); } shouldParseAsyncArrow() { return this.match(14) || super.shouldParseAsyncArrow(); } parseMaybeAssign(refExpressionErrors, afterLeftParse) { var _jsx; let state = null; let jsx; if (this.hasPlugin("jsx") && (this.match(138) || this.match(47))) { state = this.state.clone(); jsx = this.tryParse(() => super.parseMaybeAssign(refExpressionErrors, afterLeftParse), state); if (!jsx.error) return jsx.node; const { context } = this.state; const currentContext = context[context.length - 1]; if (currentContext === types.j_oTag || currentContext === types.j_expr) { context.pop(); } } if ((_jsx = jsx) != null && _jsx.error || this.match(47)) { var _jsx2, _jsx3; state = state || this.state.clone(); let typeParameters; const arrow = this.tryParse(abort => { var _arrowExpression$extr; typeParameters = this.flowParseTypeParameterDeclaration(); const arrowExpression = this.forwardNoArrowParamsConversionAt(typeParameters, () => { const result = super.parseMaybeAssign(refExpressionErrors, afterLeftParse); this.resetStartLocationFromNode(result, typeParameters); return result; }); if ((_arrowExpression$extr = arrowExpression.extra) != null && _arrowExpression$extr.parenthesized) abort(); const expr = this.maybeUnwrapTypeCastExpression(arrowExpression); if (expr.type !== "ArrowFunctionExpression") abort(); expr.typeParameters = typeParameters; this.resetStartLocationFromNode(expr, typeParameters); return arrowExpression; }, state); let arrowExpression = null; if (arrow.node && this.maybeUnwrapTypeCastExpression(arrow.node).type === "ArrowFunctionExpression") { if (!arrow.error && !arrow.aborted) { if (arrow.node.async) { this.raise(FlowErrors.UnexpectedTypeParameterBeforeAsyncArrowFunction, { at: typeParameters }); } return arrow.node; } arrowExpression = arrow.node; } if ((_jsx2 = jsx) != null && _jsx2.node) { this.state = jsx.failState; return jsx.node; } if (arrowExpression) { this.state = arrow.failState; return arrowExpression; } if ((_jsx3 = jsx) != null && _jsx3.thrown) throw jsx.error; if (arrow.thrown) throw arrow.error; throw this.raise(FlowErrors.UnexpectedTokenAfterTypeParameter, { at: typeParameters }); } return super.parseMaybeAssign(refExpressionErrors, afterLeftParse); } parseArrow(node) { if (this.match(14)) { const result = this.tryParse(() => { const oldNoAnonFunctionType = this.state.noAnonFunctionType; this.state.noAnonFunctionType = true; const typeNode = this.startNode(); [typeNode.typeAnnotation, node.predicate] = this.flowParseTypeAndPredicateInitialiser(); this.state.noAnonFunctionType = oldNoAnonFunctionType; if (this.canInsertSemicolon()) this.unexpected(); if (!this.match(19)) this.unexpected(); return typeNode; }); if (result.thrown) return null; if (result.error) this.state = result.failState; node.returnType = result.node.typeAnnotation ? this.finishNode(result.node, "TypeAnnotation") : null; } return super.parseArrow(node); } shouldParseArrow(params) { return this.match(14) || super.shouldParseArrow(params); } setArrowFunctionParameters(node, params) { if (this.state.noArrowParamsConversionAt.indexOf(node.start) !== -1) { node.params = params; } else { super.setArrowFunctionParameters(node, params); } } checkParams(node, allowDuplicates, isArrowFunction, strictModeChanged = true) { if (isArrowFunction && this.state.noArrowParamsConversionAt.indexOf(node.start) !== -1) { return; } for (let i = 0; i < node.params.length; i++) { if (this.isThisParam(node.params[i]) && i > 0) { this.raise(FlowErrors.ThisParamMustBeFirst, { at: node.params[i] }); } } return super.checkParams(node, allowDuplicates, isArrowFunction, strictModeChanged); } parseParenAndDistinguishExpression(canBeArrow) { return super.parseParenAndDistinguishExpression(canBeArrow && this.state.noArrowAt.indexOf(this.state.start) === -1); } parseSubscripts(base, startPos, startLoc, noCalls) { if (base.type === "Identifier" && base.name === "async" && this.state.noArrowAt.indexOf(startPos) !== -1) { this.next(); const node = this.startNodeAt(startPos, startLoc); node.callee = base; node.arguments = super.parseCallExpressionArguments(11, false); base = this.finishNode(node, "CallExpression"); } else if (base.type === "Identifier" && base.name === "async" && this.match(47)) { const state = this.state.clone(); const arrow = this.tryParse(abort => this.parseAsyncArrowWithTypeParameters(startPos, startLoc) || abort(), state); if (!arrow.error && !arrow.aborted) return arrow.node; const result = this.tryParse(() => super.parseSubscripts(base, startPos, startLoc, noCalls), state); if (result.node && !result.error) return result.node; if (arrow.node) { this.state = arrow.failState; return arrow.node; } if (result.node) { this.state = result.failState; return result.node; } throw arrow.error || result.error; } return super.parseSubscripts(base, startPos, startLoc, noCalls); } parseSubscript(base, startPos, startLoc, noCalls, subscriptState) { if (this.match(18) && this.isLookaheadToken_lt()) { subscriptState.optionalChainMember = true; if (noCalls) { subscriptState.stop = true; return base; } this.next(); const node = this.startNodeAt(startPos, startLoc); node.callee = base; node.typeArguments = this.flowParseTypeParameterInstantiation(); this.expect(10); node.arguments = this.parseCallExpressionArguments(11, false); node.optional = true; return this.finishCallExpression(node, true); } else if (!noCalls && this.shouldParseTypes() && this.match(47)) { const node = this.startNodeAt(startPos, startLoc); node.callee = base; const result = this.tryParse(() => { node.typeArguments = this.flowParseTypeParameterInstantiationCallOrNew(); this.expect(10); node.arguments = super.parseCallExpressionArguments(11, false); if (subscriptState.optionalChainMember) { node.optional = false; } return this.finishCallExpression(node, subscriptState.optionalChainMember); }); if (result.node) { if (result.error) this.state = result.failState; return result.node; } } return super.parseSubscript(base, startPos, startLoc, noCalls, subscriptState); } parseNewCallee(node) { super.parseNewCallee(node); let targs = null; if (this.shouldParseTypes() && this.match(47)) { targs = this.tryParse(() => this.flowParseTypeParameterInstantiationCallOrNew()).node; } node.typeArguments = targs; } parseAsyncArrowWithTypeParameters(startPos, startLoc) { const node = this.startNodeAt(startPos, startLoc); this.parseFunctionParams(node); if (!this.parseArrow(node)) return; return super.parseArrowExpression(node, undefined, true); } readToken_mult_modulo(code) { const next = this.input.charCodeAt(this.state.pos + 1); if (code === 42 && next === 47 && this.state.hasFlowComment) { this.state.hasFlowComment = false; this.state.pos += 2; this.nextToken(); return; } super.readToken_mult_modulo(code); } readToken_pipe_amp(code) { const next = this.input.charCodeAt(this.state.pos + 1); if (code === 124 && next === 125) { this.finishOp(9, 2); return; } super.readToken_pipe_amp(code); } parseTopLevel(file, program) { const fileNode = super.parseTopLevel(file, program); if (this.state.hasFlowComment) { this.raise(FlowErrors.UnterminatedFlowComment, { at: this.state.curPosition() }); } return fileNode; } skipBlockComment() { if (this.hasPlugin("flowComments") && this.skipFlowComment()) { if (this.state.hasFlowComment) { throw this.raise(FlowErrors.NestedFlowComment, { at: this.state.startLoc }); } this.hasFlowCommentCompletion(); const commentSkip = this.skipFlowComment(); if (commentSkip) { this.state.pos += commentSkip; this.state.hasFlowComment = true; } return; } if (this.state.hasFlowComment) { const end = this.input.indexOf("*-/", this.state.pos + 2); if (end === -1) { throw this.raise(Errors.UnterminatedComment, { at: this.state.curPosition() }); } this.state.pos = end + 2 + 3; return; } return super.skipBlockComment(); } skipFlowComment() { const { pos } = this.state; let shiftToFirstNonWhiteSpace = 2; while ([32, 9].includes(this.input.charCodeAt(pos + shiftToFirstNonWhiteSpace))) { shiftToFirstNonWhiteSpace++; } const ch2 = this.input.charCodeAt(shiftToFirstNonWhiteSpace + pos); const ch3 = this.input.charCodeAt(shiftToFirstNonWhiteSpace + pos + 1); if (ch2 === 58 && ch3 === 58) { return shiftToFirstNonWhiteSpace + 2; } if (this.input.slice(shiftToFirstNonWhiteSpace + pos, shiftToFirstNonWhiteSpace + pos + 12) === "flow-include") { return shiftToFirstNonWhiteSpace + 12; } if (ch2 === 58 && ch3 !== 58) { return shiftToFirstNonWhiteSpace; } return false; } hasFlowCommentCompletion() { const end = this.input.indexOf("*/", this.state.pos); if (end === -1) { throw this.raise(Errors.UnterminatedComment, { at: this.state.curPosition() }); } } flowEnumErrorBooleanMemberNotInitialized(loc, { enumName, memberName }) { this.raise(FlowErrors.EnumBooleanMemberNotInitialized, { at: loc, memberName, enumName }); } flowEnumErrorInvalidMemberInitializer(loc, enumContext) { return this.raise(!enumContext.explicitType ? FlowErrors.EnumInvalidMemberInitializerUnknownType : enumContext.explicitType === "symbol" ? FlowErrors.EnumInvalidMemberInitializerSymbolType : FlowErrors.EnumInvalidMemberInitializerPrimaryType, Object.assign({ at: loc }, enumContext)); } flowEnumErrorNumberMemberNotInitialized(loc, { enumName, memberName }) { this.raise(FlowErrors.EnumNumberMemberNotInitialized, { at: loc, enumName, memberName }); } flowEnumErrorStringMemberInconsistentlyInitailized(node, { enumName }) { this.raise(FlowErrors.EnumStringMemberInconsistentlyInitailized, { at: node, enumName }); } flowEnumMemberInit() { const startLoc = this.state.startLoc; const endOfInit = () => this.match(12) || this.match(8); switch (this.state.type) { case 130: { const literal = this.parseNumericLiteral(this.state.value); if (endOfInit()) { return { type: "number", loc: literal.loc.start, value: literal }; } return { type: "invalid", loc: startLoc }; } case 129: { const literal = this.parseStringLiteral(this.state.value); if (endOfInit()) { return { type: "string", loc: literal.loc.start, value: literal }; } return { type: "invalid", loc: startLoc }; } case 85: case 86: { const literal = this.parseBooleanLiteral(this.match(85)); if (endOfInit()) { return { type: "boolean", loc: literal.loc.start, value: literal }; } return { type: "invalid", loc: startLoc }; } default: return { type: "invalid", loc: startLoc }; } } flowEnumMemberRaw() { const loc = this.state.startLoc; const id = this.parseIdentifier(true); const init = this.eat(29) ? this.flowEnumMemberInit() : { type: "none", loc }; return { id, init }; } flowEnumCheckExplicitTypeMismatch(loc, context, expectedType) { const { explicitType } = context; if (explicitType === null) { return; } if (explicitType !== expectedType) { this.flowEnumErrorInvalidMemberInitializer(loc, context); } } flowEnumMembers({ enumName, explicitType }) { const seenNames = new Set(); const members = { booleanMembers: [], numberMembers: [], stringMembers: [], defaultedMembers: [] }; let hasUnknownMembers = false; while (!this.match(8)) { if (this.eat(21)) { hasUnknownMembers = true; break; } const memberNode = this.startNode(); const { id, init } = this.flowEnumMemberRaw(); const memberName = id.name; if (memberName === "") { continue; } if (/^[a-z]/.test(memberName)) { this.raise(FlowErrors.EnumInvalidMemberName, { at: id, memberName, suggestion: memberName[0].toUpperCase() + memberName.slice(1), enumName }); } if (seenNames.has(memberName)) { this.raise(FlowErrors.EnumDuplicateMemberName, { at: id, memberName, enumName }); } seenNames.add(memberName); const context = { enumName, explicitType, memberName }; memberNode.id = id; switch (init.type) { case "boolean": { this.flowEnumCheckExplicitTypeMismatch(init.loc, context, "boolean"); memberNode.init = init.value; members.booleanMembers.push(this.finishNode(memberNode, "EnumBooleanMember")); break; } case "number": { this.flowEnumCheckExplicitTypeMismatch(init.loc, context, "number"); memberNode.init = init.value; members.numberMembers.push(this.finishNode(memberNode, "EnumNumberMember")); break; } case "string": { this.flowEnumCheckExplicitTypeMismatch(init.loc, context, "string"); memberNode.init = init.value; members.stringMembers.push(this.finishNode(memberNode, "EnumStringMember")); break; } case "invalid": { throw this.flowEnumErrorInvalidMemberInitializer(init.loc, context); } case "none": { switch (explicitType) { case "boolean": this.flowEnumErrorBooleanMemberNotInitialized(init.loc, context); break; case "number": this.flowEnumErrorNumberMemberNotInitialized(init.loc, context); break; default: members.defaultedMembers.push(this.finishNode(memberNode, "EnumDefaultedMember")); } } } if (!this.match(8)) { this.expect(12); } } return { members, hasUnknownMembers }; } flowEnumStringMembers(initializedMembers, defaultedMembers, { enumName }) { if (initializedMembers.length === 0) { return defaultedMembers; } else if (defaultedMembers.length === 0) { return initializedMembers; } else if (defaultedMembers.length > initializedMembers.length) { for (const member of initializedMembers) { this.flowEnumErrorStringMemberInconsistentlyInitailized(member, { enumName }); } return defaultedMembers; } else { for (const member of defaultedMembers) { this.flowEnumErrorStringMemberInconsistentlyInitailized(member, { enumName }); } return initializedMembers; } } flowEnumParseExplicitType({ enumName }) { if (!this.eatContextual(101)) return null; if (!tokenIsIdentifier(this.state.type)) { throw this.raise(FlowErrors.EnumInvalidExplicitTypeUnknownSupplied, { at: this.state.startLoc, enumName }); } const { value } = this.state; this.next(); if (value !== "boolean" && value !== "number" && value !== "string" && value !== "symbol") { this.raise(FlowErrors.EnumInvalidExplicitType, { at: this.state.startLoc, enumName, invalidEnumType: value }); } return value; } flowEnumBody(node, id) { const enumName = id.name; const nameLoc = id.loc.start; const explicitType = this.flowEnumParseExplicitType({ enumName }); this.expect(5); const { members, hasUnknownMembers } = this.flowEnumMembers({ enumName, explicitType }); node.hasUnknownMembers = hasUnknownMembers; switch (explicitType) { case "boolean": node.explicitType = true; node.members = members.booleanMembers; this.expect(8); return this.finishNode(node, "EnumBooleanBody"); case "number": node.explicitType = true; node.members = members.numberMembers; this.expect(8); return this.finishNode(node, "EnumNumberBody"); case "string": node.explicitType = true; node.members = this.flowEnumStringMembers(members.stringMembers, members.defaultedMembers, { enumName }); this.expect(8); return this.finishNode(node, "EnumStringBody"); case "symbol": node.members = members.defaultedMembers; this.expect(8); return this.finishNode(node, "EnumSymbolBody"); default: { const empty = () => { node.members = []; this.expect(8); return this.finishNode(node, "EnumStringBody"); }; node.explicitType = false; const boolsLen = members.booleanMembers.length; const numsLen = members.numberMembers.length; const strsLen = members.stringMembers.length; const defaultedLen = members.defaultedMembers.length; if (!boolsLen && !numsLen && !strsLen && !defaultedLen) { return empty(); } else if (!boolsLen && !numsLen) { node.members = this.flowEnumStringMembers(members.stringMembers, members.defaultedMembers, { enumName }); this.expect(8); return this.finishNode(node, "EnumStringBody"); } else if (!numsLen && !strsLen && boolsLen >= defaultedLen) { for (const member of members.defaultedMembers) { this.flowEnumErrorBooleanMemberNotInitialized(member.loc.start, { enumName, memberName: member.id.name }); } node.members = members.booleanMembers; this.expect(8); return this.finishNode(node, "EnumBooleanBody"); } else if (!boolsLen && !strsLen && numsLen >= defaultedLen) { for (const member of members.defaultedMembers) { this.flowEnumErrorNumberMemberNotInitialized(member.loc.start, { enumName, memberName: member.id.name }); } node.members = members.numberMembers; this.expect(8); return this.finishNode(node, "EnumNumberBody"); } else { this.raise(FlowErrors.EnumInconsistentMemberValues, { at: nameLoc, enumName }); return empty(); } } } } flowParseEnumDeclaration(node) { const id = this.parseIdentifier(); node.id = id; node.body = this.flowEnumBody(this.startNode(), id); return this.finishNode(node, "EnumDeclaration"); } isLookaheadToken_lt() { const next = this.nextTokenStart(); if (this.input.charCodeAt(next) === 60) { const afterNext = this.input.charCodeAt(next + 1); return afterNext !== 60 && afterNext !== 61; } return false; } maybeUnwrapTypeCastExpression(node) { return node.type === "TypeCastExpression" ? node.expression : node; } }); const entities = { __proto__: null, quot: "\u0022", amp: "&", apos: "\u0027", lt: "<", gt: ">", nbsp: "\u00A0", iexcl: "\u00A1", cent: "\u00A2", pound: "\u00A3", curren: "\u00A4", yen: "\u00A5", brvbar: "\u00A6", sect: "\u00A7", uml: "\u00A8", copy: "\u00A9", ordf: "\u00AA", laquo: "\u00AB", not: "\u00AC", shy: "\u00AD", reg: "\u00AE", macr: "\u00AF", deg: "\u00B0", plusmn: "\u00B1", sup2: "\u00B2", sup3: "\u00B3", acute: "\u00B4", micro: "\u00B5", para: "\u00B6", middot: "\u00B7", cedil: "\u00B8", sup1: "\u00B9", ordm: "\u00BA", raquo: "\u00BB", frac14: "\u00BC", frac12: "\u00BD", frac34: "\u00BE", iquest: "\u00BF", Agrave: "\u00C0", Aacute: "\u00C1", Acirc: "\u00C2", Atilde: "\u00C3", Auml: "\u00C4", Aring: "\u00C5", AElig: "\u00C6", Ccedil: "\u00C7", Egrave: "\u00C8", Eacute: "\u00C9", Ecirc: "\u00CA", Euml: "\u00CB", Igrave: "\u00CC", Iacute: "\u00CD", Icirc: "\u00CE", Iuml: "\u00CF", ETH: "\u00D0", Ntilde: "\u00D1", Ograve: "\u00D2", Oacute: "\u00D3", Ocirc: "\u00D4", Otilde: "\u00D5", Ouml: "\u00D6", times: "\u00D7", Oslash: "\u00D8", Ugrave: "\u00D9", Uacute: "\u00DA", Ucirc: "\u00DB", Uuml: "\u00DC", Yacute: "\u00DD", THORN: "\u00DE", szlig: "\u00DF", agrave: "\u00E0", aacute: "\u00E1", acirc: "\u00E2", atilde: "\u00E3", auml: "\u00E4", aring: "\u00E5", aelig: "\u00E6", ccedil: "\u00E7", egrave: "\u00E8", eacute: "\u00E9", ecirc: "\u00EA", euml: "\u00EB", igrave: "\u00EC", iacute: "\u00ED", icirc: "\u00EE", iuml: "\u00EF", eth: "\u00F0", ntilde: "\u00F1", ograve: "\u00F2", oacute: "\u00F3", ocirc: "\u00F4", otilde: "\u00F5", ouml: "\u00F6", divide: "\u00F7", oslash: "\u00F8", ugrave: "\u00F9", uacute: "\u00FA", ucirc: "\u00FB", uuml: "\u00FC", yacute: "\u00FD", thorn: "\u00FE", yuml: "\u00FF", OElig: "\u0152", oelig: "\u0153", Scaron: "\u0160", scaron: "\u0161", Yuml: "\u0178", fnof: "\u0192", circ: "\u02C6", tilde: "\u02DC", Alpha: "\u0391", Beta: "\u0392", Gamma: "\u0393", Delta: "\u0394", Epsilon: "\u0395", Zeta: "\u0396", Eta: "\u0397", Theta: "\u0398", Iota: "\u0399", Kappa: "\u039A", Lambda: "\u039B", Mu: "\u039C", Nu: "\u039D", Xi: "\u039E", Omicron: "\u039F", Pi: "\u03A0", Rho: "\u03A1", Sigma: "\u03A3", Tau: "\u03A4", Upsilon: "\u03A5", Phi: "\u03A6", Chi: "\u03A7", Psi: "\u03A8", Omega: "\u03A9", alpha: "\u03B1", beta: "\u03B2", gamma: "\u03B3", delta: "\u03B4", epsilon: "\u03B5", zeta: "\u03B6", eta: "\u03B7", theta: "\u03B8", iota: "\u03B9", kappa: "\u03BA", lambda: "\u03BB", mu: "\u03BC", nu: "\u03BD", xi: "\u03BE", omicron: "\u03BF", pi: "\u03C0", rho: "\u03C1", sigmaf: "\u03C2", sigma: "\u03C3", tau: "\u03C4", upsilon: "\u03C5", phi: "\u03C6", chi: "\u03C7", psi: "\u03C8", omega: "\u03C9", thetasym: "\u03D1", upsih: "\u03D2", piv: "\u03D6", ensp: "\u2002", emsp: "\u2003", thinsp: "\u2009", zwnj: "\u200C", zwj: "\u200D", lrm: "\u200E", rlm: "\u200F", ndash: "\u2013", mdash: "\u2014", lsquo: "\u2018", rsquo: "\u2019", sbquo: "\u201A", ldquo: "\u201C", rdquo: "\u201D", bdquo: "\u201E", dagger: "\u2020", Dagger: "\u2021", bull: "\u2022", hellip: "\u2026", permil: "\u2030", prime: "\u2032", Prime: "\u2033", lsaquo: "\u2039", rsaquo: "\u203A", oline: "\u203E", frasl: "\u2044", euro: "\u20AC", image: "\u2111", weierp: "\u2118", real: "\u211C", trade: "\u2122", alefsym: "\u2135", larr: "\u2190", uarr: "\u2191", rarr: "\u2192", darr: "\u2193", harr: "\u2194", crarr: "\u21B5", lArr: "\u21D0", uArr: "\u21D1", rArr: "\u21D2", dArr: "\u21D3", hArr: "\u21D4", forall: "\u2200", part: "\u2202", exist: "\u2203", empty: "\u2205", nabla: "\u2207", isin: "\u2208", notin: "\u2209", ni: "\u220B", prod: "\u220F", sum: "\u2211", minus: "\u2212", lowast: "\u2217", radic: "\u221A", prop: "\u221D", infin: "\u221E", ang: "\u2220", and: "\u2227", or: "\u2228", cap: "\u2229", cup: "\u222A", int: "\u222B", there4: "\u2234", sim: "\u223C", cong: "\u2245", asymp: "\u2248", ne: "\u2260", equiv: "\u2261", le: "\u2264", ge: "\u2265", sub: "\u2282", sup: "\u2283", nsub: "\u2284", sube: "\u2286", supe: "\u2287", oplus: "\u2295", otimes: "\u2297", perp: "\u22A5", sdot: "\u22C5", lceil: "\u2308", rceil: "\u2309", lfloor: "\u230A", rfloor: "\u230B", lang: "\u2329", rang: "\u232A", loz: "\u25CA", spades: "\u2660", clubs: "\u2663", hearts: "\u2665", diams: "\u2666" }; const JsxErrors = ParseErrorEnum`jsx`({ AttributeIsEmpty: "JSX attributes must only be assigned a non-empty expression.", MissingClosingTagElement: ({ openingTagName }) => `Expected corresponding JSX closing tag for <${openingTagName}>.`, MissingClosingTagFragment: "Expected corresponding JSX closing tag for <>.", UnexpectedSequenceExpression: "Sequence expressions cannot be directly nested inside JSX. Did you mean to wrap it in parentheses (...)?", UnexpectedToken: ({ unexpected, HTMLEntity }) => `Unexpected token \`${unexpected}\`. Did you mean \`${HTMLEntity}\` or \`{'${unexpected}'}\`?`, UnsupportedJsxValue: "JSX value should be either an expression or a quoted JSX text.", UnterminatedJsxContent: "Unterminated JSX contents.", UnwrappedAdjacentJSXElements: "Adjacent JSX elements must be wrapped in an enclosing tag. Did you want a JSX fragment <>...?" }); function isFragment(object) { return object ? object.type === "JSXOpeningFragment" || object.type === "JSXClosingFragment" : false; } function getQualifiedJSXName(object) { if (object.type === "JSXIdentifier") { return object.name; } if (object.type === "JSXNamespacedName") { return object.namespace.name + ":" + object.name.name; } if (object.type === "JSXMemberExpression") { return getQualifiedJSXName(object.object) + "." + getQualifiedJSXName(object.property); } throw new Error("Node had unexpected type: " + object.type); } var jsx = (superClass => class JSXParserMixin extends superClass { jsxReadToken() { let out = ""; let chunkStart = this.state.pos; for (;;) { if (this.state.pos >= this.length) { throw this.raise(JsxErrors.UnterminatedJsxContent, { at: this.state.startLoc }); } const ch = this.input.charCodeAt(this.state.pos); switch (ch) { case 60: case 123: if (this.state.pos === this.state.start) { if (ch === 60 && this.state.canStartJSXElement) { ++this.state.pos; return this.finishToken(138); } return super.getTokenFromCode(ch); } out += this.input.slice(chunkStart, this.state.pos); return this.finishToken(137, out); case 38: out += this.input.slice(chunkStart, this.state.pos); out += this.jsxReadEntity(); chunkStart = this.state.pos; break; case 62: case 125: default: if (isNewLine(ch)) { out += this.input.slice(chunkStart, this.state.pos); out += this.jsxReadNewLine(true); chunkStart = this.state.pos; } else { ++this.state.pos; } } } } jsxReadNewLine(normalizeCRLF) { const ch = this.input.charCodeAt(this.state.pos); let out; ++this.state.pos; if (ch === 13 && this.input.charCodeAt(this.state.pos) === 10) { ++this.state.pos; out = normalizeCRLF ? "\n" : "\r\n"; } else { out = String.fromCharCode(ch); } ++this.state.curLine; this.state.lineStart = this.state.pos; return out; } jsxReadString(quote) { let out = ""; let chunkStart = ++this.state.pos; for (;;) { if (this.state.pos >= this.length) { throw this.raise(Errors.UnterminatedString, { at: this.state.startLoc }); } const ch = this.input.charCodeAt(this.state.pos); if (ch === quote) break; if (ch === 38) { out += this.input.slice(chunkStart, this.state.pos); out += this.jsxReadEntity(); chunkStart = this.state.pos; } else if (isNewLine(ch)) { out += this.input.slice(chunkStart, this.state.pos); out += this.jsxReadNewLine(false); chunkStart = this.state.pos; } else { ++this.state.pos; } } out += this.input.slice(chunkStart, this.state.pos++); return this.finishToken(129, out); } jsxReadEntity() { const startPos = ++this.state.pos; if (this.codePointAtPos(this.state.pos) === 35) { ++this.state.pos; let radix = 10; if (this.codePointAtPos(this.state.pos) === 120) { radix = 16; ++this.state.pos; } const codePoint = this.readInt(radix, undefined, false, "bail"); if (codePoint !== null && this.codePointAtPos(this.state.pos) === 59) { ++this.state.pos; return String.fromCodePoint(codePoint); } } else { let count = 0; let semi = false; while (count++ < 10 && this.state.pos < this.length && !(semi = this.codePointAtPos(this.state.pos) == 59)) { ++this.state.pos; } if (semi) { const desc = this.input.slice(startPos, this.state.pos); const entity = entities[desc]; ++this.state.pos; if (entity) { return entity; } } } this.state.pos = startPos; return "&"; } jsxReadWord() { let ch; const start = this.state.pos; do { ch = this.input.charCodeAt(++this.state.pos); } while (isIdentifierChar(ch) || ch === 45); return this.finishToken(136, this.input.slice(start, this.state.pos)); } jsxParseIdentifier() { const node = this.startNode(); if (this.match(136)) { node.name = this.state.value; } else if (tokenIsKeyword(this.state.type)) { node.name = tokenLabelName(this.state.type); } else { this.unexpected(); } this.next(); return this.finishNode(node, "JSXIdentifier"); } jsxParseNamespacedName() { const startPos = this.state.start; const startLoc = this.state.startLoc; const name = this.jsxParseIdentifier(); if (!this.eat(14)) return name; const node = this.startNodeAt(startPos, startLoc); node.namespace = name; node.name = this.jsxParseIdentifier(); return this.finishNode(node, "JSXNamespacedName"); } jsxParseElementName() { const startPos = this.state.start; const startLoc = this.state.startLoc; let node = this.jsxParseNamespacedName(); if (node.type === "JSXNamespacedName") { return node; } while (this.eat(16)) { const newNode = this.startNodeAt(startPos, startLoc); newNode.object = node; newNode.property = this.jsxParseIdentifier(); node = this.finishNode(newNode, "JSXMemberExpression"); } return node; } jsxParseAttributeValue() { let node; switch (this.state.type) { case 5: node = this.startNode(); this.setContext(types.brace); this.next(); node = this.jsxParseExpressionContainer(node, types.j_oTag); if (node.expression.type === "JSXEmptyExpression") { this.raise(JsxErrors.AttributeIsEmpty, { at: node }); } return node; case 138: case 129: return this.parseExprAtom(); default: throw this.raise(JsxErrors.UnsupportedJsxValue, { at: this.state.startLoc }); } } jsxParseEmptyExpression() { const node = this.startNodeAt(this.state.lastTokEndLoc.index, this.state.lastTokEndLoc); return this.finishNodeAt(node, "JSXEmptyExpression", this.state.startLoc); } jsxParseSpreadChild(node) { this.next(); node.expression = this.parseExpression(); this.setContext(types.j_expr); this.state.canStartJSXElement = true; this.expect(8); return this.finishNode(node, "JSXSpreadChild"); } jsxParseExpressionContainer(node, previousContext) { if (this.match(8)) { node.expression = this.jsxParseEmptyExpression(); } else { const expression = this.parseExpression(); node.expression = expression; } this.setContext(previousContext); this.state.canStartJSXElement = true; this.expect(8); return this.finishNode(node, "JSXExpressionContainer"); } jsxParseAttribute() { const node = this.startNode(); if (this.match(5)) { this.setContext(types.brace); this.next(); this.expect(21); node.argument = this.parseMaybeAssignAllowIn(); this.setContext(types.j_oTag); this.state.canStartJSXElement = true; this.expect(8); return this.finishNode(node, "JSXSpreadAttribute"); } node.name = this.jsxParseNamespacedName(); node.value = this.eat(29) ? this.jsxParseAttributeValue() : null; return this.finishNode(node, "JSXAttribute"); } jsxParseOpeningElementAt(startPos, startLoc) { const node = this.startNodeAt(startPos, startLoc); if (this.eat(139)) { return this.finishNode(node, "JSXOpeningFragment"); } node.name = this.jsxParseElementName(); return this.jsxParseOpeningElementAfterName(node); } jsxParseOpeningElementAfterName(node) { const attributes = []; while (!this.match(56) && !this.match(139)) { attributes.push(this.jsxParseAttribute()); } node.attributes = attributes; node.selfClosing = this.eat(56); this.expect(139); return this.finishNode(node, "JSXOpeningElement"); } jsxParseClosingElementAt(startPos, startLoc) { const node = this.startNodeAt(startPos, startLoc); if (this.eat(139)) { return this.finishNode(node, "JSXClosingFragment"); } node.name = this.jsxParseElementName(); this.expect(139); return this.finishNode(node, "JSXClosingElement"); } jsxParseElementAt(startPos, startLoc) { const node = this.startNodeAt(startPos, startLoc); const children = []; const openingElement = this.jsxParseOpeningElementAt(startPos, startLoc); let closingElement = null; if (!openingElement.selfClosing) { contents: for (;;) { switch (this.state.type) { case 138: startPos = this.state.start; startLoc = this.state.startLoc; this.next(); if (this.eat(56)) { closingElement = this.jsxParseClosingElementAt(startPos, startLoc); break contents; } children.push(this.jsxParseElementAt(startPos, startLoc)); break; case 137: children.push(this.parseExprAtom()); break; case 5: { const node = this.startNode(); this.setContext(types.brace); this.next(); if (this.match(21)) { children.push(this.jsxParseSpreadChild(node)); } else { children.push(this.jsxParseExpressionContainer(node, types.j_expr)); } break; } default: throw this.unexpected(); } } if (isFragment(openingElement) && !isFragment(closingElement) && closingElement !== null) { this.raise(JsxErrors.MissingClosingTagFragment, { at: closingElement }); } else if (!isFragment(openingElement) && isFragment(closingElement)) { this.raise(JsxErrors.MissingClosingTagElement, { at: closingElement, openingTagName: getQualifiedJSXName(openingElement.name) }); } else if (!isFragment(openingElement) && !isFragment(closingElement)) { if (getQualifiedJSXName(closingElement.name) !== getQualifiedJSXName(openingElement.name)) { this.raise(JsxErrors.MissingClosingTagElement, { at: closingElement, openingTagName: getQualifiedJSXName(openingElement.name) }); } } } if (isFragment(openingElement)) { node.openingFragment = openingElement; node.closingFragment = closingElement; } else { node.openingElement = openingElement; node.closingElement = closingElement; } node.children = children; if (this.match(47)) { throw this.raise(JsxErrors.UnwrappedAdjacentJSXElements, { at: this.state.startLoc }); } return isFragment(openingElement) ? this.finishNode(node, "JSXFragment") : this.finishNode(node, "JSXElement"); } jsxParseElement() { const startPos = this.state.start; const startLoc = this.state.startLoc; this.next(); return this.jsxParseElementAt(startPos, startLoc); } setContext(newContext) { const { context } = this.state; context[context.length - 1] = newContext; } parseExprAtom(refExpressionErrors) { if (this.match(137)) { return this.parseLiteral(this.state.value, "JSXText"); } else if (this.match(138)) { return this.jsxParseElement(); } else if (this.match(47) && this.input.charCodeAt(this.state.pos) !== 33) { this.replaceToken(138); return this.jsxParseElement(); } else { return super.parseExprAtom(refExpressionErrors); } } skipSpace() { const curContext = this.curContext(); if (!curContext.preserveSpace) super.skipSpace(); } getTokenFromCode(code) { const context = this.curContext(); if (context === types.j_expr) { return this.jsxReadToken(); } if (context === types.j_oTag || context === types.j_cTag) { if (isIdentifierStart(code)) { return this.jsxReadWord(); } if (code === 62) { ++this.state.pos; return this.finishToken(139); } if ((code === 34 || code === 39) && context === types.j_oTag) { return this.jsxReadString(code); } } if (code === 60 && this.state.canStartJSXElement && this.input.charCodeAt(this.state.pos + 1) !== 33) { ++this.state.pos; return this.finishToken(138); } return super.getTokenFromCode(code); } updateContext(prevType) { const { context, type } = this.state; if (type === 56 && prevType === 138) { context.splice(-2, 2, types.j_cTag); this.state.canStartJSXElement = false; } else if (type === 138) { context.push(types.j_oTag); } else if (type === 139) { const out = context[context.length - 1]; if (out === types.j_oTag && prevType === 56 || out === types.j_cTag) { context.pop(); this.state.canStartJSXElement = context[context.length - 1] === types.j_expr; } else { this.setContext(types.j_expr); this.state.canStartJSXElement = true; } } else { this.state.canStartJSXElement = tokenComesBeforeExpression(type); } } }); class TypeScriptScope extends Scope { constructor(...args) { super(...args); this.types = new Set(); this.enums = new Set(); this.constEnums = new Set(); this.classes = new Set(); this.exportOnlyBindings = new Set(); } } class TypeScriptScopeHandler extends ScopeHandler { constructor(...args) { super(...args); this.importsStack = []; } createScope(flags) { this.importsStack.push(new Set()); return new TypeScriptScope(flags); } enter(flags) { if (flags == SCOPE_TS_MODULE) { this.importsStack.push(new Set()); } super.enter(flags); } exit() { const flags = super.exit(); if (flags == SCOPE_TS_MODULE) { this.importsStack.pop(); } return flags; } hasImport(name, allowShadow) { const len = this.importsStack.length; if (this.importsStack[len - 1].has(name)) { return true; } if (!allowShadow && len > 1) { for (let i = 0; i < len - 1; i++) { if (this.importsStack[i].has(name)) return true; } } return false; } declareName(name, bindingType, loc) { if (bindingType & BIND_FLAGS_TS_IMPORT) { if (this.hasImport(name, true)) { this.parser.raise(Errors.VarRedeclaration, { at: loc, identifierName: name }); } this.importsStack[this.importsStack.length - 1].add(name); return; } const scope = this.currentScope(); if (bindingType & BIND_FLAGS_TS_EXPORT_ONLY) { this.maybeExportDefined(scope, name); scope.exportOnlyBindings.add(name); return; } super.declareName(name, bindingType, loc); if (bindingType & BIND_KIND_TYPE) { if (!(bindingType & BIND_KIND_VALUE)) { this.checkRedeclarationInScope(scope, name, bindingType, loc); this.maybeExportDefined(scope, name); } scope.types.add(name); } if (bindingType & BIND_FLAGS_TS_ENUM) scope.enums.add(name); if (bindingType & BIND_FLAGS_TS_CONST_ENUM) scope.constEnums.add(name); if (bindingType & BIND_FLAGS_CLASS) scope.classes.add(name); } isRedeclaredInScope(scope, name, bindingType) { if (scope.enums.has(name)) { if (bindingType & BIND_FLAGS_TS_ENUM) { const isConst = !!(bindingType & BIND_FLAGS_TS_CONST_ENUM); const wasConst = scope.constEnums.has(name); return isConst !== wasConst; } return true; } if (bindingType & BIND_FLAGS_CLASS && scope.classes.has(name)) { if (scope.lexical.has(name)) { return !!(bindingType & BIND_KIND_VALUE); } else { return false; } } if (bindingType & BIND_KIND_TYPE && scope.types.has(name)) { return true; } return super.isRedeclaredInScope(scope, name, bindingType); } checkLocalExport(id) { const { name } = id; if (this.hasImport(name)) return; const len = this.scopeStack.length; for (let i = len - 1; i >= 0; i--) { const scope = this.scopeStack[i]; if (scope.types.has(name) || scope.exportOnlyBindings.has(name)) return; } super.checkLocalExport(id); } } const getOwn$1 = (object, key) => Object.hasOwnProperty.call(object, key) && object[key]; function nonNull(x) { if (x == null) { throw new Error(`Unexpected ${x} value.`); } return x; } function assert(x) { if (!x) { throw new Error("Assert fail"); } } const TSErrors = ParseErrorEnum`typescript`({ AbstractMethodHasImplementation: ({ methodName }) => `Method '${methodName}' cannot have an implementation because it is marked abstract.`, AbstractPropertyHasInitializer: ({ propertyName }) => `Property '${propertyName}' cannot have an initializer because it is marked abstract.`, AccesorCannotDeclareThisParameter: "'get' and 'set' accessors cannot declare 'this' parameters.", AccesorCannotHaveTypeParameters: "An accessor cannot have type parameters.", CannotFindName: ({ name }) => `Cannot find name '${name}'.`, ClassMethodHasDeclare: "Class methods cannot have the 'declare' modifier.", ClassMethodHasReadonly: "Class methods cannot have the 'readonly' modifier.", ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference: "A 'const' initializer in an ambient context must be a string or numeric literal or literal enum reference.", ConstructorHasTypeParameters: "Type parameters cannot appear on a constructor declaration.", DeclareAccessor: ({ kind }) => `'declare' is not allowed in ${kind}ters.`, DeclareClassFieldHasInitializer: "Initializers are not allowed in ambient contexts.", DeclareFunctionHasImplementation: "An implementation cannot be declared in ambient contexts.", DuplicateAccessibilityModifier: ({ modifier }) => `Accessibility modifier already seen.`, DuplicateModifier: ({ modifier }) => `Duplicate modifier: '${modifier}'.`, EmptyHeritageClauseType: ({ token }) => `'${token}' list cannot be empty.`, EmptyTypeArguments: "Type argument list cannot be empty.", EmptyTypeParameters: "Type parameter list cannot be empty.", ExpectedAmbientAfterExportDeclare: "'export declare' must be followed by an ambient declaration.", ImportAliasHasImportType: "An import alias can not use 'import type'.", IncompatibleModifiers: ({ modifiers }) => `'${modifiers[0]}' modifier cannot be used with '${modifiers[1]}' modifier.`, IndexSignatureHasAbstract: "Index signatures cannot have the 'abstract' modifier.", IndexSignatureHasAccessibility: ({ modifier }) => `Index signatures cannot have an accessibility modifier ('${modifier}').`, IndexSignatureHasDeclare: "Index signatures cannot have the 'declare' modifier.", IndexSignatureHasOverride: "'override' modifier cannot appear on an index signature.", IndexSignatureHasStatic: "Index signatures cannot have the 'static' modifier.", InitializerNotAllowedInAmbientContext: "Initializers are not allowed in ambient contexts.", InvalidModifierOnTypeMember: ({ modifier }) => `'${modifier}' modifier cannot appear on a type member.`, InvalidModifierOnTypeParameter: ({ modifier }) => `'${modifier}' modifier cannot appear on a type parameter.`, InvalidModifierOnTypeParameterPositions: ({ modifier }) => `'${modifier}' modifier can only appear on a type parameter of a class, interface or type alias.`, InvalidModifiersOrder: ({ orderedModifiers }) => `'${orderedModifiers[0]}' modifier must precede '${orderedModifiers[1]}' modifier.`, InvalidPropertyAccessAfterInstantiationExpression: "Invalid property access after an instantiation expression. " + "You can either wrap the instantiation expression in parentheses, or delete the type arguments.", InvalidTupleMemberLabel: "Tuple members must be labeled with a simple identifier.", MissingInterfaceName: "'interface' declarations must be followed by an identifier.", MixedLabeledAndUnlabeledElements: "Tuple members must all have names or all not have names.", NonAbstractClassHasAbstractMethod: "Abstract methods can only appear within an abstract class.", NonClassMethodPropertyHasAbstractModifer: "'abstract' modifier can only appear on a class, method, or property declaration.", OptionalTypeBeforeRequired: "A required element cannot follow an optional element.", OverrideNotInSubClass: "This member cannot have an 'override' modifier because its containing class does not extend another class.", PatternIsOptional: "A binding pattern parameter cannot be optional in an implementation signature.", PrivateElementHasAbstract: "Private elements cannot have the 'abstract' modifier.", PrivateElementHasAccessibility: ({ modifier }) => `Private elements cannot have an accessibility modifier ('${modifier}').`, ReadonlyForMethodSignature: "'readonly' modifier can only appear on a property declaration or index signature.", ReservedArrowTypeParam: "This syntax is reserved in files with the .mts or .cts extension. Add a trailing comma, as in `() => ...`.", ReservedTypeAssertion: "This syntax is reserved in files with the .mts or .cts extension. Use an `as` expression instead.", SetAccesorCannotHaveOptionalParameter: "A 'set' accessor cannot have an optional parameter.", SetAccesorCannotHaveRestParameter: "A 'set' accessor cannot have rest parameter.", SetAccesorCannotHaveReturnType: "A 'set' accessor cannot have a return type annotation.", SingleTypeParameterWithoutTrailingComma: ({ typeParameterName }) => `Single type parameter ${typeParameterName} should have a trailing comma. Example usage: <${typeParameterName},>.`, StaticBlockCannotHaveModifier: "Static class blocks cannot have any modifier.", TypeAnnotationAfterAssign: "Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`.", TypeImportCannotSpecifyDefaultAndNamed: "A type-only import can specify a default import or named bindings, but not both.", TypeModifierIsUsedInTypeExports: "The 'type' modifier cannot be used on a named export when 'export type' is used on its export statement.", TypeModifierIsUsedInTypeImports: "The 'type' modifier cannot be used on a named import when 'import type' is used on its import statement.", UnexpectedParameterModifier: "A parameter property is only allowed in a constructor implementation.", UnexpectedReadonly: "'readonly' type modifier is only permitted on array and tuple literal types.", UnexpectedTypeAnnotation: "Did not expect a type annotation here.", UnexpectedTypeCastInParameter: "Unexpected type cast in parameter position.", UnsupportedImportTypeArgument: "Argument in a type import must be a string literal.", UnsupportedParameterPropertyKind: "A parameter property may not be declared using a binding pattern.", UnsupportedSignatureParameterKind: ({ type }) => `Name in a signature must be an Identifier, ObjectPattern or ArrayPattern, instead got ${type}.` }); function keywordTypeFromName(value) { switch (value) { case "any": return "TSAnyKeyword"; case "boolean": return "TSBooleanKeyword"; case "bigint": return "TSBigIntKeyword"; case "never": return "TSNeverKeyword"; case "number": return "TSNumberKeyword"; case "object": return "TSObjectKeyword"; case "string": return "TSStringKeyword"; case "symbol": return "TSSymbolKeyword"; case "undefined": return "TSUndefinedKeyword"; case "unknown": return "TSUnknownKeyword"; default: return undefined; } } function tsIsAccessModifier(modifier) { return modifier === "private" || modifier === "public" || modifier === "protected"; } function tsIsVarianceAnnotations(modifier) { return modifier === "in" || modifier === "out"; } var typescript = (superClass => class TypeScriptParserMixin extends superClass { getScopeHandler() { return TypeScriptScopeHandler; } tsIsIdentifier() { return tokenIsIdentifier(this.state.type); } tsTokenCanFollowModifier() { return (this.match(0) || this.match(5) || this.match(55) || this.match(21) || this.match(134) || this.isLiteralPropertyName()) && !this.hasPrecedingLineBreak(); } tsNextTokenCanFollowModifier() { this.next(); return this.tsTokenCanFollowModifier(); } tsParseModifier(allowedModifiers, stopOnStartOfClassStaticBlock) { if (!tokenIsIdentifier(this.state.type) && this.state.type !== 58) { return undefined; } const modifier = this.state.value; if (allowedModifiers.indexOf(modifier) !== -1) { if (stopOnStartOfClassStaticBlock && this.tsIsStartOfStaticBlocks()) { return undefined; } if (this.tsTryParse(this.tsNextTokenCanFollowModifier.bind(this))) { return modifier; } } return undefined; } tsParseModifiers({ modified, allowedModifiers, disallowedModifiers, stopOnStartOfClassStaticBlock, errorTemplate = TSErrors.InvalidModifierOnTypeMember }) { const enforceOrder = (loc, modifier, before, after) => { if (modifier === before && modified[after]) { this.raise(TSErrors.InvalidModifiersOrder, { at: loc, orderedModifiers: [before, after] }); } }; const incompatible = (loc, modifier, mod1, mod2) => { if (modified[mod1] && modifier === mod2 || modified[mod2] && modifier === mod1) { this.raise(TSErrors.IncompatibleModifiers, { at: loc, modifiers: [mod1, mod2] }); } }; for (;;) { const { startLoc } = this.state; const modifier = this.tsParseModifier(allowedModifiers.concat(disallowedModifiers != null ? disallowedModifiers : []), stopOnStartOfClassStaticBlock); if (!modifier) break; if (tsIsAccessModifier(modifier)) { if (modified.accessibility) { this.raise(TSErrors.DuplicateAccessibilityModifier, { at: startLoc, modifier }); } else { enforceOrder(startLoc, modifier, modifier, "override"); enforceOrder(startLoc, modifier, modifier, "static"); enforceOrder(startLoc, modifier, modifier, "readonly"); modified.accessibility = modifier; } } else if (tsIsVarianceAnnotations(modifier)) { if (modified[modifier]) { this.raise(TSErrors.DuplicateModifier, { at: startLoc, modifier }); } modified[modifier] = true; enforceOrder(startLoc, modifier, "in", "out"); } else { if (Object.hasOwnProperty.call(modified, modifier)) { this.raise(TSErrors.DuplicateModifier, { at: startLoc, modifier }); } else { enforceOrder(startLoc, modifier, "static", "readonly"); enforceOrder(startLoc, modifier, "static", "override"); enforceOrder(startLoc, modifier, "override", "readonly"); enforceOrder(startLoc, modifier, "abstract", "override"); incompatible(startLoc, modifier, "declare", "override"); incompatible(startLoc, modifier, "static", "abstract"); } modified[modifier] = true; } if (disallowedModifiers != null && disallowedModifiers.includes(modifier)) { this.raise(errorTemplate, { at: startLoc, modifier }); } } } tsIsListTerminator(kind) { switch (kind) { case "EnumMembers": case "TypeMembers": return this.match(8); case "HeritageClauseElement": return this.match(5); case "TupleElementTypes": return this.match(3); case "TypeParametersOrArguments": return this.match(48); } throw new Error("Unreachable"); } tsParseList(kind, parseElement) { const result = []; while (!this.tsIsListTerminator(kind)) { result.push(parseElement()); } return result; } tsParseDelimitedList(kind, parseElement, refTrailingCommaPos) { return nonNull(this.tsParseDelimitedListWorker(kind, parseElement, true, refTrailingCommaPos)); } tsParseDelimitedListWorker(kind, parseElement, expectSuccess, refTrailingCommaPos) { const result = []; let trailingCommaPos = -1; for (;;) { if (this.tsIsListTerminator(kind)) { break; } trailingCommaPos = -1; const element = parseElement(); if (element == null) { return undefined; } result.push(element); if (this.eat(12)) { trailingCommaPos = this.state.lastTokStart; continue; } if (this.tsIsListTerminator(kind)) { break; } if (expectSuccess) { this.expect(12); } return undefined; } if (refTrailingCommaPos) { refTrailingCommaPos.value = trailingCommaPos; } return result; } tsParseBracketedList(kind, parseElement, bracket, skipFirstToken, refTrailingCommaPos) { if (!skipFirstToken) { if (bracket) { this.expect(0); } else { this.expect(47); } } const result = this.tsParseDelimitedList(kind, parseElement, refTrailingCommaPos); if (bracket) { this.expect(3); } else { this.expect(48); } return result; } tsParseImportType() { const node = this.startNode(); this.expect(83); this.expect(10); if (!this.match(129)) { this.raise(TSErrors.UnsupportedImportTypeArgument, { at: this.state.startLoc }); } node.argument = super.parseExprAtom(); this.expect(11); if (this.eat(16)) { node.qualifier = this.tsParseEntityName(); } if (this.match(47)) { node.typeParameters = this.tsParseTypeArguments(); } return this.finishNode(node, "TSImportType"); } tsParseEntityName(allowReservedWords = true) { let entity = this.parseIdentifier(allowReservedWords); while (this.eat(16)) { const node = this.startNodeAtNode(entity); node.left = entity; node.right = this.parseIdentifier(allowReservedWords); entity = this.finishNode(node, "TSQualifiedName"); } return entity; } tsParseTypeReference() { const node = this.startNode(); node.typeName = this.tsParseEntityName(); if (!this.hasPrecedingLineBreak() && this.match(47)) { node.typeParameters = this.tsParseTypeArguments(); } return this.finishNode(node, "TSTypeReference"); } tsParseThisTypePredicate(lhs) { this.next(); const node = this.startNodeAtNode(lhs); node.parameterName = lhs; node.typeAnnotation = this.tsParseTypeAnnotation(false); node.asserts = false; return this.finishNode(node, "TSTypePredicate"); } tsParseThisTypeNode() { const node = this.startNode(); this.next(); return this.finishNode(node, "TSThisType"); } tsParseTypeQuery() { const node = this.startNode(); this.expect(87); if (this.match(83)) { node.exprName = this.tsParseImportType(); } else { node.exprName = this.tsParseEntityName(); } if (!this.hasPrecedingLineBreak() && this.match(47)) { node.typeParameters = this.tsParseTypeArguments(); } return this.finishNode(node, "TSTypeQuery"); } tsParseInOutModifiers(node) { this.tsParseModifiers({ modified: node, allowedModifiers: ["in", "out"], disallowedModifiers: ["public", "private", "protected", "readonly", "declare", "abstract", "override"], errorTemplate: TSErrors.InvalidModifierOnTypeParameter }); } tsParseNoneModifiers(node) { this.tsParseModifiers({ modified: node, allowedModifiers: [], disallowedModifiers: ["in", "out"], errorTemplate: TSErrors.InvalidModifierOnTypeParameterPositions }); } tsParseTypeParameter(parseModifiers = this.tsParseNoneModifiers.bind(this)) { const node = this.startNode(); parseModifiers(node); node.name = this.tsParseTypeParameterName(); node.constraint = this.tsEatThenParseType(81); node.default = this.tsEatThenParseType(29); return this.finishNode(node, "TSTypeParameter"); } tsTryParseTypeParameters(parseModifiers) { if (this.match(47)) { return this.tsParseTypeParameters(parseModifiers); } } tsParseTypeParameters(parseModifiers) { const node = this.startNode(); if (this.match(47) || this.match(138)) { this.next(); } else { this.unexpected(); } const refTrailingCommaPos = { value: -1 }; node.params = this.tsParseBracketedList("TypeParametersOrArguments", this.tsParseTypeParameter.bind(this, parseModifiers), false, true, refTrailingCommaPos); if (node.params.length === 0) { this.raise(TSErrors.EmptyTypeParameters, { at: node }); } if (refTrailingCommaPos.value !== -1) { this.addExtra(node, "trailingComma", refTrailingCommaPos.value); } return this.finishNode(node, "TSTypeParameterDeclaration"); } tsTryNextParseConstantContext() { if (this.lookahead().type !== 75) return null; this.next(); const typeReference = this.tsParseTypeReference(); if (typeReference.typeParameters) { this.raise(TSErrors.CannotFindName, { at: typeReference.typeName, name: "const" }); } return typeReference; } tsFillSignature(returnToken, signature) { const returnTokenRequired = returnToken === 19; const paramsKey = "parameters"; const returnTypeKey = "typeAnnotation"; signature.typeParameters = this.tsTryParseTypeParameters(); this.expect(10); signature[paramsKey] = this.tsParseBindingListForSignature(); if (returnTokenRequired) { signature[returnTypeKey] = this.tsParseTypeOrTypePredicateAnnotation(returnToken); } else if (this.match(returnToken)) { signature[returnTypeKey] = this.tsParseTypeOrTypePredicateAnnotation(returnToken); } } tsParseBindingListForSignature() { return super.parseBindingList(11, 41).map(pattern => { if (pattern.type !== "Identifier" && pattern.type !== "RestElement" && pattern.type !== "ObjectPattern" && pattern.type !== "ArrayPattern") { this.raise(TSErrors.UnsupportedSignatureParameterKind, { at: pattern, type: pattern.type }); } return pattern; }); } tsParseTypeMemberSemicolon() { if (!this.eat(12) && !this.isLineTerminator()) { this.expect(13); } } tsParseSignatureMember(kind, node) { this.tsFillSignature(14, node); this.tsParseTypeMemberSemicolon(); return this.finishNode(node, kind); } tsIsUnambiguouslyIndexSignature() { this.next(); if (tokenIsIdentifier(this.state.type)) { this.next(); return this.match(14); } return false; } tsTryParseIndexSignature(node) { if (!(this.match(0) && this.tsLookAhead(this.tsIsUnambiguouslyIndexSignature.bind(this)))) { return undefined; } this.expect(0); const id = this.parseIdentifier(); id.typeAnnotation = this.tsParseTypeAnnotation(); this.resetEndLocation(id); this.expect(3); node.parameters = [id]; const type = this.tsTryParseTypeAnnotation(); if (type) node.typeAnnotation = type; this.tsParseTypeMemberSemicolon(); return this.finishNode(node, "TSIndexSignature"); } tsParsePropertyOrMethodSignature(node, readonly) { if (this.eat(17)) node.optional = true; const nodeAny = node; if (this.match(10) || this.match(47)) { if (readonly) { this.raise(TSErrors.ReadonlyForMethodSignature, { at: node }); } const method = nodeAny; if (method.kind && this.match(47)) { this.raise(TSErrors.AccesorCannotHaveTypeParameters, { at: this.state.curPosition() }); } this.tsFillSignature(14, method); this.tsParseTypeMemberSemicolon(); const paramsKey = "parameters"; const returnTypeKey = "typeAnnotation"; if (method.kind === "get") { if (method[paramsKey].length > 0) { this.raise(Errors.BadGetterArity, { at: this.state.curPosition() }); if (this.isThisParam(method[paramsKey][0])) { this.raise(TSErrors.AccesorCannotDeclareThisParameter, { at: this.state.curPosition() }); } } } else if (method.kind === "set") { if (method[paramsKey].length !== 1) { this.raise(Errors.BadSetterArity, { at: this.state.curPosition() }); } else { const firstParameter = method[paramsKey][0]; if (this.isThisParam(firstParameter)) { this.raise(TSErrors.AccesorCannotDeclareThisParameter, { at: this.state.curPosition() }); } if (firstParameter.type === "Identifier" && firstParameter.optional) { this.raise(TSErrors.SetAccesorCannotHaveOptionalParameter, { at: this.state.curPosition() }); } if (firstParameter.type === "RestElement") { this.raise(TSErrors.SetAccesorCannotHaveRestParameter, { at: this.state.curPosition() }); } } if (method[returnTypeKey]) { this.raise(TSErrors.SetAccesorCannotHaveReturnType, { at: method[returnTypeKey] }); } } else { method.kind = "method"; } return this.finishNode(method, "TSMethodSignature"); } else { const property = nodeAny; if (readonly) property.readonly = true; const type = this.tsTryParseTypeAnnotation(); if (type) property.typeAnnotation = type; this.tsParseTypeMemberSemicolon(); return this.finishNode(property, "TSPropertySignature"); } } tsParseTypeMember() { const node = this.startNode(); if (this.match(10) || this.match(47)) { return this.tsParseSignatureMember("TSCallSignatureDeclaration", node); } if (this.match(77)) { const id = this.startNode(); this.next(); if (this.match(10) || this.match(47)) { return this.tsParseSignatureMember("TSConstructSignatureDeclaration", node); } else { node.key = this.createIdentifier(id, "new"); return this.tsParsePropertyOrMethodSignature(node, false); } } this.tsParseModifiers({ modified: node, allowedModifiers: ["readonly"], disallowedModifiers: ["declare", "abstract", "private", "protected", "public", "static", "override"] }); const idx = this.tsTryParseIndexSignature(node); if (idx) { return idx; } super.parsePropertyName(node); if (!node.computed && node.key.type === "Identifier" && (node.key.name === "get" || node.key.name === "set") && this.tsTokenCanFollowModifier()) { node.kind = node.key.name; super.parsePropertyName(node); } return this.tsParsePropertyOrMethodSignature(node, !!node.readonly); } tsParseTypeLiteral() { const node = this.startNode(); node.members = this.tsParseObjectTypeMembers(); return this.finishNode(node, "TSTypeLiteral"); } tsParseObjectTypeMembers() { this.expect(5); const members = this.tsParseList("TypeMembers", this.tsParseTypeMember.bind(this)); this.expect(8); return members; } tsIsStartOfMappedType() { this.next(); if (this.eat(53)) { return this.isContextual(118); } if (this.isContextual(118)) { this.next(); } if (!this.match(0)) { return false; } this.next(); if (!this.tsIsIdentifier()) { return false; } this.next(); return this.match(58); } tsParseMappedTypeParameter() { const node = this.startNode(); node.name = this.tsParseTypeParameterName(); node.constraint = this.tsExpectThenParseType(58); return this.finishNode(node, "TSTypeParameter"); } tsParseMappedType() { const node = this.startNode(); this.expect(5); if (this.match(53)) { node.readonly = this.state.value; this.next(); this.expectContextual(118); } else if (this.eatContextual(118)) { node.readonly = true; } this.expect(0); node.typeParameter = this.tsParseMappedTypeParameter(); node.nameType = this.eatContextual(93) ? this.tsParseType() : null; this.expect(3); if (this.match(53)) { node.optional = this.state.value; this.next(); this.expect(17); } else if (this.eat(17)) { node.optional = true; } node.typeAnnotation = this.tsTryParseType(); this.semicolon(); this.expect(8); return this.finishNode(node, "TSMappedType"); } tsParseTupleType() { const node = this.startNode(); node.elementTypes = this.tsParseBracketedList("TupleElementTypes", this.tsParseTupleElementType.bind(this), true, false); let seenOptionalElement = false; let labeledElements = null; node.elementTypes.forEach(elementNode => { var _labeledElements; const { type } = elementNode; if (seenOptionalElement && type !== "TSRestType" && type !== "TSOptionalType" && !(type === "TSNamedTupleMember" && elementNode.optional)) { this.raise(TSErrors.OptionalTypeBeforeRequired, { at: elementNode }); } seenOptionalElement || (seenOptionalElement = type === "TSNamedTupleMember" && elementNode.optional || type === "TSOptionalType"); let checkType = type; if (type === "TSRestType") { elementNode = elementNode.typeAnnotation; checkType = elementNode.type; } const isLabeled = checkType === "TSNamedTupleMember"; (_labeledElements = labeledElements) != null ? _labeledElements : labeledElements = isLabeled; if (labeledElements !== isLabeled) { this.raise(TSErrors.MixedLabeledAndUnlabeledElements, { at: elementNode }); } }); return this.finishNode(node, "TSTupleType"); } tsParseTupleElementType() { const { start: startPos, startLoc } = this.state; const rest = this.eat(21); let type = this.tsParseType(); const optional = this.eat(17); const labeled = this.eat(14); if (labeled) { const labeledNode = this.startNodeAtNode(type); labeledNode.optional = optional; if (type.type === "TSTypeReference" && !type.typeParameters && type.typeName.type === "Identifier") { labeledNode.label = type.typeName; } else { this.raise(TSErrors.InvalidTupleMemberLabel, { at: type }); labeledNode.label = type; } labeledNode.elementType = this.tsParseType(); type = this.finishNode(labeledNode, "TSNamedTupleMember"); } else if (optional) { const optionalTypeNode = this.startNodeAtNode(type); optionalTypeNode.typeAnnotation = type; type = this.finishNode(optionalTypeNode, "TSOptionalType"); } if (rest) { const restNode = this.startNodeAt(startPos, startLoc); restNode.typeAnnotation = type; type = this.finishNode(restNode, "TSRestType"); } return type; } tsParseParenthesizedType() { const node = this.startNode(); this.expect(10); node.typeAnnotation = this.tsParseType(); this.expect(11); return this.finishNode(node, "TSParenthesizedType"); } tsParseFunctionOrConstructorType(type, abstract) { const node = this.startNode(); if (type === "TSConstructorType") { node.abstract = !!abstract; if (abstract) this.next(); this.next(); } this.tsInAllowConditionalTypesContext(() => this.tsFillSignature(19, node)); return this.finishNode(node, type); } tsParseLiteralTypeNode() { const node = this.startNode(); node.literal = (() => { switch (this.state.type) { case 130: case 131: case 129: case 85: case 86: return super.parseExprAtom(); default: throw this.unexpected(); } })(); return this.finishNode(node, "TSLiteralType"); } tsParseTemplateLiteralType() { const node = this.startNode(); node.literal = super.parseTemplate(false); return this.finishNode(node, "TSLiteralType"); } parseTemplateSubstitution() { if (this.state.inType) return this.tsParseType(); return super.parseTemplateSubstitution(); } tsParseThisTypeOrThisTypePredicate() { const thisKeyword = this.tsParseThisTypeNode(); if (this.isContextual(113) && !this.hasPrecedingLineBreak()) { return this.tsParseThisTypePredicate(thisKeyword); } else { return thisKeyword; } } tsParseNonArrayType() { switch (this.state.type) { case 129: case 130: case 131: case 85: case 86: return this.tsParseLiteralTypeNode(); case 53: if (this.state.value === "-") { const node = this.startNode(); const nextToken = this.lookahead(); if (nextToken.type !== 130 && nextToken.type !== 131) { throw this.unexpected(); } node.literal = this.parseMaybeUnary(); return this.finishNode(node, "TSLiteralType"); } break; case 78: return this.tsParseThisTypeOrThisTypePredicate(); case 87: return this.tsParseTypeQuery(); case 83: return this.tsParseImportType(); case 5: return this.tsLookAhead(this.tsIsStartOfMappedType.bind(this)) ? this.tsParseMappedType() : this.tsParseTypeLiteral(); case 0: return this.tsParseTupleType(); case 10: return this.tsParseParenthesizedType(); case 25: case 24: return this.tsParseTemplateLiteralType(); default: { const { type } = this.state; if (tokenIsIdentifier(type) || type === 88 || type === 84) { const nodeType = type === 88 ? "TSVoidKeyword" : type === 84 ? "TSNullKeyword" : keywordTypeFromName(this.state.value); if (nodeType !== undefined && this.lookaheadCharCode() !== 46) { const node = this.startNode(); this.next(); return this.finishNode(node, nodeType); } return this.tsParseTypeReference(); } } } throw this.unexpected(); } tsParseArrayTypeOrHigher() { let type = this.tsParseNonArrayType(); while (!this.hasPrecedingLineBreak() && this.eat(0)) { if (this.match(3)) { const node = this.startNodeAtNode(type); node.elementType = type; this.expect(3); type = this.finishNode(node, "TSArrayType"); } else { const node = this.startNodeAtNode(type); node.objectType = type; node.indexType = this.tsParseType(); this.expect(3); type = this.finishNode(node, "TSIndexedAccessType"); } } return type; } tsParseTypeOperator() { const node = this.startNode(); const operator = this.state.value; this.next(); node.operator = operator; node.typeAnnotation = this.tsParseTypeOperatorOrHigher(); if (operator === "readonly") { this.tsCheckTypeAnnotationForReadOnly(node); } return this.finishNode(node, "TSTypeOperator"); } tsCheckTypeAnnotationForReadOnly(node) { switch (node.typeAnnotation.type) { case "TSTupleType": case "TSArrayType": return; default: this.raise(TSErrors.UnexpectedReadonly, { at: node }); } } tsParseInferType() { const node = this.startNode(); this.expectContextual(112); const typeParameter = this.startNode(); typeParameter.name = this.tsParseTypeParameterName(); typeParameter.constraint = this.tsTryParse(() => this.tsParseConstraintForInferType()); node.typeParameter = this.finishNode(typeParameter, "TSTypeParameter"); return this.finishNode(node, "TSInferType"); } tsParseConstraintForInferType() { if (this.eat(81)) { const constraint = this.tsInDisallowConditionalTypesContext(() => this.tsParseType()); if (this.state.inDisallowConditionalTypesContext || !this.match(17)) { return constraint; } } } tsParseTypeOperatorOrHigher() { const isTypeOperator = tokenIsTSTypeOperator(this.state.type) && !this.state.containsEsc; return isTypeOperator ? this.tsParseTypeOperator() : this.isContextual(112) ? this.tsParseInferType() : this.tsInAllowConditionalTypesContext(() => this.tsParseArrayTypeOrHigher()); } tsParseUnionOrIntersectionType(kind, parseConstituentType, operator) { const node = this.startNode(); const hasLeadingOperator = this.eat(operator); const types = []; do { types.push(parseConstituentType()); } while (this.eat(operator)); if (types.length === 1 && !hasLeadingOperator) { return types[0]; } node.types = types; return this.finishNode(node, kind); } tsParseIntersectionTypeOrHigher() { return this.tsParseUnionOrIntersectionType("TSIntersectionType", this.tsParseTypeOperatorOrHigher.bind(this), 45); } tsParseUnionTypeOrHigher() { return this.tsParseUnionOrIntersectionType("TSUnionType", this.tsParseIntersectionTypeOrHigher.bind(this), 43); } tsIsStartOfFunctionType() { if (this.match(47)) { return true; } return this.match(10) && this.tsLookAhead(this.tsIsUnambiguouslyStartOfFunctionType.bind(this)); } tsSkipParameterStart() { if (tokenIsIdentifier(this.state.type) || this.match(78)) { this.next(); return true; } if (this.match(5)) { const { errors } = this.state; const previousErrorCount = errors.length; try { this.parseObjectLike(8, true); return errors.length === previousErrorCount; } catch (_unused) { return false; } } if (this.match(0)) { this.next(); const { errors } = this.state; const previousErrorCount = errors.length; try { super.parseBindingList(3, 93, true); return errors.length === previousErrorCount; } catch (_unused2) { return false; } } return false; } tsIsUnambiguouslyStartOfFunctionType() { this.next(); if (this.match(11) || this.match(21)) { return true; } if (this.tsSkipParameterStart()) { if (this.match(14) || this.match(12) || this.match(17) || this.match(29)) { return true; } if (this.match(11)) { this.next(); if (this.match(19)) { return true; } } } return false; } tsParseTypeOrTypePredicateAnnotation(returnToken) { return this.tsInType(() => { const t = this.startNode(); this.expect(returnToken); const node = this.startNode(); const asserts = !!this.tsTryParse(this.tsParseTypePredicateAsserts.bind(this)); if (asserts && this.match(78)) { let thisTypePredicate = this.tsParseThisTypeOrThisTypePredicate(); if (thisTypePredicate.type === "TSThisType") { node.parameterName = thisTypePredicate; node.asserts = true; node.typeAnnotation = null; thisTypePredicate = this.finishNode(node, "TSTypePredicate"); } else { this.resetStartLocationFromNode(thisTypePredicate, node); thisTypePredicate.asserts = true; } t.typeAnnotation = thisTypePredicate; return this.finishNode(t, "TSTypeAnnotation"); } const typePredicateVariable = this.tsIsIdentifier() && this.tsTryParse(this.tsParseTypePredicatePrefix.bind(this)); if (!typePredicateVariable) { if (!asserts) { return this.tsParseTypeAnnotation(false, t); } node.parameterName = this.parseIdentifier(); node.asserts = asserts; node.typeAnnotation = null; t.typeAnnotation = this.finishNode(node, "TSTypePredicate"); return this.finishNode(t, "TSTypeAnnotation"); } const type = this.tsParseTypeAnnotation(false); node.parameterName = typePredicateVariable; node.typeAnnotation = type; node.asserts = asserts; t.typeAnnotation = this.finishNode(node, "TSTypePredicate"); return this.finishNode(t, "TSTypeAnnotation"); }); } tsTryParseTypeOrTypePredicateAnnotation() { return this.match(14) ? this.tsParseTypeOrTypePredicateAnnotation(14) : undefined; } tsTryParseTypeAnnotation() { return this.match(14) ? this.tsParseTypeAnnotation() : undefined; } tsTryParseType() { return this.tsEatThenParseType(14); } tsParseTypePredicatePrefix() { const id = this.parseIdentifier(); if (this.isContextual(113) && !this.hasPrecedingLineBreak()) { this.next(); return id; } } tsParseTypePredicateAsserts() { if (this.state.type !== 106) { return false; } const containsEsc = this.state.containsEsc; this.next(); if (!tokenIsIdentifier(this.state.type) && !this.match(78)) { return false; } if (containsEsc) { this.raise(Errors.InvalidEscapedReservedWord, { at: this.state.lastTokStartLoc, reservedWord: "asserts" }); } return true; } tsParseTypeAnnotation(eatColon = true, t = this.startNode()) { this.tsInType(() => { if (eatColon) this.expect(14); t.typeAnnotation = this.tsParseType(); }); return this.finishNode(t, "TSTypeAnnotation"); } tsParseType() { assert(this.state.inType); const type = this.tsParseNonConditionalType(); if (this.state.inDisallowConditionalTypesContext || this.hasPrecedingLineBreak() || !this.eat(81)) { return type; } const node = this.startNodeAtNode(type); node.checkType = type; node.extendsType = this.tsInDisallowConditionalTypesContext(() => this.tsParseNonConditionalType()); this.expect(17); node.trueType = this.tsInAllowConditionalTypesContext(() => this.tsParseType()); this.expect(14); node.falseType = this.tsInAllowConditionalTypesContext(() => this.tsParseType()); return this.finishNode(node, "TSConditionalType"); } isAbstractConstructorSignature() { return this.isContextual(120) && this.lookahead().type === 77; } tsParseNonConditionalType() { if (this.tsIsStartOfFunctionType()) { return this.tsParseFunctionOrConstructorType("TSFunctionType"); } if (this.match(77)) { return this.tsParseFunctionOrConstructorType("TSConstructorType"); } else if (this.isAbstractConstructorSignature()) { return this.tsParseFunctionOrConstructorType("TSConstructorType", true); } return this.tsParseUnionTypeOrHigher(); } tsParseTypeAssertion() { if (this.getPluginOption("typescript", "disallowAmbiguousJSXLike")) { this.raise(TSErrors.ReservedTypeAssertion, { at: this.state.startLoc }); } const node = this.startNode(); const _const = this.tsTryNextParseConstantContext(); node.typeAnnotation = _const || this.tsNextThenParseType(); this.expect(48); node.expression = this.parseMaybeUnary(); return this.finishNode(node, "TSTypeAssertion"); } tsParseHeritageClause(token) { const originalStartLoc = this.state.startLoc; const delimitedList = this.tsParseDelimitedList("HeritageClauseElement", () => { const node = this.startNode(); node.expression = this.tsParseEntityName(); if (this.match(47)) { node.typeParameters = this.tsParseTypeArguments(); } return this.finishNode(node, "TSExpressionWithTypeArguments"); }); if (!delimitedList.length) { this.raise(TSErrors.EmptyHeritageClauseType, { at: originalStartLoc, token }); } return delimitedList; } tsParseInterfaceDeclaration(node, properties = {}) { if (this.hasFollowingLineBreak()) return null; this.expectContextual(125); if (properties.declare) node.declare = true; if (tokenIsIdentifier(this.state.type)) { node.id = this.parseIdentifier(); this.checkIdentifier(node.id, BIND_TS_INTERFACE); } else { node.id = null; this.raise(TSErrors.MissingInterfaceName, { at: this.state.startLoc }); } node.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutModifiers.bind(this)); if (this.eat(81)) { node.extends = this.tsParseHeritageClause("extends"); } const body = this.startNode(); body.body = this.tsInType(this.tsParseObjectTypeMembers.bind(this)); node.body = this.finishNode(body, "TSInterfaceBody"); return this.finishNode(node, "TSInterfaceDeclaration"); } tsParseTypeAliasDeclaration(node) { node.id = this.parseIdentifier(); this.checkIdentifier(node.id, BIND_TS_TYPE); node.typeAnnotation = this.tsInType(() => { node.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutModifiers.bind(this)); this.expect(29); if (this.isContextual(111) && this.lookahead().type !== 16) { const node = this.startNode(); this.next(); return this.finishNode(node, "TSIntrinsicKeyword"); } return this.tsParseType(); }); this.semicolon(); return this.finishNode(node, "TSTypeAliasDeclaration"); } tsInNoContext(cb) { const oldContext = this.state.context; this.state.context = [oldContext[0]]; try { return cb(); } finally { this.state.context = oldContext; } } tsInType(cb) { const oldInType = this.state.inType; this.state.inType = true; try { return cb(); } finally { this.state.inType = oldInType; } } tsInDisallowConditionalTypesContext(cb) { const oldInDisallowConditionalTypesContext = this.state.inDisallowConditionalTypesContext; this.state.inDisallowConditionalTypesContext = true; try { return cb(); } finally { this.state.inDisallowConditionalTypesContext = oldInDisallowConditionalTypesContext; } } tsInAllowConditionalTypesContext(cb) { const oldInDisallowConditionalTypesContext = this.state.inDisallowConditionalTypesContext; this.state.inDisallowConditionalTypesContext = false; try { return cb(); } finally { this.state.inDisallowConditionalTypesContext = oldInDisallowConditionalTypesContext; } } tsEatThenParseType(token) { return !this.match(token) ? undefined : this.tsNextThenParseType(); } tsExpectThenParseType(token) { return this.tsDoThenParseType(() => this.expect(token)); } tsNextThenParseType() { return this.tsDoThenParseType(() => this.next()); } tsDoThenParseType(cb) { return this.tsInType(() => { cb(); return this.tsParseType(); }); } tsParseEnumMember() { const node = this.startNode(); node.id = this.match(129) ? super.parseStringLiteral(this.state.value) : this.parseIdentifier(true); if (this.eat(29)) { node.initializer = super.parseMaybeAssignAllowIn(); } return this.finishNode(node, "TSEnumMember"); } tsParseEnumDeclaration(node, properties = {}) { if (properties.const) node.const = true; if (properties.declare) node.declare = true; this.expectContextual(122); node.id = this.parseIdentifier(); this.checkIdentifier(node.id, node.const ? BIND_TS_CONST_ENUM : BIND_TS_ENUM); this.expect(5); node.members = this.tsParseDelimitedList("EnumMembers", this.tsParseEnumMember.bind(this)); this.expect(8); return this.finishNode(node, "TSEnumDeclaration"); } tsParseModuleBlock() { const node = this.startNode(); this.scope.enter(SCOPE_OTHER); this.expect(5); super.parseBlockOrModuleBlockBody(node.body = [], undefined, true, 8); this.next(); this.scope.exit(); return this.finishNode(node, "TSModuleBlock"); } tsParseModuleOrNamespaceDeclaration(node, nested = false) { node.id = this.parseIdentifier(); if (!nested) { this.checkIdentifier(node.id, BIND_TS_NAMESPACE); } if (this.eat(16)) { const inner = this.startNode(); this.tsParseModuleOrNamespaceDeclaration(inner, true); node.body = inner; } else { this.scope.enter(SCOPE_TS_MODULE); this.prodParam.enter(PARAM); node.body = this.tsParseModuleBlock(); this.prodParam.exit(); this.scope.exit(); } return this.finishNode(node, "TSModuleDeclaration"); } tsParseAmbientExternalModuleDeclaration(node) { if (this.isContextual(109)) { node.global = true; node.id = this.parseIdentifier(); } else if (this.match(129)) { node.id = super.parseStringLiteral(this.state.value); } else { this.unexpected(); } if (this.match(5)) { this.scope.enter(SCOPE_TS_MODULE); this.prodParam.enter(PARAM); node.body = this.tsParseModuleBlock(); this.prodParam.exit(); this.scope.exit(); } else { this.semicolon(); } return this.finishNode(node, "TSModuleDeclaration"); } tsParseImportEqualsDeclaration(node, isExport) { node.isExport = isExport || false; node.id = this.parseIdentifier(); this.checkIdentifier(node.id, BIND_FLAGS_TS_IMPORT); this.expect(29); const moduleReference = this.tsParseModuleReference(); if (node.importKind === "type" && moduleReference.type !== "TSExternalModuleReference") { this.raise(TSErrors.ImportAliasHasImportType, { at: moduleReference }); } node.moduleReference = moduleReference; this.semicolon(); return this.finishNode(node, "TSImportEqualsDeclaration"); } tsIsExternalModuleReference() { return this.isContextual(116) && this.lookaheadCharCode() === 40; } tsParseModuleReference() { return this.tsIsExternalModuleReference() ? this.tsParseExternalModuleReference() : this.tsParseEntityName(false); } tsParseExternalModuleReference() { const node = this.startNode(); this.expectContextual(116); this.expect(10); if (!this.match(129)) { throw this.unexpected(); } node.expression = super.parseExprAtom(); this.expect(11); return this.finishNode(node, "TSExternalModuleReference"); } tsLookAhead(f) { const state = this.state.clone(); const res = f(); this.state = state; return res; } tsTryParseAndCatch(f) { const result = this.tryParse(abort => f() || abort()); if (result.aborted || !result.node) return undefined; if (result.error) this.state = result.failState; return result.node; } tsTryParse(f) { const state = this.state.clone(); const result = f(); if (result !== undefined && result !== false) { return result; } else { this.state = state; return undefined; } } tsTryParseDeclare(nany) { if (this.isLineTerminator()) { return; } let starttype = this.state.type; let kind; if (this.isContextual(99)) { starttype = 74; kind = "let"; } return this.tsInAmbientContext(() => { if (starttype === 68) { nany.declare = true; return super.parseFunctionStatement(nany, false, true); } if (starttype === 80) { nany.declare = true; return this.parseClass(nany, true, false); } if (starttype === 122) { return this.tsParseEnumDeclaration(nany, { declare: true }); } if (starttype === 109) { return this.tsParseAmbientExternalModuleDeclaration(nany); } if (starttype === 75 || starttype === 74) { if (!this.match(75) || !this.isLookaheadContextual("enum")) { nany.declare = true; return this.parseVarStatement(nany, kind || this.state.value, true); } this.expect(75); return this.tsParseEnumDeclaration(nany, { const: true, declare: true }); } if (starttype === 125) { const result = this.tsParseInterfaceDeclaration(nany, { declare: true }); if (result) return result; } if (tokenIsIdentifier(starttype)) { return this.tsParseDeclaration(nany, this.state.value, true); } }); } tsTryParseExportDeclaration() { return this.tsParseDeclaration(this.startNode(), this.state.value, true); } tsParseExpressionStatement(node, expr) { switch (expr.name) { case "declare": { const declaration = this.tsTryParseDeclare(node); if (declaration) { declaration.declare = true; return declaration; } break; } case "global": if (this.match(5)) { this.scope.enter(SCOPE_TS_MODULE); this.prodParam.enter(PARAM); const mod = node; mod.global = true; mod.id = expr; mod.body = this.tsParseModuleBlock(); this.scope.exit(); this.prodParam.exit(); return this.finishNode(mod, "TSModuleDeclaration"); } break; default: return this.tsParseDeclaration(node, expr.name, false); } } tsParseDeclaration(node, value, next) { switch (value) { case "abstract": if (this.tsCheckLineTerminator(next) && (this.match(80) || tokenIsIdentifier(this.state.type))) { return this.tsParseAbstractDeclaration(node); } break; case "module": if (this.tsCheckLineTerminator(next)) { if (this.match(129)) { return this.tsParseAmbientExternalModuleDeclaration(node); } else if (tokenIsIdentifier(this.state.type)) { return this.tsParseModuleOrNamespaceDeclaration(node); } } break; case "namespace": if (this.tsCheckLineTerminator(next) && tokenIsIdentifier(this.state.type)) { return this.tsParseModuleOrNamespaceDeclaration(node); } break; case "type": if (this.tsCheckLineTerminator(next) && tokenIsIdentifier(this.state.type)) { return this.tsParseTypeAliasDeclaration(node); } break; } } tsCheckLineTerminator(next) { if (next) { if (this.hasFollowingLineBreak()) return false; this.next(); return true; } return !this.isLineTerminator(); } tsTryParseGenericAsyncArrowFunction(startPos, startLoc) { if (!this.match(47)) { return undefined; } const oldMaybeInArrowParameters = this.state.maybeInArrowParameters; this.state.maybeInArrowParameters = true; const res = this.tsTryParseAndCatch(() => { const node = this.startNodeAt(startPos, startLoc); node.typeParameters = this.tsParseTypeParameters(); super.parseFunctionParams(node); node.returnType = this.tsTryParseTypeOrTypePredicateAnnotation(); this.expect(19); return node; }); this.state.maybeInArrowParameters = oldMaybeInArrowParameters; if (!res) { return undefined; } return super.parseArrowExpression(res, null, true); } tsParseTypeArgumentsInExpression() { if (this.reScan_lt() !== 47) { return undefined; } return this.tsParseTypeArguments(); } tsParseTypeArguments() { const node = this.startNode(); node.params = this.tsInType(() => this.tsInNoContext(() => { this.expect(47); return this.tsParseDelimitedList("TypeParametersOrArguments", this.tsParseType.bind(this)); })); if (node.params.length === 0) { this.raise(TSErrors.EmptyTypeArguments, { at: node }); } this.expect(48); return this.finishNode(node, "TSTypeParameterInstantiation"); } tsIsDeclarationStart() { return tokenIsTSDeclarationStart(this.state.type); } isExportDefaultSpecifier() { if (this.tsIsDeclarationStart()) return false; return super.isExportDefaultSpecifier(); } parseAssignableListItem(allowModifiers, decorators) { const startPos = this.state.start; const startLoc = this.state.startLoc; let accessibility; let readonly = false; let override = false; if (allowModifiers !== undefined) { const modified = {}; this.tsParseModifiers({ modified, allowedModifiers: ["public", "private", "protected", "override", "readonly"] }); accessibility = modified.accessibility; override = modified.override; readonly = modified.readonly; if (allowModifiers === false && (accessibility || readonly || override)) { this.raise(TSErrors.UnexpectedParameterModifier, { at: startLoc }); } } const left = this.parseMaybeDefault(); this.parseAssignableListItemTypes(left); const elt = this.parseMaybeDefault(left.start, left.loc.start, left); if (accessibility || readonly || override) { const pp = this.startNodeAt(startPos, startLoc); if (decorators.length) { pp.decorators = decorators; } if (accessibility) pp.accessibility = accessibility; if (readonly) pp.readonly = readonly; if (override) pp.override = override; if (elt.type !== "Identifier" && elt.type !== "AssignmentPattern") { this.raise(TSErrors.UnsupportedParameterPropertyKind, { at: pp }); } pp.parameter = elt; return this.finishNode(pp, "TSParameterProperty"); } if (decorators.length) { left.decorators = decorators; } return elt; } isSimpleParameter(node) { return node.type === "TSParameterProperty" && super.isSimpleParameter(node.parameter) || super.isSimpleParameter(node); } parseFunctionBodyAndFinish(node, type, isMethod = false) { if (this.match(14)) { node.returnType = this.tsParseTypeOrTypePredicateAnnotation(14); } const bodilessType = type === "FunctionDeclaration" ? "TSDeclareFunction" : type === "ClassMethod" || type === "ClassPrivateMethod" ? "TSDeclareMethod" : undefined; if (bodilessType && !this.match(5) && this.isLineTerminator()) { return this.finishNode(node, bodilessType); } if (bodilessType === "TSDeclareFunction" && this.state.isAmbientContext) { this.raise(TSErrors.DeclareFunctionHasImplementation, { at: node }); if (node.declare) { return super.parseFunctionBodyAndFinish(node, bodilessType, isMethod); } } return super.parseFunctionBodyAndFinish(node, type, isMethod); } registerFunctionStatementId(node) { if (!node.body && node.id) { this.checkIdentifier(node.id, BIND_TS_AMBIENT); } else { super.registerFunctionStatementId(node); } } tsCheckForInvalidTypeCasts(items) { items.forEach(node => { if ((node == null ? void 0 : node.type) === "TSTypeCastExpression") { this.raise(TSErrors.UnexpectedTypeAnnotation, { at: node.typeAnnotation }); } }); } toReferencedList(exprList, isInParens) { this.tsCheckForInvalidTypeCasts(exprList); return exprList; } parseArrayLike(close, canBePattern, isTuple, refExpressionErrors) { const node = super.parseArrayLike(close, canBePattern, isTuple, refExpressionErrors); if (node.type === "ArrayExpression") { this.tsCheckForInvalidTypeCasts(node.elements); } return node; } parseSubscript(base, startPos, startLoc, noCalls, state) { if (!this.hasPrecedingLineBreak() && this.match(35)) { this.state.canStartJSXElement = false; this.next(); const nonNullExpression = this.startNodeAt(startPos, startLoc); nonNullExpression.expression = base; return this.finishNode(nonNullExpression, "TSNonNullExpression"); } let isOptionalCall = false; if (this.match(18) && this.lookaheadCharCode() === 60) { if (noCalls) { state.stop = true; return base; } state.optionalChainMember = isOptionalCall = true; this.next(); } if (this.match(47) || this.match(51)) { let missingParenErrorLoc; const result = this.tsTryParseAndCatch(() => { if (!noCalls && this.atPossibleAsyncArrow(base)) { const asyncArrowFn = this.tsTryParseGenericAsyncArrowFunction(startPos, startLoc); if (asyncArrowFn) { return asyncArrowFn; } } const typeArguments = this.tsParseTypeArgumentsInExpression(); if (!typeArguments) return; if (isOptionalCall && !this.match(10)) { missingParenErrorLoc = this.state.curPosition(); return; } if (tokenIsTemplate(this.state.type)) { const result = super.parseTaggedTemplateExpression(base, startPos, startLoc, state); result.typeParameters = typeArguments; return result; } if (!noCalls && this.eat(10)) { const node = this.startNodeAt(startPos, startLoc); node.callee = base; node.arguments = this.parseCallExpressionArguments(11, false); this.tsCheckForInvalidTypeCasts(node.arguments); node.typeParameters = typeArguments; if (state.optionalChainMember) { node.optional = isOptionalCall; } return this.finishCallExpression(node, state.optionalChainMember); } const tokenType = this.state.type; if (tokenType === 48 || tokenType === 52 || tokenType !== 10 && tokenCanStartExpression(tokenType) && !this.hasPrecedingLineBreak()) { return; } const node = this.startNodeAt(startPos, startLoc); node.expression = base; node.typeParameters = typeArguments; return this.finishNode(node, "TSInstantiationExpression"); }); if (missingParenErrorLoc) { this.unexpected(missingParenErrorLoc, 10); } if (result) { if (result.type === "TSInstantiationExpression" && (this.match(16) || this.match(18) && this.lookaheadCharCode() !== 40)) { this.raise(TSErrors.InvalidPropertyAccessAfterInstantiationExpression, { at: this.state.startLoc }); } return result; } } return super.parseSubscript(base, startPos, startLoc, noCalls, state); } parseNewCallee(node) { var _callee$extra; super.parseNewCallee(node); const { callee } = node; if (callee.type === "TSInstantiationExpression" && !((_callee$extra = callee.extra) != null && _callee$extra.parenthesized)) { node.typeParameters = callee.typeParameters; node.callee = callee.expression; } } parseExprOp(left, leftStartPos, leftStartLoc, minPrec) { if (tokenOperatorPrecedence(58) > minPrec && !this.hasPrecedingLineBreak() && this.isContextual(93)) { const node = this.startNodeAt(leftStartPos, leftStartLoc); node.expression = left; const _const = this.tsTryNextParseConstantContext(); if (_const) { node.typeAnnotation = _const; } else { node.typeAnnotation = this.tsNextThenParseType(); } this.finishNode(node, "TSAsExpression"); this.reScan_lt_gt(); return this.parseExprOp(node, leftStartPos, leftStartLoc, minPrec); } return super.parseExprOp(left, leftStartPos, leftStartLoc, minPrec); } checkReservedWord(word, startLoc, checkKeywords, isBinding) { if (!this.state.isAmbientContext) { super.checkReservedWord(word, startLoc, checkKeywords, isBinding); } } checkDuplicateExports() {} parseImport(node) { node.importKind = "value"; if (tokenIsIdentifier(this.state.type) || this.match(55) || this.match(5)) { let ahead = this.lookahead(); if (this.isContextual(126) && ahead.type !== 12 && ahead.type !== 97 && ahead.type !== 29) { node.importKind = "type"; this.next(); ahead = this.lookahead(); } if (tokenIsIdentifier(this.state.type) && ahead.type === 29) { return this.tsParseImportEqualsDeclaration(node); } } const importNode = super.parseImport(node); if (importNode.importKind === "type" && importNode.specifiers.length > 1 && importNode.specifiers[0].type === "ImportDefaultSpecifier") { this.raise(TSErrors.TypeImportCannotSpecifyDefaultAndNamed, { at: importNode }); } return importNode; } parseExport(node) { if (this.match(83)) { this.next(); if (this.isContextual(126) && this.lookaheadCharCode() !== 61) { node.importKind = "type"; this.next(); } else { node.importKind = "value"; } return this.tsParseImportEqualsDeclaration(node, true); } else if (this.eat(29)) { const assign = node; assign.expression = super.parseExpression(); this.semicolon(); return this.finishNode(assign, "TSExportAssignment"); } else if (this.eatContextual(93)) { const decl = node; this.expectContextual(124); decl.id = this.parseIdentifier(); this.semicolon(); return this.finishNode(decl, "TSNamespaceExportDeclaration"); } else { if (this.isContextual(126) && this.lookahead().type === 5) { this.next(); node.exportKind = "type"; } else { node.exportKind = "value"; } return super.parseExport(node); } } isAbstractClass() { return this.isContextual(120) && this.lookahead().type === 80; } parseExportDefaultExpression() { if (this.isAbstractClass()) { const cls = this.startNode(); this.next(); cls.abstract = true; return this.parseClass(cls, true, true); } if (this.match(125)) { const result = this.tsParseInterfaceDeclaration(this.startNode()); if (result) return result; } return super.parseExportDefaultExpression(); } parseVarStatement(node, kind, allowMissingInitializer = false) { const { isAmbientContext } = this.state; const declaration = super.parseVarStatement(node, kind, allowMissingInitializer || isAmbientContext); if (!isAmbientContext) return declaration; for (const { id, init } of declaration.declarations) { if (!init) continue; if (kind !== "const" || !!id.typeAnnotation) { this.raise(TSErrors.InitializerNotAllowedInAmbientContext, { at: init }); } else if (init.type !== "StringLiteral" && init.type !== "BooleanLiteral" && init.type !== "NumericLiteral" && init.type !== "BigIntLiteral" && (init.type !== "TemplateLiteral" || init.expressions.length > 0) && !isPossiblyLiteralEnum(init)) { this.raise(TSErrors.ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference, { at: init }); } } return declaration; } parseStatementContent(context, topLevel) { if (this.match(75) && this.isLookaheadContextual("enum")) { const node = this.startNode(); this.expect(75); return this.tsParseEnumDeclaration(node, { const: true }); } if (this.isContextual(122)) { return this.tsParseEnumDeclaration(this.startNode()); } if (this.isContextual(125)) { const result = this.tsParseInterfaceDeclaration(this.startNode()); if (result) return result; } return super.parseStatementContent(context, topLevel); } parseAccessModifier() { return this.tsParseModifier(["public", "protected", "private"]); } tsHasSomeModifiers(member, modifiers) { return modifiers.some(modifier => { if (tsIsAccessModifier(modifier)) { return member.accessibility === modifier; } return !!member[modifier]; }); } tsIsStartOfStaticBlocks() { return this.isContextual(104) && this.lookaheadCharCode() === 123; } parseClassMember(classBody, member, state) { const modifiers = ["declare", "private", "public", "protected", "override", "abstract", "readonly", "static"]; this.tsParseModifiers({ modified: member, allowedModifiers: modifiers, disallowedModifiers: ["in", "out"], stopOnStartOfClassStaticBlock: true, errorTemplate: TSErrors.InvalidModifierOnTypeParameterPositions }); const callParseClassMemberWithIsStatic = () => { if (this.tsIsStartOfStaticBlocks()) { this.next(); this.next(); if (this.tsHasSomeModifiers(member, modifiers)) { this.raise(TSErrors.StaticBlockCannotHaveModifier, { at: this.state.curPosition() }); } super.parseClassStaticBlock(classBody, member); } else { this.parseClassMemberWithIsStatic(classBody, member, state, !!member.static); } }; if (member.declare) { this.tsInAmbientContext(callParseClassMemberWithIsStatic); } else { callParseClassMemberWithIsStatic(); } } parseClassMemberWithIsStatic(classBody, member, state, isStatic) { const idx = this.tsTryParseIndexSignature(member); if (idx) { classBody.body.push(idx); if (member.abstract) { this.raise(TSErrors.IndexSignatureHasAbstract, { at: member }); } if (member.accessibility) { this.raise(TSErrors.IndexSignatureHasAccessibility, { at: member, modifier: member.accessibility }); } if (member.declare) { this.raise(TSErrors.IndexSignatureHasDeclare, { at: member }); } if (member.override) { this.raise(TSErrors.IndexSignatureHasOverride, { at: member }); } return; } if (!this.state.inAbstractClass && member.abstract) { this.raise(TSErrors.NonAbstractClassHasAbstractMethod, { at: member }); } if (member.override) { if (!state.hadSuperClass) { this.raise(TSErrors.OverrideNotInSubClass, { at: member }); } } super.parseClassMemberWithIsStatic(classBody, member, state, isStatic); } parsePostMemberNameModifiers(methodOrProp) { const optional = this.eat(17); if (optional) methodOrProp.optional = true; if (methodOrProp.readonly && this.match(10)) { this.raise(TSErrors.ClassMethodHasReadonly, { at: methodOrProp }); } if (methodOrProp.declare && this.match(10)) { this.raise(TSErrors.ClassMethodHasDeclare, { at: methodOrProp }); } } parseExpressionStatement(node, expr) { const decl = expr.type === "Identifier" ? this.tsParseExpressionStatement(node, expr) : undefined; return decl || super.parseExpressionStatement(node, expr); } shouldParseExportDeclaration() { if (this.tsIsDeclarationStart()) return true; return super.shouldParseExportDeclaration(); } parseConditional(expr, startPos, startLoc, refExpressionErrors) { if (!this.state.maybeInArrowParameters || !this.match(17)) { return super.parseConditional(expr, startPos, startLoc, refExpressionErrors); } const result = this.tryParse(() => super.parseConditional(expr, startPos, startLoc)); if (!result.node) { if (result.error) { super.setOptionalParametersError(refExpressionErrors, result.error); } return expr; } if (result.error) this.state = result.failState; return result.node; } parseParenItem(node, startPos, startLoc) { node = super.parseParenItem(node, startPos, startLoc); if (this.eat(17)) { node.optional = true; this.resetEndLocation(node); } if (this.match(14)) { const typeCastNode = this.startNodeAt(startPos, startLoc); typeCastNode.expression = node; typeCastNode.typeAnnotation = this.tsParseTypeAnnotation(); return this.finishNode(typeCastNode, "TSTypeCastExpression"); } return node; } parseExportDeclaration(node) { if (!this.state.isAmbientContext && this.isContextual(121)) { return this.tsInAmbientContext(() => this.parseExportDeclaration(node)); } const startPos = this.state.start; const startLoc = this.state.startLoc; const isDeclare = this.eatContextual(121); if (isDeclare && (this.isContextual(121) || !this.shouldParseExportDeclaration())) { throw this.raise(TSErrors.ExpectedAmbientAfterExportDeclare, { at: this.state.startLoc }); } const isIdentifier = tokenIsIdentifier(this.state.type); const declaration = isIdentifier && this.tsTryParseExportDeclaration() || super.parseExportDeclaration(node); if (!declaration) return null; if (declaration.type === "TSInterfaceDeclaration" || declaration.type === "TSTypeAliasDeclaration" || isDeclare) { node.exportKind = "type"; } if (isDeclare) { this.resetStartLocation(declaration, startPos, startLoc); declaration.declare = true; } return declaration; } parseClassId(node, isStatement, optionalId, bindingType) { if ((!isStatement || optionalId) && this.isContextual(110)) { return; } super.parseClassId(node, isStatement, optionalId, node.declare ? BIND_TS_AMBIENT : BIND_CLASS); const typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutModifiers.bind(this)); if (typeParameters) node.typeParameters = typeParameters; } parseClassPropertyAnnotation(node) { if (!node.optional && this.eat(35)) { node.definite = true; } const type = this.tsTryParseTypeAnnotation(); if (type) node.typeAnnotation = type; } parseClassProperty(node) { this.parseClassPropertyAnnotation(node); if (this.state.isAmbientContext && !(node.readonly && !node.typeAnnotation) && this.match(29)) { this.raise(TSErrors.DeclareClassFieldHasInitializer, { at: this.state.startLoc }); } if (node.abstract && this.match(29)) { const { key } = node; this.raise(TSErrors.AbstractPropertyHasInitializer, { at: this.state.startLoc, propertyName: key.type === "Identifier" && !node.computed ? key.name : `[${this.input.slice(key.start, key.end)}]` }); } return super.parseClassProperty(node); } parseClassPrivateProperty(node) { if (node.abstract) { this.raise(TSErrors.PrivateElementHasAbstract, { at: node }); } if (node.accessibility) { this.raise(TSErrors.PrivateElementHasAccessibility, { at: node, modifier: node.accessibility }); } this.parseClassPropertyAnnotation(node); return super.parseClassPrivateProperty(node); } pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) { const typeParameters = this.tsTryParseTypeParameters(); if (typeParameters && isConstructor) { this.raise(TSErrors.ConstructorHasTypeParameters, { at: typeParameters }); } const { declare = false, kind } = method; if (declare && (kind === "get" || kind === "set")) { this.raise(TSErrors.DeclareAccessor, { at: method, kind }); } if (typeParameters) method.typeParameters = typeParameters; super.pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper); } pushClassPrivateMethod(classBody, method, isGenerator, isAsync) { const typeParameters = this.tsTryParseTypeParameters(); if (typeParameters) method.typeParameters = typeParameters; super.pushClassPrivateMethod(classBody, method, isGenerator, isAsync); } declareClassPrivateMethodInScope(node, kind) { if (node.type === "TSDeclareMethod") return; if (node.type === "MethodDefinition" && !node.value.body) return; super.declareClassPrivateMethodInScope(node, kind); } parseClassSuper(node) { super.parseClassSuper(node); if (node.superClass && (this.match(47) || this.match(51))) { node.superTypeParameters = this.tsParseTypeArgumentsInExpression(); } if (this.eatContextual(110)) { node.implements = this.tsParseHeritageClause("implements"); } } parseObjPropValue(prop, startPos, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors) { const typeParameters = this.tsTryParseTypeParameters(); if (typeParameters) prop.typeParameters = typeParameters; return super.parseObjPropValue(prop, startPos, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors); } parseFunctionParams(node, allowModifiers) { const typeParameters = this.tsTryParseTypeParameters(); if (typeParameters) node.typeParameters = typeParameters; super.parseFunctionParams(node, allowModifiers); } parseVarId(decl, kind) { super.parseVarId(decl, kind); if (decl.id.type === "Identifier" && !this.hasPrecedingLineBreak() && this.eat(35)) { decl.definite = true; } const type = this.tsTryParseTypeAnnotation(); if (type) { decl.id.typeAnnotation = type; this.resetEndLocation(decl.id); } } parseAsyncArrowFromCallExpression(node, call) { if (this.match(14)) { node.returnType = this.tsParseTypeAnnotation(); } return super.parseAsyncArrowFromCallExpression(node, call); } parseMaybeAssign(refExpressionErrors, afterLeftParse) { var _jsx, _jsx2, _typeCast, _jsx3, _typeCast2, _jsx4, _typeCast3; let state; let jsx; let typeCast; if (this.hasPlugin("jsx") && (this.match(138) || this.match(47))) { state = this.state.clone(); jsx = this.tryParse(() => super.parseMaybeAssign(refExpressionErrors, afterLeftParse), state); if (!jsx.error) return jsx.node; const { context } = this.state; const currentContext = context[context.length - 1]; if (currentContext === types.j_oTag || currentContext === types.j_expr) { context.pop(); } } if (!((_jsx = jsx) != null && _jsx.error) && !this.match(47)) { return super.parseMaybeAssign(refExpressionErrors, afterLeftParse); } if (!state || state === this.state) state = this.state.clone(); let typeParameters; const arrow = this.tryParse(abort => { var _expr$extra, _typeParameters; typeParameters = this.tsParseTypeParameters(); const expr = super.parseMaybeAssign(refExpressionErrors, afterLeftParse); if (expr.type !== "ArrowFunctionExpression" || (_expr$extra = expr.extra) != null && _expr$extra.parenthesized) { abort(); } if (((_typeParameters = typeParameters) == null ? void 0 : _typeParameters.params.length) !== 0) { this.resetStartLocationFromNode(expr, typeParameters); } expr.typeParameters = typeParameters; return expr; }, state); if (!arrow.error && !arrow.aborted) { if (typeParameters) this.reportReservedArrowTypeParam(typeParameters); return arrow.node; } if (!jsx) { assert(!this.hasPlugin("jsx")); typeCast = this.tryParse(() => super.parseMaybeAssign(refExpressionErrors, afterLeftParse), state); if (!typeCast.error) return typeCast.node; } if ((_jsx2 = jsx) != null && _jsx2.node) { this.state = jsx.failState; return jsx.node; } if (arrow.node) { this.state = arrow.failState; if (typeParameters) this.reportReservedArrowTypeParam(typeParameters); return arrow.node; } if ((_typeCast = typeCast) != null && _typeCast.node) { this.state = typeCast.failState; return typeCast.node; } if ((_jsx3 = jsx) != null && _jsx3.thrown) throw jsx.error; if (arrow.thrown) throw arrow.error; if ((_typeCast2 = typeCast) != null && _typeCast2.thrown) throw typeCast.error; throw ((_jsx4 = jsx) == null ? void 0 : _jsx4.error) || arrow.error || ((_typeCast3 = typeCast) == null ? void 0 : _typeCast3.error); } reportReservedArrowTypeParam(node) { var _node$extra; if (node.params.length === 1 && !((_node$extra = node.extra) != null && _node$extra.trailingComma) && this.getPluginOption("typescript", "disallowAmbiguousJSXLike")) { this.raise(TSErrors.ReservedArrowTypeParam, { at: node }); } } parseMaybeUnary(refExpressionErrors, sawUnary) { if (!this.hasPlugin("jsx") && this.match(47)) { return this.tsParseTypeAssertion(); } else { return super.parseMaybeUnary(refExpressionErrors, sawUnary); } } parseArrow(node) { if (this.match(14)) { const result = this.tryParse(abort => { const returnType = this.tsParseTypeOrTypePredicateAnnotation(14); if (this.canInsertSemicolon() || !this.match(19)) abort(); return returnType; }); if (result.aborted) return; if (!result.thrown) { if (result.error) this.state = result.failState; node.returnType = result.node; } } return super.parseArrow(node); } parseAssignableListItemTypes(param) { if (this.eat(17)) { if (param.type !== "Identifier" && !this.state.isAmbientContext && !this.state.inType) { this.raise(TSErrors.PatternIsOptional, { at: param }); } param.optional = true; } const type = this.tsTryParseTypeAnnotation(); if (type) param.typeAnnotation = type; this.resetEndLocation(param); return param; } isAssignable(node, isBinding) { switch (node.type) { case "TSTypeCastExpression": return this.isAssignable(node.expression, isBinding); case "TSParameterProperty": return true; default: return super.isAssignable(node, isBinding); } } toAssignable(node, isLHS = false) { switch (node.type) { case "ParenthesizedExpression": this.toAssignableParenthesizedExpression(node, isLHS); break; case "TSAsExpression": case "TSNonNullExpression": case "TSTypeAssertion": if (isLHS) { this.expressionScope.recordArrowParemeterBindingError(TSErrors.UnexpectedTypeCastInParameter, { at: node }); } else { this.raise(TSErrors.UnexpectedTypeCastInParameter, { at: node }); } this.toAssignable(node.expression, isLHS); break; case "AssignmentExpression": if (!isLHS && node.left.type === "TSTypeCastExpression") { node.left = this.typeCastToParameter(node.left); } default: super.toAssignable(node, isLHS); } } toAssignableParenthesizedExpression(node, isLHS) { switch (node.expression.type) { case "TSAsExpression": case "TSNonNullExpression": case "TSTypeAssertion": case "ParenthesizedExpression": this.toAssignable(node.expression, isLHS); break; default: super.toAssignable(node, isLHS); } } checkToRestConversion(node, allowPattern) { switch (node.type) { case "TSAsExpression": case "TSTypeAssertion": case "TSNonNullExpression": this.checkToRestConversion(node.expression, false); break; default: super.checkToRestConversion(node, allowPattern); } } isValidLVal(type, isUnparenthesizedInAssign, binding) { return getOwn$1({ TSTypeCastExpression: true, TSParameterProperty: "parameter", TSNonNullExpression: "expression", TSAsExpression: (binding !== BIND_NONE || !isUnparenthesizedInAssign) && ["expression", true], TSTypeAssertion: (binding !== BIND_NONE || !isUnparenthesizedInAssign) && ["expression", true] }, type) || super.isValidLVal(type, isUnparenthesizedInAssign, binding); } parseBindingAtom() { switch (this.state.type) { case 78: return this.parseIdentifier(true); default: return super.parseBindingAtom(); } } parseMaybeDecoratorArguments(expr) { if (this.match(47) || this.match(51)) { const typeArguments = this.tsParseTypeArgumentsInExpression(); if (this.match(10)) { const call = super.parseMaybeDecoratorArguments(expr); call.typeParameters = typeArguments; return call; } this.unexpected(null, 10); } return super.parseMaybeDecoratorArguments(expr); } checkCommaAfterRest(close) { if (this.state.isAmbientContext && this.match(12) && this.lookaheadCharCode() === close) { this.next(); return false; } else { return super.checkCommaAfterRest(close); } } isClassMethod() { return this.match(47) || super.isClassMethod(); } isClassProperty() { return this.match(35) || this.match(14) || super.isClassProperty(); } parseMaybeDefault(startPos, startLoc, left) { const node = super.parseMaybeDefault(startPos, startLoc, left); if (node.type === "AssignmentPattern" && node.typeAnnotation && node.right.start < node.typeAnnotation.start) { this.raise(TSErrors.TypeAnnotationAfterAssign, { at: node.typeAnnotation }); } return node; } getTokenFromCode(code) { if (this.state.inType) { if (code === 62) { return this.finishOp(48, 1); } if (code === 60) { return this.finishOp(47, 1); } } return super.getTokenFromCode(code); } reScan_lt_gt() { const { type } = this.state; if (type === 47) { this.state.pos -= 1; this.readToken_lt(); } else if (type === 48) { this.state.pos -= 1; this.readToken_gt(); } } reScan_lt() { const { type } = this.state; if (type === 51) { this.state.pos -= 2; this.finishOp(47, 1); return 47; } return type; } toAssignableList(exprList, trailingCommaLoc, isLHS) { for (let i = 0; i < exprList.length; i++) { const expr = exprList[i]; if ((expr == null ? void 0 : expr.type) === "TSTypeCastExpression") { exprList[i] = this.typeCastToParameter(expr); } } super.toAssignableList(exprList, trailingCommaLoc, isLHS); } typeCastToParameter(node) { node.expression.typeAnnotation = node.typeAnnotation; this.resetEndLocation(node.expression, node.typeAnnotation.loc.end); return node.expression; } shouldParseArrow(params) { if (this.match(14)) { return params.every(expr => this.isAssignable(expr, true)); } return super.shouldParseArrow(params); } shouldParseAsyncArrow() { return this.match(14) || super.shouldParseAsyncArrow(); } canHaveLeadingDecorator() { return super.canHaveLeadingDecorator() || this.isAbstractClass(); } jsxParseOpeningElementAfterName(node) { if (this.match(47) || this.match(51)) { const typeArguments = this.tsTryParseAndCatch(() => this.tsParseTypeArgumentsInExpression()); if (typeArguments) node.typeParameters = typeArguments; } return super.jsxParseOpeningElementAfterName(node); } getGetterSetterExpectedParamCount(method) { const baseCount = super.getGetterSetterExpectedParamCount(method); const params = this.getObjectOrClassMethodParams(method); const firstParam = params[0]; const hasContextParam = firstParam && this.isThisParam(firstParam); return hasContextParam ? baseCount + 1 : baseCount; } parseCatchClauseParam() { const param = super.parseCatchClauseParam(); const type = this.tsTryParseTypeAnnotation(); if (type) { param.typeAnnotation = type; this.resetEndLocation(param); } return param; } tsInAmbientContext(cb) { const oldIsAmbientContext = this.state.isAmbientContext; this.state.isAmbientContext = true; try { return cb(); } finally { this.state.isAmbientContext = oldIsAmbientContext; } } parseClass(node, isStatement, optionalId) { const oldInAbstractClass = this.state.inAbstractClass; this.state.inAbstractClass = !!node.abstract; try { return super.parseClass(node, isStatement, optionalId); } finally { this.state.inAbstractClass = oldInAbstractClass; } } tsParseAbstractDeclaration(node) { if (this.match(80)) { node.abstract = true; return this.parseClass(node, true, false); } else if (this.isContextual(125)) { if (!this.hasFollowingLineBreak()) { node.abstract = true; this.raise(TSErrors.NonClassMethodPropertyHasAbstractModifer, { at: node }); return this.tsParseInterfaceDeclaration(node); } } else { this.unexpected(null, 80); } } parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope) { const method = super.parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope); if (method.abstract) { const hasBody = this.hasPlugin("estree") ? !!method.value.body : !!method.body; if (hasBody) { const { key } = method; this.raise(TSErrors.AbstractMethodHasImplementation, { at: method, methodName: key.type === "Identifier" && !method.computed ? key.name : `[${this.input.slice(key.start, key.end)}]` }); } } return method; } tsParseTypeParameterName() { const typeName = this.parseIdentifier(); return typeName.name; } shouldParseAsAmbientContext() { return !!this.getPluginOption("typescript", "dts"); } parse() { if (this.shouldParseAsAmbientContext()) { this.state.isAmbientContext = true; } return super.parse(); } getExpression() { if (this.shouldParseAsAmbientContext()) { this.state.isAmbientContext = true; } return super.getExpression(); } parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly) { if (!isString && isMaybeTypeOnly) { this.parseTypeOnlyImportExportSpecifier(node, false, isInTypeExport); return this.finishNode(node, "ExportSpecifier"); } node.exportKind = "value"; return super.parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly); } parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, bindingType) { if (!importedIsString && isMaybeTypeOnly) { this.parseTypeOnlyImportExportSpecifier(specifier, true, isInTypeOnlyImport); return this.finishNode(specifier, "ImportSpecifier"); } specifier.importKind = "value"; return super.parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, isInTypeOnlyImport ? BIND_TS_TYPE_IMPORT : BIND_FLAGS_TS_IMPORT); } parseTypeOnlyImportExportSpecifier(node, isImport, isInTypeOnlyImportExport) { const leftOfAsKey = isImport ? "imported" : "local"; const rightOfAsKey = isImport ? "local" : "exported"; let leftOfAs = node[leftOfAsKey]; let rightOfAs; let hasTypeSpecifier = false; let canParseAsKeyword = true; const loc = leftOfAs.loc.start; if (this.isContextual(93)) { const firstAs = this.parseIdentifier(); if (this.isContextual(93)) { const secondAs = this.parseIdentifier(); if (tokenIsKeywordOrIdentifier(this.state.type)) { hasTypeSpecifier = true; leftOfAs = firstAs; rightOfAs = isImport ? this.parseIdentifier() : this.parseModuleExportName(); canParseAsKeyword = false; } else { rightOfAs = secondAs; canParseAsKeyword = false; } } else if (tokenIsKeywordOrIdentifier(this.state.type)) { canParseAsKeyword = false; rightOfAs = isImport ? this.parseIdentifier() : this.parseModuleExportName(); } else { hasTypeSpecifier = true; leftOfAs = firstAs; } } else if (tokenIsKeywordOrIdentifier(this.state.type)) { hasTypeSpecifier = true; if (isImport) { leftOfAs = this.parseIdentifier(true); if (!this.isContextual(93)) { this.checkReservedWord(leftOfAs.name, leftOfAs.loc.start, true, true); } } else { leftOfAs = this.parseModuleExportName(); } } if (hasTypeSpecifier && isInTypeOnlyImportExport) { this.raise(isImport ? TSErrors.TypeModifierIsUsedInTypeImports : TSErrors.TypeModifierIsUsedInTypeExports, { at: loc }); } node[leftOfAsKey] = leftOfAs; node[rightOfAsKey] = rightOfAs; const kindKey = isImport ? "importKind" : "exportKind"; node[kindKey] = hasTypeSpecifier ? "type" : "value"; if (canParseAsKeyword && this.eatContextual(93)) { node[rightOfAsKey] = isImport ? this.parseIdentifier() : this.parseModuleExportName(); } if (!node[rightOfAsKey]) { node[rightOfAsKey] = cloneIdentifier(node[leftOfAsKey]); } if (isImport) { this.checkIdentifier(node[rightOfAsKey], hasTypeSpecifier ? BIND_TS_TYPE_IMPORT : BIND_FLAGS_TS_IMPORT); } } }); function isPossiblyLiteralEnum(expression) { if (expression.type !== "MemberExpression") return false; const { computed, property } = expression; if (computed && property.type !== "StringLiteral" && (property.type !== "TemplateLiteral" || property.expressions.length > 0)) { return false; } return isUncomputedMemberExpressionChain(expression.object); } function isUncomputedMemberExpressionChain(expression) { if (expression.type === "Identifier") return true; if (expression.type !== "MemberExpression") return false; if (expression.computed) return false; return isUncomputedMemberExpressionChain(expression.object); } const PlaceholderErrors = ParseErrorEnum`placeholders`({ ClassNameIsRequired: "A class name is required.", UnexpectedSpace: "Unexpected space in placeholder." }); var placeholders = (superClass => class PlaceholdersParserMixin extends superClass { parsePlaceholder(expectedNode) { if (this.match(140)) { const node = this.startNode(); this.next(); this.assertNoSpace(); node.name = super.parseIdentifier(true); this.assertNoSpace(); this.expect(140); return this.finishPlaceholder(node, expectedNode); } } finishPlaceholder(node, expectedNode) { const isFinished = !!(node.expectedNode && node.type === "Placeholder"); node.expectedNode = expectedNode; return isFinished ? node : this.finishNode(node, "Placeholder"); } getTokenFromCode(code) { if (code === 37 && this.input.charCodeAt(this.state.pos + 1) === 37) { return this.finishOp(140, 2); } return super.getTokenFromCode(code); } parseExprAtom(refExpressionErrors) { return this.parsePlaceholder("Expression") || super.parseExprAtom(refExpressionErrors); } parseIdentifier(liberal) { return this.parsePlaceholder("Identifier") || super.parseIdentifier(liberal); } checkReservedWord(word, startLoc, checkKeywords, isBinding) { if (word !== undefined) { super.checkReservedWord(word, startLoc, checkKeywords, isBinding); } } parseBindingAtom() { return this.parsePlaceholder("Pattern") || super.parseBindingAtom(); } isValidLVal(type, isParenthesized, binding) { return type === "Placeholder" || super.isValidLVal(type, isParenthesized, binding); } toAssignable(node, isLHS) { if (node && node.type === "Placeholder" && node.expectedNode === "Expression") { node.expectedNode = "Pattern"; } else { super.toAssignable(node, isLHS); } } isLet(context) { if (super.isLet(context)) { return true; } if (!this.isContextual(99)) { return false; } if (context) return false; const nextToken = this.lookahead(); if (nextToken.type === 140) { return true; } return false; } verifyBreakContinue(node, isBreak) { if (node.label && node.label.type === "Placeholder") return; super.verifyBreakContinue(node, isBreak); } parseExpressionStatement(node, expr) { if (expr.type !== "Placeholder" || expr.extra && expr.extra.parenthesized) { return super.parseExpressionStatement(node, expr); } if (this.match(14)) { const stmt = node; stmt.label = this.finishPlaceholder(expr, "Identifier"); this.next(); stmt.body = super.parseStatement("label"); return this.finishNode(stmt, "LabeledStatement"); } this.semicolon(); node.name = expr.name; return this.finishPlaceholder(node, "Statement"); } parseBlock(allowDirectives, createNewLexicalScope, afterBlockParse) { return this.parsePlaceholder("BlockStatement") || super.parseBlock(allowDirectives, createNewLexicalScope, afterBlockParse); } parseFunctionId(requireId) { return this.parsePlaceholder("Identifier") || super.parseFunctionId(requireId); } parseClass(node, isStatement, optionalId) { const type = isStatement ? "ClassDeclaration" : "ClassExpression"; this.next(); this.takeDecorators(node); const oldStrict = this.state.strict; const placeholder = this.parsePlaceholder("Identifier"); if (placeholder) { if (this.match(81) || this.match(140) || this.match(5)) { node.id = placeholder; } else if (optionalId || !isStatement) { node.id = null; node.body = this.finishPlaceholder(placeholder, "ClassBody"); return this.finishNode(node, type); } else { throw this.raise(PlaceholderErrors.ClassNameIsRequired, { at: this.state.startLoc }); } } else { this.parseClassId(node, isStatement, optionalId); } super.parseClassSuper(node); node.body = this.parsePlaceholder("ClassBody") || super.parseClassBody(!!node.superClass, oldStrict); return this.finishNode(node, type); } parseExport(node) { const placeholder = this.parsePlaceholder("Identifier"); if (!placeholder) return super.parseExport(node); if (!this.isContextual(97) && !this.match(12)) { node.specifiers = []; node.source = null; node.declaration = this.finishPlaceholder(placeholder, "Declaration"); return this.finishNode(node, "ExportNamedDeclaration"); } this.expectPlugin("exportDefaultFrom"); const specifier = this.startNode(); specifier.exported = placeholder; node.specifiers = [this.finishNode(specifier, "ExportDefaultSpecifier")]; return super.parseExport(node); } isExportDefaultSpecifier() { if (this.match(65)) { const next = this.nextTokenStart(); if (this.isUnparsedContextual(next, "from")) { if (this.input.startsWith(tokenLabelName(140), this.nextTokenStartSince(next + 4))) { return true; } } } return super.isExportDefaultSpecifier(); } maybeParseExportDefaultSpecifier(node) { if (node.specifiers && node.specifiers.length > 0) { return true; } return super.maybeParseExportDefaultSpecifier(node); } checkExport(node) { const { specifiers } = node; if (specifiers != null && specifiers.length) { node.specifiers = specifiers.filter(node => node.exported.type === "Placeholder"); } super.checkExport(node); node.specifiers = specifiers; } parseImport(node) { const placeholder = this.parsePlaceholder("Identifier"); if (!placeholder) return super.parseImport(node); node.specifiers = []; if (!this.isContextual(97) && !this.match(12)) { node.source = this.finishPlaceholder(placeholder, "StringLiteral"); this.semicolon(); return this.finishNode(node, "ImportDeclaration"); } const specifier = this.startNodeAtNode(placeholder); specifier.local = placeholder; node.specifiers.push(this.finishNode(specifier, "ImportDefaultSpecifier")); if (this.eat(12)) { const hasStarImport = this.maybeParseStarImportSpecifier(node); if (!hasStarImport) this.parseNamedImportSpecifiers(node); } this.expectContextual(97); node.source = this.parseImportSource(); this.semicolon(); return this.finishNode(node, "ImportDeclaration"); } parseImportSource() { return this.parsePlaceholder("StringLiteral") || super.parseImportSource(); } assertNoSpace() { if (this.state.start > this.state.lastTokEndLoc.index) { this.raise(PlaceholderErrors.UnexpectedSpace, { at: this.state.lastTokEndLoc }); } } }); var v8intrinsic = (superClass => class V8IntrinsicMixin extends superClass { parseV8Intrinsic() { if (this.match(54)) { const v8IntrinsicStartLoc = this.state.startLoc; const node = this.startNode(); this.next(); if (tokenIsIdentifier(this.state.type)) { const name = this.parseIdentifierName(this.state.start); const identifier = this.createIdentifier(node, name); identifier.type = "V8IntrinsicIdentifier"; if (this.match(10)) { return identifier; } } this.unexpected(v8IntrinsicStartLoc); } } parseExprAtom(refExpressionErrors) { return this.parseV8Intrinsic() || super.parseExprAtom(refExpressionErrors); } }); function hasPlugin(plugins, expectedConfig) { const [expectedName, expectedOptions] = typeof expectedConfig === "string" ? [expectedConfig, {}] : expectedConfig; const expectedKeys = Object.keys(expectedOptions); const expectedOptionsIsEmpty = expectedKeys.length === 0; return plugins.some(p => { if (typeof p === "string") { return expectedOptionsIsEmpty && p === expectedName; } else { const [pluginName, pluginOptions] = p; if (pluginName !== expectedName) { return false; } for (const key of expectedKeys) { if (pluginOptions[key] !== expectedOptions[key]) { return false; } } return true; } }); } function getPluginOption(plugins, name, option) { const plugin = plugins.find(plugin => { if (Array.isArray(plugin)) { return plugin[0] === name; } else { return plugin === name; } }); if (plugin && Array.isArray(plugin) && plugin.length > 1) { return plugin[1][option]; } return null; } const PIPELINE_PROPOSALS = ["minimal", "fsharp", "hack", "smart"]; const TOPIC_TOKENS = ["^^", "@@", "^", "%", "#"]; const RECORD_AND_TUPLE_SYNTAX_TYPES = ["hash", "bar"]; function validatePlugins(plugins) { if (hasPlugin(plugins, "decorators")) { if (hasPlugin(plugins, "decorators-legacy")) { throw new Error("Cannot use the decorators and decorators-legacy plugin together"); } const decoratorsBeforeExport = getPluginOption(plugins, "decorators", "decoratorsBeforeExport"); if (decoratorsBeforeExport != null && typeof decoratorsBeforeExport !== "boolean") { throw new Error("'decoratorsBeforeExport' must be a boolean."); } const allowCallParenthesized = getPluginOption(plugins, "decorators", "allowCallParenthesized"); if (allowCallParenthesized != null && typeof allowCallParenthesized !== "boolean") { throw new Error("'allowCallParenthesized' must be a boolean."); } } if (hasPlugin(plugins, "flow") && hasPlugin(plugins, "typescript")) { throw new Error("Cannot combine flow and typescript plugins."); } if (hasPlugin(plugins, "placeholders") && hasPlugin(plugins, "v8intrinsic")) { throw new Error("Cannot combine placeholders and v8intrinsic plugins."); } if (hasPlugin(plugins, "pipelineOperator")) { const proposal = getPluginOption(plugins, "pipelineOperator", "proposal"); if (!PIPELINE_PROPOSALS.includes(proposal)) { const proposalList = PIPELINE_PROPOSALS.map(p => `"${p}"`).join(", "); throw new Error(`"pipelineOperator" requires "proposal" option whose value must be one of: ${proposalList}.`); } const tupleSyntaxIsHash = hasPlugin(plugins, ["recordAndTuple", { syntaxType: "hash" }]); if (proposal === "hack") { if (hasPlugin(plugins, "placeholders")) { throw new Error("Cannot combine placeholders plugin and Hack-style pipes."); } if (hasPlugin(plugins, "v8intrinsic")) { throw new Error("Cannot combine v8intrinsic plugin and Hack-style pipes."); } const topicToken = getPluginOption(plugins, "pipelineOperator", "topicToken"); if (!TOPIC_TOKENS.includes(topicToken)) { const tokenList = TOPIC_TOKENS.map(t => `"${t}"`).join(", "); throw new Error(`"pipelineOperator" in "proposal": "hack" mode also requires a "topicToken" option whose value must be one of: ${tokenList}.`); } if (topicToken === "#" && tupleSyntaxIsHash) { throw new Error('Plugin conflict between `["pipelineOperator", { proposal: "hack", topicToken: "#" }]` and `["recordAndtuple", { syntaxType: "hash"}]`.'); } } else if (proposal === "smart" && tupleSyntaxIsHash) { throw new Error('Plugin conflict between `["pipelineOperator", { proposal: "smart" }]` and `["recordAndtuple", { syntaxType: "hash"}]`.'); } } if (hasPlugin(plugins, "moduleAttributes")) { { if (hasPlugin(plugins, "importAssertions")) { throw new Error("Cannot combine importAssertions and moduleAttributes plugins."); } const moduleAttributesVersionPluginOption = getPluginOption(plugins, "moduleAttributes", "version"); if (moduleAttributesVersionPluginOption !== "may-2020") { throw new Error("The 'moduleAttributes' plugin requires a 'version' option," + " representing the last proposal update. Currently, the" + " only supported value is 'may-2020'."); } } } if (hasPlugin(plugins, "recordAndTuple") && getPluginOption(plugins, "recordAndTuple", "syntaxType") != null && !RECORD_AND_TUPLE_SYNTAX_TYPES.includes(getPluginOption(plugins, "recordAndTuple", "syntaxType"))) { throw new Error("The 'syntaxType' option of the 'recordAndTuple' plugin must be one of: " + RECORD_AND_TUPLE_SYNTAX_TYPES.map(p => `'${p}'`).join(", ")); } if (hasPlugin(plugins, "asyncDoExpressions") && !hasPlugin(plugins, "doExpressions")) { const error = new Error("'asyncDoExpressions' requires 'doExpressions', please add 'doExpressions' to parser plugins."); error.missingPlugins = "doExpressions"; throw error; } } const mixinPlugins = { estree, jsx, flow, typescript, v8intrinsic, placeholders }; const mixinPluginNames = Object.keys(mixinPlugins); const defaultOptions = { sourceType: "script", sourceFilename: undefined, startColumn: 0, startLine: 1, allowAwaitOutsideFunction: false, allowReturnOutsideFunction: false, allowImportExportEverywhere: false, allowSuperOutsideMethod: false, allowUndeclaredExports: false, plugins: [], strictMode: null, ranges: false, tokens: false, createParenthesizedExpressions: false, errorRecovery: false, attachComment: true }; function getOptions(opts) { const options = {}; for (const key of Object.keys(defaultOptions)) { options[key] = opts && opts[key] != null ? opts[key] : defaultOptions[key]; } return options; } const getOwn = (object, key) => Object.hasOwnProperty.call(object, key) && object[key]; const unwrapParenthesizedExpression = node => { return node.type === "ParenthesizedExpression" ? unwrapParenthesizedExpression(node.expression) : node; }; class LValParser extends NodeUtils { toAssignable(node, isLHS = false) { var _node$extra, _node$extra3; let parenthesized = undefined; if (node.type === "ParenthesizedExpression" || (_node$extra = node.extra) != null && _node$extra.parenthesized) { parenthesized = unwrapParenthesizedExpression(node); if (isLHS) { if (parenthesized.type === "Identifier") { this.expressionScope.recordArrowParemeterBindingError(Errors.InvalidParenthesizedAssignment, { at: node }); } else if (parenthesized.type !== "MemberExpression") { this.raise(Errors.InvalidParenthesizedAssignment, { at: node }); } } else { this.raise(Errors.InvalidParenthesizedAssignment, { at: node }); } } switch (node.type) { case "Identifier": case "ObjectPattern": case "ArrayPattern": case "AssignmentPattern": case "RestElement": break; case "ObjectExpression": node.type = "ObjectPattern"; for (let i = 0, length = node.properties.length, last = length - 1; i < length; i++) { var _node$extra2; const prop = node.properties[i]; const isLast = i === last; this.toAssignableObjectExpressionProp(prop, isLast, isLHS); if (isLast && prop.type === "RestElement" && (_node$extra2 = node.extra) != null && _node$extra2.trailingCommaLoc) { this.raise(Errors.RestTrailingComma, { at: node.extra.trailingCommaLoc }); } } break; case "ObjectProperty": { const { key, value } = node; if (this.isPrivateName(key)) { this.classScope.usePrivateName(this.getPrivateNameSV(key), key.loc.start); } this.toAssignable(value, isLHS); break; } case "SpreadElement": { throw new Error("Internal @babel/parser error (this is a bug, please report it)." + " SpreadElement should be converted by .toAssignable's caller."); } case "ArrayExpression": node.type = "ArrayPattern"; this.toAssignableList(node.elements, (_node$extra3 = node.extra) == null ? void 0 : _node$extra3.trailingCommaLoc, isLHS); break; case "AssignmentExpression": if (node.operator !== "=") { this.raise(Errors.MissingEqInAssignment, { at: node.left.loc.end }); } node.type = "AssignmentPattern"; delete node.operator; this.toAssignable(node.left, isLHS); break; case "ParenthesizedExpression": this.toAssignable(parenthesized, isLHS); break; } } toAssignableObjectExpressionProp(prop, isLast, isLHS) { if (prop.type === "ObjectMethod") { this.raise(prop.kind === "get" || prop.kind === "set" ? Errors.PatternHasAccessor : Errors.PatternHasMethod, { at: prop.key }); } else if (prop.type === "SpreadElement") { prop.type = "RestElement"; const arg = prop.argument; this.checkToRestConversion(arg, false); this.toAssignable(arg, isLHS); if (!isLast) { this.raise(Errors.RestTrailingComma, { at: prop }); } } else { this.toAssignable(prop, isLHS); } } toAssignableList(exprList, trailingCommaLoc, isLHS) { const end = exprList.length - 1; for (let i = 0; i <= end; i++) { const elt = exprList[i]; if (!elt) continue; if (elt.type === "SpreadElement") { elt.type = "RestElement"; const arg = elt.argument; this.checkToRestConversion(arg, true); this.toAssignable(arg, isLHS); } else { this.toAssignable(elt, isLHS); } if (elt.type === "RestElement") { if (i < end) { this.raise(Errors.RestTrailingComma, { at: elt }); } else if (trailingCommaLoc) { this.raise(Errors.RestTrailingComma, { at: trailingCommaLoc }); } } } } isAssignable(node, isBinding) { switch (node.type) { case "Identifier": case "ObjectPattern": case "ArrayPattern": case "AssignmentPattern": case "RestElement": return true; case "ObjectExpression": { const last = node.properties.length - 1; return node.properties.every((prop, i) => { return prop.type !== "ObjectMethod" && (i === last || prop.type !== "SpreadElement") && this.isAssignable(prop); }); } case "ObjectProperty": return this.isAssignable(node.value); case "SpreadElement": return this.isAssignable(node.argument); case "ArrayExpression": return node.elements.every(element => element === null || this.isAssignable(element)); case "AssignmentExpression": return node.operator === "="; case "ParenthesizedExpression": return this.isAssignable(node.expression); case "MemberExpression": case "OptionalMemberExpression": return !isBinding; default: return false; } } toReferencedList(exprList, isParenthesizedExpr) { return exprList; } toReferencedListDeep(exprList, isParenthesizedExpr) { this.toReferencedList(exprList, isParenthesizedExpr); for (const expr of exprList) { if ((expr == null ? void 0 : expr.type) === "ArrayExpression") { this.toReferencedListDeep(expr.elements); } } } parseSpread(refExpressionErrors) { const node = this.startNode(); this.next(); node.argument = this.parseMaybeAssignAllowIn(refExpressionErrors, undefined); return this.finishNode(node, "SpreadElement"); } parseRestBinding() { const node = this.startNode(); this.next(); node.argument = this.parseBindingAtom(); return this.finishNode(node, "RestElement"); } parseBindingAtom() { switch (this.state.type) { case 0: { const node = this.startNode(); this.next(); node.elements = this.parseBindingList(3, 93, true); return this.finishNode(node, "ArrayPattern"); } case 5: return this.parseObjectLike(8, true); } return this.parseIdentifier(); } parseBindingList(close, closeCharCode, allowEmpty, allowModifiers) { const elts = []; let first = true; while (!this.eat(close)) { if (first) { first = false; } else { this.expect(12); } if (allowEmpty && this.match(12)) { elts.push(null); } else if (this.eat(close)) { break; } else if (this.match(21)) { elts.push(this.parseAssignableListItemTypes(this.parseRestBinding())); if (!this.checkCommaAfterRest(closeCharCode)) { this.expect(close); break; } } else { const decorators = []; if (this.match(26) && this.hasPlugin("decorators")) { this.raise(Errors.UnsupportedParameterDecorator, { at: this.state.startLoc }); } while (this.match(26)) { decorators.push(this.parseDecorator()); } elts.push(this.parseAssignableListItem(allowModifiers, decorators)); } } return elts; } parseBindingRestProperty(prop) { this.next(); prop.argument = this.parseIdentifier(); this.checkCommaAfterRest(125); return this.finishNode(prop, "RestElement"); } parseBindingProperty() { const prop = this.startNode(); const { type, start: startPos, startLoc } = this.state; if (type === 21) { return this.parseBindingRestProperty(prop); } else if (type === 134) { this.expectPlugin("destructuringPrivate", startLoc); this.classScope.usePrivateName(this.state.value, startLoc); prop.key = this.parsePrivateName(); } else { this.parsePropertyName(prop); } prop.method = false; return this.parseObjPropValue(prop, startPos, startLoc, false, false, true, false); } parseAssignableListItem(allowModifiers, decorators) { const left = this.parseMaybeDefault(); this.parseAssignableListItemTypes(left); const elt = this.parseMaybeDefault(left.start, left.loc.start, left); if (decorators.length) { left.decorators = decorators; } return elt; } parseAssignableListItemTypes(param) { return param; } parseMaybeDefault(startPos, startLoc, left) { var _startLoc, _startPos, _left; startLoc = (_startLoc = startLoc) != null ? _startLoc : this.state.startLoc; startPos = (_startPos = startPos) != null ? _startPos : this.state.start; left = (_left = left) != null ? _left : this.parseBindingAtom(); if (!this.eat(29)) return left; const node = this.startNodeAt(startPos, startLoc); node.left = left; node.right = this.parseMaybeAssignAllowIn(); return this.finishNode(node, "AssignmentPattern"); } isValidLVal(type, isUnparenthesizedInAssign, binding) { return getOwn({ AssignmentPattern: "left", RestElement: "argument", ObjectProperty: "value", ParenthesizedExpression: "expression", ArrayPattern: "elements", ObjectPattern: "properties" }, type); } checkLVal(expression, { in: ancestor, binding = BIND_NONE, checkClashes = false, strictModeChanged = false, allowingSloppyLetBinding = !(binding & BIND_SCOPE_LEXICAL), hasParenthesizedAncestor = false }) { var _expression$extra; const type = expression.type; if (this.isObjectMethod(expression)) return; if (type === "MemberExpression") { if (binding !== BIND_NONE) { this.raise(Errors.InvalidPropertyBindingPattern, { at: expression }); } return; } if (expression.type === "Identifier") { this.checkIdentifier(expression, binding, strictModeChanged, allowingSloppyLetBinding); const { name } = expression; if (checkClashes) { if (checkClashes.has(name)) { this.raise(Errors.ParamDupe, { at: expression }); } else { checkClashes.add(name); } } return; } const validity = this.isValidLVal(expression.type, !(hasParenthesizedAncestor || (_expression$extra = expression.extra) != null && _expression$extra.parenthesized) && ancestor.type === "AssignmentExpression", binding); if (validity === true) return; if (validity === false) { const ParseErrorClass = binding === BIND_NONE ? Errors.InvalidLhs : Errors.InvalidLhsBinding; this.raise(ParseErrorClass, { at: expression, ancestor: ancestor.type === "UpdateExpression" ? { type: "UpdateExpression", prefix: ancestor.prefix } : { type: ancestor.type } }); return; } const [key, isParenthesizedExpression] = Array.isArray(validity) ? validity : [validity, type === "ParenthesizedExpression"]; const nextAncestor = expression.type === "ArrayPattern" || expression.type === "ObjectPattern" || expression.type === "ParenthesizedExpression" ? expression : ancestor; for (const child of [].concat(expression[key])) { if (child) { this.checkLVal(child, { in: nextAncestor, binding, checkClashes, allowingSloppyLetBinding, strictModeChanged, hasParenthesizedAncestor: isParenthesizedExpression }); } } } checkIdentifier(at, bindingType, strictModeChanged = false, allowLetBinding = !(bindingType & BIND_SCOPE_LEXICAL)) { if (this.state.strict && (strictModeChanged ? isStrictBindReservedWord(at.name, this.inModule) : isStrictBindOnlyReservedWord(at.name))) { if (bindingType === BIND_NONE) { this.raise(Errors.StrictEvalArguments, { at, referenceName: at.name }); } else { this.raise(Errors.StrictEvalArgumentsBinding, { at, bindingName: at.name }); } } if (!allowLetBinding && at.name === "let") { this.raise(Errors.LetInLexicalBinding, { at }); } if (!(bindingType & BIND_NONE)) { this.declareNameFromIdentifier(at, bindingType); } } declareNameFromIdentifier(identifier, binding) { this.scope.declareName(identifier.name, binding, identifier.loc.start); } checkToRestConversion(node, allowPattern) { switch (node.type) { case "ParenthesizedExpression": this.checkToRestConversion(node.expression, allowPattern); break; case "Identifier": case "MemberExpression": break; case "ArrayExpression": case "ObjectExpression": if (allowPattern) break; default: this.raise(Errors.InvalidRestAssignmentPattern, { at: node }); } } checkCommaAfterRest(close) { if (!this.match(12)) { return false; } this.raise(this.lookaheadCharCode() === close ? Errors.RestTrailingComma : Errors.ElementAfterRest, { at: this.state.startLoc }); return true; } } class ExpressionParser extends LValParser { checkProto(prop, isRecord, protoRef, refExpressionErrors) { if (prop.type === "SpreadElement" || this.isObjectMethod(prop) || prop.computed || prop.shorthand) { return; } const key = prop.key; const name = key.type === "Identifier" ? key.name : key.value; if (name === "__proto__") { if (isRecord) { this.raise(Errors.RecordNoProto, { at: key }); return; } if (protoRef.used) { if (refExpressionErrors) { if (refExpressionErrors.doubleProtoLoc === null) { refExpressionErrors.doubleProtoLoc = key.loc.start; } } else { this.raise(Errors.DuplicateProto, { at: key }); } } protoRef.used = true; } } shouldExitDescending(expr, potentialArrowAt) { return expr.type === "ArrowFunctionExpression" && expr.start === potentialArrowAt; } getExpression() { this.enterInitialScopes(); this.nextToken(); const expr = this.parseExpression(); if (!this.match(135)) { this.unexpected(); } this.finalizeRemainingComments(); expr.comments = this.state.comments; expr.errors = this.state.errors; if (this.options.tokens) { expr.tokens = this.tokens; } return expr; } parseExpression(disallowIn, refExpressionErrors) { if (disallowIn) { return this.disallowInAnd(() => this.parseExpressionBase(refExpressionErrors)); } return this.allowInAnd(() => this.parseExpressionBase(refExpressionErrors)); } parseExpressionBase(refExpressionErrors) { const startPos = this.state.start; const startLoc = this.state.startLoc; const expr = this.parseMaybeAssign(refExpressionErrors); if (this.match(12)) { const node = this.startNodeAt(startPos, startLoc); node.expressions = [expr]; while (this.eat(12)) { node.expressions.push(this.parseMaybeAssign(refExpressionErrors)); } this.toReferencedList(node.expressions); return this.finishNode(node, "SequenceExpression"); } return expr; } parseMaybeAssignDisallowIn(refExpressionErrors, afterLeftParse) { return this.disallowInAnd(() => this.parseMaybeAssign(refExpressionErrors, afterLeftParse)); } parseMaybeAssignAllowIn(refExpressionErrors, afterLeftParse) { return this.allowInAnd(() => this.parseMaybeAssign(refExpressionErrors, afterLeftParse)); } setOptionalParametersError(refExpressionErrors, resultError) { var _resultError$loc; refExpressionErrors.optionalParametersLoc = (_resultError$loc = resultError == null ? void 0 : resultError.loc) != null ? _resultError$loc : this.state.startLoc; } parseMaybeAssign(refExpressionErrors, afterLeftParse) { const startPos = this.state.start; const startLoc = this.state.startLoc; if (this.isContextual(105)) { if (this.prodParam.hasYield) { let left = this.parseYield(); if (afterLeftParse) { left = afterLeftParse.call(this, left, startPos, startLoc); } return left; } } let ownExpressionErrors; if (refExpressionErrors) { ownExpressionErrors = false; } else { refExpressionErrors = new ExpressionErrors(); ownExpressionErrors = true; } const { type } = this.state; if (type === 10 || tokenIsIdentifier(type)) { this.state.potentialArrowAt = this.state.start; } let left = this.parseMaybeConditional(refExpressionErrors); if (afterLeftParse) { left = afterLeftParse.call(this, left, startPos, startLoc); } if (tokenIsAssignment(this.state.type)) { const node = this.startNodeAt(startPos, startLoc); const operator = this.state.value; node.operator = operator; if (this.match(29)) { this.toAssignable(left, true); node.left = left; if (refExpressionErrors.doubleProtoLoc != null && refExpressionErrors.doubleProtoLoc.index >= startPos) { refExpressionErrors.doubleProtoLoc = null; } if (refExpressionErrors.shorthandAssignLoc != null && refExpressionErrors.shorthandAssignLoc.index >= startPos) { refExpressionErrors.shorthandAssignLoc = null; } if (refExpressionErrors.privateKeyLoc != null && refExpressionErrors.privateKeyLoc.index >= startPos) { this.checkDestructuringPrivate(refExpressionErrors); refExpressionErrors.privateKeyLoc = null; } } else { node.left = left; } this.next(); node.right = this.parseMaybeAssign(); this.checkLVal(left, { in: this.finishNode(node, "AssignmentExpression") }); return node; } else if (ownExpressionErrors) { this.checkExpressionErrors(refExpressionErrors, true); } return left; } parseMaybeConditional(refExpressionErrors) { const startPos = this.state.start; const startLoc = this.state.startLoc; const potentialArrowAt = this.state.potentialArrowAt; const expr = this.parseExprOps(refExpressionErrors); if (this.shouldExitDescending(expr, potentialArrowAt)) { return expr; } return this.parseConditional(expr, startPos, startLoc, refExpressionErrors); } parseConditional(expr, startPos, startLoc, refExpressionErrors) { if (this.eat(17)) { const node = this.startNodeAt(startPos, startLoc); node.test = expr; node.consequent = this.parseMaybeAssignAllowIn(); this.expect(14); node.alternate = this.parseMaybeAssign(); return this.finishNode(node, "ConditionalExpression"); } return expr; } parseMaybeUnaryOrPrivate(refExpressionErrors) { return this.match(134) ? this.parsePrivateName() : this.parseMaybeUnary(refExpressionErrors); } parseExprOps(refExpressionErrors) { const startPos = this.state.start; const startLoc = this.state.startLoc; const potentialArrowAt = this.state.potentialArrowAt; const expr = this.parseMaybeUnaryOrPrivate(refExpressionErrors); if (this.shouldExitDescending(expr, potentialArrowAt)) { return expr; } return this.parseExprOp(expr, startPos, startLoc, -1); } parseExprOp(left, leftStartPos, leftStartLoc, minPrec) { if (this.isPrivateName(left)) { const value = this.getPrivateNameSV(left); if (minPrec >= tokenOperatorPrecedence(58) || !this.prodParam.hasIn || !this.match(58)) { this.raise(Errors.PrivateInExpectedIn, { at: left, identifierName: value }); } this.classScope.usePrivateName(value, left.loc.start); } const op = this.state.type; if (tokenIsOperator(op) && (this.prodParam.hasIn || !this.match(58))) { let prec = tokenOperatorPrecedence(op); if (prec > minPrec) { if (op === 39) { this.expectPlugin("pipelineOperator"); if (this.state.inFSharpPipelineDirectBody) { return left; } this.checkPipelineAtInfixOperator(left, leftStartLoc); } const node = this.startNodeAt(leftStartPos, leftStartLoc); node.left = left; node.operator = this.state.value; const logical = op === 41 || op === 42; const coalesce = op === 40; if (coalesce) { prec = tokenOperatorPrecedence(42); } this.next(); if (op === 39 && this.hasPlugin(["pipelineOperator", { proposal: "minimal" }])) { if (this.state.type === 96 && this.prodParam.hasAwait) { throw this.raise(Errors.UnexpectedAwaitAfterPipelineBody, { at: this.state.startLoc }); } } node.right = this.parseExprOpRightExpr(op, prec); const finishedNode = this.finishNode(node, logical || coalesce ? "LogicalExpression" : "BinaryExpression"); const nextOp = this.state.type; if (coalesce && (nextOp === 41 || nextOp === 42) || logical && nextOp === 40) { throw this.raise(Errors.MixingCoalesceWithLogical, { at: this.state.startLoc }); } return this.parseExprOp(finishedNode, leftStartPos, leftStartLoc, minPrec); } } return left; } parseExprOpRightExpr(op, prec) { const startPos = this.state.start; const startLoc = this.state.startLoc; switch (op) { case 39: switch (this.getPluginOption("pipelineOperator", "proposal")) { case "hack": return this.withTopicBindingContext(() => { return this.parseHackPipeBody(); }); case "smart": return this.withTopicBindingContext(() => { if (this.prodParam.hasYield && this.isContextual(105)) { throw this.raise(Errors.PipeBodyIsTighter, { at: this.state.startLoc }); } return this.parseSmartPipelineBodyInStyle(this.parseExprOpBaseRightExpr(op, prec), startPos, startLoc); }); case "fsharp": return this.withSoloAwaitPermittingContext(() => { return this.parseFSharpPipelineBody(prec); }); } default: return this.parseExprOpBaseRightExpr(op, prec); } } parseExprOpBaseRightExpr(op, prec) { const startPos = this.state.start; const startLoc = this.state.startLoc; return this.parseExprOp(this.parseMaybeUnaryOrPrivate(), startPos, startLoc, tokenIsRightAssociative(op) ? prec - 1 : prec); } parseHackPipeBody() { var _body$extra; const { startLoc } = this.state; const body = this.parseMaybeAssign(); const requiredParentheses = UnparenthesizedPipeBodyDescriptions.has(body.type); if (requiredParentheses && !((_body$extra = body.extra) != null && _body$extra.parenthesized)) { this.raise(Errors.PipeUnparenthesizedBody, { at: startLoc, type: body.type }); } if (!this.topicReferenceWasUsedInCurrentContext()) { this.raise(Errors.PipeTopicUnused, { at: startLoc }); } return body; } checkExponentialAfterUnary(node) { if (this.match(57)) { this.raise(Errors.UnexpectedTokenUnaryExponentiation, { at: node.argument }); } } parseMaybeUnary(refExpressionErrors, sawUnary) { const startPos = this.state.start; const startLoc = this.state.startLoc; const isAwait = this.isContextual(96); if (isAwait && this.isAwaitAllowed()) { this.next(); const expr = this.parseAwait(startPos, startLoc); if (!sawUnary) this.checkExponentialAfterUnary(expr); return expr; } const update = this.match(34); const node = this.startNode(); if (tokenIsPrefix(this.state.type)) { node.operator = this.state.value; node.prefix = true; if (this.match(72)) { this.expectPlugin("throwExpressions"); } const isDelete = this.match(89); this.next(); node.argument = this.parseMaybeUnary(null, true); this.checkExpressionErrors(refExpressionErrors, true); if (this.state.strict && isDelete) { const arg = node.argument; if (arg.type === "Identifier") { this.raise(Errors.StrictDelete, { at: node }); } else if (this.hasPropertyAsPrivateName(arg)) { this.raise(Errors.DeletePrivateField, { at: node }); } } if (!update) { if (!sawUnary) { this.checkExponentialAfterUnary(node); } return this.finishNode(node, "UnaryExpression"); } } const expr = this.parseUpdate(node, update, refExpressionErrors); if (isAwait) { const { type } = this.state; const startsExpr = this.hasPlugin("v8intrinsic") ? tokenCanStartExpression(type) : tokenCanStartExpression(type) && !this.match(54); if (startsExpr && !this.isAmbiguousAwait()) { this.raiseOverwrite(Errors.AwaitNotInAsyncContext, { at: startLoc }); return this.parseAwait(startPos, startLoc); } } return expr; } parseUpdate(node, update, refExpressionErrors) { if (update) { const updateExpressionNode = node; this.checkLVal(updateExpressionNode.argument, { in: this.finishNode(updateExpressionNode, "UpdateExpression") }); return node; } const startPos = this.state.start; const startLoc = this.state.startLoc; let expr = this.parseExprSubscripts(refExpressionErrors); if (this.checkExpressionErrors(refExpressionErrors, false)) return expr; while (tokenIsPostfix(this.state.type) && !this.canInsertSemicolon()) { const node = this.startNodeAt(startPos, startLoc); node.operator = this.state.value; node.prefix = false; node.argument = expr; this.next(); this.checkLVal(expr, { in: expr = this.finishNode(node, "UpdateExpression") }); } return expr; } parseExprSubscripts(refExpressionErrors) { const startPos = this.state.start; const startLoc = this.state.startLoc; const potentialArrowAt = this.state.potentialArrowAt; const expr = this.parseExprAtom(refExpressionErrors); if (this.shouldExitDescending(expr, potentialArrowAt)) { return expr; } return this.parseSubscripts(expr, startPos, startLoc); } parseSubscripts(base, startPos, startLoc, noCalls) { const state = { optionalChainMember: false, maybeAsyncArrow: this.atPossibleAsyncArrow(base), stop: false }; do { base = this.parseSubscript(base, startPos, startLoc, noCalls, state); state.maybeAsyncArrow = false; } while (!state.stop); return base; } parseSubscript(base, startPos, startLoc, noCalls, state) { const { type } = this.state; if (!noCalls && type === 15) { return this.parseBind(base, startPos, startLoc, noCalls, state); } else if (tokenIsTemplate(type)) { return this.parseTaggedTemplateExpression(base, startPos, startLoc, state); } let optional = false; if (type === 18) { if (noCalls && this.lookaheadCharCode() === 40) { state.stop = true; return base; } state.optionalChainMember = optional = true; this.next(); } if (!noCalls && this.match(10)) { return this.parseCoverCallAndAsyncArrowHead(base, startPos, startLoc, state, optional); } else { const computed = this.eat(0); if (computed || optional || this.eat(16)) { return this.parseMember(base, startPos, startLoc, state, computed, optional); } else { state.stop = true; return base; } } } parseMember(base, startPos, startLoc, state, computed, optional) { const node = this.startNodeAt(startPos, startLoc); node.object = base; node.computed = computed; if (computed) { node.property = this.parseExpression(); this.expect(3); } else if (this.match(134)) { if (base.type === "Super") { this.raise(Errors.SuperPrivateField, { at: startLoc }); } this.classScope.usePrivateName(this.state.value, this.state.startLoc); node.property = this.parsePrivateName(); } else { node.property = this.parseIdentifier(true); } if (state.optionalChainMember) { node.optional = optional; return this.finishNode(node, "OptionalMemberExpression"); } else { return this.finishNode(node, "MemberExpression"); } } parseBind(base, startPos, startLoc, noCalls, state) { const node = this.startNodeAt(startPos, startLoc); node.object = base; this.next(); node.callee = this.parseNoCallExpr(); state.stop = true; return this.parseSubscripts(this.finishNode(node, "BindExpression"), startPos, startLoc, noCalls); } parseCoverCallAndAsyncArrowHead(base, startPos, startLoc, state, optional) { const oldMaybeInArrowParameters = this.state.maybeInArrowParameters; let refExpressionErrors = null; this.state.maybeInArrowParameters = true; this.next(); const node = this.startNodeAt(startPos, startLoc); node.callee = base; const { maybeAsyncArrow, optionalChainMember } = state; if (maybeAsyncArrow) { this.expressionScope.enter(newAsyncArrowScope()); refExpressionErrors = new ExpressionErrors(); } if (optionalChainMember) { node.optional = optional; } if (optional) { node.arguments = this.parseCallExpressionArguments(11); } else { node.arguments = this.parseCallExpressionArguments(11, base.type === "Import", base.type !== "Super", node, refExpressionErrors); } let finishedNode = this.finishCallExpression(node, optionalChainMember); if (maybeAsyncArrow && this.shouldParseAsyncArrow() && !optional) { state.stop = true; this.checkDestructuringPrivate(refExpressionErrors); this.expressionScope.validateAsPattern(); this.expressionScope.exit(); finishedNode = this.parseAsyncArrowFromCallExpression(this.startNodeAt(startPos, startLoc), finishedNode); } else { if (maybeAsyncArrow) { this.checkExpressionErrors(refExpressionErrors, true); this.expressionScope.exit(); } this.toReferencedArguments(finishedNode); } this.state.maybeInArrowParameters = oldMaybeInArrowParameters; return finishedNode; } toReferencedArguments(node, isParenthesizedExpr) { this.toReferencedListDeep(node.arguments, isParenthesizedExpr); } parseTaggedTemplateExpression(base, startPos, startLoc, state) { const node = this.startNodeAt(startPos, startLoc); node.tag = base; node.quasi = this.parseTemplate(true); if (state.optionalChainMember) { this.raise(Errors.OptionalChainingNoTemplate, { at: startLoc }); } return this.finishNode(node, "TaggedTemplateExpression"); } atPossibleAsyncArrow(base) { return base.type === "Identifier" && base.name === "async" && this.state.lastTokEndLoc.index === base.end && !this.canInsertSemicolon() && base.end - base.start === 5 && base.start === this.state.potentialArrowAt; } finishCallExpression(node, optional) { if (node.callee.type === "Import") { if (node.arguments.length === 2) { { if (!this.hasPlugin("moduleAttributes")) { this.expectPlugin("importAssertions"); } } } if (node.arguments.length === 0 || node.arguments.length > 2) { this.raise(Errors.ImportCallArity, { at: node, maxArgumentCount: this.hasPlugin("importAssertions") || this.hasPlugin("moduleAttributes") ? 2 : 1 }); } else { for (const arg of node.arguments) { if (arg.type === "SpreadElement") { this.raise(Errors.ImportCallSpreadArgument, { at: arg }); } } } } return this.finishNode(node, optional ? "OptionalCallExpression" : "CallExpression"); } parseCallExpressionArguments(close, dynamicImport, allowPlaceholder, nodeForExtra, refExpressionErrors) { const elts = []; let first = true; const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody; this.state.inFSharpPipelineDirectBody = false; while (!this.eat(close)) { if (first) { first = false; } else { this.expect(12); if (this.match(close)) { if (dynamicImport && !this.hasPlugin("importAssertions") && !this.hasPlugin("moduleAttributes")) { this.raise(Errors.ImportCallArgumentTrailingComma, { at: this.state.lastTokStartLoc }); } if (nodeForExtra) { this.addTrailingCommaExtraToNode(nodeForExtra); } this.next(); break; } } elts.push(this.parseExprListItem(false, refExpressionErrors, allowPlaceholder)); } this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody; return elts; } shouldParseAsyncArrow() { return this.match(19) && !this.canInsertSemicolon(); } parseAsyncArrowFromCallExpression(node, call) { var _call$extra; this.resetPreviousNodeTrailingComments(call); this.expect(19); this.parseArrowExpression(node, call.arguments, true, (_call$extra = call.extra) == null ? void 0 : _call$extra.trailingCommaLoc); if (call.innerComments) { setInnerComments(node, call.innerComments); } if (call.callee.trailingComments) { setInnerComments(node, call.callee.trailingComments); } return node; } parseNoCallExpr() { const startPos = this.state.start; const startLoc = this.state.startLoc; return this.parseSubscripts(this.parseExprAtom(), startPos, startLoc, true); } parseExprAtom(refExpressionErrors) { let node; const { type } = this.state; switch (type) { case 79: return this.parseSuper(); case 83: node = this.startNode(); this.next(); if (this.match(16)) { return this.parseImportMetaProperty(node); } if (!this.match(10)) { this.raise(Errors.UnsupportedImport, { at: this.state.lastTokStartLoc }); } return this.finishNode(node, "Import"); case 78: node = this.startNode(); this.next(); return this.finishNode(node, "ThisExpression"); case 90: { return this.parseDo(this.startNode(), false); } case 56: case 31: { this.readRegexp(); return this.parseRegExpLiteral(this.state.value); } case 130: return this.parseNumericLiteral(this.state.value); case 131: return this.parseBigIntLiteral(this.state.value); case 132: return this.parseDecimalLiteral(this.state.value); case 129: return this.parseStringLiteral(this.state.value); case 84: return this.parseNullLiteral(); case 85: return this.parseBooleanLiteral(true); case 86: return this.parseBooleanLiteral(false); case 10: { const canBeArrow = this.state.potentialArrowAt === this.state.start; return this.parseParenAndDistinguishExpression(canBeArrow); } case 2: case 1: { return this.parseArrayLike(this.state.type === 2 ? 4 : 3, false, true); } case 0: { return this.parseArrayLike(3, true, false, refExpressionErrors); } case 6: case 7: { return this.parseObjectLike(this.state.type === 6 ? 9 : 8, false, true); } case 5: { return this.parseObjectLike(8, false, false, refExpressionErrors); } case 68: return this.parseFunctionOrFunctionSent(); case 26: this.parseDecorators(); case 80: node = this.startNode(); this.takeDecorators(node); return this.parseClass(node, false); case 77: return this.parseNewOrNewTarget(); case 25: case 24: return this.parseTemplate(false); case 15: { node = this.startNode(); this.next(); node.object = null; const callee = node.callee = this.parseNoCallExpr(); if (callee.type === "MemberExpression") { return this.finishNode(node, "BindExpression"); } else { throw this.raise(Errors.UnsupportedBind, { at: callee }); } } case 134: { this.raise(Errors.PrivateInExpectedIn, { at: this.state.startLoc, identifierName: this.state.value }); return this.parsePrivateName(); } case 33: { return this.parseTopicReferenceThenEqualsSign(54, "%"); } case 32: { return this.parseTopicReferenceThenEqualsSign(44, "^"); } case 37: case 38: { return this.parseTopicReference("hack"); } case 44: case 54: case 27: { const pipeProposal = this.getPluginOption("pipelineOperator", "proposal"); if (pipeProposal) { return this.parseTopicReference(pipeProposal); } else { throw this.unexpected(); } } case 47: { const lookaheadCh = this.input.codePointAt(this.nextTokenStart()); if (isIdentifierStart(lookaheadCh) || lookaheadCh === 62) { this.expectOnePlugin(["jsx", "flow", "typescript"]); break; } else { throw this.unexpected(); } } default: if (tokenIsIdentifier(type)) { if (this.isContextual(123) && this.lookaheadCharCode() === 123 && !this.hasFollowingLineBreak()) { return this.parseModuleExpression(); } const canBeArrow = this.state.potentialArrowAt === this.state.start; const containsEsc = this.state.containsEsc; const id = this.parseIdentifier(); if (!containsEsc && id.name === "async" && !this.canInsertSemicolon()) { const { type } = this.state; if (type === 68) { this.resetPreviousNodeTrailingComments(id); this.next(); return this.parseFunction(this.startNodeAtNode(id), undefined, true); } else if (tokenIsIdentifier(type)) { if (this.lookaheadCharCode() === 61) { return this.parseAsyncArrowUnaryFunction(this.startNodeAtNode(id)); } else { return id; } } else if (type === 90) { this.resetPreviousNodeTrailingComments(id); return this.parseDo(this.startNodeAtNode(id), true); } } if (canBeArrow && this.match(19) && !this.canInsertSemicolon()) { this.next(); return this.parseArrowExpression(this.startNodeAtNode(id), [id], false); } return id; } else { throw this.unexpected(); } } } parseTopicReferenceThenEqualsSign(topicTokenType, topicTokenValue) { const pipeProposal = this.getPluginOption("pipelineOperator", "proposal"); if (pipeProposal) { this.state.type = topicTokenType; this.state.value = topicTokenValue; this.state.pos--; this.state.end--; this.state.endLoc = createPositionWithColumnOffset(this.state.endLoc, -1); return this.parseTopicReference(pipeProposal); } else { throw this.unexpected(); } } parseTopicReference(pipeProposal) { const node = this.startNode(); const startLoc = this.state.startLoc; const tokenType = this.state.type; this.next(); return this.finishTopicReference(node, startLoc, pipeProposal, tokenType); } finishTopicReference(node, startLoc, pipeProposal, tokenType) { if (this.testTopicReferenceConfiguration(pipeProposal, startLoc, tokenType)) { const nodeType = pipeProposal === "smart" ? "PipelinePrimaryTopicReference" : "TopicReference"; if (!this.topicReferenceIsAllowedInCurrentContext()) { this.raise(pipeProposal === "smart" ? Errors.PrimaryTopicNotAllowed : Errors.PipeTopicUnbound, { at: startLoc }); } this.registerTopicReference(); return this.finishNode(node, nodeType); } else { throw this.raise(Errors.PipeTopicUnconfiguredToken, { at: startLoc, token: tokenLabelName(tokenType) }); } } testTopicReferenceConfiguration(pipeProposal, startLoc, tokenType) { switch (pipeProposal) { case "hack": { return this.hasPlugin(["pipelineOperator", { topicToken: tokenLabelName(tokenType) }]); } case "smart": return tokenType === 27; default: throw this.raise(Errors.PipeTopicRequiresHackPipes, { at: startLoc }); } } parseAsyncArrowUnaryFunction(node) { this.prodParam.enter(functionFlags(true, this.prodParam.hasYield)); const params = [this.parseIdentifier()]; this.prodParam.exit(); if (this.hasPrecedingLineBreak()) { this.raise(Errors.LineTerminatorBeforeArrow, { at: this.state.curPosition() }); } this.expect(19); return this.parseArrowExpression(node, params, true); } parseDo(node, isAsync) { this.expectPlugin("doExpressions"); if (isAsync) { this.expectPlugin("asyncDoExpressions"); } node.async = isAsync; this.next(); const oldLabels = this.state.labels; this.state.labels = []; if (isAsync) { this.prodParam.enter(PARAM_AWAIT); node.body = this.parseBlock(); this.prodParam.exit(); } else { node.body = this.parseBlock(); } this.state.labels = oldLabels; return this.finishNode(node, "DoExpression"); } parseSuper() { const node = this.startNode(); this.next(); if (this.match(10) && !this.scope.allowDirectSuper && !this.options.allowSuperOutsideMethod) { this.raise(Errors.SuperNotAllowed, { at: node }); } else if (!this.scope.allowSuper && !this.options.allowSuperOutsideMethod) { this.raise(Errors.UnexpectedSuper, { at: node }); } if (!this.match(10) && !this.match(0) && !this.match(16)) { this.raise(Errors.UnsupportedSuper, { at: node }); } return this.finishNode(node, "Super"); } parsePrivateName() { const node = this.startNode(); const id = this.startNodeAt(this.state.start + 1, new Position(this.state.curLine, this.state.start + 1 - this.state.lineStart, this.state.start + 1)); const name = this.state.value; this.next(); node.id = this.createIdentifier(id, name); return this.finishNode(node, "PrivateName"); } parseFunctionOrFunctionSent() { const node = this.startNode(); this.next(); if (this.prodParam.hasYield && this.match(16)) { const meta = this.createIdentifier(this.startNodeAtNode(node), "function"); this.next(); if (this.match(102)) { this.expectPlugin("functionSent"); } else if (!this.hasPlugin("functionSent")) { this.unexpected(); } return this.parseMetaProperty(node, meta, "sent"); } return this.parseFunction(node); } parseMetaProperty(node, meta, propertyName) { node.meta = meta; const containsEsc = this.state.containsEsc; node.property = this.parseIdentifier(true); if (node.property.name !== propertyName || containsEsc) { this.raise(Errors.UnsupportedMetaProperty, { at: node.property, target: meta.name, onlyValidPropertyName: propertyName }); } return this.finishNode(node, "MetaProperty"); } parseImportMetaProperty(node) { const id = this.createIdentifier(this.startNodeAtNode(node), "import"); this.next(); if (this.isContextual(100)) { if (!this.inModule) { this.raise(Errors.ImportMetaOutsideModule, { at: id }); } this.sawUnambiguousESM = true; } return this.parseMetaProperty(node, id, "meta"); } parseLiteralAtNode(value, type, node) { this.addExtra(node, "rawValue", value); this.addExtra(node, "raw", this.input.slice(node.start, this.state.end)); node.value = value; this.next(); return this.finishNode(node, type); } parseLiteral(value, type) { const node = this.startNode(); return this.parseLiteralAtNode(value, type, node); } parseStringLiteral(value) { return this.parseLiteral(value, "StringLiteral"); } parseNumericLiteral(value) { return this.parseLiteral(value, "NumericLiteral"); } parseBigIntLiteral(value) { return this.parseLiteral(value, "BigIntLiteral"); } parseDecimalLiteral(value) { return this.parseLiteral(value, "DecimalLiteral"); } parseRegExpLiteral(value) { const node = this.parseLiteral(value.value, "RegExpLiteral"); node.pattern = value.pattern; node.flags = value.flags; return node; } parseBooleanLiteral(value) { const node = this.startNode(); node.value = value; this.next(); return this.finishNode(node, "BooleanLiteral"); } parseNullLiteral() { const node = this.startNode(); this.next(); return this.finishNode(node, "NullLiteral"); } parseParenAndDistinguishExpression(canBeArrow) { const startPos = this.state.start; const startLoc = this.state.startLoc; let val; this.next(); this.expressionScope.enter(newArrowHeadScope()); const oldMaybeInArrowParameters = this.state.maybeInArrowParameters; const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody; this.state.maybeInArrowParameters = true; this.state.inFSharpPipelineDirectBody = false; const innerStartPos = this.state.start; const innerStartLoc = this.state.startLoc; const exprList = []; const refExpressionErrors = new ExpressionErrors(); let first = true; let spreadStartLoc; let optionalCommaStartLoc; while (!this.match(11)) { if (first) { first = false; } else { this.expect(12, refExpressionErrors.optionalParametersLoc === null ? null : refExpressionErrors.optionalParametersLoc); if (this.match(11)) { optionalCommaStartLoc = this.state.startLoc; break; } } if (this.match(21)) { const spreadNodeStartPos = this.state.start; const spreadNodeStartLoc = this.state.startLoc; spreadStartLoc = this.state.startLoc; exprList.push(this.parseParenItem(this.parseRestBinding(), spreadNodeStartPos, spreadNodeStartLoc)); if (!this.checkCommaAfterRest(41)) { break; } } else { exprList.push(this.parseMaybeAssignAllowIn(refExpressionErrors, this.parseParenItem)); } } const innerEndLoc = this.state.lastTokEndLoc; this.expect(11); this.state.maybeInArrowParameters = oldMaybeInArrowParameters; this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody; let arrowNode = this.startNodeAt(startPos, startLoc); if (canBeArrow && this.shouldParseArrow(exprList) && (arrowNode = this.parseArrow(arrowNode))) { this.checkDestructuringPrivate(refExpressionErrors); this.expressionScope.validateAsPattern(); this.expressionScope.exit(); this.parseArrowExpression(arrowNode, exprList, false); return arrowNode; } this.expressionScope.exit(); if (!exprList.length) { this.unexpected(this.state.lastTokStartLoc); } if (optionalCommaStartLoc) this.unexpected(optionalCommaStartLoc); if (spreadStartLoc) this.unexpected(spreadStartLoc); this.checkExpressionErrors(refExpressionErrors, true); this.toReferencedListDeep(exprList, true); if (exprList.length > 1) { val = this.startNodeAt(innerStartPos, innerStartLoc); val.expressions = exprList; this.finishNode(val, "SequenceExpression"); this.resetEndLocation(val, innerEndLoc); } else { val = exprList[0]; } return this.wrapParenthesis(startPos, startLoc, val); } wrapParenthesis(startPos, startLoc, expression) { if (!this.options.createParenthesizedExpressions) { this.addExtra(expression, "parenthesized", true); this.addExtra(expression, "parenStart", startPos); this.takeSurroundingComments(expression, startPos, this.state.lastTokEndLoc.index); return expression; } const parenExpression = this.startNodeAt(startPos, startLoc); parenExpression.expression = expression; return this.finishNode(parenExpression, "ParenthesizedExpression"); } shouldParseArrow(params) { return !this.canInsertSemicolon(); } parseArrow(node) { if (this.eat(19)) { return node; } } parseParenItem(node, startPos, startLoc) { return node; } parseNewOrNewTarget() { const node = this.startNode(); this.next(); if (this.match(16)) { const meta = this.createIdentifier(this.startNodeAtNode(node), "new"); this.next(); const metaProp = this.parseMetaProperty(node, meta, "target"); if (!this.scope.inNonArrowFunction && !this.scope.inClass) { this.raise(Errors.UnexpectedNewTarget, { at: metaProp }); } return metaProp; } return this.parseNew(node); } parseNew(node) { this.parseNewCallee(node); if (this.eat(10)) { const args = this.parseExprList(11); this.toReferencedList(args); node.arguments = args; } else { node.arguments = []; } return this.finishNode(node, "NewExpression"); } parseNewCallee(node) { node.callee = this.parseNoCallExpr(); if (node.callee.type === "Import") { this.raise(Errors.ImportCallNotNewExpression, { at: node.callee }); } else if (this.isOptionalChain(node.callee)) { this.raise(Errors.OptionalChainingNoNew, { at: this.state.lastTokEndLoc }); } else if (this.eat(18)) { this.raise(Errors.OptionalChainingNoNew, { at: this.state.startLoc }); } } parseTemplateElement(isTagged) { const { start, startLoc, end, value } = this.state; const elemStart = start + 1; const elem = this.startNodeAt(elemStart, createPositionWithColumnOffset(startLoc, 1)); if (value === null) { if (!isTagged) { this.raise(Errors.InvalidEscapeSequenceTemplate, { at: createPositionWithColumnOffset(this.state.firstInvalidTemplateEscapePos, 1) }); } } const isTail = this.match(24); const endOffset = isTail ? -1 : -2; const elemEnd = end + endOffset; elem.value = { raw: this.input.slice(elemStart, elemEnd).replace(/\r\n?/g, "\n"), cooked: value === null ? null : value.slice(1, endOffset) }; elem.tail = isTail; this.next(); const finishedNode = this.finishNode(elem, "TemplateElement"); this.resetEndLocation(finishedNode, createPositionWithColumnOffset(this.state.lastTokEndLoc, endOffset)); return finishedNode; } parseTemplate(isTagged) { const node = this.startNode(); node.expressions = []; let curElt = this.parseTemplateElement(isTagged); node.quasis = [curElt]; while (!curElt.tail) { node.expressions.push(this.parseTemplateSubstitution()); this.readTemplateContinuation(); node.quasis.push(curElt = this.parseTemplateElement(isTagged)); } return this.finishNode(node, "TemplateLiteral"); } parseTemplateSubstitution() { return this.parseExpression(); } parseObjectLike(close, isPattern, isRecord, refExpressionErrors) { if (isRecord) { this.expectPlugin("recordAndTuple"); } const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody; this.state.inFSharpPipelineDirectBody = false; const propHash = Object.create(null); let first = true; const node = this.startNode(); node.properties = []; this.next(); while (!this.match(close)) { if (first) { first = false; } else { this.expect(12); if (this.match(close)) { this.addTrailingCommaExtraToNode(node); break; } } let prop; if (isPattern) { prop = this.parseBindingProperty(); } else { prop = this.parsePropertyDefinition(refExpressionErrors); this.checkProto(prop, isRecord, propHash, refExpressionErrors); } if (isRecord && !this.isObjectProperty(prop) && prop.type !== "SpreadElement") { this.raise(Errors.InvalidRecordProperty, { at: prop }); } if (prop.shorthand) { this.addExtra(prop, "shorthand", true); } node.properties.push(prop); } this.next(); this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody; let type = "ObjectExpression"; if (isPattern) { type = "ObjectPattern"; } else if (isRecord) { type = "RecordExpression"; } return this.finishNode(node, type); } addTrailingCommaExtraToNode(node) { this.addExtra(node, "trailingComma", this.state.lastTokStart); this.addExtra(node, "trailingCommaLoc", this.state.lastTokStartLoc, false); } maybeAsyncOrAccessorProp(prop) { return !prop.computed && prop.key.type === "Identifier" && (this.isLiteralPropertyName() || this.match(0) || this.match(55)); } parsePropertyDefinition(refExpressionErrors) { let decorators = []; if (this.match(26)) { if (this.hasPlugin("decorators")) { this.raise(Errors.UnsupportedPropertyDecorator, { at: this.state.startLoc }); } while (this.match(26)) { decorators.push(this.parseDecorator()); } } const prop = this.startNode(); let isAsync = false; let isAccessor = false; let startPos; let startLoc; if (this.match(21)) { if (decorators.length) this.unexpected(); return this.parseSpread(); } if (decorators.length) { prop.decorators = decorators; decorators = []; } prop.method = false; if (refExpressionErrors) { startPos = this.state.start; startLoc = this.state.startLoc; } let isGenerator = this.eat(55); this.parsePropertyNamePrefixOperator(prop); const containsEsc = this.state.containsEsc; const key = this.parsePropertyName(prop, refExpressionErrors); if (!isGenerator && !containsEsc && this.maybeAsyncOrAccessorProp(prop)) { const keyName = key.name; if (keyName === "async" && !this.hasPrecedingLineBreak()) { isAsync = true; this.resetPreviousNodeTrailingComments(key); isGenerator = this.eat(55); this.parsePropertyName(prop); } if (keyName === "get" || keyName === "set") { isAccessor = true; this.resetPreviousNodeTrailingComments(key); prop.kind = keyName; if (this.match(55)) { isGenerator = true; this.raise(Errors.AccessorIsGenerator, { at: this.state.curPosition(), kind: keyName }); this.next(); } this.parsePropertyName(prop); } } return this.parseObjPropValue(prop, startPos, startLoc, isGenerator, isAsync, false, isAccessor, refExpressionErrors); } getGetterSetterExpectedParamCount(method) { return method.kind === "get" ? 0 : 1; } getObjectOrClassMethodParams(method) { return method.params; } checkGetterSetterParams(method) { var _params; const paramCount = this.getGetterSetterExpectedParamCount(method); const params = this.getObjectOrClassMethodParams(method); if (params.length !== paramCount) { this.raise(method.kind === "get" ? Errors.BadGetterArity : Errors.BadSetterArity, { at: method }); } if (method.kind === "set" && ((_params = params[params.length - 1]) == null ? void 0 : _params.type) === "RestElement") { this.raise(Errors.BadSetterRestParameter, { at: method }); } } parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor) { if (isAccessor) { const finishedProp = this.parseMethod(prop, isGenerator, false, false, false, "ObjectMethod"); this.checkGetterSetterParams(finishedProp); return finishedProp; } if (isAsync || isGenerator || this.match(10)) { if (isPattern) this.unexpected(); prop.kind = "method"; prop.method = true; return this.parseMethod(prop, isGenerator, isAsync, false, false, "ObjectMethod"); } } parseObjectProperty(prop, startPos, startLoc, isPattern, refExpressionErrors) { prop.shorthand = false; if (this.eat(14)) { prop.value = isPattern ? this.parseMaybeDefault(this.state.start, this.state.startLoc) : this.parseMaybeAssignAllowIn(refExpressionErrors); return this.finishNode(prop, "ObjectProperty"); } if (!prop.computed && prop.key.type === "Identifier") { this.checkReservedWord(prop.key.name, prop.key.loc.start, true, false); if (isPattern) { prop.value = this.parseMaybeDefault(startPos, startLoc, cloneIdentifier(prop.key)); } else if (this.match(29)) { const shorthandAssignLoc = this.state.startLoc; if (refExpressionErrors != null) { if (refExpressionErrors.shorthandAssignLoc === null) { refExpressionErrors.shorthandAssignLoc = shorthandAssignLoc; } } else { this.raise(Errors.InvalidCoverInitializedName, { at: shorthandAssignLoc }); } prop.value = this.parseMaybeDefault(startPos, startLoc, cloneIdentifier(prop.key)); } else { prop.value = cloneIdentifier(prop.key); } prop.shorthand = true; return this.finishNode(prop, "ObjectProperty"); } } parseObjPropValue(prop, startPos, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors) { const node = this.parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor) || this.parseObjectProperty(prop, startPos, startLoc, isPattern, refExpressionErrors); if (!node) this.unexpected(); return node; } parsePropertyName(prop, refExpressionErrors) { if (this.eat(0)) { prop.computed = true; prop.key = this.parseMaybeAssignAllowIn(); this.expect(3); } else { const { type, value } = this.state; let key; if (tokenIsKeywordOrIdentifier(type)) { key = this.parseIdentifier(true); } else { switch (type) { case 130: key = this.parseNumericLiteral(value); break; case 129: key = this.parseStringLiteral(value); break; case 131: key = this.parseBigIntLiteral(value); break; case 132: key = this.parseDecimalLiteral(value); break; case 134: { const privateKeyLoc = this.state.startLoc; if (refExpressionErrors != null) { if (refExpressionErrors.privateKeyLoc === null) { refExpressionErrors.privateKeyLoc = privateKeyLoc; } } else { this.raise(Errors.UnexpectedPrivateField, { at: privateKeyLoc }); } key = this.parsePrivateName(); break; } default: throw this.unexpected(); } } prop.key = key; if (type !== 134) { prop.computed = false; } } return prop.key; } initFunction(node, isAsync) { node.id = null; node.generator = false; node.async = !!isAsync; } parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope = false) { this.initFunction(node, isAsync); node.generator = !!isGenerator; const allowModifiers = isConstructor; this.scope.enter(SCOPE_FUNCTION | SCOPE_SUPER | (inClassScope ? SCOPE_CLASS : 0) | (allowDirectSuper ? SCOPE_DIRECT_SUPER : 0)); this.prodParam.enter(functionFlags(isAsync, node.generator)); this.parseFunctionParams(node, allowModifiers); const finishedNode = this.parseFunctionBodyAndFinish(node, type, true); this.prodParam.exit(); this.scope.exit(); return finishedNode; } parseArrayLike(close, canBePattern, isTuple, refExpressionErrors) { if (isTuple) { this.expectPlugin("recordAndTuple"); } const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody; this.state.inFSharpPipelineDirectBody = false; const node = this.startNode(); this.next(); node.elements = this.parseExprList(close, !isTuple, refExpressionErrors, node); this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody; return this.finishNode(node, isTuple ? "TupleExpression" : "ArrayExpression"); } parseArrowExpression(node, params, isAsync, trailingCommaLoc) { this.scope.enter(SCOPE_FUNCTION | SCOPE_ARROW); let flags = functionFlags(isAsync, false); if (!this.match(5) && this.prodParam.hasIn) { flags |= PARAM_IN; } this.prodParam.enter(flags); this.initFunction(node, isAsync); const oldMaybeInArrowParameters = this.state.maybeInArrowParameters; if (params) { this.state.maybeInArrowParameters = true; this.setArrowFunctionParameters(node, params, trailingCommaLoc); } this.state.maybeInArrowParameters = false; this.parseFunctionBody(node, true); this.prodParam.exit(); this.scope.exit(); this.state.maybeInArrowParameters = oldMaybeInArrowParameters; return this.finishNode(node, "ArrowFunctionExpression"); } setArrowFunctionParameters(node, params, trailingCommaLoc) { this.toAssignableList(params, trailingCommaLoc, false); node.params = params; } parseFunctionBodyAndFinish(node, type, isMethod = false) { this.parseFunctionBody(node, false, isMethod); return this.finishNode(node, type); } parseFunctionBody(node, allowExpression, isMethod = false) { const isExpression = allowExpression && !this.match(5); this.expressionScope.enter(newExpressionScope()); if (isExpression) { node.body = this.parseMaybeAssign(); this.checkParams(node, false, allowExpression, false); } else { const oldStrict = this.state.strict; const oldLabels = this.state.labels; this.state.labels = []; this.prodParam.enter(this.prodParam.currentFlags() | PARAM_RETURN); node.body = this.parseBlock(true, false, hasStrictModeDirective => { const nonSimple = !this.isSimpleParamList(node.params); if (hasStrictModeDirective && nonSimple) { this.raise(Errors.IllegalLanguageModeDirective, { at: (node.kind === "method" || node.kind === "constructor") && !!node.key ? node.key.loc.end : node }); } const strictModeChanged = !oldStrict && this.state.strict; this.checkParams(node, !this.state.strict && !allowExpression && !isMethod && !nonSimple, allowExpression, strictModeChanged); if (this.state.strict && node.id) { this.checkIdentifier(node.id, BIND_OUTSIDE, strictModeChanged); } }); this.prodParam.exit(); this.state.labels = oldLabels; } this.expressionScope.exit(); } isSimpleParameter(node) { return node.type === "Identifier"; } isSimpleParamList(params) { for (let i = 0, len = params.length; i < len; i++) { if (!this.isSimpleParameter(params[i])) return false; } return true; } checkParams(node, allowDuplicates, isArrowFunction, strictModeChanged = true) { const checkClashes = !allowDuplicates && new Set(); const formalParameters = { type: "FormalParameters" }; for (const param of node.params) { this.checkLVal(param, { in: formalParameters, binding: BIND_VAR, checkClashes, strictModeChanged }); } } parseExprList(close, allowEmpty, refExpressionErrors, nodeForExtra) { const elts = []; let first = true; while (!this.eat(close)) { if (first) { first = false; } else { this.expect(12); if (this.match(close)) { if (nodeForExtra) { this.addTrailingCommaExtraToNode(nodeForExtra); } this.next(); break; } } elts.push(this.parseExprListItem(allowEmpty, refExpressionErrors)); } return elts; } parseExprListItem(allowEmpty, refExpressionErrors, allowPlaceholder) { let elt; if (this.match(12)) { if (!allowEmpty) { this.raise(Errors.UnexpectedToken, { at: this.state.curPosition(), unexpected: "," }); } elt = null; } else if (this.match(21)) { const spreadNodeStartPos = this.state.start; const spreadNodeStartLoc = this.state.startLoc; elt = this.parseParenItem(this.parseSpread(refExpressionErrors), spreadNodeStartPos, spreadNodeStartLoc); } else if (this.match(17)) { this.expectPlugin("partialApplication"); if (!allowPlaceholder) { this.raise(Errors.UnexpectedArgumentPlaceholder, { at: this.state.startLoc }); } const node = this.startNode(); this.next(); elt = this.finishNode(node, "ArgumentPlaceholder"); } else { elt = this.parseMaybeAssignAllowIn(refExpressionErrors, this.parseParenItem); } return elt; } parseIdentifier(liberal) { const node = this.startNode(); const name = this.parseIdentifierName(node.start, liberal); return this.createIdentifier(node, name); } createIdentifier(node, name) { node.name = name; node.loc.identifierName = name; return this.finishNode(node, "Identifier"); } parseIdentifierName(pos, liberal) { let name; const { startLoc, type } = this.state; if (tokenIsKeywordOrIdentifier(type)) { name = this.state.value; } else { throw this.unexpected(); } const tokenIsKeyword = tokenKeywordOrIdentifierIsKeyword(type); if (liberal) { if (tokenIsKeyword) { this.replaceToken(128); } } else { this.checkReservedWord(name, startLoc, tokenIsKeyword, false); } this.next(); return name; } checkReservedWord(word, startLoc, checkKeywords, isBinding) { if (word.length > 10) { return; } if (!canBeReservedWord(word)) { return; } if (word === "yield") { if (this.prodParam.hasYield) { this.raise(Errors.YieldBindingIdentifier, { at: startLoc }); return; } } else if (word === "await") { if (this.prodParam.hasAwait) { this.raise(Errors.AwaitBindingIdentifier, { at: startLoc }); return; } if (this.scope.inStaticBlock) { this.raise(Errors.AwaitBindingIdentifierInStaticBlock, { at: startLoc }); return; } this.expressionScope.recordAsyncArrowParametersError({ at: startLoc }); } else if (word === "arguments") { if (this.scope.inClassAndNotInNonArrowFunction) { this.raise(Errors.ArgumentsInClass, { at: startLoc }); return; } } if (checkKeywords && isKeyword(word)) { this.raise(Errors.UnexpectedKeyword, { at: startLoc, keyword: word }); return; } const reservedTest = !this.state.strict ? isReservedWord : isBinding ? isStrictBindReservedWord : isStrictReservedWord; if (reservedTest(word, this.inModule)) { this.raise(Errors.UnexpectedReservedWord, { at: startLoc, reservedWord: word }); } } isAwaitAllowed() { if (this.prodParam.hasAwait) return true; if (this.options.allowAwaitOutsideFunction && !this.scope.inFunction) { return true; } return false; } parseAwait(startPos, startLoc) { const node = this.startNodeAt(startPos, startLoc); this.expressionScope.recordParameterInitializerError(Errors.AwaitExpressionFormalParameter, { at: node }); if (this.eat(55)) { this.raise(Errors.ObsoleteAwaitStar, { at: node }); } if (!this.scope.inFunction && !this.options.allowAwaitOutsideFunction) { if (this.isAmbiguousAwait()) { this.ambiguousScriptDifferentAst = true; } else { this.sawUnambiguousESM = true; } } if (!this.state.soloAwait) { node.argument = this.parseMaybeUnary(null, true); } return this.finishNode(node, "AwaitExpression"); } isAmbiguousAwait() { if (this.hasPrecedingLineBreak()) return true; const { type } = this.state; return type === 53 || type === 10 || type === 0 || tokenIsTemplate(type) || type === 133 || type === 56 || this.hasPlugin("v8intrinsic") && type === 54; } parseYield() { const node = this.startNode(); this.expressionScope.recordParameterInitializerError(Errors.YieldInParameter, { at: node }); this.next(); let delegating = false; let argument = null; if (!this.hasPrecedingLineBreak()) { delegating = this.eat(55); switch (this.state.type) { case 13: case 135: case 8: case 11: case 3: case 9: case 14: case 12: if (!delegating) break; default: argument = this.parseMaybeAssign(); } } node.delegate = delegating; node.argument = argument; return this.finishNode(node, "YieldExpression"); } checkPipelineAtInfixOperator(left, leftStartLoc) { if (this.hasPlugin(["pipelineOperator", { proposal: "smart" }])) { if (left.type === "SequenceExpression") { this.raise(Errors.PipelineHeadSequenceExpression, { at: leftStartLoc }); } } } parseSmartPipelineBodyInStyle(childExpr, startPos, startLoc) { if (this.isSimpleReference(childExpr)) { const bodyNode = this.startNodeAt(startPos, startLoc); bodyNode.callee = childExpr; return this.finishNode(bodyNode, "PipelineBareFunction"); } else { const bodyNode = this.startNodeAt(startPos, startLoc); this.checkSmartPipeTopicBodyEarlyErrors(startLoc); bodyNode.expression = childExpr; return this.finishNode(bodyNode, "PipelineTopicExpression"); } } isSimpleReference(expression) { switch (expression.type) { case "MemberExpression": return !expression.computed && this.isSimpleReference(expression.object); case "Identifier": return true; default: return false; } } checkSmartPipeTopicBodyEarlyErrors(startLoc) { if (this.match(19)) { throw this.raise(Errors.PipelineBodyNoArrow, { at: this.state.startLoc }); } if (!this.topicReferenceWasUsedInCurrentContext()) { this.raise(Errors.PipelineTopicUnused, { at: startLoc }); } } withTopicBindingContext(callback) { const outerContextTopicState = this.state.topicContext; this.state.topicContext = { maxNumOfResolvableTopics: 1, maxTopicIndex: null }; try { return callback(); } finally { this.state.topicContext = outerContextTopicState; } } withSmartMixTopicForbiddingContext(callback) { if (this.hasPlugin(["pipelineOperator", { proposal: "smart" }])) { const outerContextTopicState = this.state.topicContext; this.state.topicContext = { maxNumOfResolvableTopics: 0, maxTopicIndex: null }; try { return callback(); } finally { this.state.topicContext = outerContextTopicState; } } else { return callback(); } } withSoloAwaitPermittingContext(callback) { const outerContextSoloAwaitState = this.state.soloAwait; this.state.soloAwait = true; try { return callback(); } finally { this.state.soloAwait = outerContextSoloAwaitState; } } allowInAnd(callback) { const flags = this.prodParam.currentFlags(); const prodParamToSet = PARAM_IN & ~flags; if (prodParamToSet) { this.prodParam.enter(flags | PARAM_IN); try { return callback(); } finally { this.prodParam.exit(); } } return callback(); } disallowInAnd(callback) { const flags = this.prodParam.currentFlags(); const prodParamToClear = PARAM_IN & flags; if (prodParamToClear) { this.prodParam.enter(flags & ~PARAM_IN); try { return callback(); } finally { this.prodParam.exit(); } } return callback(); } registerTopicReference() { this.state.topicContext.maxTopicIndex = 0; } topicReferenceIsAllowedInCurrentContext() { return this.state.topicContext.maxNumOfResolvableTopics >= 1; } topicReferenceWasUsedInCurrentContext() { return this.state.topicContext.maxTopicIndex != null && this.state.topicContext.maxTopicIndex >= 0; } parseFSharpPipelineBody(prec) { const startPos = this.state.start; const startLoc = this.state.startLoc; this.state.potentialArrowAt = this.state.start; const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody; this.state.inFSharpPipelineDirectBody = true; const ret = this.parseExprOp(this.parseMaybeUnaryOrPrivate(), startPos, startLoc, prec); this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody; return ret; } parseModuleExpression() { this.expectPlugin("moduleBlocks"); const node = this.startNode(); this.next(); this.expect(5); const revertScopes = this.initializeScopes(true); this.enterInitialScopes(); const program = this.startNode(); try { node.body = this.parseProgram(program, 8, "module"); } finally { revertScopes(); } this.eat(8); return this.finishNode(node, "ModuleExpression"); } parsePropertyNamePrefixOperator(prop) {} } const loopLabel = { kind: "loop" }, switchLabel = { kind: "switch" }; const FUNC_NO_FLAGS = 0b000, FUNC_STATEMENT = 0b001, FUNC_HANGING_STATEMENT = 0b010, FUNC_NULLABLE_ID = 0b100; const loneSurrogate = /[\uD800-\uDFFF]/u; const keywordRelationalOperator = /in(?:stanceof)?/y; function babel7CompatTokens(tokens, input) { for (let i = 0; i < tokens.length; i++) { const token = tokens[i]; const { type } = token; if (typeof type === "number") { { if (type === 134) { const { loc, start, value, end } = token; const hashEndPos = start + 1; const hashEndLoc = createPositionWithColumnOffset(loc.start, 1); tokens.splice(i, 1, new Token({ type: getExportedToken(27), value: "#", start: start, end: hashEndPos, startLoc: loc.start, endLoc: hashEndLoc }), new Token({ type: getExportedToken(128), value: value, start: hashEndPos, end: end, startLoc: hashEndLoc, endLoc: loc.end })); i++; continue; } if (tokenIsTemplate(type)) { const { loc, start, value, end } = token; const backquoteEnd = start + 1; const backquoteEndLoc = createPositionWithColumnOffset(loc.start, 1); let startToken; if (input.charCodeAt(start) === 96) { startToken = new Token({ type: getExportedToken(22), value: "`", start: start, end: backquoteEnd, startLoc: loc.start, endLoc: backquoteEndLoc }); } else { startToken = new Token({ type: getExportedToken(8), value: "}", start: start, end: backquoteEnd, startLoc: loc.start, endLoc: backquoteEndLoc }); } let templateValue, templateElementEnd, templateElementEndLoc, endToken; if (type === 24) { templateElementEnd = end - 1; templateElementEndLoc = createPositionWithColumnOffset(loc.end, -1); templateValue = value === null ? null : value.slice(1, -1); endToken = new Token({ type: getExportedToken(22), value: "`", start: templateElementEnd, end: end, startLoc: templateElementEndLoc, endLoc: loc.end }); } else { templateElementEnd = end - 2; templateElementEndLoc = createPositionWithColumnOffset(loc.end, -2); templateValue = value === null ? null : value.slice(1, -2); endToken = new Token({ type: getExportedToken(23), value: "${", start: templateElementEnd, end: end, startLoc: templateElementEndLoc, endLoc: loc.end }); } tokens.splice(i, 1, startToken, new Token({ type: getExportedToken(20), value: templateValue, start: backquoteEnd, end: templateElementEnd, startLoc: backquoteEndLoc, endLoc: templateElementEndLoc }), endToken); i += 2; continue; } } token.type = getExportedToken(type); } } return tokens; } class StatementParser extends ExpressionParser { parseTopLevel(file, program) { file.program = this.parseProgram(program); file.comments = this.state.comments; if (this.options.tokens) { file.tokens = babel7CompatTokens(this.tokens, this.input); } return this.finishNode(file, "File"); } parseProgram(program, end = 135, sourceType = this.options.sourceType) { program.sourceType = sourceType; program.interpreter = this.parseInterpreterDirective(); this.parseBlockBody(program, true, true, end); if (this.inModule && !this.options.allowUndeclaredExports && this.scope.undefinedExports.size > 0) { for (const [localName, at] of Array.from(this.scope.undefinedExports)) { this.raise(Errors.ModuleExportUndefined, { at, localName }); } } if (end === 135) { this.next(); } return this.finishNode(program, "Program"); } stmtToDirective(stmt) { const directive = stmt; directive.type = "Directive"; directive.value = directive.expression; delete directive.expression; const directiveLiteral = directive.value; const expressionValue = directiveLiteral.value; const raw = this.input.slice(directiveLiteral.start, directiveLiteral.end); const val = directiveLiteral.value = raw.slice(1, -1); this.addExtra(directiveLiteral, "raw", raw); this.addExtra(directiveLiteral, "rawValue", val); this.addExtra(directiveLiteral, "expressionValue", expressionValue); directiveLiteral.type = "DirectiveLiteral"; return directive; } parseInterpreterDirective() { if (!this.match(28)) { return null; } const node = this.startNode(); node.value = this.state.value; this.next(); return this.finishNode(node, "InterpreterDirective"); } isLet(context) { if (!this.isContextual(99)) { return false; } return this.isLetKeyword(context); } isLetKeyword(context) { const next = this.nextTokenStart(); const nextCh = this.codePointAtPos(next); if (nextCh === 92 || nextCh === 91) { return true; } if (context) return false; if (nextCh === 123) return true; if (isIdentifierStart(nextCh)) { keywordRelationalOperator.lastIndex = next; if (keywordRelationalOperator.test(this.input)) { const endCh = this.codePointAtPos(keywordRelationalOperator.lastIndex); if (!isIdentifierChar(endCh) && endCh !== 92) { return false; } } return true; } return false; } parseStatement(context, topLevel) { if (this.match(26)) { this.parseDecorators(true); } return this.parseStatementContent(context, topLevel); } parseStatementContent(context, topLevel) { let starttype = this.state.type; const node = this.startNode(); let kind; if (this.isLet(context)) { starttype = 74; kind = "let"; } switch (starttype) { case 60: return this.parseBreakContinueStatement(node, true); case 63: return this.parseBreakContinueStatement(node, false); case 64: return this.parseDebuggerStatement(node); case 90: return this.parseDoStatement(node); case 91: return this.parseForStatement(node); case 68: if (this.lookaheadCharCode() === 46) break; if (context) { if (this.state.strict) { this.raise(Errors.StrictFunction, { at: this.state.startLoc }); } else if (context !== "if" && context !== "label") { this.raise(Errors.SloppyFunction, { at: this.state.startLoc }); } } return this.parseFunctionStatement(node, false, !context); case 80: if (context) this.unexpected(); return this.parseClass(node, true); case 69: return this.parseIfStatement(node); case 70: return this.parseReturnStatement(node); case 71: return this.parseSwitchStatement(node); case 72: return this.parseThrowStatement(node); case 73: return this.parseTryStatement(node); case 75: case 74: kind = kind || this.state.value; if (context && kind !== "var") { this.raise(Errors.UnexpectedLexicalDeclaration, { at: this.state.startLoc }); } return this.parseVarStatement(node, kind); case 92: return this.parseWhileStatement(node); case 76: return this.parseWithStatement(node); case 5: return this.parseBlock(); case 13: return this.parseEmptyStatement(node); case 83: { const nextTokenCharCode = this.lookaheadCharCode(); if (nextTokenCharCode === 40 || nextTokenCharCode === 46) { break; } } case 82: { if (!this.options.allowImportExportEverywhere && !topLevel) { this.raise(Errors.UnexpectedImportExport, { at: this.state.startLoc }); } this.next(); let result; if (starttype === 83) { result = this.parseImport(node); if (result.type === "ImportDeclaration" && (!result.importKind || result.importKind === "value")) { this.sawUnambiguousESM = true; } } else { result = this.parseExport(node); if (result.type === "ExportNamedDeclaration" && (!result.exportKind || result.exportKind === "value") || result.type === "ExportAllDeclaration" && (!result.exportKind || result.exportKind === "value") || result.type === "ExportDefaultDeclaration") { this.sawUnambiguousESM = true; } } this.assertModuleNodeAllowed(result); return result; } default: { if (this.isAsyncFunction()) { if (context) { this.raise(Errors.AsyncFunctionInSingleStatementContext, { at: this.state.startLoc }); } this.next(); return this.parseFunctionStatement(node, true, !context); } } } const maybeName = this.state.value; const expr = this.parseExpression(); if (tokenIsIdentifier(starttype) && expr.type === "Identifier" && this.eat(14)) { return this.parseLabeledStatement(node, maybeName, expr, context); } else { return this.parseExpressionStatement(node, expr); } } assertModuleNodeAllowed(node) { if (!this.options.allowImportExportEverywhere && !this.inModule) { this.raise(Errors.ImportOutsideModule, { at: node }); } } takeDecorators(node) { const decorators = this.state.decoratorStack[this.state.decoratorStack.length - 1]; if (decorators.length) { node.decorators = decorators; this.resetStartLocationFromNode(node, decorators[0]); this.state.decoratorStack[this.state.decoratorStack.length - 1] = []; } } canHaveLeadingDecorator() { return this.match(80); } parseDecorators(allowExport) { const currentContextDecorators = this.state.decoratorStack[this.state.decoratorStack.length - 1]; while (this.match(26)) { const decorator = this.parseDecorator(); currentContextDecorators.push(decorator); } if (this.match(82)) { if (!allowExport) { this.unexpected(); } if (this.hasPlugin("decorators") && !this.getPluginOption("decorators", "decoratorsBeforeExport")) { this.raise(Errors.DecoratorExportClass, { at: this.state.startLoc }); } } else if (!this.canHaveLeadingDecorator()) { throw this.raise(Errors.UnexpectedLeadingDecorator, { at: this.state.startLoc }); } } parseDecorator() { this.expectOnePlugin(["decorators", "decorators-legacy"]); const node = this.startNode(); this.next(); if (this.hasPlugin("decorators")) { this.state.decoratorStack.push([]); const startPos = this.state.start; const startLoc = this.state.startLoc; let expr; if (this.match(10)) { const startPos = this.state.start; const startLoc = this.state.startLoc; this.next(); expr = this.parseExpression(); this.expect(11); expr = this.wrapParenthesis(startPos, startLoc, expr); const paramsStartLoc = this.state.startLoc; node.expression = this.parseMaybeDecoratorArguments(expr); if (this.getPluginOption("decorators", "allowCallParenthesized") === false && node.expression !== expr) { this.raise(Errors.DecoratorArgumentsOutsideParentheses, { at: paramsStartLoc }); } } else { expr = this.parseIdentifier(false); while (this.eat(16)) { const node = this.startNodeAt(startPos, startLoc); node.object = expr; if (this.match(134)) { this.classScope.usePrivateName(this.state.value, this.state.startLoc); node.property = this.parsePrivateName(); } else { node.property = this.parseIdentifier(true); } node.computed = false; expr = this.finishNode(node, "MemberExpression"); } node.expression = this.parseMaybeDecoratorArguments(expr); } this.state.decoratorStack.pop(); } else { node.expression = this.parseExprSubscripts(); } return this.finishNode(node, "Decorator"); } parseMaybeDecoratorArguments(expr) { if (this.eat(10)) { const node = this.startNodeAtNode(expr); node.callee = expr; node.arguments = this.parseCallExpressionArguments(11, false); this.toReferencedList(node.arguments); return this.finishNode(node, "CallExpression"); } return expr; } parseBreakContinueStatement(node, isBreak) { this.next(); if (this.isLineTerminator()) { node.label = null; } else { node.label = this.parseIdentifier(); this.semicolon(); } this.verifyBreakContinue(node, isBreak); return this.finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement"); } verifyBreakContinue(node, isBreak) { let i; for (i = 0; i < this.state.labels.length; ++i) { const lab = this.state.labels[i]; if (node.label == null || lab.name === node.label.name) { if (lab.kind != null && (isBreak || lab.kind === "loop")) break; if (node.label && isBreak) break; } } if (i === this.state.labels.length) { const type = isBreak ? "BreakStatement" : "ContinueStatement"; this.raise(Errors.IllegalBreakContinue, { at: node, type }); } } parseDebuggerStatement(node) { this.next(); this.semicolon(); return this.finishNode(node, "DebuggerStatement"); } parseHeaderExpression() { this.expect(10); const val = this.parseExpression(); this.expect(11); return val; } parseDoStatement(node) { this.next(); this.state.labels.push(loopLabel); node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement("do")); this.state.labels.pop(); this.expect(92); node.test = this.parseHeaderExpression(); this.eat(13); return this.finishNode(node, "DoWhileStatement"); } parseForStatement(node) { this.next(); this.state.labels.push(loopLabel); let awaitAt = null; if (this.isAwaitAllowed() && this.eatContextual(96)) { awaitAt = this.state.lastTokStartLoc; } this.scope.enter(SCOPE_OTHER); this.expect(10); if (this.match(13)) { if (awaitAt !== null) { this.unexpected(awaitAt); } return this.parseFor(node, null); } const startsWithLet = this.isContextual(99); const isLet = startsWithLet && this.isLetKeyword(); if (this.match(74) || this.match(75) || isLet) { const initNode = this.startNode(); const kind = isLet ? "let" : this.state.value; this.next(); this.parseVar(initNode, true, kind); const init = this.finishNode(initNode, "VariableDeclaration"); if ((this.match(58) || this.isContextual(101)) && init.declarations.length === 1) { return this.parseForIn(node, init, awaitAt); } if (awaitAt !== null) { this.unexpected(awaitAt); } return this.parseFor(node, init); } const startsWithAsync = this.isContextual(95); const refExpressionErrors = new ExpressionErrors(); const init = this.parseExpression(true, refExpressionErrors); const isForOf = this.isContextual(101); if (isForOf) { if (startsWithLet) { this.raise(Errors.ForOfLet, { at: init }); } if (awaitAt === null && startsWithAsync && init.type === "Identifier") { this.raise(Errors.ForOfAsync, { at: init }); } } if (isForOf || this.match(58)) { this.checkDestructuringPrivate(refExpressionErrors); this.toAssignable(init, true); const type = isForOf ? "ForOfStatement" : "ForInStatement"; this.checkLVal(init, { in: { type } }); return this.parseForIn(node, init, awaitAt); } else { this.checkExpressionErrors(refExpressionErrors, true); } if (awaitAt !== null) { this.unexpected(awaitAt); } return this.parseFor(node, init); } parseFunctionStatement(node, isAsync, declarationPosition) { this.next(); return this.parseFunction(node, FUNC_STATEMENT | (declarationPosition ? 0 : FUNC_HANGING_STATEMENT), isAsync); } parseIfStatement(node) { this.next(); node.test = this.parseHeaderExpression(); node.consequent = this.parseStatement("if"); node.alternate = this.eat(66) ? this.parseStatement("if") : null; return this.finishNode(node, "IfStatement"); } parseReturnStatement(node) { if (!this.prodParam.hasReturn && !this.options.allowReturnOutsideFunction) { this.raise(Errors.IllegalReturn, { at: this.state.startLoc }); } this.next(); if (this.isLineTerminator()) { node.argument = null; } else { node.argument = this.parseExpression(); this.semicolon(); } return this.finishNode(node, "ReturnStatement"); } parseSwitchStatement(node) { this.next(); node.discriminant = this.parseHeaderExpression(); const cases = node.cases = []; this.expect(5); this.state.labels.push(switchLabel); this.scope.enter(SCOPE_OTHER); let cur; for (let sawDefault; !this.match(8);) { if (this.match(61) || this.match(65)) { const isCase = this.match(61); if (cur) this.finishNode(cur, "SwitchCase"); cases.push(cur = this.startNode()); cur.consequent = []; this.next(); if (isCase) { cur.test = this.parseExpression(); } else { if (sawDefault) { this.raise(Errors.MultipleDefaultsInSwitch, { at: this.state.lastTokStartLoc }); } sawDefault = true; cur.test = null; } this.expect(14); } else { if (cur) { cur.consequent.push(this.parseStatement(null)); } else { this.unexpected(); } } } this.scope.exit(); if (cur) this.finishNode(cur, "SwitchCase"); this.next(); this.state.labels.pop(); return this.finishNode(node, "SwitchStatement"); } parseThrowStatement(node) { this.next(); if (this.hasPrecedingLineBreak()) { this.raise(Errors.NewlineAfterThrow, { at: this.state.lastTokEndLoc }); } node.argument = this.parseExpression(); this.semicolon(); return this.finishNode(node, "ThrowStatement"); } parseCatchClauseParam() { const param = this.parseBindingAtom(); const simple = param.type === "Identifier"; this.scope.enter(simple ? SCOPE_SIMPLE_CATCH : 0); this.checkLVal(param, { in: { type: "CatchClause" }, binding: BIND_LEXICAL, allowingSloppyLetBinding: true }); return param; } parseTryStatement(node) { this.next(); node.block = this.parseBlock(); node.handler = null; if (this.match(62)) { const clause = this.startNode(); this.next(); if (this.match(10)) { this.expect(10); clause.param = this.parseCatchClauseParam(); this.expect(11); } else { clause.param = null; this.scope.enter(SCOPE_OTHER); } clause.body = this.withSmartMixTopicForbiddingContext(() => this.parseBlock(false, false)); this.scope.exit(); node.handler = this.finishNode(clause, "CatchClause"); } node.finalizer = this.eat(67) ? this.parseBlock() : null; if (!node.handler && !node.finalizer) { this.raise(Errors.NoCatchOrFinally, { at: node }); } return this.finishNode(node, "TryStatement"); } parseVarStatement(node, kind, allowMissingInitializer = false) { this.next(); this.parseVar(node, false, kind, allowMissingInitializer); this.semicolon(); return this.finishNode(node, "VariableDeclaration"); } parseWhileStatement(node) { this.next(); node.test = this.parseHeaderExpression(); this.state.labels.push(loopLabel); node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement("while")); this.state.labels.pop(); return this.finishNode(node, "WhileStatement"); } parseWithStatement(node) { if (this.state.strict) { this.raise(Errors.StrictWith, { at: this.state.startLoc }); } this.next(); node.object = this.parseHeaderExpression(); node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement("with")); return this.finishNode(node, "WithStatement"); } parseEmptyStatement(node) { this.next(); return this.finishNode(node, "EmptyStatement"); } parseLabeledStatement(node, maybeName, expr, context) { for (const label of this.state.labels) { if (label.name === maybeName) { this.raise(Errors.LabelRedeclaration, { at: expr, labelName: maybeName }); } } const kind = tokenIsLoop(this.state.type) ? "loop" : this.match(71) ? "switch" : null; for (let i = this.state.labels.length - 1; i >= 0; i--) { const label = this.state.labels[i]; if (label.statementStart === node.start) { label.statementStart = this.state.start; label.kind = kind; } else { break; } } this.state.labels.push({ name: maybeName, kind: kind, statementStart: this.state.start }); node.body = this.parseStatement(context ? context.indexOf("label") === -1 ? context + "label" : context : "label"); this.state.labels.pop(); node.label = expr; return this.finishNode(node, "LabeledStatement"); } parseExpressionStatement(node, expr) { node.expression = expr; this.semicolon(); return this.finishNode(node, "ExpressionStatement"); } parseBlock(allowDirectives = false, createNewLexicalScope = true, afterBlockParse) { const node = this.startNode(); if (allowDirectives) { this.state.strictErrors.clear(); } this.expect(5); if (createNewLexicalScope) { this.scope.enter(SCOPE_OTHER); } this.parseBlockBody(node, allowDirectives, false, 8, afterBlockParse); this.next(); if (createNewLexicalScope) { this.scope.exit(); } return this.finishNode(node, "BlockStatement"); } isValidDirective(stmt) { return stmt.type === "ExpressionStatement" && stmt.expression.type === "StringLiteral" && !stmt.expression.extra.parenthesized; } parseBlockBody(node, allowDirectives, topLevel, end, afterBlockParse) { const body = node.body = []; const directives = node.directives = []; this.parseBlockOrModuleBlockBody(body, allowDirectives ? directives : undefined, topLevel, end, afterBlockParse); } parseBlockOrModuleBlockBody(body, directives, topLevel, end, afterBlockParse) { const oldStrict = this.state.strict; let hasStrictModeDirective = false; let parsedNonDirective = false; while (!this.match(end)) { const stmt = this.parseStatement(null, topLevel); if (directives && !parsedNonDirective) { if (this.isValidDirective(stmt)) { const directive = this.stmtToDirective(stmt); directives.push(directive); if (!hasStrictModeDirective && directive.value.value === "use strict") { hasStrictModeDirective = true; this.setStrict(true); } continue; } parsedNonDirective = true; this.state.strictErrors.clear(); } body.push(stmt); } if (afterBlockParse) { afterBlockParse.call(this, hasStrictModeDirective); } if (!oldStrict) { this.setStrict(false); } } parseFor(node, init) { node.init = init; this.semicolon(false); node.test = this.match(13) ? null : this.parseExpression(); this.semicolon(false); node.update = this.match(11) ? null : this.parseExpression(); this.expect(11); node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement("for")); this.scope.exit(); this.state.labels.pop(); return this.finishNode(node, "ForStatement"); } parseForIn(node, init, awaitAt) { const isForIn = this.match(58); this.next(); if (isForIn) { if (awaitAt !== null) this.unexpected(awaitAt); } else { node.await = awaitAt !== null; } if (init.type === "VariableDeclaration" && init.declarations[0].init != null && (!isForIn || this.state.strict || init.kind !== "var" || init.declarations[0].id.type !== "Identifier")) { this.raise(Errors.ForInOfLoopInitializer, { at: init, type: isForIn ? "ForInStatement" : "ForOfStatement" }); } if (init.type === "AssignmentPattern") { this.raise(Errors.InvalidLhs, { at: init, ancestor: { type: "ForStatement" } }); } node.left = init; node.right = isForIn ? this.parseExpression() : this.parseMaybeAssignAllowIn(); this.expect(11); node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement("for")); this.scope.exit(); this.state.labels.pop(); return this.finishNode(node, isForIn ? "ForInStatement" : "ForOfStatement"); } parseVar(node, isFor, kind, allowMissingInitializer = false) { const declarations = node.declarations = []; node.kind = kind; for (;;) { const decl = this.startNode(); this.parseVarId(decl, kind); decl.init = !this.eat(29) ? null : isFor ? this.parseMaybeAssignDisallowIn() : this.parseMaybeAssignAllowIn(); if (decl.init === null && !allowMissingInitializer) { if (decl.id.type !== "Identifier" && !(isFor && (this.match(58) || this.isContextual(101)))) { this.raise(Errors.DeclarationMissingInitializer, { at: this.state.lastTokEndLoc, kind: "destructuring" }); } else if (kind === "const" && !(this.match(58) || this.isContextual(101))) { this.raise(Errors.DeclarationMissingInitializer, { at: this.state.lastTokEndLoc, kind: "const" }); } } declarations.push(this.finishNode(decl, "VariableDeclarator")); if (!this.eat(12)) break; } return node; } parseVarId(decl, kind) { decl.id = this.parseBindingAtom(); this.checkLVal(decl.id, { in: { type: "VariableDeclarator" }, binding: kind === "var" ? BIND_VAR : BIND_LEXICAL }); } parseFunction(node, statement = FUNC_NO_FLAGS, isAsync = false) { const isStatement = statement & FUNC_STATEMENT; const isHangingStatement = statement & FUNC_HANGING_STATEMENT; const requireId = !!isStatement && !(statement & FUNC_NULLABLE_ID); this.initFunction(node, isAsync); if (this.match(55) && isHangingStatement) { this.raise(Errors.GeneratorInSingleStatementContext, { at: this.state.startLoc }); } node.generator = this.eat(55); if (isStatement) { node.id = this.parseFunctionId(requireId); } const oldMaybeInArrowParameters = this.state.maybeInArrowParameters; this.state.maybeInArrowParameters = false; this.scope.enter(SCOPE_FUNCTION); this.prodParam.enter(functionFlags(isAsync, node.generator)); if (!isStatement) { node.id = this.parseFunctionId(); } this.parseFunctionParams(node, false); this.withSmartMixTopicForbiddingContext(() => { this.parseFunctionBodyAndFinish(node, isStatement ? "FunctionDeclaration" : "FunctionExpression"); }); this.prodParam.exit(); this.scope.exit(); if (isStatement && !isHangingStatement) { this.registerFunctionStatementId(node); } this.state.maybeInArrowParameters = oldMaybeInArrowParameters; return node; } parseFunctionId(requireId) { return requireId || tokenIsIdentifier(this.state.type) ? this.parseIdentifier() : null; } parseFunctionParams(node, allowModifiers) { this.expect(10); this.expressionScope.enter(newParameterDeclarationScope()); node.params = this.parseBindingList(11, 41, false, allowModifiers); this.expressionScope.exit(); } registerFunctionStatementId(node) { if (!node.id) return; this.scope.declareName(node.id.name, this.state.strict || node.generator || node.async ? this.scope.treatFunctionsAsVar ? BIND_VAR : BIND_LEXICAL : BIND_FUNCTION, node.id.loc.start); } parseClass(node, isStatement, optionalId) { this.next(); this.takeDecorators(node); const oldStrict = this.state.strict; this.state.strict = true; this.parseClassId(node, isStatement, optionalId); this.parseClassSuper(node); node.body = this.parseClassBody(!!node.superClass, oldStrict); return this.finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression"); } isClassProperty() { return this.match(29) || this.match(13) || this.match(8); } isClassMethod() { return this.match(10); } isNonstaticConstructor(method) { return !method.computed && !method.static && (method.key.name === "constructor" || method.key.value === "constructor"); } parseClassBody(hadSuperClass, oldStrict) { this.classScope.enter(); const state = { hadConstructor: false, hadSuperClass }; let decorators = []; const classBody = this.startNode(); classBody.body = []; this.expect(5); this.withSmartMixTopicForbiddingContext(() => { while (!this.match(8)) { if (this.eat(13)) { if (decorators.length > 0) { throw this.raise(Errors.DecoratorSemicolon, { at: this.state.lastTokEndLoc }); } continue; } if (this.match(26)) { decorators.push(this.parseDecorator()); continue; } const member = this.startNode(); if (decorators.length) { member.decorators = decorators; this.resetStartLocationFromNode(member, decorators[0]); decorators = []; } this.parseClassMember(classBody, member, state); if (member.kind === "constructor" && member.decorators && member.decorators.length > 0) { this.raise(Errors.DecoratorConstructor, { at: member }); } } }); this.state.strict = oldStrict; this.next(); if (decorators.length) { throw this.raise(Errors.TrailingDecorator, { at: this.state.startLoc }); } this.classScope.exit(); return this.finishNode(classBody, "ClassBody"); } parseClassMemberFromModifier(classBody, member) { const key = this.parseIdentifier(true); if (this.isClassMethod()) { const method = member; method.kind = "method"; method.computed = false; method.key = key; method.static = false; this.pushClassMethod(classBody, method, false, false, false, false); return true; } else if (this.isClassProperty()) { const prop = member; prop.computed = false; prop.key = key; prop.static = false; classBody.body.push(this.parseClassProperty(prop)); return true; } this.resetPreviousNodeTrailingComments(key); return false; } parseClassMember(classBody, member, state) { const isStatic = this.isContextual(104); if (isStatic) { if (this.parseClassMemberFromModifier(classBody, member)) { return; } if (this.eat(5)) { this.parseClassStaticBlock(classBody, member); return; } } this.parseClassMemberWithIsStatic(classBody, member, state, isStatic); } parseClassMemberWithIsStatic(classBody, member, state, isStatic) { const publicMethod = member; const privateMethod = member; const publicProp = member; const privateProp = member; const accessorProp = member; const method = publicMethod; const publicMember = publicMethod; member.static = isStatic; this.parsePropertyNamePrefixOperator(member); if (this.eat(55)) { method.kind = "method"; const isPrivateName = this.match(134); this.parseClassElementName(method); if (isPrivateName) { this.pushClassPrivateMethod(classBody, privateMethod, true, false); return; } if (this.isNonstaticConstructor(publicMethod)) { this.raise(Errors.ConstructorIsGenerator, { at: publicMethod.key }); } this.pushClassMethod(classBody, publicMethod, true, false, false, false); return; } const isContextual = tokenIsIdentifier(this.state.type) && !this.state.containsEsc; const isPrivate = this.match(134); const key = this.parseClassElementName(member); const maybeQuestionTokenStartLoc = this.state.startLoc; this.parsePostMemberNameModifiers(publicMember); if (this.isClassMethod()) { method.kind = "method"; if (isPrivate) { this.pushClassPrivateMethod(classBody, privateMethod, false, false); return; } const isConstructor = this.isNonstaticConstructor(publicMethod); let allowsDirectSuper = false; if (isConstructor) { publicMethod.kind = "constructor"; if (state.hadConstructor && !this.hasPlugin("typescript")) { this.raise(Errors.DuplicateConstructor, { at: key }); } if (isConstructor && this.hasPlugin("typescript") && member.override) { this.raise(Errors.OverrideOnConstructor, { at: key }); } state.hadConstructor = true; allowsDirectSuper = state.hadSuperClass; } this.pushClassMethod(classBody, publicMethod, false, false, isConstructor, allowsDirectSuper); } else if (this.isClassProperty()) { if (isPrivate) { this.pushClassPrivateProperty(classBody, privateProp); } else { this.pushClassProperty(classBody, publicProp); } } else if (isContextual && key.name === "async" && !this.isLineTerminator()) { this.resetPreviousNodeTrailingComments(key); const isGenerator = this.eat(55); if (publicMember.optional) { this.unexpected(maybeQuestionTokenStartLoc); } method.kind = "method"; const isPrivate = this.match(134); this.parseClassElementName(method); this.parsePostMemberNameModifiers(publicMember); if (isPrivate) { this.pushClassPrivateMethod(classBody, privateMethod, isGenerator, true); } else { if (this.isNonstaticConstructor(publicMethod)) { this.raise(Errors.ConstructorIsAsync, { at: publicMethod.key }); } this.pushClassMethod(classBody, publicMethod, isGenerator, true, false, false); } } else if (isContextual && (key.name === "get" || key.name === "set") && !(this.match(55) && this.isLineTerminator())) { this.resetPreviousNodeTrailingComments(key); method.kind = key.name; const isPrivate = this.match(134); this.parseClassElementName(publicMethod); if (isPrivate) { this.pushClassPrivateMethod(classBody, privateMethod, false, false); } else { if (this.isNonstaticConstructor(publicMethod)) { this.raise(Errors.ConstructorIsAccessor, { at: publicMethod.key }); } this.pushClassMethod(classBody, publicMethod, false, false, false, false); } this.checkGetterSetterParams(publicMethod); } else if (isContextual && key.name === "accessor" && !this.isLineTerminator()) { this.expectPlugin("decoratorAutoAccessors"); this.resetPreviousNodeTrailingComments(key); const isPrivate = this.match(134); this.parseClassElementName(publicProp); this.pushClassAccessorProperty(classBody, accessorProp, isPrivate); } else if (this.isLineTerminator()) { if (isPrivate) { this.pushClassPrivateProperty(classBody, privateProp); } else { this.pushClassProperty(classBody, publicProp); } } else { this.unexpected(); } } parseClassElementName(member) { const { type, value } = this.state; if ((type === 128 || type === 129) && member.static && value === "prototype") { this.raise(Errors.StaticPrototype, { at: this.state.startLoc }); } if (type === 134) { if (value === "constructor") { this.raise(Errors.ConstructorClassPrivateField, { at: this.state.startLoc }); } const key = this.parsePrivateName(); member.key = key; return key; } return this.parsePropertyName(member); } parseClassStaticBlock(classBody, member) { var _member$decorators; this.scope.enter(SCOPE_CLASS | SCOPE_STATIC_BLOCK | SCOPE_SUPER); const oldLabels = this.state.labels; this.state.labels = []; this.prodParam.enter(PARAM); const body = member.body = []; this.parseBlockOrModuleBlockBody(body, undefined, false, 8); this.next(); this.prodParam.exit(); this.scope.exit(); this.state.labels = oldLabels; classBody.body.push(this.finishNode(member, "StaticBlock")); if ((_member$decorators = member.decorators) != null && _member$decorators.length) { this.raise(Errors.DecoratorStaticBlock, { at: member }); } } pushClassProperty(classBody, prop) { if (!prop.computed && (prop.key.name === "constructor" || prop.key.value === "constructor")) { this.raise(Errors.ConstructorClassField, { at: prop.key }); } classBody.body.push(this.parseClassProperty(prop)); } pushClassPrivateProperty(classBody, prop) { const node = this.parseClassPrivateProperty(prop); classBody.body.push(node); this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), CLASS_ELEMENT_OTHER, node.key.loc.start); } pushClassAccessorProperty(classBody, prop, isPrivate) { if (!isPrivate && !prop.computed) { const key = prop.key; if (key.name === "constructor" || key.value === "constructor") { this.raise(Errors.ConstructorClassField, { at: key }); } } const node = this.parseClassAccessorProperty(prop); classBody.body.push(node); if (isPrivate) { this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), CLASS_ELEMENT_OTHER, node.key.loc.start); } } pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) { classBody.body.push(this.parseMethod(method, isGenerator, isAsync, isConstructor, allowsDirectSuper, "ClassMethod", true)); } pushClassPrivateMethod(classBody, method, isGenerator, isAsync) { const node = this.parseMethod(method, isGenerator, isAsync, false, false, "ClassPrivateMethod", true); classBody.body.push(node); const kind = node.kind === "get" ? node.static ? CLASS_ELEMENT_STATIC_GETTER : CLASS_ELEMENT_INSTANCE_GETTER : node.kind === "set" ? node.static ? CLASS_ELEMENT_STATIC_SETTER : CLASS_ELEMENT_INSTANCE_SETTER : CLASS_ELEMENT_OTHER; this.declareClassPrivateMethodInScope(node, kind); } declareClassPrivateMethodInScope(node, kind) { this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), kind, node.key.loc.start); } parsePostMemberNameModifiers(methodOrProp) {} parseClassPrivateProperty(node) { this.parseInitializer(node); this.semicolon(); return this.finishNode(node, "ClassPrivateProperty"); } parseClassProperty(node) { this.parseInitializer(node); this.semicolon(); return this.finishNode(node, "ClassProperty"); } parseClassAccessorProperty(node) { this.parseInitializer(node); this.semicolon(); return this.finishNode(node, "ClassAccessorProperty"); } parseInitializer(node) { this.scope.enter(SCOPE_CLASS | SCOPE_SUPER); this.expressionScope.enter(newExpressionScope()); this.prodParam.enter(PARAM); node.value = this.eat(29) ? this.parseMaybeAssignAllowIn() : null; this.expressionScope.exit(); this.prodParam.exit(); this.scope.exit(); } parseClassId(node, isStatement, optionalId, bindingType = BIND_CLASS) { if (tokenIsIdentifier(this.state.type)) { node.id = this.parseIdentifier(); if (isStatement) { this.declareNameFromIdentifier(node.id, bindingType); } } else { if (optionalId || !isStatement) { node.id = null; } else { throw this.raise(Errors.MissingClassName, { at: this.state.startLoc }); } } } parseClassSuper(node) { node.superClass = this.eat(81) ? this.parseExprSubscripts() : null; } parseExport(node) { const hasDefault = this.maybeParseExportDefaultSpecifier(node); const parseAfterDefault = !hasDefault || this.eat(12); const hasStar = parseAfterDefault && this.eatExportStar(node); const hasNamespace = hasStar && this.maybeParseExportNamespaceSpecifier(node); const parseAfterNamespace = parseAfterDefault && (!hasNamespace || this.eat(12)); const isFromRequired = hasDefault || hasStar; if (hasStar && !hasNamespace) { if (hasDefault) this.unexpected(); this.parseExportFrom(node, true); return this.finishNode(node, "ExportAllDeclaration"); } const hasSpecifiers = this.maybeParseExportNamedSpecifiers(node); if (hasDefault && parseAfterDefault && !hasStar && !hasSpecifiers || hasNamespace && parseAfterNamespace && !hasSpecifiers) { throw this.unexpected(null, 5); } let hasDeclaration; if (isFromRequired || hasSpecifiers) { hasDeclaration = false; this.parseExportFrom(node, isFromRequired); } else { hasDeclaration = this.maybeParseExportDeclaration(node); } if (isFromRequired || hasSpecifiers || hasDeclaration) { this.checkExport(node, true, false, !!node.source); return this.finishNode(node, "ExportNamedDeclaration"); } if (this.eat(65)) { node.declaration = this.parseExportDefaultExpression(); this.checkExport(node, true, true); return this.finishNode(node, "ExportDefaultDeclaration"); } throw this.unexpected(null, 5); } eatExportStar(node) { return this.eat(55); } maybeParseExportDefaultSpecifier(node) { if (this.isExportDefaultSpecifier()) { this.expectPlugin("exportDefaultFrom"); const specifier = this.startNode(); specifier.exported = this.parseIdentifier(true); node.specifiers = [this.finishNode(specifier, "ExportDefaultSpecifier")]; return true; } return false; } maybeParseExportNamespaceSpecifier(node) { if (this.isContextual(93)) { if (!node.specifiers) node.specifiers = []; const specifier = this.startNodeAt(this.state.lastTokStart, this.state.lastTokStartLoc); this.next(); specifier.exported = this.parseModuleExportName(); node.specifiers.push(this.finishNode(specifier, "ExportNamespaceSpecifier")); return true; } return false; } maybeParseExportNamedSpecifiers(node) { if (this.match(5)) { if (!node.specifiers) node.specifiers = []; const isTypeExport = node.exportKind === "type"; node.specifiers.push(...this.parseExportSpecifiers(isTypeExport)); node.source = null; node.declaration = null; if (this.hasPlugin("importAssertions")) { node.assertions = []; } return true; } return false; } maybeParseExportDeclaration(node) { if (this.shouldParseExportDeclaration()) { node.specifiers = []; node.source = null; if (this.hasPlugin("importAssertions")) { node.assertions = []; } node.declaration = this.parseExportDeclaration(node); return true; } return false; } isAsyncFunction() { if (!this.isContextual(95)) return false; const next = this.nextTokenStart(); return !lineBreak.test(this.input.slice(this.state.pos, next)) && this.isUnparsedContextual(next, "function"); } parseExportDefaultExpression() { const expr = this.startNode(); const isAsync = this.isAsyncFunction(); if (this.match(68) || isAsync) { this.next(); if (isAsync) { this.next(); } return this.parseFunction(expr, FUNC_STATEMENT | FUNC_NULLABLE_ID, isAsync); } if (this.match(80)) { return this.parseClass(expr, true, true); } if (this.match(26)) { if (this.hasPlugin("decorators") && this.getPluginOption("decorators", "decoratorsBeforeExport")) { this.raise(Errors.DecoratorBeforeExport, { at: this.state.startLoc }); } this.parseDecorators(false); return this.parseClass(expr, true, true); } if (this.match(75) || this.match(74) || this.isLet()) { throw this.raise(Errors.UnsupportedDefaultExport, { at: this.state.startLoc }); } const res = this.parseMaybeAssignAllowIn(); this.semicolon(); return res; } parseExportDeclaration(node) { return this.parseStatement(null); } isExportDefaultSpecifier() { const { type } = this.state; if (tokenIsIdentifier(type)) { if (type === 95 && !this.state.containsEsc || type === 99) { return false; } if ((type === 126 || type === 125) && !this.state.containsEsc) { const { type: nextType } = this.lookahead(); if (tokenIsIdentifier(nextType) && nextType !== 97 || nextType === 5) { this.expectOnePlugin(["flow", "typescript"]); return false; } } } else if (!this.match(65)) { return false; } const next = this.nextTokenStart(); const hasFrom = this.isUnparsedContextual(next, "from"); if (this.input.charCodeAt(next) === 44 || tokenIsIdentifier(this.state.type) && hasFrom) { return true; } if (this.match(65) && hasFrom) { const nextAfterFrom = this.input.charCodeAt(this.nextTokenStartSince(next + 4)); return nextAfterFrom === 34 || nextAfterFrom === 39; } return false; } parseExportFrom(node, expect) { if (this.eatContextual(97)) { node.source = this.parseImportSource(); this.checkExport(node); const assertions = this.maybeParseImportAssertions(); if (assertions) { node.assertions = assertions; this.checkJSONModuleImport(node); } } else if (expect) { this.unexpected(); } this.semicolon(); } shouldParseExportDeclaration() { const { type } = this.state; if (type === 26) { this.expectOnePlugin(["decorators", "decorators-legacy"]); if (this.hasPlugin("decorators")) { if (this.getPluginOption("decorators", "decoratorsBeforeExport")) { throw this.raise(Errors.DecoratorBeforeExport, { at: this.state.startLoc }); } return true; } } return type === 74 || type === 75 || type === 68 || type === 80 || this.isLet() || this.isAsyncFunction(); } checkExport(node, checkNames, isDefault, isFrom) { if (checkNames) { if (isDefault) { this.checkDuplicateExports(node, "default"); if (this.hasPlugin("exportDefaultFrom")) { var _declaration$extra; const declaration = node.declaration; if (declaration.type === "Identifier" && declaration.name === "from" && declaration.end - declaration.start === 4 && !((_declaration$extra = declaration.extra) != null && _declaration$extra.parenthesized)) { this.raise(Errors.ExportDefaultFromAsIdentifier, { at: declaration }); } } } else if (node.specifiers && node.specifiers.length) { for (const specifier of node.specifiers) { const { exported } = specifier; const exportName = exported.type === "Identifier" ? exported.name : exported.value; this.checkDuplicateExports(specifier, exportName); if (!isFrom && specifier.local) { const { local } = specifier; if (local.type !== "Identifier") { this.raise(Errors.ExportBindingIsString, { at: specifier, localName: local.value, exportName }); } else { this.checkReservedWord(local.name, local.loc.start, true, false); this.scope.checkLocalExport(local); } } } } else if (node.declaration) { if (node.declaration.type === "FunctionDeclaration" || node.declaration.type === "ClassDeclaration") { const id = node.declaration.id; if (!id) throw new Error("Assertion failure"); this.checkDuplicateExports(node, id.name); } else if (node.declaration.type === "VariableDeclaration") { for (const declaration of node.declaration.declarations) { this.checkDeclaration(declaration.id); } } } } const currentContextDecorators = this.state.decoratorStack[this.state.decoratorStack.length - 1]; if (currentContextDecorators.length) { throw this.raise(Errors.UnsupportedDecoratorExport, { at: node }); } } checkDeclaration(node) { if (node.type === "Identifier") { this.checkDuplicateExports(node, node.name); } else if (node.type === "ObjectPattern") { for (const prop of node.properties) { this.checkDeclaration(prop); } } else if (node.type === "ArrayPattern") { for (const elem of node.elements) { if (elem) { this.checkDeclaration(elem); } } } else if (node.type === "ObjectProperty") { this.checkDeclaration(node.value); } else if (node.type === "RestElement") { this.checkDeclaration(node.argument); } else if (node.type === "AssignmentPattern") { this.checkDeclaration(node.left); } } checkDuplicateExports(node, exportName) { if (this.exportedIdentifiers.has(exportName)) { if (exportName === "default") { this.raise(Errors.DuplicateDefaultExport, { at: node }); } else { this.raise(Errors.DuplicateExport, { at: node, exportName }); } } this.exportedIdentifiers.add(exportName); } parseExportSpecifiers(isInTypeExport) { const nodes = []; let first = true; this.expect(5); while (!this.eat(8)) { if (first) { first = false; } else { this.expect(12); if (this.eat(8)) break; } const isMaybeTypeOnly = this.isContextual(126); const isString = this.match(129); const node = this.startNode(); node.local = this.parseModuleExportName(); nodes.push(this.parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly)); } return nodes; } parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly) { if (this.eatContextual(93)) { node.exported = this.parseModuleExportName(); } else if (isString) { node.exported = cloneStringLiteral(node.local); } else if (!node.exported) { node.exported = cloneIdentifier(node.local); } return this.finishNode(node, "ExportSpecifier"); } parseModuleExportName() { if (this.match(129)) { const result = this.parseStringLiteral(this.state.value); const surrogate = result.value.match(loneSurrogate); if (surrogate) { this.raise(Errors.ModuleExportNameHasLoneSurrogate, { at: result, surrogateCharCode: surrogate[0].charCodeAt(0) }); } return result; } return this.parseIdentifier(true); } isJSONModuleImport(node) { if (node.assertions != null) { return node.assertions.some(({ key, value }) => { return value.value === "json" && (key.type === "Identifier" ? key.name === "type" : key.value === "type"); }); } return false; } checkJSONModuleImport(node) { if (this.isJSONModuleImport(node) && node.type !== "ExportAllDeclaration") { const { specifiers } = node; if (specifiers != null) { const nonDefaultNamedSpecifier = specifiers.find(specifier => { let imported; if (specifier.type === "ExportSpecifier") { imported = specifier.local; } else if (specifier.type === "ImportSpecifier") { imported = specifier.imported; } if (imported !== undefined) { return imported.type === "Identifier" ? imported.name !== "default" : imported.value !== "default"; } }); if (nonDefaultNamedSpecifier !== undefined) { this.raise(Errors.ImportJSONBindingNotDefault, { at: nonDefaultNamedSpecifier.loc.start }); } } } } parseImport(node) { node.specifiers = []; if (!this.match(129)) { const hasDefault = this.maybeParseDefaultImportSpecifier(node); const parseNext = !hasDefault || this.eat(12); const hasStar = parseNext && this.maybeParseStarImportSpecifier(node); if (parseNext && !hasStar) this.parseNamedImportSpecifiers(node); this.expectContextual(97); } node.source = this.parseImportSource(); const assertions = this.maybeParseImportAssertions(); if (assertions) { node.assertions = assertions; } else { const attributes = this.maybeParseModuleAttributes(); if (attributes) { node.attributes = attributes; } } this.checkJSONModuleImport(node); this.semicolon(); return this.finishNode(node, "ImportDeclaration"); } parseImportSource() { if (!this.match(129)) this.unexpected(); return this.parseExprAtom(); } shouldParseDefaultImport(node) { return tokenIsIdentifier(this.state.type); } parseImportSpecifierLocal(node, specifier, type) { specifier.local = this.parseIdentifier(); node.specifiers.push(this.finishImportSpecifier(specifier, type)); } finishImportSpecifier(specifier, type, bindingType = BIND_LEXICAL) { this.checkLVal(specifier.local, { in: specifier, binding: bindingType }); return this.finishNode(specifier, type); } parseAssertEntries() { const attrs = []; const attrNames = new Set(); do { if (this.match(8)) { break; } const node = this.startNode(); const keyName = this.state.value; if (attrNames.has(keyName)) { this.raise(Errors.ModuleAttributesWithDuplicateKeys, { at: this.state.startLoc, key: keyName }); } attrNames.add(keyName); if (this.match(129)) { node.key = this.parseStringLiteral(keyName); } else { node.key = this.parseIdentifier(true); } this.expect(14); if (!this.match(129)) { throw this.raise(Errors.ModuleAttributeInvalidValue, { at: this.state.startLoc }); } node.value = this.parseStringLiteral(this.state.value); attrs.push(this.finishNode(node, "ImportAttribute")); } while (this.eat(12)); return attrs; } maybeParseModuleAttributes() { if (this.match(76) && !this.hasPrecedingLineBreak()) { this.expectPlugin("moduleAttributes"); this.next(); } else { if (this.hasPlugin("moduleAttributes")) return []; return null; } const attrs = []; const attributes = new Set(); do { const node = this.startNode(); node.key = this.parseIdentifier(true); if (node.key.name !== "type") { this.raise(Errors.ModuleAttributeDifferentFromType, { at: node.key }); } if (attributes.has(node.key.name)) { this.raise(Errors.ModuleAttributesWithDuplicateKeys, { at: node.key, key: node.key.name }); } attributes.add(node.key.name); this.expect(14); if (!this.match(129)) { throw this.raise(Errors.ModuleAttributeInvalidValue, { at: this.state.startLoc }); } node.value = this.parseStringLiteral(this.state.value); this.finishNode(node, "ImportAttribute"); attrs.push(node); } while (this.eat(12)); return attrs; } maybeParseImportAssertions() { if (this.isContextual(94) && !this.hasPrecedingLineBreak()) { this.expectPlugin("importAssertions"); this.next(); } else { if (this.hasPlugin("importAssertions")) return []; return null; } this.eat(5); const attrs = this.parseAssertEntries(); this.eat(8); return attrs; } maybeParseDefaultImportSpecifier(node) { if (this.shouldParseDefaultImport(node)) { this.parseImportSpecifierLocal(node, this.startNode(), "ImportDefaultSpecifier"); return true; } return false; } maybeParseStarImportSpecifier(node) { if (this.match(55)) { const specifier = this.startNode(); this.next(); this.expectContextual(93); this.parseImportSpecifierLocal(node, specifier, "ImportNamespaceSpecifier"); return true; } return false; } parseNamedImportSpecifiers(node) { let first = true; this.expect(5); while (!this.eat(8)) { if (first) { first = false; } else { if (this.eat(14)) { throw this.raise(Errors.DestructureNamedImport, { at: this.state.startLoc }); } this.expect(12); if (this.eat(8)) break; } const specifier = this.startNode(); const importedIsString = this.match(129); const isMaybeTypeOnly = this.isContextual(126); specifier.imported = this.parseModuleExportName(); const importSpecifier = this.parseImportSpecifier(specifier, importedIsString, node.importKind === "type" || node.importKind === "typeof", isMaybeTypeOnly, undefined); node.specifiers.push(importSpecifier); } } parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, bindingType) { if (this.eatContextual(93)) { specifier.local = this.parseIdentifier(); } else { const { imported } = specifier; if (importedIsString) { throw this.raise(Errors.ImportBindingIsString, { at: specifier, importName: imported.value }); } this.checkReservedWord(imported.name, specifier.loc.start, true, true); if (!specifier.local) { specifier.local = cloneIdentifier(imported); } } return this.finishImportSpecifier(specifier, "ImportSpecifier", bindingType); } isThisParam(param) { return param.type === "Identifier" && param.name === "this"; } } class Parser extends StatementParser { constructor(options, input) { options = getOptions(options); super(options, input); this.options = options; this.initializeScopes(); this.plugins = pluginsMap(this.options.plugins); this.filename = options.sourceFilename; } getScopeHandler() { return ScopeHandler; } parse() { this.enterInitialScopes(); const file = this.startNode(); const program = this.startNode(); this.nextToken(); file.errors = null; this.parseTopLevel(file, program); file.errors = this.state.errors; return file; } } function pluginsMap(plugins) { const pluginMap = new Map(); for (const plugin of plugins) { const [name, options] = Array.isArray(plugin) ? plugin : [plugin, {}]; if (!pluginMap.has(name)) pluginMap.set(name, options || {}); } return pluginMap; } function parse(input, options) { var _options; if (((_options = options) == null ? void 0 : _options.sourceType) === "unambiguous") { options = Object.assign({}, options); try { options.sourceType = "module"; const parser = getParser(options, input); const ast = parser.parse(); if (parser.sawUnambiguousESM) { return ast; } if (parser.ambiguousScriptDifferentAst) { try { options.sourceType = "script"; return getParser(options, input).parse(); } catch (_unused) {} } else { ast.program.sourceType = "script"; } return ast; } catch (moduleError) { try { options.sourceType = "script"; return getParser(options, input).parse(); } catch (_unused2) {} throw moduleError; } } else { return getParser(options, input).parse(); } } function parseExpression(input, options) { const parser = getParser(options, input); if (parser.options.strictMode) { parser.state.strict = true; } return parser.getExpression(); } function generateExportedTokenTypes(internalTokenTypes) { const tokenTypes = {}; for (const typeName of Object.keys(internalTokenTypes)) { tokenTypes[typeName] = getExportedToken(internalTokenTypes[typeName]); } return tokenTypes; } const tokTypes = generateExportedTokenTypes(tt); function getParser(options, input) { let cls = Parser; if (options != null && options.plugins) { validatePlugins(options.plugins); cls = getParserClass(options.plugins); } return new cls(options, input); } const parserClassCache = {}; function getParserClass(pluginsFromOptions) { const pluginList = mixinPluginNames.filter(name => hasPlugin(pluginsFromOptions, name)); const key = pluginList.join("/"); let cls = parserClassCache[key]; if (!cls) { cls = Parser; for (const plugin of pluginList) { cls = mixinPlugins[plugin](cls); } parserClassCache[key] = cls; } return cls; } exports.parse = parse; exports.parseExpression = parseExpression; exports.tokTypes = tokTypes; },{}],267:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = void 0; var _helperPluginUtils = require("@babel/helper-plugin-utils"); var _pluginSyntaxFunctionSent = _interopRequireDefault(require("@babel/plugin-syntax-function-sent")); var _helperWrapFunction = _interopRequireDefault(require("@babel/helper-wrap-function")); var _core = require("@babel/core"); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } var _default = (0, _helperPluginUtils.declare)(api => { api.assertVersion(7); const isFunctionSent = node => _core.types.isIdentifier(node.meta, { name: "function" }) && _core.types.isIdentifier(node.property, { name: "sent" }); const hasBeenReplaced = (node, sentId) => _core.types.isAssignmentExpression(node) && _core.types.isIdentifier(node.left, { name: sentId }); const yieldVisitor = { Function(path) { path.skip(); }, YieldExpression(path) { if (!hasBeenReplaced(path.parent, this.sentId)) { path.replaceWith(_core.types.assignmentExpression("=", _core.types.identifier(this.sentId), path.node)); } }, MetaProperty(path) { if (isFunctionSent(path.node)) { path.replaceWith(_core.types.identifier(this.sentId)); } } }; return { name: "proposal-function-sent", inherits: _pluginSyntaxFunctionSent.default, visitor: { MetaProperty(path, state) { if (!isFunctionSent(path.node)) return; const fnPath = path.getFunctionParent(); if (!fnPath.node.generator) { throw new Error("Parent generator function not found"); } const sentId = path.scope.generateUid("function.sent"); fnPath.traverse(yieldVisitor, { sentId }); fnPath.node.body.body.unshift(_core.types.variableDeclaration("let", [_core.types.variableDeclarator(_core.types.identifier(sentId), _core.types.yieldExpression())])); (0, _helperWrapFunction.default)(fnPath, state.addHelper("skipFirstGeneratorNext")); } } }; }); exports.default = _default; },{"@babel/core":30,"@babel/helper-plugin-utils":170,"@babel/helper-wrap-function":261,"@babel/plugin-syntax-function-sent":269}],268:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = void 0; var _helperPluginUtils = require("@babel/helper-plugin-utils"); var _default = (0, _helperPluginUtils.declare)(api => { api.assertVersion(7); return { name: "syntax-async-generators", manipulateOptions(opts, parserOpts) { parserOpts.plugins.push("asyncGenerators"); } }; }); exports.default = _default; },{"@babel/helper-plugin-utils":170}],269:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = void 0; var _helperPluginUtils = require("@babel/helper-plugin-utils"); var _default = (0, _helperPluginUtils.declare)(api => { api.assertVersion(7); return { name: "syntax-function-sent", manipulateOptions(opts, parserOpts) { parserOpts.plugins.push("functionSent"); } }; }); exports.default = _default; },{"@babel/helper-plugin-utils":170}],270:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = void 0; var _helperPluginUtils = require("@babel/helper-plugin-utils"); var _default = (0, _helperPluginUtils.declare)((api, options) => { var _api$assumption; api.assertVersion(7); const noNewArrows = (_api$assumption = api.assumption("noNewArrows")) != null ? _api$assumption : !options.spec; return { name: "transform-arrow-functions", visitor: { ArrowFunctionExpression(path) { if (!path.isArrowFunctionExpression()) return; path.arrowFunctionToExpression({ allowInsertArrow: false, noNewArrows, specCompliant: !noNewArrows }); } } }; }); exports.default = _default; },{"@babel/helper-plugin-utils":170}],271:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = void 0; var _helperPluginUtils = require("@babel/helper-plugin-utils"); var _tdz = require("./tdz"); var _core = require("@babel/core"); const DONE = new WeakSet(); var _default = (0, _helperPluginUtils.declare)((api, opts) => { api.assertVersion(7); const { throwIfClosureRequired = false, tdz: tdzEnabled = false } = opts; if (typeof throwIfClosureRequired !== "boolean") { throw new Error(`.throwIfClosureRequired must be a boolean, or undefined`); } if (typeof tdzEnabled !== "boolean") { throw new Error(`.tdz must be a boolean, or undefined`); } return { name: "transform-block-scoping", visitor: { VariableDeclaration(path) { const { node, parent, scope } = path; if (!isBlockScoped(node)) return; convertBlockScopedToVar(path, null, parent, scope, true); if (node._tdzThis) { const nodes = [node]; for (let i = 0; i < node.declarations.length; i++) { const decl = node.declarations[i]; const assign = _core.types.assignmentExpression("=", _core.types.cloneNode(decl.id), decl.init || scope.buildUndefinedNode()); assign._ignoreBlockScopingTDZ = true; nodes.push(_core.types.expressionStatement(assign)); decl.init = this.addHelper("temporalUndefined"); } node._blockHoist = 2; if (path.isCompletionRecord()) { nodes.push(_core.types.expressionStatement(scope.buildUndefinedNode())); } path.replaceWithMultiple(nodes); } }, Loop(path, state) { const { parent, scope } = path; path.ensureBlock(); const blockScoping = new BlockScoping(path, path.get("body"), parent, scope, throwIfClosureRequired, tdzEnabled, state); const replace = blockScoping.run(); if (replace) path.replaceWith(replace); }, CatchClause(path, state) { const { parent, scope } = path; const blockScoping = new BlockScoping(null, path.get("body"), parent, scope, throwIfClosureRequired, tdzEnabled, state); blockScoping.run(); }, "BlockStatement|SwitchStatement|Program"(path, state) { if (!ignoreBlock(path)) { const blockScoping = new BlockScoping(null, path, path.parent, path.scope, throwIfClosureRequired, tdzEnabled, state); blockScoping.run(); } } } }; }); exports.default = _default; function ignoreBlock(path) { return _core.types.isLoop(path.parent) || _core.types.isCatchClause(path.parent); } const buildRetCheck = _core.template.statement(` if (typeof RETURN === "object") return RETURN.v; `); function isBlockScoped(node) { if (!_core.types.isVariableDeclaration(node)) return false; if (node[_core.types.BLOCK_SCOPED_SYMBOL]) { return true; } if (node.kind !== "let" && node.kind !== "const") return false; return true; } function isInLoop(path) { const loopOrFunctionParent = path.find(path => path.isLoop() || path.isFunction()); return loopOrFunctionParent == null ? void 0 : loopOrFunctionParent.isLoop(); } function convertBlockScopedToVar(path, node, parent, scope, moveBindingsToParent = false) { if (!node) { node = path.node; } if (isInLoop(path) && !_core.types.isFor(parent)) { for (let i = 0; i < node.declarations.length; i++) { const declar = node.declarations[i]; declar.init = declar.init || scope.buildUndefinedNode(); } } node[_core.types.BLOCK_SCOPED_SYMBOL] = true; node.kind = "var"; if (moveBindingsToParent) { const parentScope = scope.getFunctionParent() || scope.getProgramParent(); for (const name of Object.keys(path.getBindingIdentifiers())) { const binding = scope.getOwnBinding(name); if (binding) binding.kind = "var"; scope.moveBindingTo(name, parentScope); } } } function isVar(node) { return _core.types.isVariableDeclaration(node, { kind: "var" }) && !isBlockScoped(node); } const letReferenceBlockVisitor = _core.traverse.visitors.merge([{ Loop: { enter(path, state) { state.loopDepth++; }, exit(path, state) { state.loopDepth--; } }, FunctionParent(path, state) { if (state.loopDepth > 0) { path.traverse(letReferenceFunctionVisitor, state); } else { path.traverse(_tdz.visitor, state); } return path.skip(); } }, _tdz.visitor]); const letReferenceFunctionVisitor = _core.traverse.visitors.merge([{ ReferencedIdentifier(path, state) { const ref = state.letReferences.get(path.node.name); if (!ref) return; const localBinding = path.scope.getBindingIdentifier(path.node.name); if (localBinding && localBinding !== ref) return; state.closurify = true; } }, _tdz.visitor]); const hoistVarDeclarationsVisitor = { enter(path, self) { if (path.isForStatement()) { const { node } = path; if (isVar(node.init)) { const nodes = self.pushDeclar(node.init); if (nodes.length === 1) { node.init = nodes[0]; } else { node.init = _core.types.sequenceExpression(nodes); } } } else if (path.isForInStatement() || path.isForOfStatement()) { const { node } = path; if (isVar(node.left)) { self.pushDeclar(node.left); node.left = node.left.declarations[0].id; } } else if (isVar(path.node)) { path.replaceWithMultiple(self.pushDeclar(path.node).map(expr => _core.types.expressionStatement(expr))); } else if (path.isFunction()) { return path.skip(); } } }; const loopLabelVisitor = { LabeledStatement({ node }, state) { state.innerLabels.push(node.label.name); } }; const continuationVisitor = { enter(path, state) { if (path.isAssignmentExpression() || path.isUpdateExpression()) { for (const name of Object.keys(path.getBindingIdentifiers())) { if (state.outsideReferences.get(name) !== path.scope.getBindingIdentifier(name)) { continue; } state.reassignments[name] = true; } } else if (path.isReturnStatement()) { state.returnStatements.push(path); } } }; function loopNodeTo(node) { if (_core.types.isBreakStatement(node)) { return "break"; } else if (_core.types.isContinueStatement(node)) { return "continue"; } } const loopVisitor = { Loop(path, state) { const oldIgnoreLabeless = state.ignoreLabeless; state.ignoreLabeless = true; path.traverse(loopVisitor, state); state.ignoreLabeless = oldIgnoreLabeless; path.skip(); }, Function(path) { path.skip(); }, SwitchCase(path, state) { const oldInSwitchCase = state.inSwitchCase; state.inSwitchCase = true; path.traverse(loopVisitor, state); state.inSwitchCase = oldInSwitchCase; path.skip(); }, "BreakStatement|ContinueStatement|ReturnStatement"(path, state) { const { node, scope } = path; if (state.loopIgnored.has(node)) return; let replace; let loopText = loopNodeTo(node); if (loopText) { if (_core.types.isReturnStatement(node)) { throw new Error("Internal error: unexpected return statement with `loopText`"); } if (node.label) { if (state.innerLabels.indexOf(node.label.name) >= 0) { return; } loopText = `${loopText}|${node.label.name}`; } else { if (state.ignoreLabeless) return; if (_core.types.isBreakStatement(node) && state.inSwitchCase) return; } state.hasBreakContinue = true; state.map.set(loopText, node); replace = _core.types.stringLiteral(loopText); } if (_core.types.isReturnStatement(node)) { state.hasReturn = true; replace = _core.types.objectExpression([_core.types.objectProperty(_core.types.identifier("v"), node.argument || scope.buildUndefinedNode())]); } if (replace) { replace = _core.types.returnStatement(replace); state.loopIgnored.add(replace); path.skip(); path.replaceWith(_core.types.inherits(replace, node)); } } }; function isStrict(path) { return !!path.find(({ node }) => { if (_core.types.isProgram(node)) { if (node.sourceType === "module") return true; } else if (!_core.types.isBlockStatement(node)) return false; return node.directives.some(directive => directive.value.value === "use strict"); }); } class BlockScoping { constructor(loopPath, blockPath, parent, scope, throwIfClosureRequired, tdzEnabled, state) { this.parent = void 0; this.state = void 0; this.scope = void 0; this.throwIfClosureRequired = void 0; this.tdzEnabled = void 0; this.blockPath = void 0; this.block = void 0; this.outsideLetReferences = void 0; this.hasLetReferences = void 0; this.letReferences = void 0; this.body = void 0; this.loopParent = void 0; this.loopLabel = void 0; this.loopPath = void 0; this.loop = void 0; this.has = void 0; this.parent = parent; this.scope = scope; this.state = state; this.throwIfClosureRequired = throwIfClosureRequired; this.tdzEnabled = tdzEnabled; this.blockPath = blockPath; this.block = blockPath.node; this.outsideLetReferences = new Map(); this.hasLetReferences = false; this.letReferences = new Map(); this.body = []; if (loopPath) { this.loopParent = loopPath.parent; this.loopLabel = _core.types.isLabeledStatement(this.loopParent) && this.loopParent.label; this.loopPath = loopPath; this.loop = loopPath.node; } } run() { const block = this.block; if (DONE.has(block)) return; DONE.add(block); const needsClosure = this.getLetReferences(); this.checkConstants(); if (_core.types.isFunction(this.parent) || _core.types.isProgram(this.block)) { this.updateScopeInfo(); return; } if (!this.hasLetReferences) return; if (needsClosure) { this.wrapClosure(); } else { this.remap(); } this.updateScopeInfo(needsClosure); if (this.loopLabel && !_core.types.isLabeledStatement(this.loopParent)) { return _core.types.labeledStatement(this.loopLabel, this.loop); } } checkConstants() { const constBindings = new Map(); for (const scope of new Set([this.scope, this.blockPath.scope])) { for (const name of Object.keys(scope.bindings)) { const binding = scope.bindings[name]; if (binding.kind === "const") constBindings.set(name, binding); } } const { state } = this; for (const [name, binding] of constBindings) { for (const violation of binding.constantViolations) { const readOnlyError = state.addHelper("readOnlyError"); const throwNode = _core.types.callExpression(readOnlyError, [_core.types.stringLiteral(name)]); if (violation.isAssignmentExpression()) { const { operator } = violation.node; if (operator === "=") { violation.replaceWith(_core.types.sequenceExpression([violation.get("right").node, throwNode])); } else if (["&&=", "||=", "??="].includes(operator)) { violation.replaceWith(_core.types.logicalExpression(operator.slice(0, -1), violation.get("left").node, _core.types.sequenceExpression([violation.get("right").node, throwNode]))); } else { violation.replaceWith(_core.types.sequenceExpression([_core.types.binaryExpression(operator.slice(0, -1), violation.get("left").node, violation.get("right").node), throwNode])); } } else if (violation.isUpdateExpression()) { violation.replaceWith(_core.types.sequenceExpression([_core.types.unaryExpression("+", violation.get("argument").node), throwNode])); } else if (violation.isForXStatement()) { violation.ensureBlock(); violation.get("left").replaceWith(_core.types.variableDeclaration("var", [_core.types.variableDeclarator(violation.scope.generateUidIdentifier(name))])); violation.node.body.body.unshift(_core.types.expressionStatement(throwNode)); } } } } updateScopeInfo(wrappedInClosure) { const blockScope = this.blockPath.scope; const parentScope = blockScope.getFunctionParent() || blockScope.getProgramParent(); const letRefs = this.letReferences; for (const key of letRefs.keys()) { const ref = letRefs.get(key); const binding = blockScope.getBinding(ref.name); if (!binding) continue; if (binding.kind === "let" || binding.kind === "const") { binding.kind = "var"; if (wrappedInClosure) { if (blockScope.hasOwnBinding(ref.name)) { blockScope.removeBinding(ref.name); } } else { blockScope.moveBindingTo(ref.name, parentScope); } } } } remap() { const letRefs = this.letReferences; const outsideLetRefs = this.outsideLetReferences; const scope = this.scope; const blockPathScope = this.blockPath.scope; for (const key of letRefs.keys()) { const ref = letRefs.get(key); if (scope.parentHasBinding(key) || scope.hasGlobal(key)) { const binding = scope.getOwnBinding(key); if (binding) { const parentBinding = scope.parent.getOwnBinding(key); if (binding.kind === "hoisted" && !binding.path.node.async && !binding.path.node.generator && (!parentBinding || isVar(parentBinding.path.parent)) && !isStrict(binding.path.parentPath)) { continue; } scope.rename(ref.name); } if (blockPathScope.hasOwnBinding(key)) { blockPathScope.rename(ref.name); } } } for (const key of outsideLetRefs.keys()) { const ref = letRefs.get(key); if (isInLoop(this.blockPath) && blockPathScope.hasOwnBinding(key)) { blockPathScope.rename(ref.name); } } } wrapClosure() { if (this.throwIfClosureRequired) { throw this.blockPath.buildCodeFrameError("Compiling let/const in this block would add a closure " + "(throwIfClosureRequired)."); } const block = this.block; const outsideRefs = this.outsideLetReferences; if (this.loop) { for (const name of Array.from(outsideRefs.keys())) { const id = outsideRefs.get(name); if (this.scope.hasGlobal(id.name) || this.scope.parentHasBinding(id.name)) { outsideRefs.delete(id.name); this.letReferences.delete(id.name); this.scope.rename(id.name); this.letReferences.set(id.name, id); outsideRefs.set(id.name, id); } } } this.has = this.checkLoop(); this.hoistVarDeclarations(); const args = Array.from(outsideRefs.values(), node => _core.types.cloneNode(node)); const params = args.map(id => _core.types.cloneNode(id)); const isSwitch = block.type === "SwitchStatement"; const fn = _core.types.functionExpression(null, params, _core.types.blockStatement(isSwitch ? [block] : block.body)); this.addContinuations(fn); let call = _core.types.callExpression(_core.types.nullLiteral(), args); let basePath = ".callee"; const hasYield = _core.traverse.hasType(fn.body, "YieldExpression", _core.types.FUNCTION_TYPES); if (hasYield) { fn.generator = true; call = _core.types.yieldExpression(call, true); basePath = ".argument" + basePath; } const hasAsync = _core.traverse.hasType(fn.body, "AwaitExpression", _core.types.FUNCTION_TYPES); if (hasAsync) { fn.async = true; call = _core.types.awaitExpression(call); basePath = ".argument" + basePath; } let placeholderPath; let index; if (this.has.hasReturn || this.has.hasBreakContinue) { const ret = this.scope.generateUid("ret"); this.body.push(_core.types.variableDeclaration("var", [_core.types.variableDeclarator(_core.types.identifier(ret), call)])); placeholderPath = "declarations.0.init" + basePath; index = this.body.length - 1; this.buildHas(ret); } else { this.body.push(_core.types.expressionStatement(call)); placeholderPath = "expression" + basePath; index = this.body.length - 1; } let callPath; if (isSwitch) { const { parentPath, listKey, key } = this.blockPath; this.blockPath.replaceWithMultiple(this.body); callPath = parentPath.get(listKey)[key + index]; } else { block.body = this.body; callPath = this.blockPath.get("body")[index]; } const placeholder = callPath.get(placeholderPath); let fnPath; if (this.loop) { const loopId = this.scope.generateUid("loop"); const p = this.loopPath.insertBefore(_core.types.variableDeclaration("var", [_core.types.variableDeclarator(_core.types.identifier(loopId), fn)])); placeholder.replaceWith(_core.types.identifier(loopId)); fnPath = p[0].get("declarations.0.init"); } else { placeholder.replaceWith(fn); fnPath = placeholder; } fnPath.unwrapFunctionEnvironment(); } addContinuations(fn) { const state = { reassignments: {}, returnStatements: [], outsideReferences: this.outsideLetReferences }; this.scope.traverse(fn, continuationVisitor, state); for (let i = 0; i < fn.params.length; i++) { const param = fn.params[i]; if (!state.reassignments[param.name]) continue; const paramName = param.name; const newParamName = this.scope.generateUid(param.name); fn.params[i] = _core.types.identifier(newParamName); this.scope.rename(paramName, newParamName, fn); state.returnStatements.forEach(returnStatement => { returnStatement.insertBefore(_core.types.expressionStatement(_core.types.assignmentExpression("=", _core.types.identifier(paramName), _core.types.identifier(newParamName)))); }); fn.body.body.push(_core.types.expressionStatement(_core.types.assignmentExpression("=", _core.types.identifier(paramName), _core.types.identifier(newParamName)))); } } getLetReferences() { const block = this.block; const declarators = []; if (this.loop) { const init = this.loop.left || this.loop.init; if (isBlockScoped(init)) { declarators.push(init); const names = _core.types.getBindingIdentifiers(init); for (const name of Object.keys(names)) { this.outsideLetReferences.set(name, names[name]); } } } const addDeclarationsFromChild = (path, node) => { if (_core.types.isClassDeclaration(node) || _core.types.isFunctionDeclaration(node) || isBlockScoped(node)) { if (isBlockScoped(node)) { convertBlockScopedToVar(path, node, block, this.scope); } if (node.type === "VariableDeclaration") { for (let i = 0; i < node.declarations.length; i++) { declarators.push(node.declarations[i]); } } else { declarators.push(node); } } if (_core.types.isLabeledStatement(node)) { addDeclarationsFromChild(path.get("body"), node.body); } }; if (block.type === "SwitchStatement") { const declarPaths = this.blockPath.get("cases"); for (let i = 0; i < block.cases.length; i++) { const consequents = block.cases[i].consequent; for (let j = 0; j < consequents.length; j++) { const declar = consequents[j]; addDeclarationsFromChild(declarPaths[i], declar); } } } else { const declarPaths = this.blockPath.get("body"); for (let i = 0; i < block.body.length; i++) { addDeclarationsFromChild(declarPaths[i], declarPaths[i].node); } } for (let i = 0; i < declarators.length; i++) { const declar = declarators[i]; const keys = _core.types.getBindingIdentifiers(declar, false, true); for (const key of Object.keys(keys)) { this.letReferences.set(key, keys[key]); } this.hasLetReferences = true; } if (!this.hasLetReferences) return; const state = { letReferences: this.letReferences, closurify: false, loopDepth: 0, tdzEnabled: this.tdzEnabled, addHelper: name => this.state.addHelper(name) }; if (isInLoop(this.blockPath)) { state.loopDepth++; } this.blockPath.traverse(letReferenceBlockVisitor, state); return state.closurify; } checkLoop() { const state = { hasBreakContinue: false, ignoreLabeless: false, inSwitchCase: false, innerLabels: [], hasReturn: false, isLoop: !!this.loop, map: new Map(), loopIgnored: new WeakSet() }; this.blockPath.traverse(loopLabelVisitor, state); this.blockPath.traverse(loopVisitor, state); return state; } hoistVarDeclarations() { this.blockPath.traverse(hoistVarDeclarationsVisitor, this); } pushDeclar(node) { const declars = []; const names = _core.types.getBindingIdentifiers(node); for (const name of Object.keys(names)) { declars.push(_core.types.variableDeclarator(names[name])); } this.body.push(_core.types.variableDeclaration(node.kind, declars)); const replace = []; for (let i = 0; i < node.declarations.length; i++) { const declar = node.declarations[i]; if (!declar.init) continue; const expr = _core.types.assignmentExpression("=", _core.types.cloneNode(declar.id), _core.types.cloneNode(declar.init)); replace.push(_core.types.inherits(expr, declar)); } return replace; } buildHas(ret) { const body = this.body; const has = this.has; if (has.hasBreakContinue) { for (const key of has.map.keys()) { body.push(_core.types.ifStatement(_core.types.binaryExpression("===", _core.types.identifier(ret), _core.types.stringLiteral(key)), has.map.get(key))); } } if (has.hasReturn) { body.push(buildRetCheck({ RETURN: _core.types.identifier(ret) })); } } } },{"./tdz":272,"@babel/core":30,"@babel/helper-plugin-utils":170}],272:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.visitor = void 0; var _core = require("@babel/core"); function getTDZStatus(refPath, bindingPath) { const executionStatus = bindingPath._guessExecutionStatusRelativeTo(refPath); if (executionStatus === "before") { return "outside"; } else if (executionStatus === "after") { return "inside"; } else { return "maybe"; } } function buildTDZAssert(node, state) { return _core.types.callExpression(state.addHelper("temporalRef"), [node, _core.types.stringLiteral(node.name)]); } function isReference(node, scope, state) { const declared = state.letReferences.get(node.name); if (!declared) return false; return scope.getBindingIdentifier(node.name) === declared; } const visitedMaybeTDZNodes = new WeakSet(); const visitor = { ReferencedIdentifier(path, state) { if (!state.tdzEnabled) return; const { node, parent, scope } = path; if (path.parentPath.isFor({ left: node })) return; if (!isReference(node, scope, state)) return; const bindingPath = scope.getBinding(node.name).path; if (bindingPath.isFunctionDeclaration()) return; const status = getTDZStatus(path, bindingPath); if (status === "outside") return; if (status === "maybe") { if (visitedMaybeTDZNodes.has(node)) { return; } visitedMaybeTDZNodes.add(node); const assert = buildTDZAssert(node, state); bindingPath.parent._tdzThis = true; if (path.parentPath.isUpdateExpression()) { if (parent._ignoreBlockScopingTDZ) return; path.parentPath.replaceWith(_core.types.sequenceExpression([assert, parent])); } else { path.replaceWith(assert); } } else if (status === "inside") { path.replaceWith(_core.template.ast`${state.addHelper("tdz")}("${node.name}")`); } }, AssignmentExpression: { exit(path, state) { if (!state.tdzEnabled) return; const { node } = path; if (node._ignoreBlockScopingTDZ) return; const nodes = []; const ids = path.getBindingIdentifiers(); for (const name of Object.keys(ids)) { const id = ids[name]; if (isReference(id, path.scope, state)) { nodes.push(id); } } if (nodes.length) { node._ignoreBlockScopingTDZ = true; nodes.push(node); path.replaceWithMultiple(nodes.map(n => _core.types.expressionStatement(n))); } } } }; exports.visitor = visitor; },{"@babel/core":30}],273:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = void 0; var _helperPluginUtils = require("@babel/helper-plugin-utils"); var _helperCompilationTargets = require("@babel/helper-compilation-targets"); var _helperAnnotateAsPure = require("@babel/helper-annotate-as-pure"); var _helperFunctionName = require("@babel/helper-function-name"); var _helperSplitExportDeclaration = require("@babel/helper-split-export-declaration"); var _core = require("@babel/core"); var _globals = require("globals"); var _transformClass = require("./transformClass"); const getBuiltinClasses = category => Object.keys(_globals[category]).filter(name => /^[A-Z]/.test(name)); const builtinClasses = new Set([...getBuiltinClasses("builtin"), ...getBuiltinClasses("browser")]); var _default = (0, _helperPluginUtils.declare)((api, options) => { var _api$assumption, _api$assumption2, _api$assumption3, _api$assumption4; api.assertVersion(7); const { loose = false } = options; const setClassMethods = (_api$assumption = api.assumption("setClassMethods")) != null ? _api$assumption : loose; const constantSuper = (_api$assumption2 = api.assumption("constantSuper")) != null ? _api$assumption2 : loose; const superIsCallableConstructor = (_api$assumption3 = api.assumption("superIsCallableConstructor")) != null ? _api$assumption3 : loose; const noClassCalls = (_api$assumption4 = api.assumption("noClassCalls")) != null ? _api$assumption4 : loose; const supportUnicodeId = !(0, _helperCompilationTargets.isRequired)("transform-unicode-escapes", api.targets()); const VISITED = new WeakSet(); return { name: "transform-classes", visitor: { ExportDefaultDeclaration(path) { if (!path.get("declaration").isClassDeclaration()) return; (0, _helperSplitExportDeclaration.default)(path); }, ClassDeclaration(path) { const { node } = path; const ref = node.id || path.scope.generateUidIdentifier("class"); path.replaceWith(_core.types.variableDeclaration("let", [_core.types.variableDeclarator(ref, _core.types.toExpression(node))])); }, ClassExpression(path, state) { const { node } = path; if (VISITED.has(node)) return; const inferred = (0, _helperFunctionName.default)(path, undefined, supportUnicodeId); if (inferred && inferred !== node) { path.replaceWith(inferred); return; } VISITED.add(node); const [replacedPath] = path.replaceWith((0, _transformClass.default)(path, state.file, builtinClasses, loose, { setClassMethods, constantSuper, superIsCallableConstructor, noClassCalls }, supportUnicodeId)); if (replacedPath.isCallExpression()) { (0, _helperAnnotateAsPure.default)(replacedPath); const callee = replacedPath.get("callee"); if (callee.isArrowFunctionExpression()) { callee.arrowFunctionToExpression(); } } } } }; }); exports.default = _default; },{"./transformClass":275,"@babel/core":30,"@babel/helper-annotate-as-pure":67,"@babel/helper-compilation-targets":70,"@babel/helper-function-name":77,"@babel/helper-plugin-utils":170,"@babel/helper-split-export-declaration":253,"globals":442}],274:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = addCreateSuperHelper; var _core = require("@babel/core"); const helperIDs = new WeakMap(); function addCreateSuperHelper(file) { if (helperIDs.has(file)) { return (_core.types.cloneNode || _core.types.clone)(helperIDs.get(file)); } try { return file.addHelper("createSuper"); } catch (_unused) {} const id = file.scope.generateUidIdentifier("createSuper"); helperIDs.set(file, id); const fn = helper({ CREATE_SUPER: id, GET_PROTOTYPE_OF: file.addHelper("getPrototypeOf"), POSSIBLE_CONSTRUCTOR_RETURN: file.addHelper("possibleConstructorReturn") }); file.path.unshiftContainer("body", [fn]); file.scope.registerDeclaration(file.path.get("body.0")); return _core.types.cloneNode(id); } const helper = _core.template.statement` function CREATE_SUPER(Derived) { function isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; // core-js@3 if (Reflect.construct.sham) return false; // Proxy can't be polyfilled. Every browser implemented // proxies before or at the same time as Reflect.construct, // so if they support Proxy they also support Reflect.construct. if (typeof Proxy === "function") return true; // Since Reflect.construct can't be properly polyfilled, some // implementations (e.g. core-js@2) don't set the correct internal slots. // Those polyfills don't allow us to subclass built-ins, so we need to // use our fallback implementation. try { // If the internal slots aren't set, this throws an error similar to // TypeError: this is not a Date object. Date.prototype.toString.call(Reflect.construct(Date, [], function() {})); return true; } catch (e) { return false; } } return function () { var Super = GET_PROTOTYPE_OF(Derived), result; if (isNativeReflectConstruct()) { // NOTE: This doesn't work if this.__proto__.constructor has been modified. var NewTarget = GET_PROTOTYPE_OF(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return POSSIBLE_CONSTRUCTOR_RETURN(this, result); } } `; },{"@babel/core":30}],275:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = transformClass; var _helperFunctionName = require("@babel/helper-function-name"); var _helperReplaceSupers = require("@babel/helper-replace-supers"); var _helperEnvironmentVisitor = require("@babel/helper-environment-visitor"); var _helperOptimiseCallExpression = require("@babel/helper-optimise-call-expression"); var _core = require("@babel/core"); var _helperAnnotateAsPure = require("@babel/helper-annotate-as-pure"); var _inlineCreateSuperHelpers = require("./inline-createSuper-helpers"); function buildConstructor(classRef, constructorBody, node) { const func = _core.types.functionDeclaration(_core.types.cloneNode(classRef), [], constructorBody); _core.types.inherits(func, node); return func; } function transformClass(path, file, builtinClasses, isLoose, assumptions, supportUnicodeId) { const classState = { parent: undefined, scope: undefined, node: undefined, path: undefined, file: undefined, classId: undefined, classRef: undefined, superFnId: undefined, superName: null, superReturns: [], isDerived: false, extendsNative: false, construct: undefined, constructorBody: undefined, userConstructor: undefined, userConstructorPath: undefined, hasConstructor: false, body: [], superThises: [], pushedConstructor: false, pushedInherits: false, pushedCreateClass: false, protoAlias: null, isLoose: false, dynamicKeys: new Map(), methods: { instance: { hasComputed: false, list: [], map: new Map() }, static: { hasComputed: false, list: [], map: new Map() } } }; const setState = newState => { Object.assign(classState, newState); }; const findThisesVisitor = _core.traverse.visitors.merge([_helperEnvironmentVisitor.default, { ThisExpression(path) { classState.superThises.push(path); } }]); function createClassHelper(args) { return _core.types.callExpression(classState.file.addHelper("createClass"), args); } function maybeCreateConstructor() { let hasConstructor = false; const paths = classState.path.get("body.body"); for (const path of paths) { hasConstructor = path.equals("kind", "constructor"); if (hasConstructor) break; } if (hasConstructor) return; let params, body; if (classState.isDerived) { const constructor = _core.template.expression.ast` (function () { super(...arguments); }) `; params = constructor.params; body = constructor.body; } else { params = []; body = _core.types.blockStatement([]); } classState.path.get("body").unshiftContainer("body", _core.types.classMethod("constructor", _core.types.identifier("constructor"), params, body)); } function buildBody() { maybeCreateConstructor(); pushBody(); verifyConstructor(); if (classState.userConstructor) { const { constructorBody, userConstructor, construct } = classState; constructorBody.body.push(...userConstructor.body.body); _core.types.inherits(construct, userConstructor); _core.types.inherits(constructorBody, userConstructor.body); } pushDescriptors(); } function pushBody() { const classBodyPaths = classState.path.get("body.body"); for (const path of classBodyPaths) { const node = path.node; if (path.isClassProperty()) { throw path.buildCodeFrameError("Missing class properties transform."); } if (node.decorators) { throw path.buildCodeFrameError("Method has decorators, put the decorator plugin before the classes one."); } if (_core.types.isClassMethod(node)) { const isConstructor = node.kind === "constructor"; const replaceSupers = new _helperReplaceSupers.default({ methodPath: path, objectRef: classState.classRef, superRef: classState.superName, constantSuper: assumptions.constantSuper, file: classState.file, refToPreserve: classState.classRef }); replaceSupers.replace(); const superReturns = []; path.traverse(_core.traverse.visitors.merge([_helperEnvironmentVisitor.default, { ReturnStatement(path) { if (!path.getFunctionParent().isArrowFunctionExpression()) { superReturns.push(path); } } }])); if (isConstructor) { pushConstructor(superReturns, node, path); } else { pushMethod(node, path); } } } } function pushDescriptors() { pushInheritsToBody(); const { body } = classState; const props = { instance: null, static: null }; for (const placement of ["static", "instance"]) { if (classState.methods[placement].list.length) { props[placement] = classState.methods[placement].list.map(desc => { const obj = _core.types.objectExpression([_core.types.objectProperty(_core.types.identifier("key"), desc.key)]); for (const kind of ["get", "set", "value"]) { if (desc[kind] != null) { obj.properties.push(_core.types.objectProperty(_core.types.identifier(kind), desc[kind])); } } return obj; }); } } if (props.instance || props.static) { let args = [_core.types.cloneNode(classState.classRef), props.instance ? _core.types.arrayExpression(props.instance) : _core.types.nullLiteral(), props.static ? _core.types.arrayExpression(props.static) : _core.types.nullLiteral()]; let lastNonNullIndex = 0; for (let i = 0; i < args.length; i++) { if (!_core.types.isNullLiteral(args[i])) lastNonNullIndex = i; } args = args.slice(0, lastNonNullIndex + 1); body.push(_core.types.expressionStatement(createClassHelper(args))); classState.pushedCreateClass = true; } } function wrapSuperCall(bareSuper, superRef, thisRef, body) { const bareSuperNode = bareSuper.node; let call; if (assumptions.superIsCallableConstructor) { bareSuperNode.arguments.unshift(_core.types.thisExpression()); if (bareSuperNode.arguments.length === 2 && _core.types.isSpreadElement(bareSuperNode.arguments[1]) && _core.types.isIdentifier(bareSuperNode.arguments[1].argument, { name: "arguments" })) { bareSuperNode.arguments[1] = bareSuperNode.arguments[1].argument; bareSuperNode.callee = _core.types.memberExpression(_core.types.cloneNode(superRef), _core.types.identifier("apply")); } else { bareSuperNode.callee = _core.types.memberExpression(_core.types.cloneNode(superRef), _core.types.identifier("call")); } call = _core.types.logicalExpression("||", bareSuperNode, _core.types.thisExpression()); } else { call = (0, _helperOptimiseCallExpression.default)(_core.types.cloneNode(classState.superFnId), _core.types.thisExpression(), bareSuperNode.arguments, false); } if (bareSuper.parentPath.isExpressionStatement() && bareSuper.parentPath.container === body.node.body && body.node.body.length - 1 === bareSuper.parentPath.key) { if (classState.superThises.length) { call = _core.types.assignmentExpression("=", thisRef(), call); } bareSuper.parentPath.replaceWith(_core.types.returnStatement(call)); } else { bareSuper.replaceWith(_core.types.assignmentExpression("=", thisRef(), call)); } } function verifyConstructor() { if (!classState.isDerived) return; const path = classState.userConstructorPath; const body = path.get("body"); path.traverse(findThisesVisitor); let thisRef = function () { const ref = path.scope.generateDeclaredUidIdentifier("this"); thisRef = () => _core.types.cloneNode(ref); return ref; }; for (const thisPath of classState.superThises) { const { node, parentPath } = thisPath; if (parentPath.isMemberExpression({ object: node })) { thisPath.replaceWith(thisRef()); continue; } thisPath.replaceWith(_core.types.callExpression(classState.file.addHelper("assertThisInitialized"), [thisRef()])); } const bareSupers = []; path.traverse(_core.traverse.visitors.merge([_helperEnvironmentVisitor.default, { Super(path) { const { node, parentPath } = path; if (parentPath.isCallExpression({ callee: node })) { bareSupers.unshift(parentPath); } } }])); let guaranteedSuperBeforeFinish = !!bareSupers.length; for (const bareSuper of bareSupers) { wrapSuperCall(bareSuper, classState.superName, thisRef, body); if (guaranteedSuperBeforeFinish) { bareSuper.find(function (parentPath) { if (parentPath === path) { return true; } if (parentPath.isLoop() || parentPath.isConditional() || parentPath.isArrowFunctionExpression()) { guaranteedSuperBeforeFinish = false; return true; } }); } } let wrapReturn; if (classState.isLoose) { wrapReturn = returnArg => { const thisExpr = _core.types.callExpression(classState.file.addHelper("assertThisInitialized"), [thisRef()]); return returnArg ? _core.types.logicalExpression("||", returnArg, thisExpr) : thisExpr; }; } else { wrapReturn = returnArg => { const returnParams = [thisRef()]; if (returnArg != null) { returnParams.push(returnArg); } return _core.types.callExpression(classState.file.addHelper("possibleConstructorReturn"), returnParams); }; } const bodyPaths = body.get("body"); if (!bodyPaths.length || !bodyPaths.pop().isReturnStatement()) { body.pushContainer("body", _core.types.returnStatement(guaranteedSuperBeforeFinish ? thisRef() : wrapReturn())); } for (const returnPath of classState.superReturns) { returnPath.get("argument").replaceWith(wrapReturn(returnPath.node.argument)); } } function pushMethod(node, path) { const scope = path ? path.scope : classState.scope; if (node.kind === "method") { if (processMethod(node, scope)) return; } const placement = node.static ? "static" : "instance"; const methods = classState.methods[placement]; const descKey = node.kind === "method" ? "value" : node.kind; const key = _core.types.isNumericLiteral(node.key) || _core.types.isBigIntLiteral(node.key) ? _core.types.stringLiteral(String(node.key.value)) : _core.types.toComputedKey(node); let fn = _core.types.toExpression(node); if (_core.types.isStringLiteral(key)) { if (node.kind === "method") { var _nameFunction; fn = (_nameFunction = (0, _helperFunctionName.default)({ id: key, node: node, scope }, undefined, supportUnicodeId)) != null ? _nameFunction : fn; } } else { methods.hasComputed = true; } let descriptor; if (!methods.hasComputed && methods.map.has(key.value)) { descriptor = methods.map.get(key.value); descriptor[descKey] = fn; if (descKey === "value") { descriptor.get = null; descriptor.set = null; } else { descriptor.value = null; } } else { descriptor = { key: key, [descKey]: fn }; methods.list.push(descriptor); if (!methods.hasComputed) { methods.map.set(key.value, descriptor); } } } function processMethod(node, scope) { if (assumptions.setClassMethods && !node.decorators) { let { classRef } = classState; if (!node.static) { insertProtoAliasOnce(); classRef = classState.protoAlias; } const methodName = _core.types.memberExpression(_core.types.cloneNode(classRef), node.key, node.computed || _core.types.isLiteral(node.key)); let func = _core.types.functionExpression(null, node.params, node.body, node.generator, node.async); _core.types.inherits(func, node); const key = _core.types.toComputedKey(node, node.key); if (_core.types.isStringLiteral(key)) { var _nameFunction2; func = (_nameFunction2 = (0, _helperFunctionName.default)({ node: func, id: key, scope }, undefined, supportUnicodeId)) != null ? _nameFunction2 : func; } const expr = _core.types.expressionStatement(_core.types.assignmentExpression("=", methodName, func)); _core.types.inheritsComments(expr, node); classState.body.push(expr); return true; } return false; } function insertProtoAliasOnce() { if (classState.protoAlias === null) { setState({ protoAlias: classState.scope.generateUidIdentifier("proto") }); const classProto = _core.types.memberExpression(classState.classRef, _core.types.identifier("prototype")); const protoDeclaration = _core.types.variableDeclaration("var", [_core.types.variableDeclarator(classState.protoAlias, classProto)]); classState.body.push(protoDeclaration); } } function pushConstructor(superReturns, method, path) { setState({ userConstructorPath: path, userConstructor: method, hasConstructor: true, superReturns }); const { construct } = classState; _core.types.inheritsComments(construct, method); construct.params = method.params; _core.types.inherits(construct.body, method.body); construct.body.directives = method.body.directives; pushConstructorToBody(); } function pushConstructorToBody() { if (classState.pushedConstructor) return; classState.pushedConstructor = true; if (classState.hasInstanceDescriptors || classState.hasStaticDescriptors) { pushDescriptors(); } classState.body.push(classState.construct); pushInheritsToBody(); } function pushInheritsToBody() { if (!classState.isDerived || classState.pushedInherits) return; const superFnId = path.scope.generateUidIdentifier("super"); setState({ pushedInherits: true, superFnId }); if (!assumptions.superIsCallableConstructor) { classState.body.unshift(_core.types.variableDeclaration("var", [_core.types.variableDeclarator(superFnId, _core.types.callExpression((0, _inlineCreateSuperHelpers.default)(classState.file), [_core.types.cloneNode(classState.classRef)]))])); } classState.body.unshift(_core.types.expressionStatement(_core.types.callExpression(classState.file.addHelper(classState.isLoose ? "inheritsLoose" : "inherits"), [_core.types.cloneNode(classState.classRef), _core.types.cloneNode(classState.superName)]))); } function extractDynamicKeys() { const { dynamicKeys, node, scope } = classState; for (const elem of node.body.body) { if (!_core.types.isClassMethod(elem) || !elem.computed) continue; if (scope.isPure(elem.key, true)) continue; const id = scope.generateUidIdentifierBasedOnNode(elem.key); dynamicKeys.set(id.name, elem.key); elem.key = id; } } function setupClosureParamsArgs() { const { superName, dynamicKeys } = classState; const closureParams = []; const closureArgs = []; if (classState.isDerived) { let arg = _core.types.cloneNode(superName); if (classState.extendsNative) { arg = _core.types.callExpression(classState.file.addHelper("wrapNativeSuper"), [arg]); (0, _helperAnnotateAsPure.default)(arg); } const param = classState.scope.generateUidIdentifierBasedOnNode(superName); closureParams.push(param); closureArgs.push(arg); setState({ superName: _core.types.cloneNode(param) }); } for (const [name, value] of dynamicKeys) { closureParams.push(_core.types.identifier(name)); closureArgs.push(value); } return { closureParams, closureArgs }; } function classTransformer(path, file, builtinClasses, isLoose) { setState({ parent: path.parent, scope: path.scope, node: path.node, path, file, isLoose }); setState({ classId: classState.node.id, classRef: classState.node.id ? _core.types.identifier(classState.node.id.name) : classState.scope.generateUidIdentifier("class"), superName: classState.node.superClass, isDerived: !!classState.node.superClass, constructorBody: _core.types.blockStatement([]) }); setState({ extendsNative: _core.types.isIdentifier(classState.superName) && builtinClasses.has(classState.superName.name) && !classState.scope.hasBinding(classState.superName.name, true) }); const { classRef, node, constructorBody } = classState; setState({ construct: buildConstructor(classRef, constructorBody, node) }); extractDynamicKeys(); const { body } = classState; const { closureParams, closureArgs } = setupClosureParamsArgs(); buildBody(); if (!assumptions.noClassCalls) { constructorBody.body.unshift(_core.types.expressionStatement(_core.types.callExpression(classState.file.addHelper("classCallCheck"), [_core.types.thisExpression(), _core.types.cloneNode(classState.classRef)]))); } const isStrict = path.isInStrictMode(); let constructorOnly = classState.classId && body.length === 1; if (constructorOnly && !isStrict) { for (const param of classState.construct.params) { if (!_core.types.isIdentifier(param)) { constructorOnly = false; break; } } } const directives = constructorOnly ? body[0].body.directives : []; if (!isStrict) { directives.push(_core.types.directive(_core.types.directiveLiteral("use strict"))); } if (constructorOnly) { const expr = _core.types.toExpression(body[0]); return classState.isLoose ? expr : createClassHelper([expr]); } let returnArg = _core.types.cloneNode(classState.classRef); if (!classState.pushedCreateClass && !classState.isLoose) { returnArg = createClassHelper([returnArg]); } body.push(_core.types.returnStatement(returnArg)); const container = _core.types.arrowFunctionExpression(closureParams, _core.types.blockStatement(body, directives)); return _core.types.callExpression(container, closureArgs); } return classTransformer(path, file, builtinClasses, isLoose); } },{"./inline-createSuper-helpers":274,"@babel/core":30,"@babel/helper-annotate-as-pure":67,"@babel/helper-environment-visitor":76,"@babel/helper-function-name":77,"@babel/helper-optimise-call-expression":169,"@babel/helper-replace-supers":171}],276:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = void 0; var _helperPluginUtils = require("@babel/helper-plugin-utils"); var _core = require("@babel/core"); var _noHelperImplementation = require("./no-helper-implementation"); function buildLoopBody(path, declar, newBody) { let block; const bodyPath = path.get("body"); const body = newBody != null ? newBody : bodyPath.node; if (_core.types.isBlockStatement(body) && Object.keys(path.getBindingIdentifiers()).some(id => bodyPath.scope.hasOwnBinding(id))) { block = _core.types.blockStatement([declar, body]); } else { block = _core.types.toBlock(body); block.body.unshift(declar); } return block; } var _default = (0, _helperPluginUtils.declare)((api, options) => { var _options$assumeArray, _options$allowArrayLi, _api$assumption; api.assertVersion(7); { const { assumeArray, allowArrayLike, loose } = options; if (loose === true && assumeArray === true) { throw new Error(`The loose and assumeArray options cannot be used together in @babel/plugin-transform-for-of`); } if (assumeArray === true && allowArrayLike === true) { throw new Error(`The assumeArray and allowArrayLike options cannot be used together in @babel/plugin-transform-for-of`); } if (allowArrayLike && /^7\.\d\./.test(api.version)) { throw new Error(`The allowArrayLike is only supported when using @babel/core@^7.10.0`); } } const iterableIsArray = (_options$assumeArray = options.assumeArray) != null ? _options$assumeArray : !options.loose && api.assumption("iterableIsArray"); const arrayLikeIsIterable = (_options$allowArrayLi = options.allowArrayLike) != null ? _options$allowArrayLi : api.assumption("arrayLikeIsIterable"); const skipteratorClosing = (_api$assumption = api.assumption("skipForOfIteratorClosing")) != null ? _api$assumption : options.loose; if (iterableIsArray && arrayLikeIsIterable) { throw new Error(`The "iterableIsArray" and "arrayLikeIsIterable" assumptions are not compatible.`); } if (iterableIsArray) { return { name: "transform-for-of", visitor: { ForOfStatement(path) { const { scope } = path; const { left, right, await: isAwait } = path.node; if (isAwait) { return; } const i = scope.generateUidIdentifier("i"); let array = scope.maybeGenerateMemoised(right, true); const inits = [_core.types.variableDeclarator(i, _core.types.numericLiteral(0))]; if (array) { inits.push(_core.types.variableDeclarator(array, right)); } else { array = right; } const item = _core.types.memberExpression(_core.types.cloneNode(array), _core.types.cloneNode(i), true); let assignment; if (_core.types.isVariableDeclaration(left)) { assignment = left; assignment.declarations[0].init = item; } else { assignment = _core.types.expressionStatement(_core.types.assignmentExpression("=", left, item)); } path.replaceWith(_core.types.forStatement(_core.types.variableDeclaration("let", inits), _core.types.binaryExpression("<", _core.types.cloneNode(i), _core.types.memberExpression(_core.types.cloneNode(array), _core.types.identifier("length"))), _core.types.updateExpression("++", _core.types.cloneNode(i)), buildLoopBody(path, assignment))); } } }; } const buildForOfArray = (0, _core.template)` for (var KEY = 0, NAME = ARR; KEY < NAME.length; KEY++) BODY; `; const buildForOfNoIteratorClosing = _core.template.statements` for (var ITERATOR_HELPER = CREATE_ITERATOR_HELPER(OBJECT, ARRAY_LIKE_IS_ITERABLE), STEP_KEY; !(STEP_KEY = ITERATOR_HELPER()).done;) BODY; `; const buildForOf = _core.template.statements` var ITERATOR_HELPER = CREATE_ITERATOR_HELPER(OBJECT, ARRAY_LIKE_IS_ITERABLE), STEP_KEY; try { for (ITERATOR_HELPER.s(); !(STEP_KEY = ITERATOR_HELPER.n()).done;) BODY; } catch (err) { ITERATOR_HELPER.e(err); } finally { ITERATOR_HELPER.f(); } `; const builder = skipteratorClosing ? { build: buildForOfNoIteratorClosing, helper: "createForOfIteratorHelperLoose", getContainer: nodes => nodes } : { build: buildForOf, helper: "createForOfIteratorHelper", getContainer: nodes => nodes[1].block.body }; function _ForOfStatementArray(path) { const { node, scope } = path; const right = scope.generateUidIdentifierBasedOnNode(node.right, "arr"); const iterationKey = scope.generateUidIdentifier("i"); const loop = buildForOfArray({ BODY: node.body, KEY: iterationKey, NAME: right, ARR: node.right }); _core.types.inherits(loop, node); const iterationValue = _core.types.memberExpression(_core.types.cloneNode(right), _core.types.cloneNode(iterationKey), true); let declar; const left = node.left; if (_core.types.isVariableDeclaration(left)) { left.declarations[0].init = iterationValue; declar = left; } else { declar = _core.types.expressionStatement(_core.types.assignmentExpression("=", left, iterationValue)); } loop.body = buildLoopBody(path, declar, loop.body); return loop; } return { name: "transform-for-of", visitor: { ForOfStatement(path, state) { const right = path.get("right"); if (right.isArrayExpression() || right.isGenericType("Array") || _core.types.isArrayTypeAnnotation(right.getTypeAnnotation())) { path.replaceWith(_ForOfStatementArray(path)); return; } if (!state.availableHelper(builder.helper)) { (0, _noHelperImplementation.default)(skipteratorClosing, path, state); return; } const { node, parent, scope } = path; const left = node.left; let declar; const stepKey = scope.generateUid("step"); const stepValue = _core.types.memberExpression(_core.types.identifier(stepKey), _core.types.identifier("value")); if (_core.types.isVariableDeclaration(left)) { declar = _core.types.variableDeclaration(left.kind, [_core.types.variableDeclarator(left.declarations[0].id, stepValue)]); } else { declar = _core.types.expressionStatement(_core.types.assignmentExpression("=", left, stepValue)); } const nodes = builder.build({ CREATE_ITERATOR_HELPER: state.addHelper(builder.helper), ITERATOR_HELPER: scope.generateUidIdentifier("iterator"), ARRAY_LIKE_IS_ITERABLE: arrayLikeIsIterable ? _core.types.booleanLiteral(true) : null, STEP_KEY: _core.types.identifier(stepKey), OBJECT: node.right, BODY: buildLoopBody(path, declar) }); const container = builder.getContainer(nodes); _core.types.inherits(container[0], node); _core.types.inherits(container[0].body, node.body); if (_core.types.isLabeledStatement(parent)) { container[0] = _core.types.labeledStatement(parent.label, container[0]); path.parentPath.replaceWithMultiple(nodes); path.skip(); } else { path.replaceWithMultiple(nodes); } } } }; }); exports.default = _default; },{"./no-helper-implementation":277,"@babel/core":30,"@babel/helper-plugin-utils":170}],277:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = transformWithoutHelper; var _core = require("@babel/core"); function transformWithoutHelper(loose, path, state) { const pushComputedProps = loose ? pushComputedPropsLoose : pushComputedPropsSpec; const { node } = path; const build = pushComputedProps(path, state); const declar = build.declar; const loop = build.loop; const block = loop.body; path.ensureBlock(); if (declar) { block.body.push(declar); } block.body.push(...node.body.body); _core.types.inherits(loop, node); _core.types.inherits(loop.body, node.body); if (build.replaceParent) { path.parentPath.replaceWithMultiple(build.node); path.remove(); } else { path.replaceWithMultiple(build.node); } } const buildForOfLoose = _core.template.statement(` for (var LOOP_OBJECT = OBJECT, IS_ARRAY = Array.isArray(LOOP_OBJECT), INDEX = 0, LOOP_OBJECT = IS_ARRAY ? LOOP_OBJECT : LOOP_OBJECT[Symbol.iterator]();;) { INTERMEDIATE; if (IS_ARRAY) { if (INDEX >= LOOP_OBJECT.length) break; ID = LOOP_OBJECT[INDEX++]; } else { INDEX = LOOP_OBJECT.next(); if (INDEX.done) break; ID = INDEX.value; } } `); const buildForOf = _core.template.statements(` var ITERATOR_COMPLETION = true; var ITERATOR_HAD_ERROR_KEY = false; var ITERATOR_ERROR_KEY = undefined; try { for ( var ITERATOR_KEY = OBJECT[Symbol.iterator](), STEP_KEY; !(ITERATOR_COMPLETION = (STEP_KEY = ITERATOR_KEY.next()).done); ITERATOR_COMPLETION = true ) {} } catch (err) { ITERATOR_HAD_ERROR_KEY = true; ITERATOR_ERROR_KEY = err; } finally { try { if (!ITERATOR_COMPLETION && ITERATOR_KEY.return != null) { ITERATOR_KEY.return(); } } finally { if (ITERATOR_HAD_ERROR_KEY) { throw ITERATOR_ERROR_KEY; } } } `); function pushComputedPropsLoose(path, state) { const { node, scope, parent } = path; const { left } = node; let declar, id, intermediate; if (_core.types.isIdentifier(left) || _core.types.isPattern(left) || _core.types.isMemberExpression(left)) { id = left; intermediate = null; } else if (_core.types.isVariableDeclaration(left)) { id = scope.generateUidIdentifier("ref"); declar = _core.types.variableDeclaration(left.kind, [_core.types.variableDeclarator(left.declarations[0].id, _core.types.identifier(id.name))]); intermediate = _core.types.variableDeclaration("var", [_core.types.variableDeclarator(_core.types.identifier(id.name))]); } else { throw state.buildCodeFrameError(left, `Unknown node type ${left.type} in ForStatement`); } const iteratorKey = scope.generateUidIdentifier("iterator"); const isArrayKey = scope.generateUidIdentifier("isArray"); const loop = buildForOfLoose({ LOOP_OBJECT: iteratorKey, IS_ARRAY: isArrayKey, OBJECT: node.right, INDEX: scope.generateUidIdentifier("i"), ID: id, INTERMEDIATE: intermediate }); const isLabeledParent = _core.types.isLabeledStatement(parent); let labeled; if (isLabeledParent) { labeled = _core.types.labeledStatement(parent.label, loop); } return { replaceParent: isLabeledParent, declar: declar, node: labeled || loop, loop: loop }; } function pushComputedPropsSpec(path, state) { const { node, scope, parent } = path; const left = node.left; let declar; const stepKey = scope.generateUid("step"); const stepValue = _core.types.memberExpression(_core.types.identifier(stepKey), _core.types.identifier("value")); if (_core.types.isIdentifier(left) || _core.types.isPattern(left) || _core.types.isMemberExpression(left)) { declar = _core.types.expressionStatement(_core.types.assignmentExpression("=", left, stepValue)); } else if (_core.types.isVariableDeclaration(left)) { declar = _core.types.variableDeclaration(left.kind, [_core.types.variableDeclarator(left.declarations[0].id, stepValue)]); } else { throw state.buildCodeFrameError(left, `Unknown node type ${left.type} in ForStatement`); } const template = buildForOf({ ITERATOR_HAD_ERROR_KEY: scope.generateUidIdentifier("didIteratorError"), ITERATOR_COMPLETION: scope.generateUidIdentifier("iteratorNormalCompletion"), ITERATOR_ERROR_KEY: scope.generateUidIdentifier("iteratorError"), ITERATOR_KEY: scope.generateUidIdentifier("iterator"), STEP_KEY: _core.types.identifier(stepKey), OBJECT: node.right }); const isLabeledParent = _core.types.isLabeledStatement(parent); const tryBody = template[3].block.body; const loop = tryBody[0]; if (isLabeledParent) { tryBody[0] = _core.types.labeledStatement(parent.label, loop); } return { replaceParent: isLabeledParent, declar: declar, loop: loop, node: template }; } },{"@babel/core":30}],278:[function(require,module,exports){ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } module.exports = _interopRequireDefault; module.exports["default"] = module.exports, module.exports.__esModule = true; },{}],279:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = createTemplateBuilder; var _options = require("./options"); var _string = require("./string"); var _literal = require("./literal"); const NO_PLACEHOLDER = (0, _options.validate)({ placeholderPattern: false }); function createTemplateBuilder(formatter, defaultOpts) { const templateFnCache = new WeakMap(); const templateAstCache = new WeakMap(); const cachedOpts = defaultOpts || (0, _options.validate)(null); return Object.assign((tpl, ...args) => { if (typeof tpl === "string") { if (args.length > 1) throw new Error("Unexpected extra params."); return extendedTrace((0, _string.default)(formatter, tpl, (0, _options.merge)(cachedOpts, (0, _options.validate)(args[0])))); } else if (Array.isArray(tpl)) { let builder = templateFnCache.get(tpl); if (!builder) { builder = (0, _literal.default)(formatter, tpl, cachedOpts); templateFnCache.set(tpl, builder); } return extendedTrace(builder(args)); } else if (typeof tpl === "object" && tpl) { if (args.length > 0) throw new Error("Unexpected extra params."); return createTemplateBuilder(formatter, (0, _options.merge)(cachedOpts, (0, _options.validate)(tpl))); } throw new Error(`Unexpected template param ${typeof tpl}`); }, { ast: (tpl, ...args) => { if (typeof tpl === "string") { if (args.length > 1) throw new Error("Unexpected extra params."); return (0, _string.default)(formatter, tpl, (0, _options.merge)((0, _options.merge)(cachedOpts, (0, _options.validate)(args[0])), NO_PLACEHOLDER))(); } else if (Array.isArray(tpl)) { let builder = templateAstCache.get(tpl); if (!builder) { builder = (0, _literal.default)(formatter, tpl, (0, _options.merge)(cachedOpts, NO_PLACEHOLDER)); templateAstCache.set(tpl, builder); } return builder(args)(); } throw new Error(`Unexpected template param ${typeof tpl}`); } }); } function extendedTrace(fn) { let rootStack = ""; try { throw new Error(); } catch (error) { if (error.stack) { rootStack = error.stack.split("\n").slice(3).join("\n"); } } return arg => { try { return fn(arg); } catch (err) { err.stack += `\n =============\n${rootStack}`; throw err; } }; } },{"./literal":282,"./options":283,"./string":286}],280:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.statements = exports.statement = exports.smart = exports.program = exports.expression = void 0; var _t = require("@babel/types"); const { assertExpressionStatement } = _t; function makeStatementFormatter(fn) { return { code: str => `/* @babel/template */;\n${str}`, validate: () => {}, unwrap: ast => { return fn(ast.program.body.slice(1)); } }; } const smart = makeStatementFormatter(body => { if (body.length > 1) { return body; } else { return body[0]; } }); exports.smart = smart; const statements = makeStatementFormatter(body => body); exports.statements = statements; const statement = makeStatementFormatter(body => { if (body.length === 0) { throw new Error("Found nothing to return."); } if (body.length > 1) { throw new Error("Found multiple statements but wanted one"); } return body[0]; }); exports.statement = statement; const expression = { code: str => `(\n${str}\n)`, validate: ast => { if (ast.program.body.length > 1) { throw new Error("Found multiple statements but wanted one"); } if (expression.unwrap(ast).start === 0) { throw new Error("Parse result included parens."); } }, unwrap: ({ program }) => { const [stmt] = program.body; assertExpressionStatement(stmt); return stmt.expression; } }; exports.expression = expression; const program = { code: str => str, validate: () => {}, unwrap: ast => ast.program }; exports.program = program; },{"@babel/types":359}],281:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.statements = exports.statement = exports.smart = exports.program = exports.expression = exports.default = void 0; var formatters = require("./formatters"); var _builder = require("./builder"); const smart = (0, _builder.default)(formatters.smart); exports.smart = smart; const statement = (0, _builder.default)(formatters.statement); exports.statement = statement; const statements = (0, _builder.default)(formatters.statements); exports.statements = statements; const expression = (0, _builder.default)(formatters.expression); exports.expression = expression; const program = (0, _builder.default)(formatters.program); exports.program = program; var _default = Object.assign(smart.bind(undefined), { smart, statement, statements, expression, program, ast: smart.ast }); exports.default = _default; },{"./builder":279,"./formatters":280}],282:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = literalTemplate; var _options = require("./options"); var _parse = require("./parse"); var _populate = require("./populate"); function literalTemplate(formatter, tpl, opts) { const { metadata, names } = buildLiteralData(formatter, tpl, opts); return arg => { const defaultReplacements = {}; arg.forEach((replacement, i) => { defaultReplacements[names[i]] = replacement; }); return arg => { const replacements = (0, _options.normalizeReplacements)(arg); if (replacements) { Object.keys(replacements).forEach(key => { if (Object.prototype.hasOwnProperty.call(defaultReplacements, key)) { throw new Error("Unexpected replacement overlap."); } }); } return formatter.unwrap((0, _populate.default)(metadata, replacements ? Object.assign(replacements, defaultReplacements) : defaultReplacements)); }; }; } function buildLiteralData(formatter, tpl, opts) { let names; let nameSet; let metadata; let prefix = ""; do { prefix += "$"; const result = buildTemplateCode(tpl, prefix); names = result.names; nameSet = new Set(names); metadata = (0, _parse.default)(formatter, formatter.code(result.code), { parser: opts.parser, placeholderWhitelist: new Set(result.names.concat(opts.placeholderWhitelist ? Array.from(opts.placeholderWhitelist) : [])), placeholderPattern: opts.placeholderPattern, preserveComments: opts.preserveComments, syntacticPlaceholders: opts.syntacticPlaceholders }); } while (metadata.placeholders.some(placeholder => placeholder.isDuplicate && nameSet.has(placeholder.name))); return { metadata, names }; } function buildTemplateCode(tpl, prefix) { const names = []; let code = tpl[0]; for (let i = 1; i < tpl.length; i++) { const value = `${prefix}${i - 1}`; names.push(value); code += value + tpl[i]; } return { names, code }; } },{"./options":283,"./parse":284,"./populate":285}],283:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.merge = merge; exports.normalizeReplacements = normalizeReplacements; exports.validate = validate; const _excluded = ["placeholderWhitelist", "placeholderPattern", "preserveComments", "syntacticPlaceholders"]; function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } function merge(a, b) { const { placeholderWhitelist = a.placeholderWhitelist, placeholderPattern = a.placeholderPattern, preserveComments = a.preserveComments, syntacticPlaceholders = a.syntacticPlaceholders } = b; return { parser: Object.assign({}, a.parser, b.parser), placeholderWhitelist, placeholderPattern, preserveComments, syntacticPlaceholders }; } function validate(opts) { if (opts != null && typeof opts !== "object") { throw new Error("Unknown template options."); } const _ref = opts || {}, { placeholderWhitelist, placeholderPattern, preserveComments, syntacticPlaceholders } = _ref, parser = _objectWithoutPropertiesLoose(_ref, _excluded); if (placeholderWhitelist != null && !(placeholderWhitelist instanceof Set)) { throw new Error("'.placeholderWhitelist' must be a Set, null, or undefined"); } if (placeholderPattern != null && !(placeholderPattern instanceof RegExp) && placeholderPattern !== false) { throw new Error("'.placeholderPattern' must be a RegExp, false, null, or undefined"); } if (preserveComments != null && typeof preserveComments !== "boolean") { throw new Error("'.preserveComments' must be a boolean, null, or undefined"); } if (syntacticPlaceholders != null && typeof syntacticPlaceholders !== "boolean") { throw new Error("'.syntacticPlaceholders' must be a boolean, null, or undefined"); } if (syntacticPlaceholders === true && (placeholderWhitelist != null || placeholderPattern != null)) { throw new Error("'.placeholderWhitelist' and '.placeholderPattern' aren't compatible" + " with '.syntacticPlaceholders: true'"); } return { parser, placeholderWhitelist: placeholderWhitelist || undefined, placeholderPattern: placeholderPattern == null ? undefined : placeholderPattern, preserveComments: preserveComments == null ? undefined : preserveComments, syntacticPlaceholders: syntacticPlaceholders == null ? undefined : syntacticPlaceholders }; } function normalizeReplacements(replacements) { if (Array.isArray(replacements)) { return replacements.reduce((acc, replacement, i) => { acc["$" + i] = replacement; return acc; }, {}); } else if (typeof replacements === "object" || replacements == null) { return replacements || undefined; } throw new Error("Template replacements must be an array, object, null, or undefined"); } },{}],284:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = parseAndBuildMetadata; var _t = require("@babel/types"); var _parser = require("@babel/parser"); var _codeFrame = require("@babel/code-frame"); const { isCallExpression, isExpressionStatement, isFunction, isIdentifier, isJSXIdentifier, isNewExpression, isPlaceholder, isStatement, isStringLiteral, removePropertiesDeep, traverse } = _t; const PATTERN = /^[_$A-Z0-9]+$/; function parseAndBuildMetadata(formatter, code, opts) { const { placeholderWhitelist, placeholderPattern, preserveComments, syntacticPlaceholders } = opts; const ast = parseWithCodeFrame(code, opts.parser, syntacticPlaceholders); removePropertiesDeep(ast, { preserveComments }); formatter.validate(ast); const syntactic = { placeholders: [], placeholderNames: new Set() }; const legacy = { placeholders: [], placeholderNames: new Set() }; const isLegacyRef = { value: undefined }; traverse(ast, placeholderVisitorHandler, { syntactic, legacy, isLegacyRef, placeholderWhitelist, placeholderPattern, syntacticPlaceholders }); return Object.assign({ ast }, isLegacyRef.value ? legacy : syntactic); } function placeholderVisitorHandler(node, ancestors, state) { var _state$placeholderWhi; let name; if (isPlaceholder(node)) { if (state.syntacticPlaceholders === false) { throw new Error("%%foo%%-style placeholders can't be used when " + "'.syntacticPlaceholders' is false."); } else { name = node.name.name; state.isLegacyRef.value = false; } } else if (state.isLegacyRef.value === false || state.syntacticPlaceholders) { return; } else if (isIdentifier(node) || isJSXIdentifier(node)) { name = node.name; state.isLegacyRef.value = true; } else if (isStringLiteral(node)) { name = node.value; state.isLegacyRef.value = true; } else { return; } if (!state.isLegacyRef.value && (state.placeholderPattern != null || state.placeholderWhitelist != null)) { throw new Error("'.placeholderWhitelist' and '.placeholderPattern' aren't compatible" + " with '.syntacticPlaceholders: true'"); } if (state.isLegacyRef.value && (state.placeholderPattern === false || !(state.placeholderPattern || PATTERN).test(name)) && !((_state$placeholderWhi = state.placeholderWhitelist) != null && _state$placeholderWhi.has(name))) { return; } ancestors = ancestors.slice(); const { node: parent, key } = ancestors[ancestors.length - 1]; let type; if (isStringLiteral(node) || isPlaceholder(node, { expectedNode: "StringLiteral" })) { type = "string"; } else if (isNewExpression(parent) && key === "arguments" || isCallExpression(parent) && key === "arguments" || isFunction(parent) && key === "params") { type = "param"; } else if (isExpressionStatement(parent) && !isPlaceholder(node)) { type = "statement"; ancestors = ancestors.slice(0, -1); } else if (isStatement(node) && isPlaceholder(node)) { type = "statement"; } else { type = "other"; } const { placeholders, placeholderNames } = state.isLegacyRef.value ? state.legacy : state.syntactic; placeholders.push({ name, type, resolve: ast => resolveAncestors(ast, ancestors), isDuplicate: placeholderNames.has(name) }); placeholderNames.add(name); } function resolveAncestors(ast, ancestors) { let parent = ast; for (let i = 0; i < ancestors.length - 1; i++) { const { key, index } = ancestors[i]; if (index === undefined) { parent = parent[key]; } else { parent = parent[key][index]; } } const { key, index } = ancestors[ancestors.length - 1]; return { parent, key, index }; } function parseWithCodeFrame(code, parserOpts, syntacticPlaceholders) { const plugins = (parserOpts.plugins || []).slice(); if (syntacticPlaceholders !== false) { plugins.push("placeholders"); } parserOpts = Object.assign({ allowReturnOutsideFunction: true, allowSuperOutsideMethod: true, sourceType: "module" }, parserOpts, { plugins }); try { return (0, _parser.parse)(code, parserOpts); } catch (err) { const loc = err.loc; if (loc) { err.message += "\n" + (0, _codeFrame.codeFrameColumns)(code, { start: loc }); err.code = "BABEL_TEMPLATE_PARSE_ERROR"; } throw err; } } },{"@babel/code-frame":4,"@babel/parser":266,"@babel/types":359}],285:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = populatePlaceholders; var _t = require("@babel/types"); const { blockStatement, cloneNode, emptyStatement, expressionStatement, identifier, isStatement, isStringLiteral, stringLiteral, validate } = _t; function populatePlaceholders(metadata, replacements) { const ast = cloneNode(metadata.ast); if (replacements) { metadata.placeholders.forEach(placeholder => { if (!Object.prototype.hasOwnProperty.call(replacements, placeholder.name)) { const placeholderName = placeholder.name; throw new Error(`Error: No substitution given for "${placeholderName}". If this is not meant to be a placeholder you may want to consider passing one of the following options to @babel/template: - { placeholderPattern: false, placeholderWhitelist: new Set(['${placeholderName}'])} - { placeholderPattern: /^${placeholderName}$/ }`); } }); Object.keys(replacements).forEach(key => { if (!metadata.placeholderNames.has(key)) { throw new Error(`Unknown substitution "${key}" given`); } }); } metadata.placeholders.slice().reverse().forEach(placeholder => { try { applyReplacement(placeholder, ast, replacements && replacements[placeholder.name] || null); } catch (e) { e.message = `@babel/template placeholder "${placeholder.name}": ${e.message}`; throw e; } }); return ast; } function applyReplacement(placeholder, ast, replacement) { if (placeholder.isDuplicate) { if (Array.isArray(replacement)) { replacement = replacement.map(node => cloneNode(node)); } else if (typeof replacement === "object") { replacement = cloneNode(replacement); } } const { parent, key, index } = placeholder.resolve(ast); if (placeholder.type === "string") { if (typeof replacement === "string") { replacement = stringLiteral(replacement); } if (!replacement || !isStringLiteral(replacement)) { throw new Error("Expected string substitution"); } } else if (placeholder.type === "statement") { if (index === undefined) { if (!replacement) { replacement = emptyStatement(); } else if (Array.isArray(replacement)) { replacement = blockStatement(replacement); } else if (typeof replacement === "string") { replacement = expressionStatement(identifier(replacement)); } else if (!isStatement(replacement)) { replacement = expressionStatement(replacement); } } else { if (replacement && !Array.isArray(replacement)) { if (typeof replacement === "string") { replacement = identifier(replacement); } if (!isStatement(replacement)) { replacement = expressionStatement(replacement); } } } } else if (placeholder.type === "param") { if (typeof replacement === "string") { replacement = identifier(replacement); } if (index === undefined) throw new Error("Assertion failure."); } else { if (typeof replacement === "string") { replacement = identifier(replacement); } if (Array.isArray(replacement)) { throw new Error("Cannot replace single expression with an array."); } } if (index === undefined) { validate(parent, key, replacement); parent[key] = replacement; } else { const items = parent[key].slice(); if (placeholder.type === "statement" || placeholder.type === "param") { if (replacement == null) { items.splice(index, 1); } else if (Array.isArray(replacement)) { items.splice(index, 1, ...replacement); } else { items[index] = replacement; } } else { items[index] = replacement; } validate(parent, key, items); parent[key] = items; } } },{"@babel/types":359}],286:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = stringTemplate; var _options = require("./options"); var _parse = require("./parse"); var _populate = require("./populate"); function stringTemplate(formatter, code, opts) { code = formatter.code(code); let metadata; return arg => { const replacements = (0, _options.normalizeReplacements)(arg); if (!metadata) metadata = (0, _parse.default)(formatter, code, opts); return formatter.unwrap((0, _populate.default)(metadata, replacements)); }; } },{"./options":283,"./parse":284,"./populate":285}],287:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.clear = clear; exports.clearPath = clearPath; exports.clearScope = clearScope; exports.scope = exports.path = void 0; let path = new WeakMap(); exports.path = path; let scope = new WeakMap(); exports.scope = scope; function clear() { clearPath(); clearScope(); } function clearPath() { exports.path = path = new WeakMap(); } function clearScope() { exports.scope = scope = new WeakMap(); } },{}],288:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = void 0; var _path = require("./path"); var _t = require("@babel/types"); const { VISITOR_KEYS } = _t; class TraversalContext { constructor(scope, opts, state, parentPath) { this.queue = null; this.priorityQueue = null; this.parentPath = parentPath; this.scope = scope; this.state = state; this.opts = opts; } shouldVisit(node) { const opts = this.opts; if (opts.enter || opts.exit) return true; if (opts[node.type]) return true; const keys = VISITOR_KEYS[node.type]; if (!(keys != null && keys.length)) return false; for (const key of keys) { if (node[key]) { return true; } } return false; } create(node, container, key, listKey) { return _path.default.get({ parentPath: this.parentPath, parent: node, container, key: key, listKey }); } maybeQueue(path, notPriority) { if (this.queue) { if (notPriority) { this.queue.push(path); } else { this.priorityQueue.push(path); } } } visitMultiple(container, parent, listKey) { if (container.length === 0) return false; const queue = []; for (let key = 0; key < container.length; key++) { const node = container[key]; if (node && this.shouldVisit(node)) { queue.push(this.create(parent, container, key, listKey)); } } return this.visitQueue(queue); } visitSingle(node, key) { if (this.shouldVisit(node[key])) { return this.visitQueue([this.create(node, node, key)]); } else { return false; } } visitQueue(queue) { this.queue = queue; this.priorityQueue = []; const visited = new WeakSet(); let stop = false; for (const path of queue) { path.resync(); if (path.contexts.length === 0 || path.contexts[path.contexts.length - 1] !== this) { path.pushContext(this); } if (path.key === null) continue; const { node } = path; if (visited.has(node)) continue; if (node) visited.add(node); if (path.visit()) { stop = true; break; } if (this.priorityQueue.length) { stop = this.visitQueue(this.priorityQueue); this.priorityQueue = []; this.queue = queue; if (stop) break; } } for (const path of queue) { path.popContext(); } this.queue = null; return stop; } visit(node, key) { const nodes = node[key]; if (!nodes) return false; if (Array.isArray(nodes)) { return this.visitMultiple(nodes, node, key); } else { return this.visitSingle(node, key); } } } exports.default = TraversalContext; },{"./path":297,"@babel/types":359}],289:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = void 0; class Hub { getCode() {} getScope() {} addHelper() { throw new Error("Helpers are not supported by the default hub."); } buildError(node, msg, Error = TypeError) { return new Error(msg); } } exports.default = Hub; },{}],290:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); Object.defineProperty(exports, "Hub", { enumerable: true, get: function () { return _hub.default; } }); Object.defineProperty(exports, "NodePath", { enumerable: true, get: function () { return _path.default; } }); Object.defineProperty(exports, "Scope", { enumerable: true, get: function () { return _scope.default; } }); exports.visitors = exports.default = void 0; var visitors = require("./visitors"); exports.visitors = visitors; var _t = require("@babel/types"); var cache = require("./cache"); var _traverseNode = require("./traverse-node"); var _path = require("./path"); var _scope = require("./scope"); var _hub = require("./hub"); const { VISITOR_KEYS, removeProperties, traverseFast } = _t; function traverse(parent, opts = {}, scope, state, parentPath) { if (!parent) return; if (!opts.noScope && !scope) { if (parent.type !== "Program" && parent.type !== "File") { throw new Error("You must pass a scope and parentPath unless traversing a Program/File. " + `Instead of that you tried to traverse a ${parent.type} node without ` + "passing scope and parentPath."); } } if (!VISITOR_KEYS[parent.type]) { return; } visitors.explode(opts); (0, _traverseNode.traverseNode)(parent, opts, scope, state, parentPath); } var _default = traverse; exports.default = _default; traverse.visitors = visitors; traverse.verify = visitors.verify; traverse.explode = visitors.explode; traverse.cheap = function (node, enter) { return traverseFast(node, enter); }; traverse.node = function (node, opts, scope, state, path, skipKeys) { (0, _traverseNode.traverseNode)(node, opts, scope, state, path, skipKeys); }; traverse.clearNode = function (node, opts) { removeProperties(node, opts); cache.path.delete(node); }; traverse.removeProperties = function (tree, opts) { traverseFast(tree, traverse.clearNode, opts); return tree; }; function hasDenylistedType(path, state) { if (path.node.type === state.type) { state.has = true; path.stop(); } } traverse.hasType = function (tree, type, denylistTypes) { if (denylistTypes != null && denylistTypes.includes(tree.type)) return false; if (tree.type === type) return true; const state = { has: false, type: type }; traverse(tree, { noScope: true, denylist: denylistTypes, enter: hasDenylistedType }, null, state); return state.has; }; traverse.cache = cache; },{"./cache":287,"./hub":289,"./path":297,"./scope":311,"./traverse-node":313,"./visitors":314,"@babel/types":359}],291:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.find = find; exports.findParent = findParent; exports.getAncestry = getAncestry; exports.getDeepestCommonAncestorFrom = getDeepestCommonAncestorFrom; exports.getEarliestCommonAncestorFrom = getEarliestCommonAncestorFrom; exports.getFunctionParent = getFunctionParent; exports.getStatementParent = getStatementParent; exports.inType = inType; exports.isAncestor = isAncestor; exports.isDescendant = isDescendant; var _t = require("@babel/types"); const { VISITOR_KEYS } = _t; function findParent(callback) { let path = this; while (path = path.parentPath) { if (callback(path)) return path; } return null; } function find(callback) { let path = this; do { if (callback(path)) return path; } while (path = path.parentPath); return null; } function getFunctionParent() { return this.findParent(p => p.isFunction()); } function getStatementParent() { let path = this; do { if (!path.parentPath || Array.isArray(path.container) && path.isStatement()) { break; } else { path = path.parentPath; } } while (path); if (path && (path.isProgram() || path.isFile())) { throw new Error("File/Program node, we can't possibly find a statement parent to this"); } return path; } function getEarliestCommonAncestorFrom(paths) { return this.getDeepestCommonAncestorFrom(paths, function (deepest, i, ancestries) { let earliest; const keys = VISITOR_KEYS[deepest.type]; for (const ancestry of ancestries) { const path = ancestry[i + 1]; if (!earliest) { earliest = path; continue; } if (path.listKey && earliest.listKey === path.listKey) { if (path.key < earliest.key) { earliest = path; continue; } } const earliestKeyIndex = keys.indexOf(earliest.parentKey); const currentKeyIndex = keys.indexOf(path.parentKey); if (earliestKeyIndex > currentKeyIndex) { earliest = path; } } return earliest; }); } function getDeepestCommonAncestorFrom(paths, filter) { if (!paths.length) { return this; } if (paths.length === 1) { return paths[0]; } let minDepth = Infinity; let lastCommonIndex, lastCommon; const ancestries = paths.map(path => { const ancestry = []; do { ancestry.unshift(path); } while ((path = path.parentPath) && path !== this); if (ancestry.length < minDepth) { minDepth = ancestry.length; } return ancestry; }); const first = ancestries[0]; depthLoop: for (let i = 0; i < minDepth; i++) { const shouldMatch = first[i]; for (const ancestry of ancestries) { if (ancestry[i] !== shouldMatch) { break depthLoop; } } lastCommonIndex = i; lastCommon = shouldMatch; } if (lastCommon) { if (filter) { return filter(lastCommon, lastCommonIndex, ancestries); } else { return lastCommon; } } else { throw new Error("Couldn't find intersection"); } } function getAncestry() { let path = this; const paths = []; do { paths.push(path); } while (path = path.parentPath); return paths; } function isAncestor(maybeDescendant) { return maybeDescendant.isDescendant(this); } function isDescendant(maybeAncestor) { return !!this.findParent(parent => parent === maybeAncestor); } function inType(...candidateTypes) { let path = this; while (path) { for (const type of candidateTypes) { if (path.node.type === type) return true; } path = path.parentPath; } return false; } },{"@babel/types":359}],292:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.addComment = addComment; exports.addComments = addComments; exports.shareCommentsWithSiblings = shareCommentsWithSiblings; var _t = require("@babel/types"); const { addComment: _addComment, addComments: _addComments } = _t; function shareCommentsWithSiblings() { if (typeof this.key === "string") return; const node = this.node; if (!node) return; const trailing = node.trailingComments; const leading = node.leadingComments; if (!trailing && !leading) return; const prev = this.getSibling(this.key - 1); const next = this.getSibling(this.key + 1); const hasPrev = Boolean(prev.node); const hasNext = Boolean(next.node); if (hasPrev && !hasNext) { prev.addComments("trailing", trailing); } else if (hasNext && !hasPrev) { next.addComments("leading", leading); } } function addComment(type, content, line) { _addComment(this.node, type, content, line); } function addComments(type, comments) { _addComments(this.node, type, comments); } },{"@babel/types":359}],293:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports._call = _call; exports._getQueueContexts = _getQueueContexts; exports._resyncKey = _resyncKey; exports._resyncList = _resyncList; exports._resyncParent = _resyncParent; exports._resyncRemoved = _resyncRemoved; exports.call = call; exports.isBlacklisted = exports.isDenylisted = isDenylisted; exports.popContext = popContext; exports.pushContext = pushContext; exports.requeue = requeue; exports.resync = resync; exports.setContext = setContext; exports.setKey = setKey; exports.setScope = setScope; exports.setup = setup; exports.skip = skip; exports.skipKey = skipKey; exports.stop = stop; exports.visit = visit; var _traverseNode = require("../traverse-node"); var _index = require("./index"); function call(key) { const opts = this.opts; this.debug(key); if (this.node) { if (this._call(opts[key])) return true; } if (this.node) { return this._call(opts[this.node.type] && opts[this.node.type][key]); } return false; } function _call(fns) { if (!fns) return false; for (const fn of fns) { if (!fn) continue; const node = this.node; if (!node) return true; const ret = fn.call(this.state, this, this.state); if (ret && typeof ret === "object" && typeof ret.then === "function") { throw new Error(`You appear to be using a plugin with an async traversal visitor, ` + `which your current version of Babel does not support. ` + `If you're using a published plugin, you may need to upgrade ` + `your @babel/core version.`); } if (ret) { throw new Error(`Unexpected return value from visitor method ${fn}`); } if (this.node !== node) return true; if (this._traverseFlags > 0) return true; } return false; } function isDenylisted() { var _this$opts$denylist; const denylist = (_this$opts$denylist = this.opts.denylist) != null ? _this$opts$denylist : this.opts.blacklist; return denylist && denylist.indexOf(this.node.type) > -1; } function restoreContext(path, context) { if (path.context !== context) { path.context = context; path.state = context.state; path.opts = context.opts; } } function visit() { if (!this.node) { return false; } if (this.isDenylisted()) { return false; } if (this.opts.shouldSkip && this.opts.shouldSkip(this)) { return false; } const currentContext = this.context; if (this.shouldSkip || this.call("enter")) { this.debug("Skip..."); return this.shouldStop; } restoreContext(this, currentContext); this.debug("Recursing into..."); this.shouldStop = (0, _traverseNode.traverseNode)(this.node, this.opts, this.scope, this.state, this, this.skipKeys); restoreContext(this, currentContext); this.call("exit"); return this.shouldStop; } function skip() { this.shouldSkip = true; } function skipKey(key) { if (this.skipKeys == null) { this.skipKeys = {}; } this.skipKeys[key] = true; } function stop() { this._traverseFlags |= _index.SHOULD_SKIP | _index.SHOULD_STOP; } function setScope() { if (this.opts && this.opts.noScope) return; let path = this.parentPath; if ((this.key === "key" || this.listKey === "decorators") && path.isMethod()) { path = path.parentPath; } let target; while (path && !target) { if (path.opts && path.opts.noScope) return; target = path.scope; path = path.parentPath; } this.scope = this.getScope(target); if (this.scope) this.scope.init(); } function setContext(context) { if (this.skipKeys != null) { this.skipKeys = {}; } this._traverseFlags = 0; if (context) { this.context = context; this.state = context.state; this.opts = context.opts; } this.setScope(); return this; } function resync() { if (this.removed) return; this._resyncParent(); this._resyncList(); this._resyncKey(); } function _resyncParent() { if (this.parentPath) { this.parent = this.parentPath.node; } } function _resyncKey() { if (!this.container) return; if (this.node === this.container[this.key]) { return; } if (Array.isArray(this.container)) { for (let i = 0; i < this.container.length; i++) { if (this.container[i] === this.node) { return this.setKey(i); } } } else { for (const key of Object.keys(this.container)) { if (this.container[key] === this.node) { return this.setKey(key); } } } this.key = null; } function _resyncList() { if (!this.parent || !this.inList) return; const newContainer = this.parent[this.listKey]; if (this.container === newContainer) return; this.container = newContainer || null; } function _resyncRemoved() { if (this.key == null || !this.container || this.container[this.key] !== this.node) { this._markRemoved(); } } function popContext() { this.contexts.pop(); if (this.contexts.length > 0) { this.setContext(this.contexts[this.contexts.length - 1]); } else { this.setContext(undefined); } } function pushContext(context) { this.contexts.push(context); this.setContext(context); } function setup(parentPath, container, listKey, key) { this.listKey = listKey; this.container = container; this.parentPath = parentPath || this.parentPath; this.setKey(key); } function setKey(key) { var _this$node; this.key = key; this.node = this.container[this.key]; this.type = (_this$node = this.node) == null ? void 0 : _this$node.type; } function requeue(pathToQueue = this) { if (pathToQueue.removed) return; ; const contexts = this.contexts; for (const context of contexts) { context.maybeQueue(pathToQueue); } } function _getQueueContexts() { let path = this; let contexts = this.contexts; while (!contexts.length) { path = path.parentPath; if (!path) break; contexts = path.contexts; } return contexts; } },{"../traverse-node":313,"./index":297}],294:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.arrowFunctionToExpression = arrowFunctionToExpression; exports.arrowFunctionToShadowed = arrowFunctionToShadowed; exports.ensureBlock = ensureBlock; exports.toComputedKey = toComputedKey; exports.unwrapFunctionEnvironment = unwrapFunctionEnvironment; var _t = require("@babel/types"); var _helperEnvironmentVisitor = require("@babel/helper-environment-visitor"); var _helperFunctionName = require("@babel/helper-function-name"); var _visitors = require("../visitors"); const { arrowFunctionExpression, assignmentExpression, binaryExpression, blockStatement, callExpression, conditionalExpression, expressionStatement, identifier, isIdentifier, jsxIdentifier, logicalExpression, LOGICAL_OPERATORS, memberExpression, metaProperty, numericLiteral, objectExpression, restElement, returnStatement, sequenceExpression, spreadElement, stringLiteral, super: _super, thisExpression, toExpression, unaryExpression } = _t; function toComputedKey() { let key; if (this.isMemberExpression()) { key = this.node.property; } else if (this.isProperty() || this.isMethod()) { key = this.node.key; } else { throw new ReferenceError("todo"); } if (!this.node.computed) { if (isIdentifier(key)) key = stringLiteral(key.name); } return key; } function ensureBlock() { const body = this.get("body"); const bodyNode = body.node; if (Array.isArray(body)) { throw new Error("Can't convert array path to a block statement"); } if (!bodyNode) { throw new Error("Can't convert node without a body"); } if (body.isBlockStatement()) { return bodyNode; } const statements = []; let stringPath = "body"; let key; let listKey; if (body.isStatement()) { listKey = "body"; key = 0; statements.push(body.node); } else { stringPath += ".body.0"; if (this.isFunction()) { key = "argument"; statements.push(returnStatement(body.node)); } else { key = "expression"; statements.push(expressionStatement(body.node)); } } this.node.body = blockStatement(statements); const parentPath = this.get(stringPath); body.setup(parentPath, listKey ? parentPath.node[listKey] : parentPath.node, listKey, key); return this.node; } function arrowFunctionToShadowed() { if (!this.isArrowFunctionExpression()) return; this.arrowFunctionToExpression(); } function unwrapFunctionEnvironment() { if (!this.isArrowFunctionExpression() && !this.isFunctionExpression() && !this.isFunctionDeclaration()) { throw this.buildCodeFrameError("Can only unwrap the environment of a function."); } hoistFunctionEnvironment(this); } function setType(path, type) { path.node.type = type; } function arrowFunctionToExpression({ allowInsertArrow = true, specCompliant = false, noNewArrows = !specCompliant } = {}) { if (!this.isArrowFunctionExpression()) { throw this.buildCodeFrameError("Cannot convert non-arrow function to a function expression."); } const { thisBinding, fnPath: fn } = hoistFunctionEnvironment(this, noNewArrows, allowInsertArrow); fn.ensureBlock(); setType(fn, "FunctionExpression"); if (!noNewArrows) { const checkBinding = thisBinding ? null : fn.scope.generateUidIdentifier("arrowCheckId"); if (checkBinding) { fn.parentPath.scope.push({ id: checkBinding, init: objectExpression([]) }); } fn.get("body").unshiftContainer("body", expressionStatement(callExpression(this.hub.addHelper("newArrowCheck"), [thisExpression(), checkBinding ? identifier(checkBinding.name) : identifier(thisBinding)]))); fn.replaceWith(callExpression(memberExpression((0, _helperFunctionName.default)(this, true) || fn.node, identifier("bind")), [checkBinding ? identifier(checkBinding.name) : thisExpression()])); return fn.get("callee.object"); } return fn; } const getSuperCallsVisitor = (0, _visitors.merge)([{ CallExpression(child, { allSuperCalls }) { if (!child.get("callee").isSuper()) return; allSuperCalls.push(child); } }, _helperEnvironmentVisitor.default]); function hoistFunctionEnvironment(fnPath, noNewArrows = true, allowInsertArrow = true) { let arrowParent; let thisEnvFn = fnPath.findParent(p => { if (p.isArrowFunctionExpression()) { var _arrowParent; (_arrowParent = arrowParent) != null ? _arrowParent : arrowParent = p; return false; } return p.isFunction() || p.isProgram() || p.isClassProperty({ static: false }) || p.isClassPrivateProperty({ static: false }); }); const inConstructor = thisEnvFn.isClassMethod({ kind: "constructor" }); if (thisEnvFn.isClassProperty() || thisEnvFn.isClassPrivateProperty()) { if (arrowParent) { thisEnvFn = arrowParent; } else if (allowInsertArrow) { fnPath.replaceWith(callExpression(arrowFunctionExpression([], toExpression(fnPath.node)), [])); thisEnvFn = fnPath.get("callee"); fnPath = thisEnvFn.get("body"); } else { throw fnPath.buildCodeFrameError("Unable to transform arrow inside class property"); } } const { thisPaths, argumentsPaths, newTargetPaths, superProps, superCalls } = getScopeInformation(fnPath); if (inConstructor && superCalls.length > 0) { if (!allowInsertArrow) { throw superCalls[0].buildCodeFrameError("Unable to handle nested super() usage in arrow"); } const allSuperCalls = []; thisEnvFn.traverse(getSuperCallsVisitor, { allSuperCalls }); const superBinding = getSuperBinding(thisEnvFn); allSuperCalls.forEach(superCall => { const callee = identifier(superBinding); callee.loc = superCall.node.callee.loc; superCall.get("callee").replaceWith(callee); }); } if (argumentsPaths.length > 0) { const argumentsBinding = getBinding(thisEnvFn, "arguments", () => { const args = () => identifier("arguments"); if (thisEnvFn.scope.path.isProgram()) { return conditionalExpression(binaryExpression("===", unaryExpression("typeof", args()), stringLiteral("undefined")), thisEnvFn.scope.buildUndefinedNode(), args()); } else { return args(); } }); argumentsPaths.forEach(argumentsChild => { const argsRef = identifier(argumentsBinding); argsRef.loc = argumentsChild.node.loc; argumentsChild.replaceWith(argsRef); }); } if (newTargetPaths.length > 0) { const newTargetBinding = getBinding(thisEnvFn, "newtarget", () => metaProperty(identifier("new"), identifier("target"))); newTargetPaths.forEach(targetChild => { const targetRef = identifier(newTargetBinding); targetRef.loc = targetChild.node.loc; targetChild.replaceWith(targetRef); }); } if (superProps.length > 0) { if (!allowInsertArrow) { throw superProps[0].buildCodeFrameError("Unable to handle nested super.prop usage"); } const flatSuperProps = superProps.reduce((acc, superProp) => acc.concat(standardizeSuperProperty(superProp)), []); flatSuperProps.forEach(superProp => { const key = superProp.node.computed ? "" : superProp.get("property").node.name; const superParentPath = superProp.parentPath; const isAssignment = superParentPath.isAssignmentExpression({ left: superProp.node }); const isCall = superParentPath.isCallExpression({ callee: superProp.node }); const superBinding = getSuperPropBinding(thisEnvFn, isAssignment, key); const args = []; if (superProp.node.computed) { args.push(superProp.get("property").node); } if (isAssignment) { const value = superParentPath.node.right; args.push(value); } const call = callExpression(identifier(superBinding), args); if (isCall) { superParentPath.unshiftContainer("arguments", thisExpression()); superProp.replaceWith(memberExpression(call, identifier("call"))); thisPaths.push(superParentPath.get("arguments.0")); } else if (isAssignment) { superParentPath.replaceWith(call); } else { superProp.replaceWith(call); } }); } let thisBinding; if (thisPaths.length > 0 || !noNewArrows) { thisBinding = getThisBinding(thisEnvFn, inConstructor); if (noNewArrows || inConstructor && hasSuperClass(thisEnvFn)) { thisPaths.forEach(thisChild => { const thisRef = thisChild.isJSX() ? jsxIdentifier(thisBinding) : identifier(thisBinding); thisRef.loc = thisChild.node.loc; thisChild.replaceWith(thisRef); }); if (!noNewArrows) thisBinding = null; } } return { thisBinding, fnPath }; } function isLogicalOp(op) { return LOGICAL_OPERATORS.includes(op); } function standardizeSuperProperty(superProp) { if (superProp.parentPath.isAssignmentExpression() && superProp.parentPath.node.operator !== "=") { const assignmentPath = superProp.parentPath; const op = assignmentPath.node.operator.slice(0, -1); const value = assignmentPath.node.right; const isLogicalAssignment = isLogicalOp(op); if (superProp.node.computed) { const tmp = superProp.scope.generateDeclaredUidIdentifier("tmp"); const object = superProp.node.object; const property = superProp.node.property; assignmentPath.get("left").replaceWith(memberExpression(object, assignmentExpression("=", tmp, property), true)); assignmentPath.get("right").replaceWith(rightExpression(isLogicalAssignment ? "=" : op, memberExpression(object, identifier(tmp.name), true), value)); } else { const object = superProp.node.object; const property = superProp.node.property; assignmentPath.get("left").replaceWith(memberExpression(object, property)); assignmentPath.get("right").replaceWith(rightExpression(isLogicalAssignment ? "=" : op, memberExpression(object, identifier(property.name)), value)); } if (isLogicalAssignment) { assignmentPath.replaceWith(logicalExpression(op, assignmentPath.node.left, assignmentPath.node.right)); } else { assignmentPath.node.operator = "="; } return [assignmentPath.get("left"), assignmentPath.get("right").get("left")]; } else if (superProp.parentPath.isUpdateExpression()) { const updateExpr = superProp.parentPath; const tmp = superProp.scope.generateDeclaredUidIdentifier("tmp"); const computedKey = superProp.node.computed ? superProp.scope.generateDeclaredUidIdentifier("prop") : null; const parts = [assignmentExpression("=", tmp, memberExpression(superProp.node.object, computedKey ? assignmentExpression("=", computedKey, superProp.node.property) : superProp.node.property, superProp.node.computed)), assignmentExpression("=", memberExpression(superProp.node.object, computedKey ? identifier(computedKey.name) : superProp.node.property, superProp.node.computed), binaryExpression(superProp.parentPath.node.operator[0], identifier(tmp.name), numericLiteral(1)))]; if (!superProp.parentPath.node.prefix) { parts.push(identifier(tmp.name)); } updateExpr.replaceWith(sequenceExpression(parts)); const left = updateExpr.get("expressions.0.right"); const right = updateExpr.get("expressions.1.left"); return [left, right]; } return [superProp]; function rightExpression(op, left, right) { if (op === "=") { return assignmentExpression("=", left, right); } else { return binaryExpression(op, left, right); } } } function hasSuperClass(thisEnvFn) { return thisEnvFn.isClassMethod() && !!thisEnvFn.parentPath.parentPath.node.superClass; } const assignSuperThisVisitor = (0, _visitors.merge)([{ CallExpression(child, { supers, thisBinding }) { if (!child.get("callee").isSuper()) return; if (supers.has(child.node)) return; supers.add(child.node); child.replaceWithMultiple([child.node, assignmentExpression("=", identifier(thisBinding), identifier("this"))]); } }, _helperEnvironmentVisitor.default]); function getThisBinding(thisEnvFn, inConstructor) { return getBinding(thisEnvFn, "this", thisBinding => { if (!inConstructor || !hasSuperClass(thisEnvFn)) return thisExpression(); thisEnvFn.traverse(assignSuperThisVisitor, { supers: new WeakSet(), thisBinding }); }); } function getSuperBinding(thisEnvFn) { return getBinding(thisEnvFn, "supercall", () => { const argsBinding = thisEnvFn.scope.generateUidIdentifier("args"); return arrowFunctionExpression([restElement(argsBinding)], callExpression(_super(), [spreadElement(identifier(argsBinding.name))])); }); } function getSuperPropBinding(thisEnvFn, isAssignment, propName) { const op = isAssignment ? "set" : "get"; return getBinding(thisEnvFn, `superprop_${op}:${propName || ""}`, () => { const argsList = []; let fnBody; if (propName) { fnBody = memberExpression(_super(), identifier(propName)); } else { const method = thisEnvFn.scope.generateUidIdentifier("prop"); argsList.unshift(method); fnBody = memberExpression(_super(), identifier(method.name), true); } if (isAssignment) { const valueIdent = thisEnvFn.scope.generateUidIdentifier("value"); argsList.push(valueIdent); fnBody = assignmentExpression("=", fnBody, identifier(valueIdent.name)); } return arrowFunctionExpression(argsList, fnBody); }); } function getBinding(thisEnvFn, key, init) { const cacheKey = "binding:" + key; let data = thisEnvFn.getData(cacheKey); if (!data) { const id = thisEnvFn.scope.generateUidIdentifier(key); data = id.name; thisEnvFn.setData(cacheKey, data); thisEnvFn.scope.push({ id: id, init: init(data) }); } return data; } const getScopeInformationVisitor = (0, _visitors.merge)([{ ThisExpression(child, { thisPaths }) { thisPaths.push(child); }, JSXIdentifier(child, { thisPaths }) { if (child.node.name !== "this") return; if (!child.parentPath.isJSXMemberExpression({ object: child.node }) && !child.parentPath.isJSXOpeningElement({ name: child.node })) { return; } thisPaths.push(child); }, CallExpression(child, { superCalls }) { if (child.get("callee").isSuper()) superCalls.push(child); }, MemberExpression(child, { superProps }) { if (child.get("object").isSuper()) superProps.push(child); }, Identifier(child, { argumentsPaths }) { if (!child.isReferencedIdentifier({ name: "arguments" })) return; let curr = child.scope; do { if (curr.hasOwnBinding("arguments")) { curr.rename("arguments"); return; } if (curr.path.isFunction() && !curr.path.isArrowFunctionExpression()) { break; } } while (curr = curr.parent); argumentsPaths.push(child); }, MetaProperty(child, { newTargetPaths }) { if (!child.get("meta").isIdentifier({ name: "new" })) return; if (!child.get("property").isIdentifier({ name: "target" })) return; newTargetPaths.push(child); } }, _helperEnvironmentVisitor.default]); function getScopeInformation(fnPath) { const thisPaths = []; const argumentsPaths = []; const newTargetPaths = []; const superProps = []; const superCalls = []; fnPath.traverse(getScopeInformationVisitor, { thisPaths, argumentsPaths, newTargetPaths, superProps, superCalls }); return { thisPaths, argumentsPaths, newTargetPaths, superProps, superCalls }; } },{"../visitors":314,"@babel/helper-environment-visitor":76,"@babel/helper-function-name":77,"@babel/types":359}],295:[function(require,module,exports){ (function (global){(function (){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.evaluate = evaluate; exports.evaluateTruthy = evaluateTruthy; const VALID_CALLEES = ["String", "Number", "Math"]; const INVALID_METHODS = ["random"]; function isValidCallee(val) { return VALID_CALLEES.includes(val); } function isInvalidMethod(val) { return INVALID_METHODS.includes(val); } function evaluateTruthy() { const res = this.evaluate(); if (res.confident) return !!res.value; } function deopt(path, state) { if (!state.confident) return; state.deoptPath = path; state.confident = false; } function evaluateCached(path, state) { const { node } = path; const { seen } = state; if (seen.has(node)) { const existing = seen.get(node); if (existing.resolved) { return existing.value; } else { deopt(path, state); return; } } else { const item = { resolved: false }; seen.set(node, item); const val = _evaluate(path, state); if (state.confident) { item.resolved = true; item.value = val; } return val; } } function _evaluate(path, state) { if (!state.confident) return; if (path.isSequenceExpression()) { const exprs = path.get("expressions"); return evaluateCached(exprs[exprs.length - 1], state); } if (path.isStringLiteral() || path.isNumericLiteral() || path.isBooleanLiteral()) { return path.node.value; } if (path.isNullLiteral()) { return null; } if (path.isTemplateLiteral()) { return evaluateQuasis(path, path.node.quasis, state); } if (path.isTaggedTemplateExpression() && path.get("tag").isMemberExpression()) { const object = path.get("tag.object"); const { node: { name } } = object; const property = path.get("tag.property"); if (object.isIdentifier() && name === "String" && !path.scope.getBinding(name) && property.isIdentifier() && property.node.name === "raw") { return evaluateQuasis(path, path.node.quasi.quasis, state, true); } } if (path.isConditionalExpression()) { const testResult = evaluateCached(path.get("test"), state); if (!state.confident) return; if (testResult) { return evaluateCached(path.get("consequent"), state); } else { return evaluateCached(path.get("alternate"), state); } } if (path.isExpressionWrapper()) { return evaluateCached(path.get("expression"), state); } if (path.isMemberExpression() && !path.parentPath.isCallExpression({ callee: path.node })) { const property = path.get("property"); const object = path.get("object"); if (object.isLiteral() && property.isIdentifier()) { const value = object.node.value; const type = typeof value; if (type === "number" || type === "string") { return value[property.node.name]; } } } if (path.isReferencedIdentifier()) { const binding = path.scope.getBinding(path.node.name); if (binding && binding.constantViolations.length > 0) { return deopt(binding.path, state); } if (binding && path.node.start < binding.path.node.end) { return deopt(binding.path, state); } if (binding != null && binding.hasValue) { return binding.value; } else { if (path.node.name === "undefined") { return binding ? deopt(binding.path, state) : undefined; } else if (path.node.name === "Infinity") { return binding ? deopt(binding.path, state) : Infinity; } else if (path.node.name === "NaN") { return binding ? deopt(binding.path, state) : NaN; } const resolved = path.resolve(); if (resolved === path) { return deopt(path, state); } else { return evaluateCached(resolved, state); } } } if (path.isUnaryExpression({ prefix: true })) { if (path.node.operator === "void") { return undefined; } const argument = path.get("argument"); if (path.node.operator === "typeof" && (argument.isFunction() || argument.isClass())) { return "function"; } const arg = evaluateCached(argument, state); if (!state.confident) return; switch (path.node.operator) { case "!": return !arg; case "+": return +arg; case "-": return -arg; case "~": return ~arg; case "typeof": return typeof arg; } } if (path.isArrayExpression()) { const arr = []; const elems = path.get("elements"); for (const elem of elems) { const elemValue = elem.evaluate(); if (elemValue.confident) { arr.push(elemValue.value); } else { return deopt(elemValue.deopt, state); } } return arr; } if (path.isObjectExpression()) { const obj = {}; const props = path.get("properties"); for (const prop of props) { if (prop.isObjectMethod() || prop.isSpreadElement()) { return deopt(prop, state); } const keyPath = prop.get("key"); let key; if (prop.node.computed) { key = keyPath.evaluate(); if (!key.confident) { return deopt(key.deopt, state); } key = key.value; } else if (keyPath.isIdentifier()) { key = keyPath.node.name; } else { key = keyPath.node.value; } const valuePath = prop.get("value"); let value = valuePath.evaluate(); if (!value.confident) { return deopt(value.deopt, state); } value = value.value; obj[key] = value; } return obj; } if (path.isLogicalExpression()) { const wasConfident = state.confident; const left = evaluateCached(path.get("left"), state); const leftConfident = state.confident; state.confident = wasConfident; const right = evaluateCached(path.get("right"), state); const rightConfident = state.confident; switch (path.node.operator) { case "||": state.confident = leftConfident && (!!left || rightConfident); if (!state.confident) return; return left || right; case "&&": state.confident = leftConfident && (!left || rightConfident); if (!state.confident) return; return left && right; case "??": state.confident = leftConfident && (left != null || rightConfident); if (!state.confident) return; return left != null ? left : right; } } if (path.isBinaryExpression()) { const left = evaluateCached(path.get("left"), state); if (!state.confident) return; const right = evaluateCached(path.get("right"), state); if (!state.confident) return; switch (path.node.operator) { case "-": return left - right; case "+": return left + right; case "/": return left / right; case "*": return left * right; case "%": return left % right; case "**": return Math.pow(left, right); case "<": return left < right; case ">": return left > right; case "<=": return left <= right; case ">=": return left >= right; case "==": return left == right; case "!=": return left != right; case "===": return left === right; case "!==": return left !== right; case "|": return left | right; case "&": return left & right; case "^": return left ^ right; case "<<": return left << right; case ">>": return left >> right; case ">>>": return left >>> right; } } if (path.isCallExpression()) { const callee = path.get("callee"); let context; let func; if (callee.isIdentifier() && !path.scope.getBinding(callee.node.name) && isValidCallee(callee.node.name)) { func = global[callee.node.name]; } if (callee.isMemberExpression()) { const object = callee.get("object"); const property = callee.get("property"); if (object.isIdentifier() && property.isIdentifier() && isValidCallee(object.node.name) && !isInvalidMethod(property.node.name)) { context = global[object.node.name]; func = context[property.node.name]; } if (object.isLiteral() && property.isIdentifier()) { const type = typeof object.node.value; if (type === "string" || type === "number") { context = object.node.value; func = context[property.node.name]; } } } if (func) { const args = path.get("arguments").map(arg => evaluateCached(arg, state)); if (!state.confident) return; return func.apply(context, args); } } deopt(path, state); } function evaluateQuasis(path, quasis, state, raw = false) { let str = ""; let i = 0; const exprs = path.get("expressions"); for (const elem of quasis) { if (!state.confident) break; str += raw ? elem.value.raw : elem.value.cooked; const expr = exprs[i++]; if (expr) str += String(evaluateCached(expr, state)); } if (!state.confident) return; return str; } function evaluate() { const state = { confident: true, deoptPath: null, seen: new Map() }; let value = evaluateCached(this, state); if (!state.confident) value = undefined; return { confident: state.confident, deopt: state.deoptPath, value: value }; } }).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) },{}],296:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports._getKey = _getKey; exports._getPattern = _getPattern; exports.get = get; exports.getAllNextSiblings = getAllNextSiblings; exports.getAllPrevSiblings = getAllPrevSiblings; exports.getBindingIdentifierPaths = getBindingIdentifierPaths; exports.getBindingIdentifiers = getBindingIdentifiers; exports.getCompletionRecords = getCompletionRecords; exports.getNextSibling = getNextSibling; exports.getOpposite = getOpposite; exports.getOuterBindingIdentifierPaths = getOuterBindingIdentifierPaths; exports.getOuterBindingIdentifiers = getOuterBindingIdentifiers; exports.getPrevSibling = getPrevSibling; exports.getSibling = getSibling; var _index = require("./index"); var _t = require("@babel/types"); const { getBindingIdentifiers: _getBindingIdentifiers, getOuterBindingIdentifiers: _getOuterBindingIdentifiers, isDeclaration, numericLiteral, unaryExpression } = _t; const NORMAL_COMPLETION = 0; const BREAK_COMPLETION = 1; function NormalCompletion(path) { return { type: NORMAL_COMPLETION, path }; } function BreakCompletion(path) { return { type: BREAK_COMPLETION, path }; } function getOpposite() { if (this.key === "left") { return this.getSibling("right"); } else if (this.key === "right") { return this.getSibling("left"); } return null; } function addCompletionRecords(path, records, context) { if (path) { records.push(..._getCompletionRecords(path, context)); } return records; } function completionRecordForSwitch(cases, records, context) { let lastNormalCompletions = []; for (let i = 0; i < cases.length; i++) { const casePath = cases[i]; const caseCompletions = _getCompletionRecords(casePath, context); const normalCompletions = []; const breakCompletions = []; for (const c of caseCompletions) { if (c.type === NORMAL_COMPLETION) { normalCompletions.push(c); } if (c.type === BREAK_COMPLETION) { breakCompletions.push(c); } } if (normalCompletions.length) { lastNormalCompletions = normalCompletions; } records.push(...breakCompletions); } records.push(...lastNormalCompletions); return records; } function normalCompletionToBreak(completions) { completions.forEach(c => { c.type = BREAK_COMPLETION; }); } function replaceBreakStatementInBreakCompletion(completions, reachable) { completions.forEach(c => { if (c.path.isBreakStatement({ label: null })) { if (reachable) { c.path.replaceWith(unaryExpression("void", numericLiteral(0))); } else { c.path.remove(); } } }); } function getStatementListCompletion(paths, context) { const completions = []; if (context.canHaveBreak) { let lastNormalCompletions = []; for (let i = 0; i < paths.length; i++) { const path = paths[i]; const newContext = Object.assign({}, context, { inCaseClause: false }); if (path.isBlockStatement() && (context.inCaseClause || context.shouldPopulateBreak)) { newContext.shouldPopulateBreak = true; } else { newContext.shouldPopulateBreak = false; } const statementCompletions = _getCompletionRecords(path, newContext); if (statementCompletions.length > 0 && statementCompletions.every(c => c.type === BREAK_COMPLETION)) { if (lastNormalCompletions.length > 0 && statementCompletions.every(c => c.path.isBreakStatement({ label: null }))) { normalCompletionToBreak(lastNormalCompletions); completions.push(...lastNormalCompletions); if (lastNormalCompletions.some(c => c.path.isDeclaration())) { completions.push(...statementCompletions); replaceBreakStatementInBreakCompletion(statementCompletions, true); } replaceBreakStatementInBreakCompletion(statementCompletions, false); } else { completions.push(...statementCompletions); if (!context.shouldPopulateBreak) { replaceBreakStatementInBreakCompletion(statementCompletions, true); } } break; } if (i === paths.length - 1) { completions.push(...statementCompletions); } else { lastNormalCompletions = []; for (let i = 0; i < statementCompletions.length; i++) { const c = statementCompletions[i]; if (c.type === BREAK_COMPLETION) { completions.push(c); } if (c.type === NORMAL_COMPLETION) { lastNormalCompletions.push(c); } } } } } else if (paths.length) { for (let i = paths.length - 1; i >= 0; i--) { const pathCompletions = _getCompletionRecords(paths[i], context); if (pathCompletions.length > 1 || pathCompletions.length === 1 && !pathCompletions[0].path.isVariableDeclaration()) { completions.push(...pathCompletions); break; } } } return completions; } function _getCompletionRecords(path, context) { let records = []; if (path.isIfStatement()) { records = addCompletionRecords(path.get("consequent"), records, context); records = addCompletionRecords(path.get("alternate"), records, context); } else if (path.isDoExpression() || path.isFor() || path.isWhile() || path.isLabeledStatement()) { return addCompletionRecords(path.get("body"), records, context); } else if (path.isProgram() || path.isBlockStatement()) { return getStatementListCompletion(path.get("body"), context); } else if (path.isFunction()) { return _getCompletionRecords(path.get("body"), context); } else if (path.isTryStatement()) { records = addCompletionRecords(path.get("block"), records, context); records = addCompletionRecords(path.get("handler"), records, context); } else if (path.isCatchClause()) { return addCompletionRecords(path.get("body"), records, context); } else if (path.isSwitchStatement()) { return completionRecordForSwitch(path.get("cases"), records, context); } else if (path.isSwitchCase()) { return getStatementListCompletion(path.get("consequent"), { canHaveBreak: true, shouldPopulateBreak: false, inCaseClause: true }); } else if (path.isBreakStatement()) { records.push(BreakCompletion(path)); } else { records.push(NormalCompletion(path)); } return records; } function getCompletionRecords() { const records = _getCompletionRecords(this, { canHaveBreak: false, shouldPopulateBreak: false, inCaseClause: false }); return records.map(r => r.path); } function getSibling(key) { return _index.default.get({ parentPath: this.parentPath, parent: this.parent, container: this.container, listKey: this.listKey, key: key }).setContext(this.context); } function getPrevSibling() { return this.getSibling(this.key - 1); } function getNextSibling() { return this.getSibling(this.key + 1); } function getAllNextSiblings() { let _key = this.key; let sibling = this.getSibling(++_key); const siblings = []; while (sibling.node) { siblings.push(sibling); sibling = this.getSibling(++_key); } return siblings; } function getAllPrevSiblings() { let _key = this.key; let sibling = this.getSibling(--_key); const siblings = []; while (sibling.node) { siblings.push(sibling); sibling = this.getSibling(--_key); } return siblings; } function get(key, context = true) { if (context === true) context = this.context; const parts = key.split("."); if (parts.length === 1) { return this._getKey(key, context); } else { return this._getPattern(parts, context); } } function _getKey(key, context) { const node = this.node; const container = node[key]; if (Array.isArray(container)) { return container.map((_, i) => { return _index.default.get({ listKey: key, parentPath: this, parent: node, container: container, key: i }).setContext(context); }); } else { return _index.default.get({ parentPath: this, parent: node, container: node, key: key }).setContext(context); } } function _getPattern(parts, context) { let path = this; for (const part of parts) { if (part === ".") { path = path.parentPath; } else { if (Array.isArray(path)) { path = path[part]; } else { path = path.get(part, context); } } } return path; } function getBindingIdentifiers(duplicates) { return _getBindingIdentifiers(this.node, duplicates); } function getOuterBindingIdentifiers(duplicates) { return _getOuterBindingIdentifiers(this.node, duplicates); } function getBindingIdentifierPaths(duplicates = false, outerOnly = false) { const path = this; const search = [path]; const ids = Object.create(null); while (search.length) { const id = search.shift(); if (!id) continue; if (!id.node) continue; const keys = _getBindingIdentifiers.keys[id.node.type]; if (id.isIdentifier()) { if (duplicates) { const _ids = ids[id.node.name] = ids[id.node.name] || []; _ids.push(id); } else { ids[id.node.name] = id; } continue; } if (id.isExportDeclaration()) { const declaration = id.get("declaration"); if (isDeclaration(declaration)) { search.push(declaration); } continue; } if (outerOnly) { if (id.isFunctionDeclaration()) { search.push(id.get("id")); continue; } if (id.isFunctionExpression()) { continue; } } if (keys) { for (let i = 0; i < keys.length; i++) { const key = keys[i]; const child = id.get(key); if (Array.isArray(child)) { search.push(...child); } else if (child.node) { search.push(child); } } } } return ids; } function getOuterBindingIdentifierPaths(duplicates = false) { return this.getBindingIdentifierPaths(duplicates, true); } },{"./index":297,"@babel/types":359}],297:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = exports.SHOULD_STOP = exports.SHOULD_SKIP = exports.REMOVED = void 0; var virtualTypes = require("./lib/virtual-types"); var _debug = require("debug"); var _index = require("../index"); var _scope = require("../scope"); var _t = require("@babel/types"); var t = _t; var _cache = require("../cache"); var _generator = require("@babel/generator"); var NodePath_ancestry = require("./ancestry"); var NodePath_inference = require("./inference"); var NodePath_replacement = require("./replacement"); var NodePath_evaluation = require("./evaluation"); var NodePath_conversion = require("./conversion"); var NodePath_introspection = require("./introspection"); var NodePath_context = require("./context"); var NodePath_removal = require("./removal"); var NodePath_modification = require("./modification"); var NodePath_family = require("./family"); var NodePath_comments = require("./comments"); var NodePath_virtual_types_validator = require("./lib/virtual-types-validator"); const { validate } = _t; const debug = _debug("babel"); const REMOVED = 1 << 0; exports.REMOVED = REMOVED; const SHOULD_STOP = 1 << 1; exports.SHOULD_STOP = SHOULD_STOP; const SHOULD_SKIP = 1 << 2; exports.SHOULD_SKIP = SHOULD_SKIP; class NodePath { constructor(hub, parent) { this.contexts = []; this.state = null; this.opts = null; this._traverseFlags = 0; this.skipKeys = null; this.parentPath = null; this.container = null; this.listKey = null; this.key = null; this.node = null; this.type = null; this.parent = parent; this.hub = hub; this.data = null; this.context = null; this.scope = null; } static get({ hub, parentPath, parent, container, listKey, key }) { if (!hub && parentPath) { hub = parentPath.hub; } if (!parent) { throw new Error("To get a node path the parent needs to exist"); } const targetNode = container[key]; let paths = _cache.path.get(parent); if (!paths) { paths = new Map(); _cache.path.set(parent, paths); } let path = paths.get(targetNode); if (!path) { path = new NodePath(hub, parent); if (targetNode) paths.set(targetNode, path); } path.setup(parentPath, container, listKey, key); return path; } getScope(scope) { return this.isScope() ? new _scope.default(this) : scope; } setData(key, val) { if (this.data == null) { this.data = Object.create(null); } return this.data[key] = val; } getData(key, def) { if (this.data == null) { this.data = Object.create(null); } let val = this.data[key]; if (val === undefined && def !== undefined) val = this.data[key] = def; return val; } hasNode() { return this.node != null; } buildCodeFrameError(msg, Error = SyntaxError) { return this.hub.buildError(this.node, msg, Error); } traverse(visitor, state) { (0, _index.default)(this.node, visitor, this.scope, state, this); } set(key, node) { validate(this.node, key, node); this.node[key] = node; } getPathLocation() { const parts = []; let path = this; do { let key = path.key; if (path.inList) key = `${path.listKey}[${key}]`; parts.unshift(key); } while (path = path.parentPath); return parts.join("."); } debug(message) { if (!debug.enabled) return; debug(`${this.getPathLocation()} ${this.type}: ${message}`); } toString() { return (0, _generator.default)(this.node).code; } get inList() { return !!this.listKey; } set inList(inList) { if (!inList) { this.listKey = null; } } get parentKey() { return this.listKey || this.key; } get shouldSkip() { return !!(this._traverseFlags & SHOULD_SKIP); } set shouldSkip(v) { if (v) { this._traverseFlags |= SHOULD_SKIP; } else { this._traverseFlags &= ~SHOULD_SKIP; } } get shouldStop() { return !!(this._traverseFlags & SHOULD_STOP); } set shouldStop(v) { if (v) { this._traverseFlags |= SHOULD_STOP; } else { this._traverseFlags &= ~SHOULD_STOP; } } get removed() { return !!(this._traverseFlags & REMOVED); } set removed(v) { if (v) { this._traverseFlags |= REMOVED; } else { this._traverseFlags &= ~REMOVED; } } } Object.assign(NodePath.prototype, NodePath_ancestry, NodePath_inference, NodePath_replacement, NodePath_evaluation, NodePath_conversion, NodePath_introspection, NodePath_context, NodePath_removal, NodePath_modification, NodePath_family, NodePath_comments); { NodePath.prototype._guessExecutionStatusRelativeToDifferentFunctions = NodePath_introspection._guessExecutionStatusRelativeTo; } for (const type of t.TYPES) { const typeKey = `is${type}`; const fn = t[typeKey]; NodePath.prototype[typeKey] = function (opts) { return fn(this.node, opts); }; NodePath.prototype[`assert${type}`] = function (opts) { if (!fn(this.node, opts)) { throw new TypeError(`Expected node path of type ${type}`); } }; } Object.assign(NodePath.prototype, NodePath_virtual_types_validator); for (const type of Object.keys(virtualTypes)) { if (type[0] === "_") continue; if (!t.TYPES.includes(type)) t.TYPES.push(type); } var _default = NodePath; exports.default = _default; },{"../cache":287,"../index":290,"../scope":311,"./ancestry":291,"./comments":292,"./context":293,"./conversion":294,"./evaluation":295,"./family":296,"./inference":298,"./introspection":302,"./lib/virtual-types":306,"./lib/virtual-types-validator":305,"./modification":307,"./removal":308,"./replacement":309,"@babel/generator":61,"@babel/types":359,"debug":430}],298:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports._getTypeAnnotation = _getTypeAnnotation; exports.baseTypeStrictlyMatches = baseTypeStrictlyMatches; exports.couldBeBaseType = couldBeBaseType; exports.getTypeAnnotation = getTypeAnnotation; exports.isBaseType = isBaseType; exports.isGenericType = isGenericType; var inferers = require("./inferers"); var _t = require("@babel/types"); const { anyTypeAnnotation, isAnyTypeAnnotation, isArrayTypeAnnotation, isBooleanTypeAnnotation, isEmptyTypeAnnotation, isFlowBaseAnnotation, isGenericTypeAnnotation, isIdentifier, isMixedTypeAnnotation, isNumberTypeAnnotation, isStringTypeAnnotation, isTSArrayType, isTSTypeAnnotation, isTSTypeReference, isTupleTypeAnnotation, isTypeAnnotation, isUnionTypeAnnotation, isVoidTypeAnnotation, stringTypeAnnotation, voidTypeAnnotation } = _t; function getTypeAnnotation() { let type = this.getData("typeAnnotation"); if (type != null) { return type; } type = this._getTypeAnnotation() || anyTypeAnnotation(); if (isTypeAnnotation(type) || isTSTypeAnnotation(type)) { type = type.typeAnnotation; } this.setData("typeAnnotation", type); return type; } const typeAnnotationInferringNodes = new WeakSet(); function _getTypeAnnotation() { const node = this.node; if (!node) { if (this.key === "init" && this.parentPath.isVariableDeclarator()) { const declar = this.parentPath.parentPath; const declarParent = declar.parentPath; if (declar.key === "left" && declarParent.isForInStatement()) { return stringTypeAnnotation(); } if (declar.key === "left" && declarParent.isForOfStatement()) { return anyTypeAnnotation(); } return voidTypeAnnotation(); } else { return; } } if (node.typeAnnotation) { return node.typeAnnotation; } if (typeAnnotationInferringNodes.has(node)) { return; } typeAnnotationInferringNodes.add(node); try { var _inferer; let inferer = inferers[node.type]; if (inferer) { return inferer.call(this, node); } inferer = inferers[this.parentPath.type]; if ((_inferer = inferer) != null && _inferer.validParent) { return this.parentPath.getTypeAnnotation(); } } finally { typeAnnotationInferringNodes.delete(node); } } function isBaseType(baseName, soft) { return _isBaseType(baseName, this.getTypeAnnotation(), soft); } function _isBaseType(baseName, type, soft) { if (baseName === "string") { return isStringTypeAnnotation(type); } else if (baseName === "number") { return isNumberTypeAnnotation(type); } else if (baseName === "boolean") { return isBooleanTypeAnnotation(type); } else if (baseName === "any") { return isAnyTypeAnnotation(type); } else if (baseName === "mixed") { return isMixedTypeAnnotation(type); } else if (baseName === "empty") { return isEmptyTypeAnnotation(type); } else if (baseName === "void") { return isVoidTypeAnnotation(type); } else { if (soft) { return false; } else { throw new Error(`Unknown base type ${baseName}`); } } } function couldBeBaseType(name) { const type = this.getTypeAnnotation(); if (isAnyTypeAnnotation(type)) return true; if (isUnionTypeAnnotation(type)) { for (const type2 of type.types) { if (isAnyTypeAnnotation(type2) || _isBaseType(name, type2, true)) { return true; } } return false; } else { return _isBaseType(name, type, true); } } function baseTypeStrictlyMatches(rightArg) { const left = this.getTypeAnnotation(); const right = rightArg.getTypeAnnotation(); if (!isAnyTypeAnnotation(left) && isFlowBaseAnnotation(left)) { return right.type === left.type; } return false; } function isGenericType(genericName) { const type = this.getTypeAnnotation(); if (genericName === "Array") { if (isTSArrayType(type) || isArrayTypeAnnotation(type) || isTupleTypeAnnotation(type)) { return true; } } return isGenericTypeAnnotation(type) && isIdentifier(type.id, { name: genericName }) || isTSTypeReference(type) && isIdentifier(type.typeName, { name: genericName }); } },{"./inferers":300,"@babel/types":359}],299:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = _default; var _t = require("@babel/types"); var _util = require("./util"); const { BOOLEAN_NUMBER_BINARY_OPERATORS, createTypeAnnotationBasedOnTypeof, numberTypeAnnotation, voidTypeAnnotation } = _t; function _default(node) { if (!this.isReferenced()) return; const binding = this.scope.getBinding(node.name); if (binding) { if (binding.identifier.typeAnnotation) { return binding.identifier.typeAnnotation; } else { return getTypeAnnotationBindingConstantViolations(binding, this, node.name); } } if (node.name === "undefined") { return voidTypeAnnotation(); } else if (node.name === "NaN" || node.name === "Infinity") { return numberTypeAnnotation(); } else if (node.name === "arguments") {} } function getTypeAnnotationBindingConstantViolations(binding, path, name) { const types = []; const functionConstantViolations = []; let constantViolations = getConstantViolationsBefore(binding, path, functionConstantViolations); const testType = getConditionalAnnotation(binding, path, name); if (testType) { const testConstantViolations = getConstantViolationsBefore(binding, testType.ifStatement); constantViolations = constantViolations.filter(path => testConstantViolations.indexOf(path) < 0); types.push(testType.typeAnnotation); } if (constantViolations.length) { constantViolations.push(...functionConstantViolations); for (const violation of constantViolations) { types.push(violation.getTypeAnnotation()); } } if (!types.length) { return; } return (0, _util.createUnionType)(types); } function getConstantViolationsBefore(binding, path, functions) { const violations = binding.constantViolations.slice(); violations.unshift(binding.path); return violations.filter(violation => { violation = violation.resolve(); const status = violation._guessExecutionStatusRelativeTo(path); if (functions && status === "unknown") functions.push(violation); return status === "before"; }); } function inferAnnotationFromBinaryExpression(name, path) { const operator = path.node.operator; const right = path.get("right").resolve(); const left = path.get("left").resolve(); let target; if (left.isIdentifier({ name })) { target = right; } else if (right.isIdentifier({ name })) { target = left; } if (target) { if (operator === "===") { return target.getTypeAnnotation(); } if (BOOLEAN_NUMBER_BINARY_OPERATORS.indexOf(operator) >= 0) { return numberTypeAnnotation(); } return; } if (operator !== "===" && operator !== "==") return; let typeofPath; let typePath; if (left.isUnaryExpression({ operator: "typeof" })) { typeofPath = left; typePath = right; } else if (right.isUnaryExpression({ operator: "typeof" })) { typeofPath = right; typePath = left; } if (!typeofPath) return; if (!typeofPath.get("argument").isIdentifier({ name })) return; typePath = typePath.resolve(); if (!typePath.isLiteral()) return; const typeValue = typePath.node.value; if (typeof typeValue !== "string") return; return createTypeAnnotationBasedOnTypeof(typeValue); } function getParentConditionalPath(binding, path, name) { let parentPath; while (parentPath = path.parentPath) { if (parentPath.isIfStatement() || parentPath.isConditionalExpression()) { if (path.key === "test") { return; } return parentPath; } if (parentPath.isFunction()) { if (parentPath.parentPath.scope.getBinding(name) !== binding) return; } path = parentPath; } } function getConditionalAnnotation(binding, path, name) { const ifStatement = getParentConditionalPath(binding, path, name); if (!ifStatement) return; const test = ifStatement.get("test"); const paths = [test]; const types = []; for (let i = 0; i < paths.length; i++) { const path = paths[i]; if (path.isLogicalExpression()) { if (path.node.operator === "&&") { paths.push(path.get("left")); paths.push(path.get("right")); } } else if (path.isBinaryExpression()) { const type = inferAnnotationFromBinaryExpression(name, path); if (type) types.push(type); } } if (types.length) { return { typeAnnotation: (0, _util.createUnionType)(types), ifStatement }; } return getConditionalAnnotation(binding, ifStatement, name); } },{"./util":301,"@babel/types":359}],300:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.ArrayExpression = ArrayExpression; exports.AssignmentExpression = AssignmentExpression; exports.BinaryExpression = BinaryExpression; exports.BooleanLiteral = BooleanLiteral; exports.CallExpression = CallExpression; exports.ConditionalExpression = ConditionalExpression; exports.ClassDeclaration = exports.ClassExpression = exports.FunctionDeclaration = exports.ArrowFunctionExpression = exports.FunctionExpression = Func; Object.defineProperty(exports, "Identifier", { enumerable: true, get: function () { return _infererReference.default; } }); exports.LogicalExpression = LogicalExpression; exports.NewExpression = NewExpression; exports.NullLiteral = NullLiteral; exports.NumericLiteral = NumericLiteral; exports.ObjectExpression = ObjectExpression; exports.ParenthesizedExpression = ParenthesizedExpression; exports.RegExpLiteral = RegExpLiteral; exports.RestElement = RestElement; exports.SequenceExpression = SequenceExpression; exports.StringLiteral = StringLiteral; exports.TSAsExpression = TSAsExpression; exports.TSNonNullExpression = TSNonNullExpression; exports.TaggedTemplateExpression = TaggedTemplateExpression; exports.TemplateLiteral = TemplateLiteral; exports.TypeCastExpression = TypeCastExpression; exports.UnaryExpression = UnaryExpression; exports.UpdateExpression = UpdateExpression; exports.VariableDeclarator = VariableDeclarator; var _t = require("@babel/types"); var _infererReference = require("./inferer-reference"); var _util = require("./util"); const { BOOLEAN_BINARY_OPERATORS, BOOLEAN_UNARY_OPERATORS, NUMBER_BINARY_OPERATORS, NUMBER_UNARY_OPERATORS, STRING_UNARY_OPERATORS, anyTypeAnnotation, arrayTypeAnnotation, booleanTypeAnnotation, buildMatchMemberExpression, genericTypeAnnotation, identifier, nullLiteralTypeAnnotation, numberTypeAnnotation, stringTypeAnnotation, tupleTypeAnnotation, unionTypeAnnotation, voidTypeAnnotation, isIdentifier } = _t; function VariableDeclarator() { if (!this.get("id").isIdentifier()) return; return this.get("init").getTypeAnnotation(); } function TypeCastExpression(node) { return node.typeAnnotation; } TypeCastExpression.validParent = true; function TSAsExpression(node) { return node.typeAnnotation; } TSAsExpression.validParent = true; function TSNonNullExpression() { return this.get("expression").getTypeAnnotation(); } function NewExpression(node) { if (node.callee.type === "Identifier") { return genericTypeAnnotation(node.callee); } } function TemplateLiteral() { return stringTypeAnnotation(); } function UnaryExpression(node) { const operator = node.operator; if (operator === "void") { return voidTypeAnnotation(); } else if (NUMBER_UNARY_OPERATORS.indexOf(operator) >= 0) { return numberTypeAnnotation(); } else if (STRING_UNARY_OPERATORS.indexOf(operator) >= 0) { return stringTypeAnnotation(); } else if (BOOLEAN_UNARY_OPERATORS.indexOf(operator) >= 0) { return booleanTypeAnnotation(); } } function BinaryExpression(node) { const operator = node.operator; if (NUMBER_BINARY_OPERATORS.indexOf(operator) >= 0) { return numberTypeAnnotation(); } else if (BOOLEAN_BINARY_OPERATORS.indexOf(operator) >= 0) { return booleanTypeAnnotation(); } else if (operator === "+") { const right = this.get("right"); const left = this.get("left"); if (left.isBaseType("number") && right.isBaseType("number")) { return numberTypeAnnotation(); } else if (left.isBaseType("string") || right.isBaseType("string")) { return stringTypeAnnotation(); } return unionTypeAnnotation([stringTypeAnnotation(), numberTypeAnnotation()]); } } function LogicalExpression() { const argumentTypes = [this.get("left").getTypeAnnotation(), this.get("right").getTypeAnnotation()]; return (0, _util.createUnionType)(argumentTypes); } function ConditionalExpression() { const argumentTypes = [this.get("consequent").getTypeAnnotation(), this.get("alternate").getTypeAnnotation()]; return (0, _util.createUnionType)(argumentTypes); } function SequenceExpression() { return this.get("expressions").pop().getTypeAnnotation(); } function ParenthesizedExpression() { return this.get("expression").getTypeAnnotation(); } function AssignmentExpression() { return this.get("right").getTypeAnnotation(); } function UpdateExpression(node) { const operator = node.operator; if (operator === "++" || operator === "--") { return numberTypeAnnotation(); } } function StringLiteral() { return stringTypeAnnotation(); } function NumericLiteral() { return numberTypeAnnotation(); } function BooleanLiteral() { return booleanTypeAnnotation(); } function NullLiteral() { return nullLiteralTypeAnnotation(); } function RegExpLiteral() { return genericTypeAnnotation(identifier("RegExp")); } function ObjectExpression() { return genericTypeAnnotation(identifier("Object")); } function ArrayExpression() { return genericTypeAnnotation(identifier("Array")); } function RestElement() { return ArrayExpression(); } RestElement.validParent = true; function Func() { return genericTypeAnnotation(identifier("Function")); } const isArrayFrom = buildMatchMemberExpression("Array.from"); const isObjectKeys = buildMatchMemberExpression("Object.keys"); const isObjectValues = buildMatchMemberExpression("Object.values"); const isObjectEntries = buildMatchMemberExpression("Object.entries"); function CallExpression() { const { callee } = this.node; if (isObjectKeys(callee)) { return arrayTypeAnnotation(stringTypeAnnotation()); } else if (isArrayFrom(callee) || isObjectValues(callee) || isIdentifier(callee, { name: "Array" })) { return arrayTypeAnnotation(anyTypeAnnotation()); } else if (isObjectEntries(callee)) { return arrayTypeAnnotation(tupleTypeAnnotation([stringTypeAnnotation(), anyTypeAnnotation()])); } return resolveCall(this.get("callee")); } function TaggedTemplateExpression() { return resolveCall(this.get("tag")); } function resolveCall(callee) { callee = callee.resolve(); if (callee.isFunction()) { const { node } = callee; if (node.async) { if (node.generator) { return genericTypeAnnotation(identifier("AsyncIterator")); } else { return genericTypeAnnotation(identifier("Promise")); } } else { if (node.generator) { return genericTypeAnnotation(identifier("Iterator")); } else if (callee.node.returnType) { return callee.node.returnType; } else {} } } } },{"./inferer-reference":299,"./util":301,"@babel/types":359}],301:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.createUnionType = createUnionType; var _t = require("@babel/types"); const { createFlowUnionType, createTSUnionType, createUnionTypeAnnotation, isFlowType, isTSType } = _t; function createUnionType(types) { { if (isFlowType(types[0])) { if (createFlowUnionType) { return createFlowUnionType(types); } return createUnionTypeAnnotation(types); } else { if (createTSUnionType) { return createTSUnionType(types); } } } } },{"@babel/types":359}],302:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports._guessExecutionStatusRelativeTo = _guessExecutionStatusRelativeTo; exports._resolve = _resolve; exports.canHaveVariableDeclarationOrExpression = canHaveVariableDeclarationOrExpression; exports.canSwapBetweenExpressionAndStatement = canSwapBetweenExpressionAndStatement; exports.equals = equals; exports.getSource = getSource; exports.has = has; exports.is = void 0; exports.isCompletionRecord = isCompletionRecord; exports.isConstantExpression = isConstantExpression; exports.isInStrictMode = isInStrictMode; exports.isNodeType = isNodeType; exports.isStatementOrBlock = isStatementOrBlock; exports.isStatic = isStatic; exports.isnt = isnt; exports.matchesPattern = matchesPattern; exports.referencesImport = referencesImport; exports.resolve = resolve; exports.willIMaybeExecuteBefore = willIMaybeExecuteBefore; var _t = require("@babel/types"); const { STATEMENT_OR_BLOCK_KEYS, VISITOR_KEYS, isBlockStatement, isExpression, isIdentifier, isLiteral, isStringLiteral, isType, matchesPattern: _matchesPattern } = _t; function matchesPattern(pattern, allowPartial) { return _matchesPattern(this.node, pattern, allowPartial); } function has(key) { const val = this.node && this.node[key]; if (val && Array.isArray(val)) { return !!val.length; } else { return !!val; } } function isStatic() { return this.scope.isStatic(this.node); } const is = has; exports.is = is; function isnt(key) { return !this.has(key); } function equals(key, value) { return this.node[key] === value; } function isNodeType(type) { return isType(this.type, type); } function canHaveVariableDeclarationOrExpression() { return (this.key === "init" || this.key === "left") && this.parentPath.isFor(); } function canSwapBetweenExpressionAndStatement(replacement) { if (this.key !== "body" || !this.parentPath.isArrowFunctionExpression()) { return false; } if (this.isExpression()) { return isBlockStatement(replacement); } else if (this.isBlockStatement()) { return isExpression(replacement); } return false; } function isCompletionRecord(allowInsideFunction) { let path = this; let first = true; do { const { type, container } = path; if (!first && (path.isFunction() || type === "StaticBlock")) { return !!allowInsideFunction; } first = false; if (Array.isArray(container) && path.key !== container.length - 1) { return false; } } while ((path = path.parentPath) && !path.isProgram() && !path.isDoExpression()); return true; } function isStatementOrBlock() { if (this.parentPath.isLabeledStatement() || isBlockStatement(this.container)) { return false; } else { return STATEMENT_OR_BLOCK_KEYS.includes(this.key); } } function referencesImport(moduleSource, importName) { if (!this.isReferencedIdentifier()) { if (this.isJSXMemberExpression() && this.node.property.name === importName || (this.isMemberExpression() || this.isOptionalMemberExpression()) && (this.node.computed ? isStringLiteral(this.node.property, { value: importName }) : this.node.property.name === importName)) { const object = this.get("object"); return object.isReferencedIdentifier() && object.referencesImport(moduleSource, "*"); } return false; } const binding = this.scope.getBinding(this.node.name); if (!binding || binding.kind !== "module") return false; const path = binding.path; const parent = path.parentPath; if (!parent.isImportDeclaration()) return false; if (parent.node.source.value === moduleSource) { if (!importName) return true; } else { return false; } if (path.isImportDefaultSpecifier() && importName === "default") { return true; } if (path.isImportNamespaceSpecifier() && importName === "*") { return true; } if (path.isImportSpecifier() && isIdentifier(path.node.imported, { name: importName })) { return true; } return false; } function getSource() { const node = this.node; if (node.end) { const code = this.hub.getCode(); if (code) return code.slice(node.start, node.end); } return ""; } function willIMaybeExecuteBefore(target) { return this._guessExecutionStatusRelativeTo(target) !== "after"; } function getOuterFunction(path) { return (path.scope.getFunctionParent() || path.scope.getProgramParent()).path; } function isExecutionUncertain(type, key) { switch (type) { case "LogicalExpression": return key === "right"; case "ConditionalExpression": case "IfStatement": return key === "consequent" || key === "alternate"; case "WhileStatement": case "DoWhileStatement": case "ForInStatement": case "ForOfStatement": return key === "body"; case "ForStatement": return key === "body" || key === "update"; case "SwitchStatement": return key === "cases"; case "TryStatement": return key === "handler"; case "AssignmentPattern": return key === "right"; case "OptionalMemberExpression": return key === "property"; case "OptionalCallExpression": return key === "arguments"; default: return false; } } function isExecutionUncertainInList(paths, maxIndex) { for (let i = 0; i < maxIndex; i++) { const path = paths[i]; if (isExecutionUncertain(path.parent.type, path.parentKey)) { return true; } } return false; } function _guessExecutionStatusRelativeTo(target) { return _guessExecutionStatusRelativeToCached(this, target, new Map()); } function _guessExecutionStatusRelativeToCached(base, target, cache) { const funcParent = { this: getOuterFunction(base), target: getOuterFunction(target) }; if (funcParent.target.node !== funcParent.this.node) { return _guessExecutionStatusRelativeToDifferentFunctionsCached(base, funcParent.target, cache); } const paths = { target: target.getAncestry(), this: base.getAncestry() }; if (paths.target.indexOf(base) >= 0) return "after"; if (paths.this.indexOf(target) >= 0) return "before"; let commonPath; const commonIndex = { target: 0, this: 0 }; while (!commonPath && commonIndex.this < paths.this.length) { const path = paths.this[commonIndex.this]; commonIndex.target = paths.target.indexOf(path); if (commonIndex.target >= 0) { commonPath = path; } else { commonIndex.this++; } } if (!commonPath) { throw new Error("Internal Babel error - The two compared nodes" + " don't appear to belong to the same program."); } if (isExecutionUncertainInList(paths.this, commonIndex.this - 1) || isExecutionUncertainInList(paths.target, commonIndex.target - 1)) { return "unknown"; } const divergence = { this: paths.this[commonIndex.this - 1], target: paths.target[commonIndex.target - 1] }; if (divergence.target.listKey && divergence.this.listKey && divergence.target.container === divergence.this.container) { return divergence.target.key > divergence.this.key ? "before" : "after"; } const keys = VISITOR_KEYS[commonPath.type]; const keyPosition = { this: keys.indexOf(divergence.this.parentKey), target: keys.indexOf(divergence.target.parentKey) }; return keyPosition.target > keyPosition.this ? "before" : "after"; } const executionOrderCheckedNodes = new Set(); function _guessExecutionStatusRelativeToDifferentFunctionsInternal(base, target, cache) { if (!target.isFunctionDeclaration() || target.parentPath.isExportDeclaration()) { return "unknown"; } const binding = target.scope.getBinding(target.node.id.name); if (!binding.references) return "before"; const referencePaths = binding.referencePaths; let allStatus; for (const path of referencePaths) { const childOfFunction = !!path.find(path => path.node === target.node); if (childOfFunction) continue; if (path.key !== "callee" || !path.parentPath.isCallExpression()) { return "unknown"; } if (executionOrderCheckedNodes.has(path.node)) continue; executionOrderCheckedNodes.add(path.node); try { const status = _guessExecutionStatusRelativeToCached(base, path, cache); if (allStatus && allStatus !== status) { return "unknown"; } else { allStatus = status; } } finally { executionOrderCheckedNodes.delete(path.node); } } return allStatus; } function _guessExecutionStatusRelativeToDifferentFunctionsCached(base, target, cache) { let nodeMap = cache.get(base.node); if (!nodeMap) { cache.set(base.node, nodeMap = new Map()); } else if (nodeMap.has(target.node)) { return nodeMap.get(target.node); } const result = _guessExecutionStatusRelativeToDifferentFunctionsInternal(base, target, cache); nodeMap.set(target.node, result); return result; } function resolve(dangerous, resolved) { return this._resolve(dangerous, resolved) || this; } function _resolve(dangerous, resolved) { if (resolved && resolved.indexOf(this) >= 0) return; resolved = resolved || []; resolved.push(this); if (this.isVariableDeclarator()) { if (this.get("id").isIdentifier()) { return this.get("init").resolve(dangerous, resolved); } else {} } else if (this.isReferencedIdentifier()) { const binding = this.scope.getBinding(this.node.name); if (!binding) return; if (!binding.constant) return; if (binding.kind === "module") return; if (binding.path !== this) { const ret = binding.path.resolve(dangerous, resolved); if (this.find(parent => parent.node === ret.node)) return; return ret; } } else if (this.isTypeCastExpression()) { return this.get("expression").resolve(dangerous, resolved); } else if (dangerous && this.isMemberExpression()) { const targetKey = this.toComputedKey(); if (!isLiteral(targetKey)) return; const targetName = targetKey.value; const target = this.get("object").resolve(dangerous, resolved); if (target.isObjectExpression()) { const props = target.get("properties"); for (const prop of props) { if (!prop.isProperty()) continue; const key = prop.get("key"); let match = prop.isnt("computed") && key.isIdentifier({ name: targetName }); match = match || key.isLiteral({ value: targetName }); if (match) return prop.get("value").resolve(dangerous, resolved); } } else if (target.isArrayExpression() && !isNaN(+targetName)) { const elems = target.get("elements"); const elem = elems[targetName]; if (elem) return elem.resolve(dangerous, resolved); } } } function isConstantExpression() { if (this.isIdentifier()) { const binding = this.scope.getBinding(this.node.name); if (!binding) return false; return binding.constant; } if (this.isLiteral()) { if (this.isRegExpLiteral()) { return false; } if (this.isTemplateLiteral()) { return this.get("expressions").every(expression => expression.isConstantExpression()); } return true; } if (this.isUnaryExpression()) { if (this.node.operator !== "void") { return false; } return this.get("argument").isConstantExpression(); } if (this.isBinaryExpression()) { return this.get("left").isConstantExpression() && this.get("right").isConstantExpression(); } return false; } function isInStrictMode() { const start = this.isProgram() ? this : this.parentPath; const strictParent = start.find(path => { if (path.isProgram({ sourceType: "module" })) return true; if (path.isClass()) return true; if (path.isArrowFunctionExpression() && !path.get("body").isBlockStatement()) { return false; } let body; if (path.isFunction()) { body = path.node.body; } else if (path.isProgram()) { body = path.node; } else { return false; } for (const directive of body.directives) { if (directive.value.value === "use strict") { return true; } } }); return !!strictParent; } },{"@babel/types":359}],303:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = void 0; var _t = require("@babel/types"); var _t2 = _t; const { react } = _t; const { cloneNode, jsxExpressionContainer, variableDeclaration, variableDeclarator } = _t2; const referenceVisitor = { ReferencedIdentifier(path, state) { if (path.isJSXIdentifier() && react.isCompatTag(path.node.name) && !path.parentPath.isJSXMemberExpression()) { return; } if (path.node.name === "this") { let scope = path.scope; do { if (scope.path.isFunction() && !scope.path.isArrowFunctionExpression()) { break; } } while (scope = scope.parent); if (scope) state.breakOnScopePaths.push(scope.path); } const binding = path.scope.getBinding(path.node.name); if (!binding) return; for (const violation of binding.constantViolations) { if (violation.scope !== binding.path.scope) { state.mutableBinding = true; path.stop(); return; } } if (binding !== state.scope.getBinding(path.node.name)) return; state.bindings[path.node.name] = binding; } }; class PathHoister { constructor(path, scope) { this.breakOnScopePaths = void 0; this.bindings = void 0; this.mutableBinding = void 0; this.scopes = void 0; this.scope = void 0; this.path = void 0; this.attachAfter = void 0; this.breakOnScopePaths = []; this.bindings = {}; this.mutableBinding = false; this.scopes = []; this.scope = scope; this.path = path; this.attachAfter = false; } isCompatibleScope(scope) { for (const key of Object.keys(this.bindings)) { const binding = this.bindings[key]; if (!scope.bindingIdentifierEquals(key, binding.identifier)) { return false; } } return true; } getCompatibleScopes() { let scope = this.path.scope; do { if (this.isCompatibleScope(scope)) { this.scopes.push(scope); } else { break; } if (this.breakOnScopePaths.indexOf(scope.path) >= 0) { break; } } while (scope = scope.parent); } getAttachmentPath() { let path = this._getAttachmentPath(); if (!path) return; let targetScope = path.scope; if (targetScope.path === path) { targetScope = path.scope.parent; } if (targetScope.path.isProgram() || targetScope.path.isFunction()) { for (const name of Object.keys(this.bindings)) { if (!targetScope.hasOwnBinding(name)) continue; const binding = this.bindings[name]; if (binding.kind === "param" || binding.path.parentKey === "params") { continue; } const bindingParentPath = this.getAttachmentParentForPath(binding.path); if (bindingParentPath.key >= path.key) { this.attachAfter = true; path = binding.path; for (const violationPath of binding.constantViolations) { if (this.getAttachmentParentForPath(violationPath).key > path.key) { path = violationPath; } } } } } return path; } _getAttachmentPath() { const scopes = this.scopes; const scope = scopes.pop(); if (!scope) return; if (scope.path.isFunction()) { if (this.hasOwnParamBindings(scope)) { if (this.scope === scope) return; const bodies = scope.path.get("body").get("body"); for (let i = 0; i < bodies.length; i++) { if (bodies[i].node._blockHoist) continue; return bodies[i]; } } else { return this.getNextScopeAttachmentParent(); } } else if (scope.path.isProgram()) { return this.getNextScopeAttachmentParent(); } } getNextScopeAttachmentParent() { const scope = this.scopes.pop(); if (scope) return this.getAttachmentParentForPath(scope.path); } getAttachmentParentForPath(path) { do { if (!path.parentPath || Array.isArray(path.container) && path.isStatement()) { return path; } } while (path = path.parentPath); } hasOwnParamBindings(scope) { for (const name of Object.keys(this.bindings)) { if (!scope.hasOwnBinding(name)) continue; const binding = this.bindings[name]; if (binding.kind === "param" && binding.constant) return true; } return false; } run() { this.path.traverse(referenceVisitor, this); if (this.mutableBinding) return; this.getCompatibleScopes(); const attachTo = this.getAttachmentPath(); if (!attachTo) return; if (attachTo.getFunctionParent() === this.path.getFunctionParent()) return; let uid = attachTo.scope.generateUidIdentifier("ref"); const declarator = variableDeclarator(uid, this.path.node); const insertFn = this.attachAfter ? "insertAfter" : "insertBefore"; const [attached] = attachTo[insertFn]([attachTo.isVariableDeclarator() ? declarator : variableDeclaration("var", [declarator])]); const parent = this.path.parentPath; if (parent.isJSXElement() && this.path.container === parent.node.children) { uid = jsxExpressionContainer(uid); } this.path.replaceWith(cloneNode(uid)); return attachTo.isVariableDeclarator() ? attached.get("init") : attached.get("declarations.0.init"); } } exports.default = PathHoister; },{"@babel/types":359}],304:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.hooks = void 0; const hooks = [function (self, parent) { const removeParent = self.key === "test" && (parent.isWhile() || parent.isSwitchCase()) || self.key === "declaration" && parent.isExportDeclaration() || self.key === "body" && parent.isLabeledStatement() || self.listKey === "declarations" && parent.isVariableDeclaration() && parent.node.declarations.length === 1 || self.key === "expression" && parent.isExpressionStatement(); if (removeParent) { parent.remove(); return true; } }, function (self, parent) { if (parent.isSequenceExpression() && parent.node.expressions.length === 1) { parent.replaceWith(parent.node.expressions[0]); return true; } }, function (self, parent) { if (parent.isBinary()) { if (self.key === "left") { parent.replaceWith(parent.node.right); } else { parent.replaceWith(parent.node.left); } return true; } }, function (self, parent) { if (parent.isIfStatement() && self.key === "consequent" || self.key === "body" && (parent.isLoop() || parent.isArrowFunctionExpression())) { self.replaceWith({ type: "BlockStatement", body: [] }); return true; } }]; exports.hooks = hooks; },{}],305:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.isBindingIdentifier = isBindingIdentifier; exports.isBlockScoped = isBlockScoped; exports.isExistentialTypeParam = isExistentialTypeParam; exports.isExpression = isExpression; exports.isFlow = isFlow; exports.isForAwaitStatement = isForAwaitStatement; exports.isGenerated = isGenerated; exports.isNumericLiteralTypeAnnotation = isNumericLiteralTypeAnnotation; exports.isPure = isPure; exports.isReferenced = isReferenced; exports.isReferencedIdentifier = isReferencedIdentifier; exports.isReferencedMemberExpression = isReferencedMemberExpression; exports.isRestProperty = isRestProperty; exports.isScope = isScope; exports.isSpreadProperty = isSpreadProperty; exports.isStatement = isStatement; exports.isUser = isUser; exports.isVar = isVar; var _t = require("@babel/types"); const { isBinding, isBlockScoped: nodeIsBlockScoped, isExportDeclaration, isExpression: nodeIsExpression, isFlow: nodeIsFlow, isForStatement, isForXStatement, isIdentifier, isImportDeclaration, isImportSpecifier, isJSXIdentifier, isJSXMemberExpression, isMemberExpression, isRestElement: nodeIsRestElement, isReferenced: nodeIsReferenced, isScope: nodeIsScope, isStatement: nodeIsStatement, isVar: nodeIsVar, isVariableDeclaration, react, isForOfStatement } = _t; const { isCompatTag } = react; function isReferencedIdentifier(opts) { const { node, parent } = this; if (!isIdentifier(node, opts) && !isJSXMemberExpression(parent, opts)) { if (isJSXIdentifier(node, opts)) { if (isCompatTag(node.name)) return false; } else { return false; } } return nodeIsReferenced(node, parent, this.parentPath.parent); } function isReferencedMemberExpression() { const { node, parent } = this; return isMemberExpression(node) && nodeIsReferenced(node, parent); } function isBindingIdentifier() { const { node, parent } = this; const grandparent = this.parentPath.parent; return isIdentifier(node) && isBinding(node, parent, grandparent); } function isStatement() { const { node, parent } = this; if (nodeIsStatement(node)) { if (isVariableDeclaration(node)) { if (isForXStatement(parent, { left: node })) return false; if (isForStatement(parent, { init: node })) return false; } return true; } else { return false; } } function isExpression() { if (this.isIdentifier()) { return this.isReferencedIdentifier(); } else { return nodeIsExpression(this.node); } } function isScope() { return nodeIsScope(this.node, this.parent); } function isReferenced() { return nodeIsReferenced(this.node, this.parent); } function isBlockScoped() { return nodeIsBlockScoped(this.node); } function isVar() { return nodeIsVar(this.node); } function isUser() { return this.node && !!this.node.loc; } function isGenerated() { return !this.isUser(); } function isPure(constantsOnly) { return this.scope.isPure(this.node, constantsOnly); } function isFlow() { const { node } = this; if (nodeIsFlow(node)) { return true; } else if (isImportDeclaration(node)) { return node.importKind === "type" || node.importKind === "typeof"; } else if (isExportDeclaration(node)) { return node.exportKind === "type"; } else if (isImportSpecifier(node)) { return node.importKind === "type" || node.importKind === "typeof"; } else { return false; } } function isRestProperty() { return nodeIsRestElement(this.node) && this.parentPath && this.parentPath.isObjectPattern(); } function isSpreadProperty() { return nodeIsRestElement(this.node) && this.parentPath && this.parentPath.isObjectExpression(); } function isForAwaitStatement() { return isForOfStatement(this.node, { await: true }); } function isExistentialTypeParam() { throw new Error("`path.isExistentialTypeParam` has been renamed to `path.isExistsTypeAnnotation()` in Babel 7."); } function isNumericLiteralTypeAnnotation() { throw new Error("`path.isNumericLiteralTypeAnnotation()` has been renamed to `path.isNumberLiteralTypeAnnotation()` in Babel 7."); } },{"@babel/types":359}],306:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.Var = exports.User = exports.Statement = exports.SpreadProperty = exports.Scope = exports.RestProperty = exports.ReferencedMemberExpression = exports.ReferencedIdentifier = exports.Referenced = exports.Pure = exports.NumericLiteralTypeAnnotation = exports.Generated = exports.ForAwaitStatement = exports.Flow = exports.Expression = exports.ExistentialTypeParam = exports.BlockScoped = exports.BindingIdentifier = void 0; const ReferencedIdentifier = ["Identifier", "JSXIdentifier"]; exports.ReferencedIdentifier = ReferencedIdentifier; const ReferencedMemberExpression = ["MemberExpression"]; exports.ReferencedMemberExpression = ReferencedMemberExpression; const BindingIdentifier = ["Identifier"]; exports.BindingIdentifier = BindingIdentifier; const Statement = ["Statement"]; exports.Statement = Statement; const Expression = ["Expression"]; exports.Expression = Expression; const Scope = ["Scopable", "Pattern"]; exports.Scope = Scope; const Referenced = null; exports.Referenced = Referenced; const BlockScoped = null; exports.BlockScoped = BlockScoped; const Var = ["VariableDeclaration"]; exports.Var = Var; const User = null; exports.User = User; const Generated = null; exports.Generated = Generated; const Pure = null; exports.Pure = Pure; const Flow = ["Flow", "ImportDeclaration", "ExportDeclaration", "ImportSpecifier"]; exports.Flow = Flow; const RestProperty = ["RestElement"]; exports.RestProperty = RestProperty; const SpreadProperty = ["RestElement"]; exports.SpreadProperty = SpreadProperty; const ExistentialTypeParam = ["ExistsTypeAnnotation"]; exports.ExistentialTypeParam = ExistentialTypeParam; const NumericLiteralTypeAnnotation = ["NumberLiteralTypeAnnotation"]; exports.NumericLiteralTypeAnnotation = NumericLiteralTypeAnnotation; const ForAwaitStatement = ["ForOfStatement"]; exports.ForAwaitStatement = ForAwaitStatement; },{}],307:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports._containerInsert = _containerInsert; exports._containerInsertAfter = _containerInsertAfter; exports._containerInsertBefore = _containerInsertBefore; exports._verifyNodeList = _verifyNodeList; exports.hoist = hoist; exports.insertAfter = insertAfter; exports.insertBefore = insertBefore; exports.pushContainer = pushContainer; exports.unshiftContainer = unshiftContainer; exports.updateSiblingKeys = updateSiblingKeys; var _cache = require("../cache"); var _hoister = require("./lib/hoister"); var _index = require("./index"); var _t = require("@babel/types"); const { arrowFunctionExpression, assertExpression, assignmentExpression, blockStatement, callExpression, cloneNode, expressionStatement, isAssignmentExpression, isCallExpression, isExpression, isIdentifier, isSequenceExpression, isSuper, thisExpression } = _t; function insertBefore(nodes_) { this._assertUnremoved(); const nodes = this._verifyNodeList(nodes_); const { parentPath } = this; if (parentPath.isExpressionStatement() || parentPath.isLabeledStatement() || parentPath.isExportNamedDeclaration() || parentPath.isExportDefaultDeclaration() && this.isDeclaration()) { return parentPath.insertBefore(nodes); } else if (this.isNodeType("Expression") && !this.isJSXElement() || parentPath.isForStatement() && this.key === "init") { if (this.node) nodes.push(this.node); return this.replaceExpressionWithStatements(nodes); } else if (Array.isArray(this.container)) { return this._containerInsertBefore(nodes); } else if (this.isStatementOrBlock()) { const node = this.node; const shouldInsertCurrentNode = node && (!this.isExpressionStatement() || node.expression != null); this.replaceWith(blockStatement(shouldInsertCurrentNode ? [node] : [])); return this.unshiftContainer("body", nodes); } else { throw new Error("We don't know what to do with this node type. " + "We were previously a Statement but we can't fit in here?"); } } function _containerInsert(from, nodes) { this.updateSiblingKeys(from, nodes.length); const paths = []; this.container.splice(from, 0, ...nodes); for (let i = 0; i < nodes.length; i++) { const to = from + i; const path = this.getSibling(to); paths.push(path); if (this.context && this.context.queue) { path.pushContext(this.context); } } const contexts = this._getQueueContexts(); for (const path of paths) { path.setScope(); path.debug("Inserted."); for (const context of contexts) { context.maybeQueue(path, true); } } return paths; } function _containerInsertBefore(nodes) { return this._containerInsert(this.key, nodes); } function _containerInsertAfter(nodes) { return this._containerInsert(this.key + 1, nodes); } const last = arr => arr[arr.length - 1]; function isHiddenInSequenceExpression(path) { return isSequenceExpression(path.parent) && (last(path.parent.expressions) !== path.node || isHiddenInSequenceExpression(path.parentPath)); } function isAlmostConstantAssignment(node, scope) { if (!isAssignmentExpression(node) || !isIdentifier(node.left)) { return false; } const blockScope = scope.getBlockParent(); return blockScope.hasOwnBinding(node.left.name) && blockScope.getOwnBinding(node.left.name).constantViolations.length <= 1; } function insertAfter(nodes_) { this._assertUnremoved(); if (this.isSequenceExpression()) { return last(this.get("expressions")).insertAfter(nodes_); } const nodes = this._verifyNodeList(nodes_); const { parentPath } = this; if (parentPath.isExpressionStatement() || parentPath.isLabeledStatement() || parentPath.isExportNamedDeclaration() || parentPath.isExportDefaultDeclaration() && this.isDeclaration()) { return parentPath.insertAfter(nodes.map(node => { return isExpression(node) ? expressionStatement(node) : node; })); } else if (this.isNodeType("Expression") && !this.isJSXElement() && !parentPath.isJSXElement() || parentPath.isForStatement() && this.key === "init") { if (this.node) { const node = this.node; let { scope } = this; if (scope.path.isPattern()) { assertExpression(node); this.replaceWith(callExpression(arrowFunctionExpression([], node), [])); this.get("callee.body").insertAfter(nodes); return [this]; } if (isHiddenInSequenceExpression(this)) { nodes.unshift(node); } else if (isCallExpression(node) && isSuper(node.callee)) { nodes.unshift(node); nodes.push(thisExpression()); } else if (isAlmostConstantAssignment(node, scope)) { nodes.unshift(node); nodes.push(cloneNode(node.left)); } else if (scope.isPure(node, true)) { nodes.push(node); } else { if (parentPath.isMethod({ computed: true, key: node })) { scope = scope.parent; } const temp = scope.generateDeclaredUidIdentifier(); nodes.unshift(expressionStatement(assignmentExpression("=", cloneNode(temp), node))); nodes.push(expressionStatement(cloneNode(temp))); } } return this.replaceExpressionWithStatements(nodes); } else if (Array.isArray(this.container)) { return this._containerInsertAfter(nodes); } else if (this.isStatementOrBlock()) { const node = this.node; const shouldInsertCurrentNode = node && (!this.isExpressionStatement() || node.expression != null); this.replaceWith(blockStatement(shouldInsertCurrentNode ? [node] : [])); return this.pushContainer("body", nodes); } else { throw new Error("We don't know what to do with this node type. " + "We were previously a Statement but we can't fit in here?"); } } function updateSiblingKeys(fromIndex, incrementBy) { if (!this.parent) return; const paths = _cache.path.get(this.parent); for (const [, path] of paths) { if (path.key >= fromIndex) { path.key += incrementBy; } } } function _verifyNodeList(nodes) { if (!nodes) { return []; } if (!Array.isArray(nodes)) { nodes = [nodes]; } for (let i = 0; i < nodes.length; i++) { const node = nodes[i]; let msg; if (!node) { msg = "has falsy node"; } else if (typeof node !== "object") { msg = "contains a non-object node"; } else if (!node.type) { msg = "without a type"; } else if (node instanceof _index.default) { msg = "has a NodePath when it expected a raw object"; } if (msg) { const type = Array.isArray(node) ? "array" : typeof node; throw new Error(`Node list ${msg} with the index of ${i} and type of ${type}`); } } return nodes; } function unshiftContainer(listKey, nodes) { this._assertUnremoved(); nodes = this._verifyNodeList(nodes); const path = _index.default.get({ parentPath: this, parent: this.node, container: this.node[listKey], listKey, key: 0 }).setContext(this.context); return path._containerInsertBefore(nodes); } function pushContainer(listKey, nodes) { this._assertUnremoved(); const verifiedNodes = this._verifyNodeList(nodes); const container = this.node[listKey]; const path = _index.default.get({ parentPath: this, parent: this.node, container: container, listKey, key: container.length }).setContext(this.context); return path.replaceWithMultiple(verifiedNodes); } function hoist(scope = this.scope) { const hoister = new _hoister.default(this, scope); return hoister.run(); } },{"../cache":287,"./index":297,"./lib/hoister":303,"@babel/types":359}],308:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports._assertUnremoved = _assertUnremoved; exports._callRemovalHooks = _callRemovalHooks; exports._markRemoved = _markRemoved; exports._remove = _remove; exports._removeFromScope = _removeFromScope; exports.remove = remove; var _removalHooks = require("./lib/removal-hooks"); var _cache = require("../cache"); var _index = require("./index"); function remove() { var _this$opts; this._assertUnremoved(); this.resync(); if (!((_this$opts = this.opts) != null && _this$opts.noScope)) { this._removeFromScope(); } if (this._callRemovalHooks()) { this._markRemoved(); return; } this.shareCommentsWithSiblings(); this._remove(); this._markRemoved(); } function _removeFromScope() { const bindings = this.getBindingIdentifiers(); Object.keys(bindings).forEach(name => this.scope.removeBinding(name)); } function _callRemovalHooks() { for (const fn of _removalHooks.hooks) { if (fn(this, this.parentPath)) return true; } } function _remove() { if (Array.isArray(this.container)) { this.container.splice(this.key, 1); this.updateSiblingKeys(this.key, -1); } else { this._replaceWith(null); } } function _markRemoved() { this._traverseFlags |= _index.SHOULD_SKIP | _index.REMOVED; if (this.parent) _cache.path.get(this.parent).delete(this.node); this.node = null; } function _assertUnremoved() { if (this.removed) { throw this.buildCodeFrameError("NodePath has been removed so is read-only."); } } },{"../cache":287,"./index":297,"./lib/removal-hooks":304}],309:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports._replaceWith = _replaceWith; exports.replaceExpressionWithStatements = replaceExpressionWithStatements; exports.replaceInline = replaceInline; exports.replaceWith = replaceWith; exports.replaceWithMultiple = replaceWithMultiple; exports.replaceWithSourceString = replaceWithSourceString; var _codeFrame = require("@babel/code-frame"); var _index = require("../index"); var _index2 = require("./index"); var _cache = require("../cache"); var _parser = require("@babel/parser"); var _t = require("@babel/types"); var _helperHoistVariables = require("@babel/helper-hoist-variables"); const { FUNCTION_TYPES, arrowFunctionExpression, assignmentExpression, awaitExpression, blockStatement, callExpression, cloneNode, expressionStatement, identifier, inheritLeadingComments, inheritTrailingComments, inheritsComments, isExpression, isProgram, isStatement, removeComments, returnStatement, toSequenceExpression, validate, yieldExpression } = _t; function replaceWithMultiple(nodes) { var _pathCache$get; this.resync(); nodes = this._verifyNodeList(nodes); inheritLeadingComments(nodes[0], this.node); inheritTrailingComments(nodes[nodes.length - 1], this.node); (_pathCache$get = _cache.path.get(this.parent)) == null ? void 0 : _pathCache$get.delete(this.node); this.node = this.container[this.key] = null; const paths = this.insertAfter(nodes); if (this.node) { this.requeue(); } else { this.remove(); } return paths; } function replaceWithSourceString(replacement) { this.resync(); let ast; try { replacement = `(${replacement})`; ast = (0, _parser.parse)(replacement); } catch (err) { const loc = err.loc; if (loc) { err.message += " - make sure this is an expression.\n" + (0, _codeFrame.codeFrameColumns)(replacement, { start: { line: loc.line, column: loc.column + 1 } }); err.code = "BABEL_REPLACE_SOURCE_ERROR"; } throw err; } const expressionAST = ast.program.body[0].expression; _index.default.removeProperties(expressionAST); return this.replaceWith(expressionAST); } function replaceWith(replacementPath) { this.resync(); if (this.removed) { throw new Error("You can't replace this node, we've already removed it"); } let replacement = replacementPath instanceof _index2.default ? replacementPath.node : replacementPath; if (!replacement) { throw new Error("You passed `path.replaceWith()` a falsy node, use `path.remove()` instead"); } if (this.node === replacement) { return [this]; } if (this.isProgram() && !isProgram(replacement)) { throw new Error("You can only replace a Program root node with another Program node"); } if (Array.isArray(replacement)) { throw new Error("Don't use `path.replaceWith()` with an array of nodes, use `path.replaceWithMultiple()`"); } if (typeof replacement === "string") { throw new Error("Don't use `path.replaceWith()` with a source string, use `path.replaceWithSourceString()`"); } let nodePath = ""; if (this.isNodeType("Statement") && isExpression(replacement)) { if (!this.canHaveVariableDeclarationOrExpression() && !this.canSwapBetweenExpressionAndStatement(replacement) && !this.parentPath.isExportDefaultDeclaration()) { replacement = expressionStatement(replacement); nodePath = "expression"; } } if (this.isNodeType("Expression") && isStatement(replacement)) { if (!this.canHaveVariableDeclarationOrExpression() && !this.canSwapBetweenExpressionAndStatement(replacement)) { return this.replaceExpressionWithStatements([replacement]); } } const oldNode = this.node; if (oldNode) { inheritsComments(replacement, oldNode); removeComments(oldNode); } this._replaceWith(replacement); this.type = replacement.type; this.setScope(); this.requeue(); return [nodePath ? this.get(nodePath) : this]; } function _replaceWith(node) { var _pathCache$get2; if (!this.container) { throw new ReferenceError("Container is falsy"); } if (this.inList) { validate(this.parent, this.key, [node]); } else { validate(this.parent, this.key, node); } this.debug(`Replace with ${node == null ? void 0 : node.type}`); (_pathCache$get2 = _cache.path.get(this.parent)) == null ? void 0 : _pathCache$get2.set(node, this).delete(this.node); this.node = this.container[this.key] = node; } function replaceExpressionWithStatements(nodes) { this.resync(); const nodesAsSequenceExpression = toSequenceExpression(nodes, this.scope); if (nodesAsSequenceExpression) { return this.replaceWith(nodesAsSequenceExpression)[0].get("expressions"); } const functionParent = this.getFunctionParent(); const isParentAsync = functionParent == null ? void 0 : functionParent.is("async"); const isParentGenerator = functionParent == null ? void 0 : functionParent.is("generator"); const container = arrowFunctionExpression([], blockStatement(nodes)); this.replaceWith(callExpression(container, [])); const callee = this.get("callee"); (0, _helperHoistVariables.default)(callee.get("body"), id => { this.scope.push({ id }); }, "var"); const completionRecords = this.get("callee").getCompletionRecords(); for (const path of completionRecords) { if (!path.isExpressionStatement()) continue; const loop = path.findParent(path => path.isLoop()); if (loop) { let uid = loop.getData("expressionReplacementReturnUid"); if (!uid) { uid = callee.scope.generateDeclaredUidIdentifier("ret"); callee.get("body").pushContainer("body", returnStatement(cloneNode(uid))); loop.setData("expressionReplacementReturnUid", uid); } else { uid = identifier(uid.name); } path.get("expression").replaceWith(assignmentExpression("=", cloneNode(uid), path.node.expression)); } else { path.replaceWith(returnStatement(path.node.expression)); } } callee.arrowFunctionToExpression(); const newCallee = callee; const needToAwaitFunction = isParentAsync && _index.default.hasType(this.get("callee.body").node, "AwaitExpression", FUNCTION_TYPES); const needToYieldFunction = isParentGenerator && _index.default.hasType(this.get("callee.body").node, "YieldExpression", FUNCTION_TYPES); if (needToAwaitFunction) { newCallee.set("async", true); if (!needToYieldFunction) { this.replaceWith(awaitExpression(this.node)); } } if (needToYieldFunction) { newCallee.set("generator", true); this.replaceWith(yieldExpression(this.node, true)); } return newCallee.get("body.body"); } function replaceInline(nodes) { this.resync(); if (Array.isArray(nodes)) { if (Array.isArray(this.container)) { nodes = this._verifyNodeList(nodes); const paths = this._containerInsertAfter(nodes); this.remove(); return paths; } else { return this.replaceWithMultiple(nodes); } } else { return this.replaceWith(nodes); } } },{"../cache":287,"../index":290,"./index":297,"@babel/code-frame":4,"@babel/helper-hoist-variables":78,"@babel/parser":266,"@babel/types":359}],310:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = void 0; class Binding { constructor({ identifier, scope, path, kind }) { this.identifier = void 0; this.scope = void 0; this.path = void 0; this.kind = void 0; this.constantViolations = []; this.constant = true; this.referencePaths = []; this.referenced = false; this.references = 0; this.identifier = identifier; this.scope = scope; this.path = path; this.kind = kind; if ((kind === "var" || kind === "hoisted") && isDeclaredInLoop(path || (() => { throw new Error("Internal Babel error: unreachable "); })())) { this.reassign(path); } this.clearValue(); } deoptValue() { this.clearValue(); this.hasDeoptedValue = true; } setValue(value) { if (this.hasDeoptedValue) return; this.hasValue = true; this.value = value; } clearValue() { this.hasDeoptedValue = false; this.hasValue = false; this.value = null; } reassign(path) { this.constant = false; if (this.constantViolations.indexOf(path) !== -1) { return; } this.constantViolations.push(path); } reference(path) { if (this.referencePaths.indexOf(path) !== -1) { return; } this.referenced = true; this.references++; this.referencePaths.push(path); } dereference() { this.references--; this.referenced = !!this.references; } } exports.default = Binding; function isDeclaredInLoop(path) { for (let { parentPath, key } = path; parentPath; ({ parentPath, key } = parentPath)) { if (parentPath.isFunctionParent()) return false; if (parentPath.isWhile() || parentPath.isForXStatement() || parentPath.isForStatement() && key === "body") { return true; } } return false; } },{}],311:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = void 0; var _renamer = require("./lib/renamer"); var _index = require("../index"); var _binding = require("./binding"); var _globals = require("globals"); var _t = require("@babel/types"); var _cache = require("../cache"); const { NOT_LOCAL_BINDING, callExpression, cloneNode, getBindingIdentifiers, identifier, isArrayExpression, isBinary, isClass, isClassBody, isClassDeclaration, isExportAllDeclaration, isExportDefaultDeclaration, isExportNamedDeclaration, isFunctionDeclaration, isIdentifier, isImportDeclaration, isLiteral, isMethod, isModuleDeclaration, isModuleSpecifier, isNullLiteral, isObjectExpression, isProperty, isPureish, isRegExpLiteral, isSuper, isTaggedTemplateExpression, isTemplateLiteral, isThisExpression, isUnaryExpression, isVariableDeclaration, matchesPattern, memberExpression, numericLiteral, toIdentifier, unaryExpression, variableDeclaration, variableDeclarator, isRecordExpression, isTupleExpression, isObjectProperty, isTopicReference, isMetaProperty, isPrivateName } = _t; function gatherNodeParts(node, parts) { switch (node == null ? void 0 : node.type) { default: if (isModuleDeclaration(node)) { if ((isExportAllDeclaration(node) || isExportNamedDeclaration(node) || isImportDeclaration(node)) && node.source) { gatherNodeParts(node.source, parts); } else if ((isExportNamedDeclaration(node) || isImportDeclaration(node)) && node.specifiers && node.specifiers.length) { for (const e of node.specifiers) gatherNodeParts(e, parts); } else if ((isExportDefaultDeclaration(node) || isExportNamedDeclaration(node)) && node.declaration) { gatherNodeParts(node.declaration, parts); } } else if (isModuleSpecifier(node)) { gatherNodeParts(node.local, parts); } else if (isLiteral(node) && !isNullLiteral(node) && !isRegExpLiteral(node) && !isTemplateLiteral(node)) { parts.push(node.value); } break; case "MemberExpression": case "OptionalMemberExpression": case "JSXMemberExpression": gatherNodeParts(node.object, parts); gatherNodeParts(node.property, parts); break; case "Identifier": case "JSXIdentifier": parts.push(node.name); break; case "CallExpression": case "OptionalCallExpression": case "NewExpression": gatherNodeParts(node.callee, parts); break; case "ObjectExpression": case "ObjectPattern": for (const e of node.properties) { gatherNodeParts(e, parts); } break; case "SpreadElement": case "RestElement": gatherNodeParts(node.argument, parts); break; case "ObjectProperty": case "ObjectMethod": case "ClassProperty": case "ClassMethod": case "ClassPrivateProperty": case "ClassPrivateMethod": gatherNodeParts(node.key, parts); break; case "ThisExpression": parts.push("this"); break; case "Super": parts.push("super"); break; case "Import": parts.push("import"); break; case "DoExpression": parts.push("do"); break; case "YieldExpression": parts.push("yield"); gatherNodeParts(node.argument, parts); break; case "AwaitExpression": parts.push("await"); gatherNodeParts(node.argument, parts); break; case "AssignmentExpression": gatherNodeParts(node.left, parts); break; case "VariableDeclarator": gatherNodeParts(node.id, parts); break; case "FunctionExpression": case "FunctionDeclaration": case "ClassExpression": case "ClassDeclaration": gatherNodeParts(node.id, parts); break; case "PrivateName": gatherNodeParts(node.id, parts); break; case "ParenthesizedExpression": gatherNodeParts(node.expression, parts); break; case "UnaryExpression": case "UpdateExpression": gatherNodeParts(node.argument, parts); break; case "MetaProperty": gatherNodeParts(node.meta, parts); gatherNodeParts(node.property, parts); break; case "JSXElement": gatherNodeParts(node.openingElement, parts); break; case "JSXOpeningElement": gatherNodeParts(node.name, parts); break; case "JSXFragment": gatherNodeParts(node.openingFragment, parts); break; case "JSXOpeningFragment": parts.push("Fragment"); break; case "JSXNamespacedName": gatherNodeParts(node.namespace, parts); gatherNodeParts(node.name, parts); break; } } const collectorVisitor = { ForStatement(path) { const declar = path.get("init"); if (declar.isVar()) { const { scope } = path; const parentScope = scope.getFunctionParent() || scope.getProgramParent(); parentScope.registerBinding("var", declar); } }, Declaration(path) { if (path.isBlockScoped()) return; if (path.isImportDeclaration()) return; if (path.isExportDeclaration()) return; const parent = path.scope.getFunctionParent() || path.scope.getProgramParent(); parent.registerDeclaration(path); }, ImportDeclaration(path) { const parent = path.scope.getBlockParent(); parent.registerDeclaration(path); }, ReferencedIdentifier(path, state) { state.references.push(path); }, ForXStatement(path, state) { const left = path.get("left"); if (left.isPattern() || left.isIdentifier()) { state.constantViolations.push(path); } else if (left.isVar()) { const { scope } = path; const parentScope = scope.getFunctionParent() || scope.getProgramParent(); parentScope.registerBinding("var", left); } }, ExportDeclaration: { exit(path) { const { node, scope } = path; if (isExportAllDeclaration(node)) return; const declar = node.declaration; if (isClassDeclaration(declar) || isFunctionDeclaration(declar)) { const id = declar.id; if (!id) return; const binding = scope.getBinding(id.name); binding == null ? void 0 : binding.reference(path); } else if (isVariableDeclaration(declar)) { for (const decl of declar.declarations) { for (const name of Object.keys(getBindingIdentifiers(decl))) { const binding = scope.getBinding(name); binding == null ? void 0 : binding.reference(path); } } } } }, LabeledStatement(path) { path.scope.getBlockParent().registerDeclaration(path); }, AssignmentExpression(path, state) { state.assignments.push(path); }, UpdateExpression(path, state) { state.constantViolations.push(path); }, UnaryExpression(path, state) { if (path.node.operator === "delete") { state.constantViolations.push(path); } }, BlockScoped(path) { let scope = path.scope; if (scope.path === path) scope = scope.parent; const parent = scope.getBlockParent(); parent.registerDeclaration(path); if (path.isClassDeclaration() && path.node.id) { const id = path.node.id; const name = id.name; path.scope.bindings[name] = path.scope.parent.getBinding(name); } }, CatchClause(path) { path.scope.registerBinding("let", path); }, Function(path) { const params = path.get("params"); for (const param of params) { path.scope.registerBinding("param", param); } if (path.isFunctionExpression() && path.has("id") && !path.get("id").node[NOT_LOCAL_BINDING]) { path.scope.registerBinding("local", path.get("id"), path); } }, ClassExpression(path) { if (path.has("id") && !path.get("id").node[NOT_LOCAL_BINDING]) { path.scope.registerBinding("local", path); } } }; let uid = 0; class Scope { constructor(path) { this.uid = void 0; this.path = void 0; this.block = void 0; this.labels = void 0; this.inited = void 0; this.bindings = void 0; this.references = void 0; this.globals = void 0; this.uids = void 0; this.data = void 0; this.crawling = void 0; const { node } = path; const cached = _cache.scope.get(node); if ((cached == null ? void 0 : cached.path) === path) { return cached; } _cache.scope.set(node, this); this.uid = uid++; this.block = node; this.path = path; this.labels = new Map(); this.inited = false; } get parent() { var _parent; let parent, path = this.path; do { const shouldSkip = path.key === "key" || path.listKey === "decorators"; path = path.parentPath; if (shouldSkip && path.isMethod()) path = path.parentPath; if (path && path.isScope()) parent = path; } while (path && !parent); return (_parent = parent) == null ? void 0 : _parent.scope; } get parentBlock() { return this.path.parent; } get hub() { return this.path.hub; } traverse(node, opts, state) { (0, _index.default)(node, opts, this, state, this.path); } generateDeclaredUidIdentifier(name) { const id = this.generateUidIdentifier(name); this.push({ id }); return cloneNode(id); } generateUidIdentifier(name) { return identifier(this.generateUid(name)); } generateUid(name = "temp") { name = toIdentifier(name).replace(/^_+/, "").replace(/[0-9]+$/g, ""); let uid; let i = 1; do { uid = this._generateUid(name, i); i++; } while (this.hasLabel(uid) || this.hasBinding(uid) || this.hasGlobal(uid) || this.hasReference(uid)); const program = this.getProgramParent(); program.references[uid] = true; program.uids[uid] = true; return uid; } _generateUid(name, i) { let id = name; if (i > 1) id += i; return `_${id}`; } generateUidBasedOnNode(node, defaultName) { const parts = []; gatherNodeParts(node, parts); let id = parts.join("$"); id = id.replace(/^_/, "") || defaultName || "ref"; return this.generateUid(id.slice(0, 20)); } generateUidIdentifierBasedOnNode(node, defaultName) { return identifier(this.generateUidBasedOnNode(node, defaultName)); } isStatic(node) { if (isThisExpression(node) || isSuper(node) || isTopicReference(node)) { return true; } if (isIdentifier(node)) { const binding = this.getBinding(node.name); if (binding) { return binding.constant; } else { return this.hasBinding(node.name); } } return false; } maybeGenerateMemoised(node, dontPush) { if (this.isStatic(node)) { return null; } else { const id = this.generateUidIdentifierBasedOnNode(node); if (!dontPush) { this.push({ id }); return cloneNode(id); } return id; } } checkBlockScopedCollisions(local, kind, name, id) { if (kind === "param") return; if (local.kind === "local") return; const duplicate = kind === "let" || local.kind === "let" || local.kind === "const" || local.kind === "module" || local.kind === "param" && kind === "const"; if (duplicate) { throw this.hub.buildError(id, `Duplicate declaration "${name}"`, TypeError); } } rename(oldName, newName, block) { const binding = this.getBinding(oldName); if (binding) { newName = newName || this.generateUidIdentifier(oldName).name; return new _renamer.default(binding, oldName, newName).rename(block); } } _renameFromMap(map, oldName, newName, value) { if (map[oldName]) { map[newName] = value; map[oldName] = null; } } dump() { const sep = "-".repeat(60); console.log(sep); let scope = this; do { console.log("#", scope.block.type); for (const name of Object.keys(scope.bindings)) { const binding = scope.bindings[name]; console.log(" -", name, { constant: binding.constant, references: binding.references, violations: binding.constantViolations.length, kind: binding.kind }); } } while (scope = scope.parent); console.log(sep); } toArray(node, i, arrayLikeIsIterable) { if (isIdentifier(node)) { const binding = this.getBinding(node.name); if (binding != null && binding.constant && binding.path.isGenericType("Array")) { return node; } } if (isArrayExpression(node)) { return node; } if (isIdentifier(node, { name: "arguments" })) { return callExpression(memberExpression(memberExpression(memberExpression(identifier("Array"), identifier("prototype")), identifier("slice")), identifier("call")), [node]); } let helperName; const args = [node]; if (i === true) { helperName = "toConsumableArray"; } else if (i) { args.push(numericLiteral(i)); helperName = "slicedToArray"; } else { helperName = "toArray"; } if (arrayLikeIsIterable) { args.unshift(this.hub.addHelper(helperName)); helperName = "maybeArrayLike"; } return callExpression(this.hub.addHelper(helperName), args); } hasLabel(name) { return !!this.getLabel(name); } getLabel(name) { return this.labels.get(name); } registerLabel(path) { this.labels.set(path.node.label.name, path); } registerDeclaration(path) { if (path.isLabeledStatement()) { this.registerLabel(path); } else if (path.isFunctionDeclaration()) { this.registerBinding("hoisted", path.get("id"), path); } else if (path.isVariableDeclaration()) { const declarations = path.get("declarations"); for (const declar of declarations) { this.registerBinding(path.node.kind, declar); } } else if (path.isClassDeclaration()) { if (path.node.declare) return; this.registerBinding("let", path); } else if (path.isImportDeclaration()) { const specifiers = path.get("specifiers"); for (const specifier of specifiers) { this.registerBinding("module", specifier); } } else if (path.isExportDeclaration()) { const declar = path.get("declaration"); if (declar.isClassDeclaration() || declar.isFunctionDeclaration() || declar.isVariableDeclaration()) { this.registerDeclaration(declar); } } else { this.registerBinding("unknown", path); } } buildUndefinedNode() { return unaryExpression("void", numericLiteral(0), true); } registerConstantViolation(path) { const ids = path.getBindingIdentifiers(); for (const name of Object.keys(ids)) { const binding = this.getBinding(name); if (binding) binding.reassign(path); } } registerBinding(kind, path, bindingPath = path) { if (!kind) throw new ReferenceError("no `kind`"); if (path.isVariableDeclaration()) { const declarators = path.get("declarations"); for (const declar of declarators) { this.registerBinding(kind, declar); } return; } const parent = this.getProgramParent(); const ids = path.getOuterBindingIdentifiers(true); for (const name of Object.keys(ids)) { parent.references[name] = true; for (const id of ids[name]) { const local = this.getOwnBinding(name); if (local) { if (local.identifier === id) continue; this.checkBlockScopedCollisions(local, kind, name, id); } if (local) { this.registerConstantViolation(bindingPath); } else { this.bindings[name] = new _binding.default({ identifier: id, scope: this, path: bindingPath, kind: kind }); } } } } addGlobal(node) { this.globals[node.name] = node; } hasUid(name) { let scope = this; do { if (scope.uids[name]) return true; } while (scope = scope.parent); return false; } hasGlobal(name) { let scope = this; do { if (scope.globals[name]) return true; } while (scope = scope.parent); return false; } hasReference(name) { return !!this.getProgramParent().references[name]; } isPure(node, constantsOnly) { if (isIdentifier(node)) { const binding = this.getBinding(node.name); if (!binding) return false; if (constantsOnly) return binding.constant; return true; } else if (isThisExpression(node) || isMetaProperty(node) || isTopicReference(node) || isPrivateName(node)) { return true; } else if (isClass(node)) { var _node$decorators; if (node.superClass && !this.isPure(node.superClass, constantsOnly)) { return false; } if (((_node$decorators = node.decorators) == null ? void 0 : _node$decorators.length) > 0) { return false; } return this.isPure(node.body, constantsOnly); } else if (isClassBody(node)) { for (const method of node.body) { if (!this.isPure(method, constantsOnly)) return false; } return true; } else if (isBinary(node)) { return this.isPure(node.left, constantsOnly) && this.isPure(node.right, constantsOnly); } else if (isArrayExpression(node) || isTupleExpression(node)) { for (const elem of node.elements) { if (elem !== null && !this.isPure(elem, constantsOnly)) return false; } return true; } else if (isObjectExpression(node) || isRecordExpression(node)) { for (const prop of node.properties) { if (!this.isPure(prop, constantsOnly)) return false; } return true; } else if (isMethod(node)) { var _node$decorators2; if (node.computed && !this.isPure(node.key, constantsOnly)) return false; if (((_node$decorators2 = node.decorators) == null ? void 0 : _node$decorators2.length) > 0) { return false; } return true; } else if (isProperty(node)) { var _node$decorators3; if (node.computed && !this.isPure(node.key, constantsOnly)) return false; if (((_node$decorators3 = node.decorators) == null ? void 0 : _node$decorators3.length) > 0) { return false; } if (isObjectProperty(node) || node.static) { if (node.value !== null && !this.isPure(node.value, constantsOnly)) { return false; } } return true; } else if (isUnaryExpression(node)) { return this.isPure(node.argument, constantsOnly); } else if (isTaggedTemplateExpression(node)) { return matchesPattern(node.tag, "String.raw") && !this.hasBinding("String", true) && this.isPure(node.quasi, constantsOnly); } else if (isTemplateLiteral(node)) { for (const expression of node.expressions) { if (!this.isPure(expression, constantsOnly)) return false; } return true; } else { return isPureish(node); } } setData(key, val) { return this.data[key] = val; } getData(key) { let scope = this; do { const data = scope.data[key]; if (data != null) return data; } while (scope = scope.parent); } removeData(key) { let scope = this; do { const data = scope.data[key]; if (data != null) scope.data[key] = null; } while (scope = scope.parent); } init() { if (!this.inited) { this.inited = true; this.crawl(); } } crawl() { const path = this.path; this.references = Object.create(null); this.bindings = Object.create(null); this.globals = Object.create(null); this.uids = Object.create(null); this.data = Object.create(null); const programParent = this.getProgramParent(); if (programParent.crawling) return; const state = { references: [], constantViolations: [], assignments: [] }; this.crawling = true; if (path.type !== "Program" && collectorVisitor._exploded) { for (const visit of collectorVisitor.enter) { visit(path, state); } const typeVisitors = collectorVisitor[path.type]; if (typeVisitors) { for (const visit of typeVisitors.enter) { visit(path, state); } } } path.traverse(collectorVisitor, state); this.crawling = false; for (const path of state.assignments) { const ids = path.getBindingIdentifiers(); for (const name of Object.keys(ids)) { if (path.scope.getBinding(name)) continue; programParent.addGlobal(ids[name]); } path.scope.registerConstantViolation(path); } for (const ref of state.references) { const binding = ref.scope.getBinding(ref.node.name); if (binding) { binding.reference(ref); } else { programParent.addGlobal(ref.node); } } for (const path of state.constantViolations) { path.scope.registerConstantViolation(path); } } push(opts) { let path = this.path; if (path.isPattern()) { path = this.getPatternParent().path; } else if (!path.isBlockStatement() && !path.isProgram()) { path = this.getBlockParent().path; } if (path.isSwitchStatement()) { path = (this.getFunctionParent() || this.getProgramParent()).path; } if (path.isLoop() || path.isCatchClause() || path.isFunction()) { path.ensureBlock(); path = path.get("body"); } const unique = opts.unique; const kind = opts.kind || "var"; const blockHoist = opts._blockHoist == null ? 2 : opts._blockHoist; const dataKey = `declaration:${kind}:${blockHoist}`; let declarPath = !unique && path.getData(dataKey); if (!declarPath) { const declar = variableDeclaration(kind, []); declar._blockHoist = blockHoist; [declarPath] = path.unshiftContainer("body", [declar]); if (!unique) path.setData(dataKey, declarPath); } const declarator = variableDeclarator(opts.id, opts.init); const len = declarPath.node.declarations.push(declarator); path.scope.registerBinding(kind, declarPath.get("declarations")[len - 1]); } getProgramParent() { let scope = this; do { if (scope.path.isProgram()) { return scope; } } while (scope = scope.parent); throw new Error("Couldn't find a Program"); } getFunctionParent() { let scope = this; do { if (scope.path.isFunctionParent()) { return scope; } } while (scope = scope.parent); return null; } getBlockParent() { let scope = this; do { if (scope.path.isBlockParent()) { return scope; } } while (scope = scope.parent); throw new Error("We couldn't find a BlockStatement, For, Switch, Function, Loop or Program..."); } getPatternParent() { let scope = this; do { if (!scope.path.isPattern()) { return scope.getBlockParent(); } } while (scope = scope.parent.parent); throw new Error("We couldn't find a BlockStatement, For, Switch, Function, Loop or Program..."); } getAllBindings() { const ids = Object.create(null); let scope = this; do { for (const key of Object.keys(scope.bindings)) { if (key in ids === false) { ids[key] = scope.bindings[key]; } } scope = scope.parent; } while (scope); return ids; } getAllBindingsOfKind(...kinds) { const ids = Object.create(null); for (const kind of kinds) { let scope = this; do { for (const name of Object.keys(scope.bindings)) { const binding = scope.bindings[name]; if (binding.kind === kind) ids[name] = binding; } scope = scope.parent; } while (scope); } return ids; } bindingIdentifierEquals(name, node) { return this.getBindingIdentifier(name) === node; } getBinding(name) { let scope = this; let previousPath; do { const binding = scope.getOwnBinding(name); if (binding) { var _previousPath; if ((_previousPath = previousPath) != null && _previousPath.isPattern() && binding.kind !== "param" && binding.kind !== "local") {} else { return binding; } } else if (!binding && name === "arguments" && scope.path.isFunction() && !scope.path.isArrowFunctionExpression()) { break; } previousPath = scope.path; } while (scope = scope.parent); } getOwnBinding(name) { return this.bindings[name]; } getBindingIdentifier(name) { var _this$getBinding; return (_this$getBinding = this.getBinding(name)) == null ? void 0 : _this$getBinding.identifier; } getOwnBindingIdentifier(name) { const binding = this.bindings[name]; return binding == null ? void 0 : binding.identifier; } hasOwnBinding(name) { return !!this.getOwnBinding(name); } hasBinding(name, noGlobals) { if (!name) return false; if (this.hasOwnBinding(name)) return true; if (this.parentHasBinding(name, noGlobals)) return true; if (this.hasUid(name)) return true; if (!noGlobals && Scope.globals.includes(name)) return true; if (!noGlobals && Scope.contextVariables.includes(name)) return true; return false; } parentHasBinding(name, noGlobals) { var _this$parent; return (_this$parent = this.parent) == null ? void 0 : _this$parent.hasBinding(name, noGlobals); } moveBindingTo(name, scope) { const info = this.getBinding(name); if (info) { info.scope.removeOwnBinding(name); info.scope = scope; scope.bindings[name] = info; } } removeOwnBinding(name) { delete this.bindings[name]; } removeBinding(name) { var _this$getBinding2; (_this$getBinding2 = this.getBinding(name)) == null ? void 0 : _this$getBinding2.scope.removeOwnBinding(name); let scope = this; do { if (scope.uids[name]) { scope.uids[name] = false; } } while (scope = scope.parent); } } exports.default = Scope; Scope.globals = Object.keys(_globals.builtin); Scope.contextVariables = ["arguments", "undefined", "Infinity", "NaN"]; },{"../cache":287,"../index":290,"./binding":310,"./lib/renamer":312,"@babel/types":359,"globals":442}],312:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = void 0; var _helperSplitExportDeclaration = require("@babel/helper-split-export-declaration"); var t = require("@babel/types"); var _helperEnvironmentVisitor = require("@babel/helper-environment-visitor"); const renameVisitor = { ReferencedIdentifier({ node }, state) { if (node.name === state.oldName) { node.name = state.newName; } }, Scope(path, state) { if (!path.scope.bindingIdentifierEquals(state.oldName, state.binding.identifier)) { path.skip(); if (path.isMethod()) { (0, _helperEnvironmentVisitor.requeueComputedKeyAndDecorators)(path); } } }, "AssignmentExpression|Declaration|VariableDeclarator"(path, state) { if (path.isVariableDeclaration()) return; const ids = path.getOuterBindingIdentifiers(); for (const name in ids) { if (name === state.oldName) ids[name].name = state.newName; } } }; class Renamer { constructor(binding, oldName, newName) { this.newName = newName; this.oldName = oldName; this.binding = binding; } maybeConvertFromExportDeclaration(parentDeclar) { const maybeExportDeclar = parentDeclar.parentPath; if (!maybeExportDeclar.isExportDeclaration()) { return; } if (maybeExportDeclar.isExportDefaultDeclaration()) { const { declaration } = maybeExportDeclar.node; if (t.isDeclaration(declaration) && !declaration.id) { return; } } if (maybeExportDeclar.isExportAllDeclaration()) { return; } (0, _helperSplitExportDeclaration.default)(maybeExportDeclar); } maybeConvertFromClassFunctionDeclaration(path) { return path; } maybeConvertFromClassFunctionExpression(path) { return path; } rename(block) { const { binding, oldName, newName } = this; const { scope, path } = binding; const parentDeclar = path.find(path => path.isDeclaration() || path.isFunctionExpression() || path.isClassExpression()); if (parentDeclar) { const bindingIds = parentDeclar.getOuterBindingIdentifiers(); if (bindingIds[oldName] === binding.identifier) { this.maybeConvertFromExportDeclaration(parentDeclar); } } const blockToTraverse = block || scope.block; if ((blockToTraverse == null ? void 0 : blockToTraverse.type) === "SwitchStatement") { blockToTraverse.cases.forEach(c => { scope.traverse(c, renameVisitor, this); }); } else { scope.traverse(blockToTraverse, renameVisitor, this); } if (!block) { scope.removeOwnBinding(oldName); scope.bindings[newName] = binding; this.binding.identifier.name = newName; } if (parentDeclar) { this.maybeConvertFromClassFunctionDeclaration(path); this.maybeConvertFromClassFunctionExpression(path); } } } exports.default = Renamer; },{"@babel/helper-environment-visitor":76,"@babel/helper-split-export-declaration":253,"@babel/types":359}],313:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.traverseNode = traverseNode; var _context = require("./context"); var _t = require("@babel/types"); const { VISITOR_KEYS } = _t; function traverseNode(node, opts, scope, state, path, skipKeys) { const keys = VISITOR_KEYS[node.type]; if (!keys) return false; const context = new _context.default(scope, opts, state, path); for (const key of keys) { if (skipKeys && skipKeys[key]) continue; if (context.visit(node, key)) { return true; } } return false; } },{"./context":288,"@babel/types":359}],314:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.explode = explode; exports.merge = merge; exports.verify = verify; var virtualTypes = require("./path/lib/virtual-types"); var _t = require("@babel/types"); const { DEPRECATED_KEYS, FLIPPED_ALIAS_KEYS, TYPES } = _t; function isVirtualType(type) { return type in virtualTypes; } function explode(visitor) { if (visitor._exploded) return visitor; visitor._exploded = true; for (const nodeType of Object.keys(visitor)) { if (shouldIgnoreKey(nodeType)) continue; const parts = nodeType.split("|"); if (parts.length === 1) continue; const fns = visitor[nodeType]; delete visitor[nodeType]; for (const part of parts) { visitor[part] = fns; } } verify(visitor); delete visitor.__esModule; ensureEntranceObjects(visitor); ensureCallbackArrays(visitor); for (const nodeType of Object.keys(visitor)) { if (shouldIgnoreKey(nodeType)) continue; if (!isVirtualType(nodeType)) continue; const fns = visitor[nodeType]; for (const type of Object.keys(fns)) { fns[type] = wrapCheck(nodeType, fns[type]); } delete visitor[nodeType]; const types = virtualTypes[nodeType]; if (types !== null) { for (const type of types) { if (visitor[type]) { mergePair(visitor[type], fns); } else { visitor[type] = fns; } } } else { mergePair(visitor, fns); } } for (const nodeType of Object.keys(visitor)) { if (shouldIgnoreKey(nodeType)) continue; const fns = visitor[nodeType]; let aliases = FLIPPED_ALIAS_KEYS[nodeType]; const deprecatedKey = DEPRECATED_KEYS[nodeType]; if (deprecatedKey) { console.trace(`Visitor defined for ${nodeType} but it has been renamed to ${deprecatedKey}`); aliases = [deprecatedKey]; } if (!aliases) continue; delete visitor[nodeType]; for (const alias of aliases) { const existing = visitor[alias]; if (existing) { mergePair(existing, fns); } else { visitor[alias] = Object.assign({}, fns); } } } for (const nodeType of Object.keys(visitor)) { if (shouldIgnoreKey(nodeType)) continue; ensureCallbackArrays(visitor[nodeType]); } return visitor; } function verify(visitor) { if (visitor._verified) return; if (typeof visitor === "function") { throw new Error("You passed `traverse()` a function when it expected a visitor object, " + "are you sure you didn't mean `{ enter: Function }`?"); } for (const nodeType of Object.keys(visitor)) { if (nodeType === "enter" || nodeType === "exit") { validateVisitorMethods(nodeType, visitor[nodeType]); } if (shouldIgnoreKey(nodeType)) continue; if (TYPES.indexOf(nodeType) < 0) { throw new Error(`You gave us a visitor for the node type ${nodeType} but it's not a valid type`); } const visitors = visitor[nodeType]; if (typeof visitors === "object") { for (const visitorKey of Object.keys(visitors)) { if (visitorKey === "enter" || visitorKey === "exit") { validateVisitorMethods(`${nodeType}.${visitorKey}`, visitors[visitorKey]); } else { throw new Error("You passed `traverse()` a visitor object with the property " + `${nodeType} that has the invalid property ${visitorKey}`); } } } } visitor._verified = true; } function validateVisitorMethods(path, val) { const fns = [].concat(val); for (const fn of fns) { if (typeof fn !== "function") { throw new TypeError(`Non-function found defined in ${path} with type ${typeof fn}`); } } } function merge(visitors, states = [], wrapper) { const rootVisitor = {}; for (let i = 0; i < visitors.length; i++) { const visitor = visitors[i]; const state = states[i]; explode(visitor); for (const type of Object.keys(visitor)) { let visitorType = visitor[type]; if (state || wrapper) { visitorType = wrapWithStateOrWrapper(visitorType, state, wrapper); } const nodeVisitor = rootVisitor[type] || (rootVisitor[type] = {}); mergePair(nodeVisitor, visitorType); } } return rootVisitor; } function wrapWithStateOrWrapper(oldVisitor, state, wrapper) { const newVisitor = {}; for (const key of Object.keys(oldVisitor)) { let fns = oldVisitor[key]; if (!Array.isArray(fns)) continue; fns = fns.map(function (fn) { let newFn = fn; if (state) { newFn = function (path) { return fn.call(state, path, state); }; } if (wrapper) { newFn = wrapper(state.key, key, newFn); } if (newFn !== fn) { newFn.toString = () => fn.toString(); } return newFn; }); newVisitor[key] = fns; } return newVisitor; } function ensureEntranceObjects(obj) { for (const key of Object.keys(obj)) { if (shouldIgnoreKey(key)) continue; const fns = obj[key]; if (typeof fns === "function") { obj[key] = { enter: fns }; } } } function ensureCallbackArrays(obj) { if (obj.enter && !Array.isArray(obj.enter)) obj.enter = [obj.enter]; if (obj.exit && !Array.isArray(obj.exit)) obj.exit = [obj.exit]; } function wrapCheck(nodeType, fn) { const newFn = function (path) { if (path[`is${nodeType}`]()) { return fn.apply(this, arguments); } }; newFn.toString = () => fn.toString(); return newFn; } function shouldIgnoreKey(key) { if (key[0] === "_") return true; if (key === "enter" || key === "exit" || key === "shouldSkip") return true; if (key === "denylist" || key === "noScope" || key === "skipKeys" || key === "blacklist") { return true; } return false; } function mergePair(dest, src) { for (const key of Object.keys(src)) { dest[key] = [].concat(dest[key] || [], src[key]); } } },{"./path/lib/virtual-types":306,"@babel/types":359}],315:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = assertNode; var _isNode = require("../validators/isNode"); function assertNode(node) { if (!(0, _isNode.default)(node)) { var _node$type; const type = (_node$type = node == null ? void 0 : node.type) != null ? _node$type : JSON.stringify(node); throw new TypeError(`Not a valid node of type "${type}"`); } } },{"../validators/isNode":381}],316:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.assertAccessor = assertAccessor; exports.assertAnyTypeAnnotation = assertAnyTypeAnnotation; exports.assertArgumentPlaceholder = assertArgumentPlaceholder; exports.assertArrayExpression = assertArrayExpression; exports.assertArrayPattern = assertArrayPattern; exports.assertArrayTypeAnnotation = assertArrayTypeAnnotation; exports.assertArrowFunctionExpression = assertArrowFunctionExpression; exports.assertAssignmentExpression = assertAssignmentExpression; exports.assertAssignmentPattern = assertAssignmentPattern; exports.assertAwaitExpression = assertAwaitExpression; exports.assertBigIntLiteral = assertBigIntLiteral; exports.assertBinary = assertBinary; exports.assertBinaryExpression = assertBinaryExpression; exports.assertBindExpression = assertBindExpression; exports.assertBlock = assertBlock; exports.assertBlockParent = assertBlockParent; exports.assertBlockStatement = assertBlockStatement; exports.assertBooleanLiteral = assertBooleanLiteral; exports.assertBooleanLiteralTypeAnnotation = assertBooleanLiteralTypeAnnotation; exports.assertBooleanTypeAnnotation = assertBooleanTypeAnnotation; exports.assertBreakStatement = assertBreakStatement; exports.assertCallExpression = assertCallExpression; exports.assertCatchClause = assertCatchClause; exports.assertClass = assertClass; exports.assertClassAccessorProperty = assertClassAccessorProperty; exports.assertClassBody = assertClassBody; exports.assertClassDeclaration = assertClassDeclaration; exports.assertClassExpression = assertClassExpression; exports.assertClassImplements = assertClassImplements; exports.assertClassMethod = assertClassMethod; exports.assertClassPrivateMethod = assertClassPrivateMethod; exports.assertClassPrivateProperty = assertClassPrivateProperty; exports.assertClassProperty = assertClassProperty; exports.assertCompletionStatement = assertCompletionStatement; exports.assertConditional = assertConditional; exports.assertConditionalExpression = assertConditionalExpression; exports.assertContinueStatement = assertContinueStatement; exports.assertDebuggerStatement = assertDebuggerStatement; exports.assertDecimalLiteral = assertDecimalLiteral; exports.assertDeclaration = assertDeclaration; exports.assertDeclareClass = assertDeclareClass; exports.assertDeclareExportAllDeclaration = assertDeclareExportAllDeclaration; exports.assertDeclareExportDeclaration = assertDeclareExportDeclaration; exports.assertDeclareFunction = assertDeclareFunction; exports.assertDeclareInterface = assertDeclareInterface; exports.assertDeclareModule = assertDeclareModule; exports.assertDeclareModuleExports = assertDeclareModuleExports; exports.assertDeclareOpaqueType = assertDeclareOpaqueType; exports.assertDeclareTypeAlias = assertDeclareTypeAlias; exports.assertDeclareVariable = assertDeclareVariable; exports.assertDeclaredPredicate = assertDeclaredPredicate; exports.assertDecorator = assertDecorator; exports.assertDirective = assertDirective; exports.assertDirectiveLiteral = assertDirectiveLiteral; exports.assertDoExpression = assertDoExpression; exports.assertDoWhileStatement = assertDoWhileStatement; exports.assertEmptyStatement = assertEmptyStatement; exports.assertEmptyTypeAnnotation = assertEmptyTypeAnnotation; exports.assertEnumBody = assertEnumBody; exports.assertEnumBooleanBody = assertEnumBooleanBody; exports.assertEnumBooleanMember = assertEnumBooleanMember; exports.assertEnumDeclaration = assertEnumDeclaration; exports.assertEnumDefaultedMember = assertEnumDefaultedMember; exports.assertEnumMember = assertEnumMember; exports.assertEnumNumberBody = assertEnumNumberBody; exports.assertEnumNumberMember = assertEnumNumberMember; exports.assertEnumStringBody = assertEnumStringBody; exports.assertEnumStringMember = assertEnumStringMember; exports.assertEnumSymbolBody = assertEnumSymbolBody; exports.assertExistsTypeAnnotation = assertExistsTypeAnnotation; exports.assertExportAllDeclaration = assertExportAllDeclaration; exports.assertExportDeclaration = assertExportDeclaration; exports.assertExportDefaultDeclaration = assertExportDefaultDeclaration; exports.assertExportDefaultSpecifier = assertExportDefaultSpecifier; exports.assertExportNamedDeclaration = assertExportNamedDeclaration; exports.assertExportNamespaceSpecifier = assertExportNamespaceSpecifier; exports.assertExportSpecifier = assertExportSpecifier; exports.assertExpression = assertExpression; exports.assertExpressionStatement = assertExpressionStatement; exports.assertExpressionWrapper = assertExpressionWrapper; exports.assertFile = assertFile; exports.assertFlow = assertFlow; exports.assertFlowBaseAnnotation = assertFlowBaseAnnotation; exports.assertFlowDeclaration = assertFlowDeclaration; exports.assertFlowPredicate = assertFlowPredicate; exports.assertFlowType = assertFlowType; exports.assertFor = assertFor; exports.assertForInStatement = assertForInStatement; exports.assertForOfStatement = assertForOfStatement; exports.assertForStatement = assertForStatement; exports.assertForXStatement = assertForXStatement; exports.assertFunction = assertFunction; exports.assertFunctionDeclaration = assertFunctionDeclaration; exports.assertFunctionExpression = assertFunctionExpression; exports.assertFunctionParent = assertFunctionParent; exports.assertFunctionTypeAnnotation = assertFunctionTypeAnnotation; exports.assertFunctionTypeParam = assertFunctionTypeParam; exports.assertGenericTypeAnnotation = assertGenericTypeAnnotation; exports.assertIdentifier = assertIdentifier; exports.assertIfStatement = assertIfStatement; exports.assertImmutable = assertImmutable; exports.assertImport = assertImport; exports.assertImportAttribute = assertImportAttribute; exports.assertImportDeclaration = assertImportDeclaration; exports.assertImportDefaultSpecifier = assertImportDefaultSpecifier; exports.assertImportNamespaceSpecifier = assertImportNamespaceSpecifier; exports.assertImportSpecifier = assertImportSpecifier; exports.assertIndexedAccessType = assertIndexedAccessType; exports.assertInferredPredicate = assertInferredPredicate; exports.assertInterfaceDeclaration = assertInterfaceDeclaration; exports.assertInterfaceExtends = assertInterfaceExtends; exports.assertInterfaceTypeAnnotation = assertInterfaceTypeAnnotation; exports.assertInterpreterDirective = assertInterpreterDirective; exports.assertIntersectionTypeAnnotation = assertIntersectionTypeAnnotation; exports.assertJSX = assertJSX; exports.assertJSXAttribute = assertJSXAttribute; exports.assertJSXClosingElement = assertJSXClosingElement; exports.assertJSXClosingFragment = assertJSXClosingFragment; exports.assertJSXElement = assertJSXElement; exports.assertJSXEmptyExpression = assertJSXEmptyExpression; exports.assertJSXExpressionContainer = assertJSXExpressionContainer; exports.assertJSXFragment = assertJSXFragment; exports.assertJSXIdentifier = assertJSXIdentifier; exports.assertJSXMemberExpression = assertJSXMemberExpression; exports.assertJSXNamespacedName = assertJSXNamespacedName; exports.assertJSXOpeningElement = assertJSXOpeningElement; exports.assertJSXOpeningFragment = assertJSXOpeningFragment; exports.assertJSXSpreadAttribute = assertJSXSpreadAttribute; exports.assertJSXSpreadChild = assertJSXSpreadChild; exports.assertJSXText = assertJSXText; exports.assertLVal = assertLVal; exports.assertLabeledStatement = assertLabeledStatement; exports.assertLiteral = assertLiteral; exports.assertLogicalExpression = assertLogicalExpression; exports.assertLoop = assertLoop; exports.assertMemberExpression = assertMemberExpression; exports.assertMetaProperty = assertMetaProperty; exports.assertMethod = assertMethod; exports.assertMiscellaneous = assertMiscellaneous; exports.assertMixedTypeAnnotation = assertMixedTypeAnnotation; exports.assertModuleDeclaration = assertModuleDeclaration; exports.assertModuleExpression = assertModuleExpression; exports.assertModuleSpecifier = assertModuleSpecifier; exports.assertNewExpression = assertNewExpression; exports.assertNoop = assertNoop; exports.assertNullLiteral = assertNullLiteral; exports.assertNullLiteralTypeAnnotation = assertNullLiteralTypeAnnotation; exports.assertNullableTypeAnnotation = assertNullableTypeAnnotation; exports.assertNumberLiteral = assertNumberLiteral; exports.assertNumberLiteralTypeAnnotation = assertNumberLiteralTypeAnnotation; exports.assertNumberTypeAnnotation = assertNumberTypeAnnotation; exports.assertNumericLiteral = assertNumericLiteral; exports.assertObjectExpression = assertObjectExpression; exports.assertObjectMember = assertObjectMember; exports.assertObjectMethod = assertObjectMethod; exports.assertObjectPattern = assertObjectPattern; exports.assertObjectProperty = assertObjectProperty; exports.assertObjectTypeAnnotation = assertObjectTypeAnnotation; exports.assertObjectTypeCallProperty = assertObjectTypeCallProperty; exports.assertObjectTypeIndexer = assertObjectTypeIndexer; exports.assertObjectTypeInternalSlot = assertObjectTypeInternalSlot; exports.assertObjectTypeProperty = assertObjectTypeProperty; exports.assertObjectTypeSpreadProperty = assertObjectTypeSpreadProperty; exports.assertOpaqueType = assertOpaqueType; exports.assertOptionalCallExpression = assertOptionalCallExpression; exports.assertOptionalIndexedAccessType = assertOptionalIndexedAccessType; exports.assertOptionalMemberExpression = assertOptionalMemberExpression; exports.assertParenthesizedExpression = assertParenthesizedExpression; exports.assertPattern = assertPattern; exports.assertPatternLike = assertPatternLike; exports.assertPipelineBareFunction = assertPipelineBareFunction; exports.assertPipelinePrimaryTopicReference = assertPipelinePrimaryTopicReference; exports.assertPipelineTopicExpression = assertPipelineTopicExpression; exports.assertPlaceholder = assertPlaceholder; exports.assertPrivate = assertPrivate; exports.assertPrivateName = assertPrivateName; exports.assertProgram = assertProgram; exports.assertProperty = assertProperty; exports.assertPureish = assertPureish; exports.assertQualifiedTypeIdentifier = assertQualifiedTypeIdentifier; exports.assertRecordExpression = assertRecordExpression; exports.assertRegExpLiteral = assertRegExpLiteral; exports.assertRegexLiteral = assertRegexLiteral; exports.assertRestElement = assertRestElement; exports.assertRestProperty = assertRestProperty; exports.assertReturnStatement = assertReturnStatement; exports.assertScopable = assertScopable; exports.assertSequenceExpression = assertSequenceExpression; exports.assertSpreadElement = assertSpreadElement; exports.assertSpreadProperty = assertSpreadProperty; exports.assertStandardized = assertStandardized; exports.assertStatement = assertStatement; exports.assertStaticBlock = assertStaticBlock; exports.assertStringLiteral = assertStringLiteral; exports.assertStringLiteralTypeAnnotation = assertStringLiteralTypeAnnotation; exports.assertStringTypeAnnotation = assertStringTypeAnnotation; exports.assertSuper = assertSuper; exports.assertSwitchCase = assertSwitchCase; exports.assertSwitchStatement = assertSwitchStatement; exports.assertSymbolTypeAnnotation = assertSymbolTypeAnnotation; exports.assertTSAnyKeyword = assertTSAnyKeyword; exports.assertTSArrayType = assertTSArrayType; exports.assertTSAsExpression = assertTSAsExpression; exports.assertTSBaseType = assertTSBaseType; exports.assertTSBigIntKeyword = assertTSBigIntKeyword; exports.assertTSBooleanKeyword = assertTSBooleanKeyword; exports.assertTSCallSignatureDeclaration = assertTSCallSignatureDeclaration; exports.assertTSConditionalType = assertTSConditionalType; exports.assertTSConstructSignatureDeclaration = assertTSConstructSignatureDeclaration; exports.assertTSConstructorType = assertTSConstructorType; exports.assertTSDeclareFunction = assertTSDeclareFunction; exports.assertTSDeclareMethod = assertTSDeclareMethod; exports.assertTSEntityName = assertTSEntityName; exports.assertTSEnumDeclaration = assertTSEnumDeclaration; exports.assertTSEnumMember = assertTSEnumMember; exports.assertTSExportAssignment = assertTSExportAssignment; exports.assertTSExpressionWithTypeArguments = assertTSExpressionWithTypeArguments; exports.assertTSExternalModuleReference = assertTSExternalModuleReference; exports.assertTSFunctionType = assertTSFunctionType; exports.assertTSImportEqualsDeclaration = assertTSImportEqualsDeclaration; exports.assertTSImportType = assertTSImportType; exports.assertTSIndexSignature = assertTSIndexSignature; exports.assertTSIndexedAccessType = assertTSIndexedAccessType; exports.assertTSInferType = assertTSInferType; exports.assertTSInstantiationExpression = assertTSInstantiationExpression; exports.assertTSInterfaceBody = assertTSInterfaceBody; exports.assertTSInterfaceDeclaration = assertTSInterfaceDeclaration; exports.assertTSIntersectionType = assertTSIntersectionType; exports.assertTSIntrinsicKeyword = assertTSIntrinsicKeyword; exports.assertTSLiteralType = assertTSLiteralType; exports.assertTSMappedType = assertTSMappedType; exports.assertTSMethodSignature = assertTSMethodSignature; exports.assertTSModuleBlock = assertTSModuleBlock; exports.assertTSModuleDeclaration = assertTSModuleDeclaration; exports.assertTSNamedTupleMember = assertTSNamedTupleMember; exports.assertTSNamespaceExportDeclaration = assertTSNamespaceExportDeclaration; exports.assertTSNeverKeyword = assertTSNeverKeyword; exports.assertTSNonNullExpression = assertTSNonNullExpression; exports.assertTSNullKeyword = assertTSNullKeyword; exports.assertTSNumberKeyword = assertTSNumberKeyword; exports.assertTSObjectKeyword = assertTSObjectKeyword; exports.assertTSOptionalType = assertTSOptionalType; exports.assertTSParameterProperty = assertTSParameterProperty; exports.assertTSParenthesizedType = assertTSParenthesizedType; exports.assertTSPropertySignature = assertTSPropertySignature; exports.assertTSQualifiedName = assertTSQualifiedName; exports.assertTSRestType = assertTSRestType; exports.assertTSStringKeyword = assertTSStringKeyword; exports.assertTSSymbolKeyword = assertTSSymbolKeyword; exports.assertTSThisType = assertTSThisType; exports.assertTSTupleType = assertTSTupleType; exports.assertTSType = assertTSType; exports.assertTSTypeAliasDeclaration = assertTSTypeAliasDeclaration; exports.assertTSTypeAnnotation = assertTSTypeAnnotation; exports.assertTSTypeAssertion = assertTSTypeAssertion; exports.assertTSTypeElement = assertTSTypeElement; exports.assertTSTypeLiteral = assertTSTypeLiteral; exports.assertTSTypeOperator = assertTSTypeOperator; exports.assertTSTypeParameter = assertTSTypeParameter; exports.assertTSTypeParameterDeclaration = assertTSTypeParameterDeclaration; exports.assertTSTypeParameterInstantiation = assertTSTypeParameterInstantiation; exports.assertTSTypePredicate = assertTSTypePredicate; exports.assertTSTypeQuery = assertTSTypeQuery; exports.assertTSTypeReference = assertTSTypeReference; exports.assertTSUndefinedKeyword = assertTSUndefinedKeyword; exports.assertTSUnionType = assertTSUnionType; exports.assertTSUnknownKeyword = assertTSUnknownKeyword; exports.assertTSVoidKeyword = assertTSVoidKeyword; exports.assertTaggedTemplateExpression = assertTaggedTemplateExpression; exports.assertTemplateElement = assertTemplateElement; exports.assertTemplateLiteral = assertTemplateLiteral; exports.assertTerminatorless = assertTerminatorless; exports.assertThisExpression = assertThisExpression; exports.assertThisTypeAnnotation = assertThisTypeAnnotation; exports.assertThrowStatement = assertThrowStatement; exports.assertTopicReference = assertTopicReference; exports.assertTryStatement = assertTryStatement; exports.assertTupleExpression = assertTupleExpression; exports.assertTupleTypeAnnotation = assertTupleTypeAnnotation; exports.assertTypeAlias = assertTypeAlias; exports.assertTypeAnnotation = assertTypeAnnotation; exports.assertTypeCastExpression = assertTypeCastExpression; exports.assertTypeParameter = assertTypeParameter; exports.assertTypeParameterDeclaration = assertTypeParameterDeclaration; exports.assertTypeParameterInstantiation = assertTypeParameterInstantiation; exports.assertTypeScript = assertTypeScript; exports.assertTypeofTypeAnnotation = assertTypeofTypeAnnotation; exports.assertUnaryExpression = assertUnaryExpression; exports.assertUnaryLike = assertUnaryLike; exports.assertUnionTypeAnnotation = assertUnionTypeAnnotation; exports.assertUpdateExpression = assertUpdateExpression; exports.assertUserWhitespacable = assertUserWhitespacable; exports.assertV8IntrinsicIdentifier = assertV8IntrinsicIdentifier; exports.assertVariableDeclaration = assertVariableDeclaration; exports.assertVariableDeclarator = assertVariableDeclarator; exports.assertVariance = assertVariance; exports.assertVoidTypeAnnotation = assertVoidTypeAnnotation; exports.assertWhile = assertWhile; exports.assertWhileStatement = assertWhileStatement; exports.assertWithStatement = assertWithStatement; exports.assertYieldExpression = assertYieldExpression; var _is = require("../../validators/is"); function assert(type, node, opts) { if (!(0, _is.default)(type, node, opts)) { throw new Error(`Expected type "${type}" with option ${JSON.stringify(opts)}, ` + `but instead got "${node.type}".`); } } function assertArrayExpression(node, opts) { assert("ArrayExpression", node, opts); } function assertAssignmentExpression(node, opts) { assert("AssignmentExpression", node, opts); } function assertBinaryExpression(node, opts) { assert("BinaryExpression", node, opts); } function assertInterpreterDirective(node, opts) { assert("InterpreterDirective", node, opts); } function assertDirective(node, opts) { assert("Directive", node, opts); } function assertDirectiveLiteral(node, opts) { assert("DirectiveLiteral", node, opts); } function assertBlockStatement(node, opts) { assert("BlockStatement", node, opts); } function assertBreakStatement(node, opts) { assert("BreakStatement", node, opts); } function assertCallExpression(node, opts) { assert("CallExpression", node, opts); } function assertCatchClause(node, opts) { assert("CatchClause", node, opts); } function assertConditionalExpression(node, opts) { assert("ConditionalExpression", node, opts); } function assertContinueStatement(node, opts) { assert("ContinueStatement", node, opts); } function assertDebuggerStatement(node, opts) { assert("DebuggerStatement", node, opts); } function assertDoWhileStatement(node, opts) { assert("DoWhileStatement", node, opts); } function assertEmptyStatement(node, opts) { assert("EmptyStatement", node, opts); } function assertExpressionStatement(node, opts) { assert("ExpressionStatement", node, opts); } function assertFile(node, opts) { assert("File", node, opts); } function assertForInStatement(node, opts) { assert("ForInStatement", node, opts); } function assertForStatement(node, opts) { assert("ForStatement", node, opts); } function assertFunctionDeclaration(node, opts) { assert("FunctionDeclaration", node, opts); } function assertFunctionExpression(node, opts) { assert("FunctionExpression", node, opts); } function assertIdentifier(node, opts) { assert("Identifier", node, opts); } function assertIfStatement(node, opts) { assert("IfStatement", node, opts); } function assertLabeledStatement(node, opts) { assert("LabeledStatement", node, opts); } function assertStringLiteral(node, opts) { assert("StringLiteral", node, opts); } function assertNumericLiteral(node, opts) { assert("NumericLiteral", node, opts); } function assertNullLiteral(node, opts) { assert("NullLiteral", node, opts); } function assertBooleanLiteral(node, opts) { assert("BooleanLiteral", node, opts); } function assertRegExpLiteral(node, opts) { assert("RegExpLiteral", node, opts); } function assertLogicalExpression(node, opts) { assert("LogicalExpression", node, opts); } function assertMemberExpression(node, opts) { assert("MemberExpression", node, opts); } function assertNewExpression(node, opts) { assert("NewExpression", node, opts); } function assertProgram(node, opts) { assert("Program", node, opts); } function assertObjectExpression(node, opts) { assert("ObjectExpression", node, opts); } function assertObjectMethod(node, opts) { assert("ObjectMethod", node, opts); } function assertObjectProperty(node, opts) { assert("ObjectProperty", node, opts); } function assertRestElement(node, opts) { assert("RestElement", node, opts); } function assertReturnStatement(node, opts) { assert("ReturnStatement", node, opts); } function assertSequenceExpression(node, opts) { assert("SequenceExpression", node, opts); } function assertParenthesizedExpression(node, opts) { assert("ParenthesizedExpression", node, opts); } function assertSwitchCase(node, opts) { assert("SwitchCase", node, opts); } function assertSwitchStatement(node, opts) { assert("SwitchStatement", node, opts); } function assertThisExpression(node, opts) { assert("ThisExpression", node, opts); } function assertThrowStatement(node, opts) { assert("ThrowStatement", node, opts); } function assertTryStatement(node, opts) { assert("TryStatement", node, opts); } function assertUnaryExpression(node, opts) { assert("UnaryExpression", node, opts); } function assertUpdateExpression(node, opts) { assert("UpdateExpression", node, opts); } function assertVariableDeclaration(node, opts) { assert("VariableDeclaration", node, opts); } function assertVariableDeclarator(node, opts) { assert("VariableDeclarator", node, opts); } function assertWhileStatement(node, opts) { assert("WhileStatement", node, opts); } function assertWithStatement(node, opts) { assert("WithStatement", node, opts); } function assertAssignmentPattern(node, opts) { assert("AssignmentPattern", node, opts); } function assertArrayPattern(node, opts) { assert("ArrayPattern", node, opts); } function assertArrowFunctionExpression(node, opts) { assert("ArrowFunctionExpression", node, opts); } function assertClassBody(node, opts) { assert("ClassBody", node, opts); } function assertClassExpression(node, opts) { assert("ClassExpression", node, opts); } function assertClassDeclaration(node, opts) { assert("ClassDeclaration", node, opts); } function assertExportAllDeclaration(node, opts) { assert("ExportAllDeclaration", node, opts); } function assertExportDefaultDeclaration(node, opts) { assert("ExportDefaultDeclaration", node, opts); } function assertExportNamedDeclaration(node, opts) { assert("ExportNamedDeclaration", node, opts); } function assertExportSpecifier(node, opts) { assert("ExportSpecifier", node, opts); } function assertForOfStatement(node, opts) { assert("ForOfStatement", node, opts); } function assertImportDeclaration(node, opts) { assert("ImportDeclaration", node, opts); } function assertImportDefaultSpecifier(node, opts) { assert("ImportDefaultSpecifier", node, opts); } function assertImportNamespaceSpecifier(node, opts) { assert("ImportNamespaceSpecifier", node, opts); } function assertImportSpecifier(node, opts) { assert("ImportSpecifier", node, opts); } function assertMetaProperty(node, opts) { assert("MetaProperty", node, opts); } function assertClassMethod(node, opts) { assert("ClassMethod", node, opts); } function assertObjectPattern(node, opts) { assert("ObjectPattern", node, opts); } function assertSpreadElement(node, opts) { assert("SpreadElement", node, opts); } function assertSuper(node, opts) { assert("Super", node, opts); } function assertTaggedTemplateExpression(node, opts) { assert("TaggedTemplateExpression", node, opts); } function assertTemplateElement(node, opts) { assert("TemplateElement", node, opts); } function assertTemplateLiteral(node, opts) { assert("TemplateLiteral", node, opts); } function assertYieldExpression(node, opts) { assert("YieldExpression", node, opts); } function assertAwaitExpression(node, opts) { assert("AwaitExpression", node, opts); } function assertImport(node, opts) { assert("Import", node, opts); } function assertBigIntLiteral(node, opts) { assert("BigIntLiteral", node, opts); } function assertExportNamespaceSpecifier(node, opts) { assert("ExportNamespaceSpecifier", node, opts); } function assertOptionalMemberExpression(node, opts) { assert("OptionalMemberExpression", node, opts); } function assertOptionalCallExpression(node, opts) { assert("OptionalCallExpression", node, opts); } function assertClassProperty(node, opts) { assert("ClassProperty", node, opts); } function assertClassAccessorProperty(node, opts) { assert("ClassAccessorProperty", node, opts); } function assertClassPrivateProperty(node, opts) { assert("ClassPrivateProperty", node, opts); } function assertClassPrivateMethod(node, opts) { assert("ClassPrivateMethod", node, opts); } function assertPrivateName(node, opts) { assert("PrivateName", node, opts); } function assertStaticBlock(node, opts) { assert("StaticBlock", node, opts); } function assertAnyTypeAnnotation(node, opts) { assert("AnyTypeAnnotation", node, opts); } function assertArrayTypeAnnotation(node, opts) { assert("ArrayTypeAnnotation", node, opts); } function assertBooleanTypeAnnotation(node, opts) { assert("BooleanTypeAnnotation", node, opts); } function assertBooleanLiteralTypeAnnotation(node, opts) { assert("BooleanLiteralTypeAnnotation", node, opts); } function assertNullLiteralTypeAnnotation(node, opts) { assert("NullLiteralTypeAnnotation", node, opts); } function assertClassImplements(node, opts) { assert("ClassImplements", node, opts); } function assertDeclareClass(node, opts) { assert("DeclareClass", node, opts); } function assertDeclareFunction(node, opts) { assert("DeclareFunction", node, opts); } function assertDeclareInterface(node, opts) { assert("DeclareInterface", node, opts); } function assertDeclareModule(node, opts) { assert("DeclareModule", node, opts); } function assertDeclareModuleExports(node, opts) { assert("DeclareModuleExports", node, opts); } function assertDeclareTypeAlias(node, opts) { assert("DeclareTypeAlias", node, opts); } function assertDeclareOpaqueType(node, opts) { assert("DeclareOpaqueType", node, opts); } function assertDeclareVariable(node, opts) { assert("DeclareVariable", node, opts); } function assertDeclareExportDeclaration(node, opts) { assert("DeclareExportDeclaration", node, opts); } function assertDeclareExportAllDeclaration(node, opts) { assert("DeclareExportAllDeclaration", node, opts); } function assertDeclaredPredicate(node, opts) { assert("DeclaredPredicate", node, opts); } function assertExistsTypeAnnotation(node, opts) { assert("ExistsTypeAnnotation", node, opts); } function assertFunctionTypeAnnotation(node, opts) { assert("FunctionTypeAnnotation", node, opts); } function assertFunctionTypeParam(node, opts) { assert("FunctionTypeParam", node, opts); } function assertGenericTypeAnnotation(node, opts) { assert("GenericTypeAnnotation", node, opts); } function assertInferredPredicate(node, opts) { assert("InferredPredicate", node, opts); } function assertInterfaceExtends(node, opts) { assert("InterfaceExtends", node, opts); } function assertInterfaceDeclaration(node, opts) { assert("InterfaceDeclaration", node, opts); } function assertInterfaceTypeAnnotation(node, opts) { assert("InterfaceTypeAnnotation", node, opts); } function assertIntersectionTypeAnnotation(node, opts) { assert("IntersectionTypeAnnotation", node, opts); } function assertMixedTypeAnnotation(node, opts) { assert("MixedTypeAnnotation", node, opts); } function assertEmptyTypeAnnotation(node, opts) { assert("EmptyTypeAnnotation", node, opts); } function assertNullableTypeAnnotation(node, opts) { assert("NullableTypeAnnotation", node, opts); } function assertNumberLiteralTypeAnnotation(node, opts) { assert("NumberLiteralTypeAnnotation", node, opts); } function assertNumberTypeAnnotation(node, opts) { assert("NumberTypeAnnotation", node, opts); } function assertObjectTypeAnnotation(node, opts) { assert("ObjectTypeAnnotation", node, opts); } function assertObjectTypeInternalSlot(node, opts) { assert("ObjectTypeInternalSlot", node, opts); } function assertObjectTypeCallProperty(node, opts) { assert("ObjectTypeCallProperty", node, opts); } function assertObjectTypeIndexer(node, opts) { assert("ObjectTypeIndexer", node, opts); } function assertObjectTypeProperty(node, opts) { assert("ObjectTypeProperty", node, opts); } function assertObjectTypeSpreadProperty(node, opts) { assert("ObjectTypeSpreadProperty", node, opts); } function assertOpaqueType(node, opts) { assert("OpaqueType", node, opts); } function assertQualifiedTypeIdentifier(node, opts) { assert("QualifiedTypeIdentifier", node, opts); } function assertStringLiteralTypeAnnotation(node, opts) { assert("StringLiteralTypeAnnotation", node, opts); } function assertStringTypeAnnotation(node, opts) { assert("StringTypeAnnotation", node, opts); } function assertSymbolTypeAnnotation(node, opts) { assert("SymbolTypeAnnotation", node, opts); } function assertThisTypeAnnotation(node, opts) { assert("ThisTypeAnnotation", node, opts); } function assertTupleTypeAnnotation(node, opts) { assert("TupleTypeAnnotation", node, opts); } function assertTypeofTypeAnnotation(node, opts) { assert("TypeofTypeAnnotation", node, opts); } function assertTypeAlias(node, opts) { assert("TypeAlias", node, opts); } function assertTypeAnnotation(node, opts) { assert("TypeAnnotation", node, opts); } function assertTypeCastExpression(node, opts) { assert("TypeCastExpression", node, opts); } function assertTypeParameter(node, opts) { assert("TypeParameter", node, opts); } function assertTypeParameterDeclaration(node, opts) { assert("TypeParameterDeclaration", node, opts); } function assertTypeParameterInstantiation(node, opts) { assert("TypeParameterInstantiation", node, opts); } function assertUnionTypeAnnotation(node, opts) { assert("UnionTypeAnnotation", node, opts); } function assertVariance(node, opts) { assert("Variance", node, opts); } function assertVoidTypeAnnotation(node, opts) { assert("VoidTypeAnnotation", node, opts); } function assertEnumDeclaration(node, opts) { assert("EnumDeclaration", node, opts); } function assertEnumBooleanBody(node, opts) { assert("EnumBooleanBody", node, opts); } function assertEnumNumberBody(node, opts) { assert("EnumNumberBody", node, opts); } function assertEnumStringBody(node, opts) { assert("EnumStringBody", node, opts); } function assertEnumSymbolBody(node, opts) { assert("EnumSymbolBody", node, opts); } function assertEnumBooleanMember(node, opts) { assert("EnumBooleanMember", node, opts); } function assertEnumNumberMember(node, opts) { assert("EnumNumberMember", node, opts); } function assertEnumStringMember(node, opts) { assert("EnumStringMember", node, opts); } function assertEnumDefaultedMember(node, opts) { assert("EnumDefaultedMember", node, opts); } function assertIndexedAccessType(node, opts) { assert("IndexedAccessType", node, opts); } function assertOptionalIndexedAccessType(node, opts) { assert("OptionalIndexedAccessType", node, opts); } function assertJSXAttribute(node, opts) { assert("JSXAttribute", node, opts); } function assertJSXClosingElement(node, opts) { assert("JSXClosingElement", node, opts); } function assertJSXElement(node, opts) { assert("JSXElement", node, opts); } function assertJSXEmptyExpression(node, opts) { assert("JSXEmptyExpression", node, opts); } function assertJSXExpressionContainer(node, opts) { assert("JSXExpressionContainer", node, opts); } function assertJSXSpreadChild(node, opts) { assert("JSXSpreadChild", node, opts); } function assertJSXIdentifier(node, opts) { assert("JSXIdentifier", node, opts); } function assertJSXMemberExpression(node, opts) { assert("JSXMemberExpression", node, opts); } function assertJSXNamespacedName(node, opts) { assert("JSXNamespacedName", node, opts); } function assertJSXOpeningElement(node, opts) { assert("JSXOpeningElement", node, opts); } function assertJSXSpreadAttribute(node, opts) { assert("JSXSpreadAttribute", node, opts); } function assertJSXText(node, opts) { assert("JSXText", node, opts); } function assertJSXFragment(node, opts) { assert("JSXFragment", node, opts); } function assertJSXOpeningFragment(node, opts) { assert("JSXOpeningFragment", node, opts); } function assertJSXClosingFragment(node, opts) { assert("JSXClosingFragment", node, opts); } function assertNoop(node, opts) { assert("Noop", node, opts); } function assertPlaceholder(node, opts) { assert("Placeholder", node, opts); } function assertV8IntrinsicIdentifier(node, opts) { assert("V8IntrinsicIdentifier", node, opts); } function assertArgumentPlaceholder(node, opts) { assert("ArgumentPlaceholder", node, opts); } function assertBindExpression(node, opts) { assert("BindExpression", node, opts); } function assertImportAttribute(node, opts) { assert("ImportAttribute", node, opts); } function assertDecorator(node, opts) { assert("Decorator", node, opts); } function assertDoExpression(node, opts) { assert("DoExpression", node, opts); } function assertExportDefaultSpecifier(node, opts) { assert("ExportDefaultSpecifier", node, opts); } function assertRecordExpression(node, opts) { assert("RecordExpression", node, opts); } function assertTupleExpression(node, opts) { assert("TupleExpression", node, opts); } function assertDecimalLiteral(node, opts) { assert("DecimalLiteral", node, opts); } function assertModuleExpression(node, opts) { assert("ModuleExpression", node, opts); } function assertTopicReference(node, opts) { assert("TopicReference", node, opts); } function assertPipelineTopicExpression(node, opts) { assert("PipelineTopicExpression", node, opts); } function assertPipelineBareFunction(node, opts) { assert("PipelineBareFunction", node, opts); } function assertPipelinePrimaryTopicReference(node, opts) { assert("PipelinePrimaryTopicReference", node, opts); } function assertTSParameterProperty(node, opts) { assert("TSParameterProperty", node, opts); } function assertTSDeclareFunction(node, opts) { assert("TSDeclareFunction", node, opts); } function assertTSDeclareMethod(node, opts) { assert("TSDeclareMethod", node, opts); } function assertTSQualifiedName(node, opts) { assert("TSQualifiedName", node, opts); } function assertTSCallSignatureDeclaration(node, opts) { assert("TSCallSignatureDeclaration", node, opts); } function assertTSConstructSignatureDeclaration(node, opts) { assert("TSConstructSignatureDeclaration", node, opts); } function assertTSPropertySignature(node, opts) { assert("TSPropertySignature", node, opts); } function assertTSMethodSignature(node, opts) { assert("TSMethodSignature", node, opts); } function assertTSIndexSignature(node, opts) { assert("TSIndexSignature", node, opts); } function assertTSAnyKeyword(node, opts) { assert("TSAnyKeyword", node, opts); } function assertTSBooleanKeyword(node, opts) { assert("TSBooleanKeyword", node, opts); } function assertTSBigIntKeyword(node, opts) { assert("TSBigIntKeyword", node, opts); } function assertTSIntrinsicKeyword(node, opts) { assert("TSIntrinsicKeyword", node, opts); } function assertTSNeverKeyword(node, opts) { assert("TSNeverKeyword", node, opts); } function assertTSNullKeyword(node, opts) { assert("TSNullKeyword", node, opts); } function assertTSNumberKeyword(node, opts) { assert("TSNumberKeyword", node, opts); } function assertTSObjectKeyword(node, opts) { assert("TSObjectKeyword", node, opts); } function assertTSStringKeyword(node, opts) { assert("TSStringKeyword", node, opts); } function assertTSSymbolKeyword(node, opts) { assert("TSSymbolKeyword", node, opts); } function assertTSUndefinedKeyword(node, opts) { assert("TSUndefinedKeyword", node, opts); } function assertTSUnknownKeyword(node, opts) { assert("TSUnknownKeyword", node, opts); } function assertTSVoidKeyword(node, opts) { assert("TSVoidKeyword", node, opts); } function assertTSThisType(node, opts) { assert("TSThisType", node, opts); } function assertTSFunctionType(node, opts) { assert("TSFunctionType", node, opts); } function assertTSConstructorType(node, opts) { assert("TSConstructorType", node, opts); } function assertTSTypeReference(node, opts) { assert("TSTypeReference", node, opts); } function assertTSTypePredicate(node, opts) { assert("TSTypePredicate", node, opts); } function assertTSTypeQuery(node, opts) { assert("TSTypeQuery", node, opts); } function assertTSTypeLiteral(node, opts) { assert("TSTypeLiteral", node, opts); } function assertTSArrayType(node, opts) { assert("TSArrayType", node, opts); } function assertTSTupleType(node, opts) { assert("TSTupleType", node, opts); } function assertTSOptionalType(node, opts) { assert("TSOptionalType", node, opts); } function assertTSRestType(node, opts) { assert("TSRestType", node, opts); } function assertTSNamedTupleMember(node, opts) { assert("TSNamedTupleMember", node, opts); } function assertTSUnionType(node, opts) { assert("TSUnionType", node, opts); } function assertTSIntersectionType(node, opts) { assert("TSIntersectionType", node, opts); } function assertTSConditionalType(node, opts) { assert("TSConditionalType", node, opts); } function assertTSInferType(node, opts) { assert("TSInferType", node, opts); } function assertTSParenthesizedType(node, opts) { assert("TSParenthesizedType", node, opts); } function assertTSTypeOperator(node, opts) { assert("TSTypeOperator", node, opts); } function assertTSIndexedAccessType(node, opts) { assert("TSIndexedAccessType", node, opts); } function assertTSMappedType(node, opts) { assert("TSMappedType", node, opts); } function assertTSLiteralType(node, opts) { assert("TSLiteralType", node, opts); } function assertTSExpressionWithTypeArguments(node, opts) { assert("TSExpressionWithTypeArguments", node, opts); } function assertTSInterfaceDeclaration(node, opts) { assert("TSInterfaceDeclaration", node, opts); } function assertTSInterfaceBody(node, opts) { assert("TSInterfaceBody", node, opts); } function assertTSTypeAliasDeclaration(node, opts) { assert("TSTypeAliasDeclaration", node, opts); } function assertTSInstantiationExpression(node, opts) { assert("TSInstantiationExpression", node, opts); } function assertTSAsExpression(node, opts) { assert("TSAsExpression", node, opts); } function assertTSTypeAssertion(node, opts) { assert("TSTypeAssertion", node, opts); } function assertTSEnumDeclaration(node, opts) { assert("TSEnumDeclaration", node, opts); } function assertTSEnumMember(node, opts) { assert("TSEnumMember", node, opts); } function assertTSModuleDeclaration(node, opts) { assert("TSModuleDeclaration", node, opts); } function assertTSModuleBlock(node, opts) { assert("TSModuleBlock", node, opts); } function assertTSImportType(node, opts) { assert("TSImportType", node, opts); } function assertTSImportEqualsDeclaration(node, opts) { assert("TSImportEqualsDeclaration", node, opts); } function assertTSExternalModuleReference(node, opts) { assert("TSExternalModuleReference", node, opts); } function assertTSNonNullExpression(node, opts) { assert("TSNonNullExpression", node, opts); } function assertTSExportAssignment(node, opts) { assert("TSExportAssignment", node, opts); } function assertTSNamespaceExportDeclaration(node, opts) { assert("TSNamespaceExportDeclaration", node, opts); } function assertTSTypeAnnotation(node, opts) { assert("TSTypeAnnotation", node, opts); } function assertTSTypeParameterInstantiation(node, opts) { assert("TSTypeParameterInstantiation", node, opts); } function assertTSTypeParameterDeclaration(node, opts) { assert("TSTypeParameterDeclaration", node, opts); } function assertTSTypeParameter(node, opts) { assert("TSTypeParameter", node, opts); } function assertStandardized(node, opts) { assert("Standardized", node, opts); } function assertExpression(node, opts) { assert("Expression", node, opts); } function assertBinary(node, opts) { assert("Binary", node, opts); } function assertScopable(node, opts) { assert("Scopable", node, opts); } function assertBlockParent(node, opts) { assert("BlockParent", node, opts); } function assertBlock(node, opts) { assert("Block", node, opts); } function assertStatement(node, opts) { assert("Statement", node, opts); } function assertTerminatorless(node, opts) { assert("Terminatorless", node, opts); } function assertCompletionStatement(node, opts) { assert("CompletionStatement", node, opts); } function assertConditional(node, opts) { assert("Conditional", node, opts); } function assertLoop(node, opts) { assert("Loop", node, opts); } function assertWhile(node, opts) { assert("While", node, opts); } function assertExpressionWrapper(node, opts) { assert("ExpressionWrapper", node, opts); } function assertFor(node, opts) { assert("For", node, opts); } function assertForXStatement(node, opts) { assert("ForXStatement", node, opts); } function assertFunction(node, opts) { assert("Function", node, opts); } function assertFunctionParent(node, opts) { assert("FunctionParent", node, opts); } function assertPureish(node, opts) { assert("Pureish", node, opts); } function assertDeclaration(node, opts) { assert("Declaration", node, opts); } function assertPatternLike(node, opts) { assert("PatternLike", node, opts); } function assertLVal(node, opts) { assert("LVal", node, opts); } function assertTSEntityName(node, opts) { assert("TSEntityName", node, opts); } function assertLiteral(node, opts) { assert("Literal", node, opts); } function assertImmutable(node, opts) { assert("Immutable", node, opts); } function assertUserWhitespacable(node, opts) { assert("UserWhitespacable", node, opts); } function assertMethod(node, opts) { assert("Method", node, opts); } function assertObjectMember(node, opts) { assert("ObjectMember", node, opts); } function assertProperty(node, opts) { assert("Property", node, opts); } function assertUnaryLike(node, opts) { assert("UnaryLike", node, opts); } function assertPattern(node, opts) { assert("Pattern", node, opts); } function assertClass(node, opts) { assert("Class", node, opts); } function assertModuleDeclaration(node, opts) { assert("ModuleDeclaration", node, opts); } function assertExportDeclaration(node, opts) { assert("ExportDeclaration", node, opts); } function assertModuleSpecifier(node, opts) { assert("ModuleSpecifier", node, opts); } function assertAccessor(node, opts) { assert("Accessor", node, opts); } function assertPrivate(node, opts) { assert("Private", node, opts); } function assertFlow(node, opts) { assert("Flow", node, opts); } function assertFlowType(node, opts) { assert("FlowType", node, opts); } function assertFlowBaseAnnotation(node, opts) { assert("FlowBaseAnnotation", node, opts); } function assertFlowDeclaration(node, opts) { assert("FlowDeclaration", node, opts); } function assertFlowPredicate(node, opts) { assert("FlowPredicate", node, opts); } function assertEnumBody(node, opts) { assert("EnumBody", node, opts); } function assertEnumMember(node, opts) { assert("EnumMember", node, opts); } function assertJSX(node, opts) { assert("JSX", node, opts); } function assertMiscellaneous(node, opts) { assert("Miscellaneous", node, opts); } function assertTypeScript(node, opts) { assert("TypeScript", node, opts); } function assertTSTypeElement(node, opts) { assert("TSTypeElement", node, opts); } function assertTSType(node, opts) { assert("TSType", node, opts); } function assertTSBaseType(node, opts) { assert("TSBaseType", node, opts); } function assertNumberLiteral(node, opts) { console.trace("The node type NumberLiteral has been renamed to NumericLiteral"); assert("NumberLiteral", node, opts); } function assertRegexLiteral(node, opts) { console.trace("The node type RegexLiteral has been renamed to RegExpLiteral"); assert("RegexLiteral", node, opts); } function assertRestProperty(node, opts) { console.trace("The node type RestProperty has been renamed to RestElement"); assert("RestProperty", node, opts); } function assertSpreadProperty(node, opts) { console.trace("The node type SpreadProperty has been renamed to SpreadElement"); assert("SpreadProperty", node, opts); } },{"../../validators/is":376}],317:[function(require,module,exports){ },{}],318:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = createFlowUnionType; var _generated = require("../generated"); var _removeTypeDuplicates = require("../../modifications/flow/removeTypeDuplicates"); function createFlowUnionType(types) { const flattened = (0, _removeTypeDuplicates.default)(types); if (flattened.length === 1) { return flattened[0]; } else { return (0, _generated.unionTypeAnnotation)(flattened); } } },{"../../modifications/flow/removeTypeDuplicates":361,"../generated":320}],319:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = void 0; var _generated = require("../generated"); var _default = createTypeAnnotationBasedOnTypeof; exports.default = _default; function createTypeAnnotationBasedOnTypeof(type) { switch (type) { case "string": return (0, _generated.stringTypeAnnotation)(); case "number": return (0, _generated.numberTypeAnnotation)(); case "undefined": return (0, _generated.voidTypeAnnotation)(); case "boolean": return (0, _generated.booleanTypeAnnotation)(); case "function": return (0, _generated.genericTypeAnnotation)((0, _generated.identifier)("Function")); case "object": return (0, _generated.genericTypeAnnotation)((0, _generated.identifier)("Object")); case "symbol": return (0, _generated.genericTypeAnnotation)((0, _generated.identifier)("Symbol")); case "bigint": return (0, _generated.anyTypeAnnotation)(); } throw new Error("Invalid typeof value: " + type); } },{"../generated":320}],320:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.anyTypeAnnotation = anyTypeAnnotation; exports.argumentPlaceholder = argumentPlaceholder; exports.arrayExpression = arrayExpression; exports.arrayPattern = arrayPattern; exports.arrayTypeAnnotation = arrayTypeAnnotation; exports.arrowFunctionExpression = arrowFunctionExpression; exports.assignmentExpression = assignmentExpression; exports.assignmentPattern = assignmentPattern; exports.awaitExpression = awaitExpression; exports.bigIntLiteral = bigIntLiteral; exports.binaryExpression = binaryExpression; exports.bindExpression = bindExpression; exports.blockStatement = blockStatement; exports.booleanLiteral = booleanLiteral; exports.booleanLiteralTypeAnnotation = booleanLiteralTypeAnnotation; exports.booleanTypeAnnotation = booleanTypeAnnotation; exports.breakStatement = breakStatement; exports.callExpression = callExpression; exports.catchClause = catchClause; exports.classAccessorProperty = classAccessorProperty; exports.classBody = classBody; exports.classDeclaration = classDeclaration; exports.classExpression = classExpression; exports.classImplements = classImplements; exports.classMethod = classMethod; exports.classPrivateMethod = classPrivateMethod; exports.classPrivateProperty = classPrivateProperty; exports.classProperty = classProperty; exports.conditionalExpression = conditionalExpression; exports.continueStatement = continueStatement; exports.debuggerStatement = debuggerStatement; exports.decimalLiteral = decimalLiteral; exports.declareClass = declareClass; exports.declareExportAllDeclaration = declareExportAllDeclaration; exports.declareExportDeclaration = declareExportDeclaration; exports.declareFunction = declareFunction; exports.declareInterface = declareInterface; exports.declareModule = declareModule; exports.declareModuleExports = declareModuleExports; exports.declareOpaqueType = declareOpaqueType; exports.declareTypeAlias = declareTypeAlias; exports.declareVariable = declareVariable; exports.declaredPredicate = declaredPredicate; exports.decorator = decorator; exports.directive = directive; exports.directiveLiteral = directiveLiteral; exports.doExpression = doExpression; exports.doWhileStatement = doWhileStatement; exports.emptyStatement = emptyStatement; exports.emptyTypeAnnotation = emptyTypeAnnotation; exports.enumBooleanBody = enumBooleanBody; exports.enumBooleanMember = enumBooleanMember; exports.enumDeclaration = enumDeclaration; exports.enumDefaultedMember = enumDefaultedMember; exports.enumNumberBody = enumNumberBody; exports.enumNumberMember = enumNumberMember; exports.enumStringBody = enumStringBody; exports.enumStringMember = enumStringMember; exports.enumSymbolBody = enumSymbolBody; exports.existsTypeAnnotation = existsTypeAnnotation; exports.exportAllDeclaration = exportAllDeclaration; exports.exportDefaultDeclaration = exportDefaultDeclaration; exports.exportDefaultSpecifier = exportDefaultSpecifier; exports.exportNamedDeclaration = exportNamedDeclaration; exports.exportNamespaceSpecifier = exportNamespaceSpecifier; exports.exportSpecifier = exportSpecifier; exports.expressionStatement = expressionStatement; exports.file = file; exports.forInStatement = forInStatement; exports.forOfStatement = forOfStatement; exports.forStatement = forStatement; exports.functionDeclaration = functionDeclaration; exports.functionExpression = functionExpression; exports.functionTypeAnnotation = functionTypeAnnotation; exports.functionTypeParam = functionTypeParam; exports.genericTypeAnnotation = genericTypeAnnotation; exports.identifier = identifier; exports.ifStatement = ifStatement; exports.import = _import; exports.importAttribute = importAttribute; exports.importDeclaration = importDeclaration; exports.importDefaultSpecifier = importDefaultSpecifier; exports.importNamespaceSpecifier = importNamespaceSpecifier; exports.importSpecifier = importSpecifier; exports.indexedAccessType = indexedAccessType; exports.inferredPredicate = inferredPredicate; exports.interfaceDeclaration = interfaceDeclaration; exports.interfaceExtends = interfaceExtends; exports.interfaceTypeAnnotation = interfaceTypeAnnotation; exports.interpreterDirective = interpreterDirective; exports.intersectionTypeAnnotation = intersectionTypeAnnotation; exports.jSXAttribute = exports.jsxAttribute = jsxAttribute; exports.jSXClosingElement = exports.jsxClosingElement = jsxClosingElement; exports.jSXClosingFragment = exports.jsxClosingFragment = jsxClosingFragment; exports.jSXElement = exports.jsxElement = jsxElement; exports.jSXEmptyExpression = exports.jsxEmptyExpression = jsxEmptyExpression; exports.jSXExpressionContainer = exports.jsxExpressionContainer = jsxExpressionContainer; exports.jSXFragment = exports.jsxFragment = jsxFragment; exports.jSXIdentifier = exports.jsxIdentifier = jsxIdentifier; exports.jSXMemberExpression = exports.jsxMemberExpression = jsxMemberExpression; exports.jSXNamespacedName = exports.jsxNamespacedName = jsxNamespacedName; exports.jSXOpeningElement = exports.jsxOpeningElement = jsxOpeningElement; exports.jSXOpeningFragment = exports.jsxOpeningFragment = jsxOpeningFragment; exports.jSXSpreadAttribute = exports.jsxSpreadAttribute = jsxSpreadAttribute; exports.jSXSpreadChild = exports.jsxSpreadChild = jsxSpreadChild; exports.jSXText = exports.jsxText = jsxText; exports.labeledStatement = labeledStatement; exports.logicalExpression = logicalExpression; exports.memberExpression = memberExpression; exports.metaProperty = metaProperty; exports.mixedTypeAnnotation = mixedTypeAnnotation; exports.moduleExpression = moduleExpression; exports.newExpression = newExpression; exports.noop = noop; exports.nullLiteral = nullLiteral; exports.nullLiteralTypeAnnotation = nullLiteralTypeAnnotation; exports.nullableTypeAnnotation = nullableTypeAnnotation; exports.numberLiteral = NumberLiteral; exports.numberLiteralTypeAnnotation = numberLiteralTypeAnnotation; exports.numberTypeAnnotation = numberTypeAnnotation; exports.numericLiteral = numericLiteral; exports.objectExpression = objectExpression; exports.objectMethod = objectMethod; exports.objectPattern = objectPattern; exports.objectProperty = objectProperty; exports.objectTypeAnnotation = objectTypeAnnotation; exports.objectTypeCallProperty = objectTypeCallProperty; exports.objectTypeIndexer = objectTypeIndexer; exports.objectTypeInternalSlot = objectTypeInternalSlot; exports.objectTypeProperty = objectTypeProperty; exports.objectTypeSpreadProperty = objectTypeSpreadProperty; exports.opaqueType = opaqueType; exports.optionalCallExpression = optionalCallExpression; exports.optionalIndexedAccessType = optionalIndexedAccessType; exports.optionalMemberExpression = optionalMemberExpression; exports.parenthesizedExpression = parenthesizedExpression; exports.pipelineBareFunction = pipelineBareFunction; exports.pipelinePrimaryTopicReference = pipelinePrimaryTopicReference; exports.pipelineTopicExpression = pipelineTopicExpression; exports.placeholder = placeholder; exports.privateName = privateName; exports.program = program; exports.qualifiedTypeIdentifier = qualifiedTypeIdentifier; exports.recordExpression = recordExpression; exports.regExpLiteral = regExpLiteral; exports.regexLiteral = RegexLiteral; exports.restElement = restElement; exports.restProperty = RestProperty; exports.returnStatement = returnStatement; exports.sequenceExpression = sequenceExpression; exports.spreadElement = spreadElement; exports.spreadProperty = SpreadProperty; exports.staticBlock = staticBlock; exports.stringLiteral = stringLiteral; exports.stringLiteralTypeAnnotation = stringLiteralTypeAnnotation; exports.stringTypeAnnotation = stringTypeAnnotation; exports.super = _super; exports.switchCase = switchCase; exports.switchStatement = switchStatement; exports.symbolTypeAnnotation = symbolTypeAnnotation; exports.taggedTemplateExpression = taggedTemplateExpression; exports.templateElement = templateElement; exports.templateLiteral = templateLiteral; exports.thisExpression = thisExpression; exports.thisTypeAnnotation = thisTypeAnnotation; exports.throwStatement = throwStatement; exports.topicReference = topicReference; exports.tryStatement = tryStatement; exports.tSAnyKeyword = exports.tsAnyKeyword = tsAnyKeyword; exports.tSArrayType = exports.tsArrayType = tsArrayType; exports.tSAsExpression = exports.tsAsExpression = tsAsExpression; exports.tSBigIntKeyword = exports.tsBigIntKeyword = tsBigIntKeyword; exports.tSBooleanKeyword = exports.tsBooleanKeyword = tsBooleanKeyword; exports.tSCallSignatureDeclaration = exports.tsCallSignatureDeclaration = tsCallSignatureDeclaration; exports.tSConditionalType = exports.tsConditionalType = tsConditionalType; exports.tSConstructSignatureDeclaration = exports.tsConstructSignatureDeclaration = tsConstructSignatureDeclaration; exports.tSConstructorType = exports.tsConstructorType = tsConstructorType; exports.tSDeclareFunction = exports.tsDeclareFunction = tsDeclareFunction; exports.tSDeclareMethod = exports.tsDeclareMethod = tsDeclareMethod; exports.tSEnumDeclaration = exports.tsEnumDeclaration = tsEnumDeclaration; exports.tSEnumMember = exports.tsEnumMember = tsEnumMember; exports.tSExportAssignment = exports.tsExportAssignment = tsExportAssignment; exports.tSExpressionWithTypeArguments = exports.tsExpressionWithTypeArguments = tsExpressionWithTypeArguments; exports.tSExternalModuleReference = exports.tsExternalModuleReference = tsExternalModuleReference; exports.tSFunctionType = exports.tsFunctionType = tsFunctionType; exports.tSImportEqualsDeclaration = exports.tsImportEqualsDeclaration = tsImportEqualsDeclaration; exports.tSImportType = exports.tsImportType = tsImportType; exports.tSIndexSignature = exports.tsIndexSignature = tsIndexSignature; exports.tSIndexedAccessType = exports.tsIndexedAccessType = tsIndexedAccessType; exports.tSInferType = exports.tsInferType = tsInferType; exports.tSInstantiationExpression = exports.tsInstantiationExpression = tsInstantiationExpression; exports.tSInterfaceBody = exports.tsInterfaceBody = tsInterfaceBody; exports.tSInterfaceDeclaration = exports.tsInterfaceDeclaration = tsInterfaceDeclaration; exports.tSIntersectionType = exports.tsIntersectionType = tsIntersectionType; exports.tSIntrinsicKeyword = exports.tsIntrinsicKeyword = tsIntrinsicKeyword; exports.tSLiteralType = exports.tsLiteralType = tsLiteralType; exports.tSMappedType = exports.tsMappedType = tsMappedType; exports.tSMethodSignature = exports.tsMethodSignature = tsMethodSignature; exports.tSModuleBlock = exports.tsModuleBlock = tsModuleBlock; exports.tSModuleDeclaration = exports.tsModuleDeclaration = tsModuleDeclaration; exports.tSNamedTupleMember = exports.tsNamedTupleMember = tsNamedTupleMember; exports.tSNamespaceExportDeclaration = exports.tsNamespaceExportDeclaration = tsNamespaceExportDeclaration; exports.tSNeverKeyword = exports.tsNeverKeyword = tsNeverKeyword; exports.tSNonNullExpression = exports.tsNonNullExpression = tsNonNullExpression; exports.tSNullKeyword = exports.tsNullKeyword = tsNullKeyword; exports.tSNumberKeyword = exports.tsNumberKeyword = tsNumberKeyword; exports.tSObjectKeyword = exports.tsObjectKeyword = tsObjectKeyword; exports.tSOptionalType = exports.tsOptionalType = tsOptionalType; exports.tSParameterProperty = exports.tsParameterProperty = tsParameterProperty; exports.tSParenthesizedType = exports.tsParenthesizedType = tsParenthesizedType; exports.tSPropertySignature = exports.tsPropertySignature = tsPropertySignature; exports.tSQualifiedName = exports.tsQualifiedName = tsQualifiedName; exports.tSRestType = exports.tsRestType = tsRestType; exports.tSStringKeyword = exports.tsStringKeyword = tsStringKeyword; exports.tSSymbolKeyword = exports.tsSymbolKeyword = tsSymbolKeyword; exports.tSThisType = exports.tsThisType = tsThisType; exports.tSTupleType = exports.tsTupleType = tsTupleType; exports.tSTypeAliasDeclaration = exports.tsTypeAliasDeclaration = tsTypeAliasDeclaration; exports.tSTypeAnnotation = exports.tsTypeAnnotation = tsTypeAnnotation; exports.tSTypeAssertion = exports.tsTypeAssertion = tsTypeAssertion; exports.tSTypeLiteral = exports.tsTypeLiteral = tsTypeLiteral; exports.tSTypeOperator = exports.tsTypeOperator = tsTypeOperator; exports.tSTypeParameter = exports.tsTypeParameter = tsTypeParameter; exports.tSTypeParameterDeclaration = exports.tsTypeParameterDeclaration = tsTypeParameterDeclaration; exports.tSTypeParameterInstantiation = exports.tsTypeParameterInstantiation = tsTypeParameterInstantiation; exports.tSTypePredicate = exports.tsTypePredicate = tsTypePredicate; exports.tSTypeQuery = exports.tsTypeQuery = tsTypeQuery; exports.tSTypeReference = exports.tsTypeReference = tsTypeReference; exports.tSUndefinedKeyword = exports.tsUndefinedKeyword = tsUndefinedKeyword; exports.tSUnionType = exports.tsUnionType = tsUnionType; exports.tSUnknownKeyword = exports.tsUnknownKeyword = tsUnknownKeyword; exports.tSVoidKeyword = exports.tsVoidKeyword = tsVoidKeyword; exports.tupleExpression = tupleExpression; exports.tupleTypeAnnotation = tupleTypeAnnotation; exports.typeAlias = typeAlias; exports.typeAnnotation = typeAnnotation; exports.typeCastExpression = typeCastExpression; exports.typeParameter = typeParameter; exports.typeParameterDeclaration = typeParameterDeclaration; exports.typeParameterInstantiation = typeParameterInstantiation; exports.typeofTypeAnnotation = typeofTypeAnnotation; exports.unaryExpression = unaryExpression; exports.unionTypeAnnotation = unionTypeAnnotation; exports.updateExpression = updateExpression; exports.v8IntrinsicIdentifier = v8IntrinsicIdentifier; exports.variableDeclaration = variableDeclaration; exports.variableDeclarator = variableDeclarator; exports.variance = variance; exports.voidTypeAnnotation = voidTypeAnnotation; exports.whileStatement = whileStatement; exports.withStatement = withStatement; exports.yieldExpression = yieldExpression; var _validateNode = require("../validateNode"); function arrayExpression(elements = []) { return (0, _validateNode.default)({ type: "ArrayExpression", elements }); } function assignmentExpression(operator, left, right) { return (0, _validateNode.default)({ type: "AssignmentExpression", operator, left, right }); } function binaryExpression(operator, left, right) { return (0, _validateNode.default)({ type: "BinaryExpression", operator, left, right }); } function interpreterDirective(value) { return (0, _validateNode.default)({ type: "InterpreterDirective", value }); } function directive(value) { return (0, _validateNode.default)({ type: "Directive", value }); } function directiveLiteral(value) { return (0, _validateNode.default)({ type: "DirectiveLiteral", value }); } function blockStatement(body, directives = []) { return (0, _validateNode.default)({ type: "BlockStatement", body, directives }); } function breakStatement(label = null) { return (0, _validateNode.default)({ type: "BreakStatement", label }); } function callExpression(callee, _arguments) { return (0, _validateNode.default)({ type: "CallExpression", callee, arguments: _arguments }); } function catchClause(param = null, body) { return (0, _validateNode.default)({ type: "CatchClause", param, body }); } function conditionalExpression(test, consequent, alternate) { return (0, _validateNode.default)({ type: "ConditionalExpression", test, consequent, alternate }); } function continueStatement(label = null) { return (0, _validateNode.default)({ type: "ContinueStatement", label }); } function debuggerStatement() { return { type: "DebuggerStatement" }; } function doWhileStatement(test, body) { return (0, _validateNode.default)({ type: "DoWhileStatement", test, body }); } function emptyStatement() { return { type: "EmptyStatement" }; } function expressionStatement(expression) { return (0, _validateNode.default)({ type: "ExpressionStatement", expression }); } function file(program, comments = null, tokens = null) { return (0, _validateNode.default)({ type: "File", program, comments, tokens }); } function forInStatement(left, right, body) { return (0, _validateNode.default)({ type: "ForInStatement", left, right, body }); } function forStatement(init = null, test = null, update = null, body) { return (0, _validateNode.default)({ type: "ForStatement", init, test, update, body }); } function functionDeclaration(id = null, params, body, generator = false, async = false) { return (0, _validateNode.default)({ type: "FunctionDeclaration", id, params, body, generator, async }); } function functionExpression(id = null, params, body, generator = false, async = false) { return (0, _validateNode.default)({ type: "FunctionExpression", id, params, body, generator, async }); } function identifier(name) { return (0, _validateNode.default)({ type: "Identifier", name }); } function ifStatement(test, consequent, alternate = null) { return (0, _validateNode.default)({ type: "IfStatement", test, consequent, alternate }); } function labeledStatement(label, body) { return (0, _validateNode.default)({ type: "LabeledStatement", label, body }); } function stringLiteral(value) { return (0, _validateNode.default)({ type: "StringLiteral", value }); } function numericLiteral(value) { return (0, _validateNode.default)({ type: "NumericLiteral", value }); } function nullLiteral() { return { type: "NullLiteral" }; } function booleanLiteral(value) { return (0, _validateNode.default)({ type: "BooleanLiteral", value }); } function regExpLiteral(pattern, flags = "") { return (0, _validateNode.default)({ type: "RegExpLiteral", pattern, flags }); } function logicalExpression(operator, left, right) { return (0, _validateNode.default)({ type: "LogicalExpression", operator, left, right }); } function memberExpression(object, property, computed = false, optional = null) { return (0, _validateNode.default)({ type: "MemberExpression", object, property, computed, optional }); } function newExpression(callee, _arguments) { return (0, _validateNode.default)({ type: "NewExpression", callee, arguments: _arguments }); } function program(body, directives = [], sourceType = "script", interpreter = null) { return (0, _validateNode.default)({ type: "Program", body, directives, sourceType, interpreter, sourceFile: null }); } function objectExpression(properties) { return (0, _validateNode.default)({ type: "ObjectExpression", properties }); } function objectMethod(kind = "method", key, params, body, computed = false, generator = false, async = false) { return (0, _validateNode.default)({ type: "ObjectMethod", kind, key, params, body, computed, generator, async }); } function objectProperty(key, value, computed = false, shorthand = false, decorators = null) { return (0, _validateNode.default)({ type: "ObjectProperty", key, value, computed, shorthand, decorators }); } function restElement(argument) { return (0, _validateNode.default)({ type: "RestElement", argument }); } function returnStatement(argument = null) { return (0, _validateNode.default)({ type: "ReturnStatement", argument }); } function sequenceExpression(expressions) { return (0, _validateNode.default)({ type: "SequenceExpression", expressions }); } function parenthesizedExpression(expression) { return (0, _validateNode.default)({ type: "ParenthesizedExpression", expression }); } function switchCase(test = null, consequent) { return (0, _validateNode.default)({ type: "SwitchCase", test, consequent }); } function switchStatement(discriminant, cases) { return (0, _validateNode.default)({ type: "SwitchStatement", discriminant, cases }); } function thisExpression() { return { type: "ThisExpression" }; } function throwStatement(argument) { return (0, _validateNode.default)({ type: "ThrowStatement", argument }); } function tryStatement(block, handler = null, finalizer = null) { return (0, _validateNode.default)({ type: "TryStatement", block, handler, finalizer }); } function unaryExpression(operator, argument, prefix = true) { return (0, _validateNode.default)({ type: "UnaryExpression", operator, argument, prefix }); } function updateExpression(operator, argument, prefix = false) { return (0, _validateNode.default)({ type: "UpdateExpression", operator, argument, prefix }); } function variableDeclaration(kind, declarations) { return (0, _validateNode.default)({ type: "VariableDeclaration", kind, declarations }); } function variableDeclarator(id, init = null) { return (0, _validateNode.default)({ type: "VariableDeclarator", id, init }); } function whileStatement(test, body) { return (0, _validateNode.default)({ type: "WhileStatement", test, body }); } function withStatement(object, body) { return (0, _validateNode.default)({ type: "WithStatement", object, body }); } function assignmentPattern(left, right) { return (0, _validateNode.default)({ type: "AssignmentPattern", left, right }); } function arrayPattern(elements) { return (0, _validateNode.default)({ type: "ArrayPattern", elements }); } function arrowFunctionExpression(params, body, async = false) { return (0, _validateNode.default)({ type: "ArrowFunctionExpression", params, body, async, expression: null }); } function classBody(body) { return (0, _validateNode.default)({ type: "ClassBody", body }); } function classExpression(id = null, superClass = null, body, decorators = null) { return (0, _validateNode.default)({ type: "ClassExpression", id, superClass, body, decorators }); } function classDeclaration(id, superClass = null, body, decorators = null) { return (0, _validateNode.default)({ type: "ClassDeclaration", id, superClass, body, decorators }); } function exportAllDeclaration(source) { return (0, _validateNode.default)({ type: "ExportAllDeclaration", source }); } function exportDefaultDeclaration(declaration) { return (0, _validateNode.default)({ type: "ExportDefaultDeclaration", declaration }); } function exportNamedDeclaration(declaration = null, specifiers = [], source = null) { return (0, _validateNode.default)({ type: "ExportNamedDeclaration", declaration, specifiers, source }); } function exportSpecifier(local, exported) { return (0, _validateNode.default)({ type: "ExportSpecifier", local, exported }); } function forOfStatement(left, right, body, _await = false) { return (0, _validateNode.default)({ type: "ForOfStatement", left, right, body, await: _await }); } function importDeclaration(specifiers, source) { return (0, _validateNode.default)({ type: "ImportDeclaration", specifiers, source }); } function importDefaultSpecifier(local) { return (0, _validateNode.default)({ type: "ImportDefaultSpecifier", local }); } function importNamespaceSpecifier(local) { return (0, _validateNode.default)({ type: "ImportNamespaceSpecifier", local }); } function importSpecifier(local, imported) { return (0, _validateNode.default)({ type: "ImportSpecifier", local, imported }); } function metaProperty(meta, property) { return (0, _validateNode.default)({ type: "MetaProperty", meta, property }); } function classMethod(kind = "method", key, params, body, computed = false, _static = false, generator = false, async = false) { return (0, _validateNode.default)({ type: "ClassMethod", kind, key, params, body, computed, static: _static, generator, async }); } function objectPattern(properties) { return (0, _validateNode.default)({ type: "ObjectPattern", properties }); } function spreadElement(argument) { return (0, _validateNode.default)({ type: "SpreadElement", argument }); } function _super() { return { type: "Super" }; } function taggedTemplateExpression(tag, quasi) { return (0, _validateNode.default)({ type: "TaggedTemplateExpression", tag, quasi }); } function templateElement(value, tail = false) { return (0, _validateNode.default)({ type: "TemplateElement", value, tail }); } function templateLiteral(quasis, expressions) { return (0, _validateNode.default)({ type: "TemplateLiteral", quasis, expressions }); } function yieldExpression(argument = null, delegate = false) { return (0, _validateNode.default)({ type: "YieldExpression", argument, delegate }); } function awaitExpression(argument) { return (0, _validateNode.default)({ type: "AwaitExpression", argument }); } function _import() { return { type: "Import" }; } function bigIntLiteral(value) { return (0, _validateNode.default)({ type: "BigIntLiteral", value }); } function exportNamespaceSpecifier(exported) { return (0, _validateNode.default)({ type: "ExportNamespaceSpecifier", exported }); } function optionalMemberExpression(object, property, computed = false, optional) { return (0, _validateNode.default)({ type: "OptionalMemberExpression", object, property, computed, optional }); } function optionalCallExpression(callee, _arguments, optional) { return (0, _validateNode.default)({ type: "OptionalCallExpression", callee, arguments: _arguments, optional }); } function classProperty(key, value = null, typeAnnotation = null, decorators = null, computed = false, _static = false) { return (0, _validateNode.default)({ type: "ClassProperty", key, value, typeAnnotation, decorators, computed, static: _static }); } function classAccessorProperty(key, value = null, typeAnnotation = null, decorators = null, computed = false, _static = false) { return (0, _validateNode.default)({ type: "ClassAccessorProperty", key, value, typeAnnotation, decorators, computed, static: _static }); } function classPrivateProperty(key, value = null, decorators = null, _static = false) { return (0, _validateNode.default)({ type: "ClassPrivateProperty", key, value, decorators, static: _static }); } function classPrivateMethod(kind = "method", key, params, body, _static = false) { return (0, _validateNode.default)({ type: "ClassPrivateMethod", kind, key, params, body, static: _static }); } function privateName(id) { return (0, _validateNode.default)({ type: "PrivateName", id }); } function staticBlock(body) { return (0, _validateNode.default)({ type: "StaticBlock", body }); } function anyTypeAnnotation() { return { type: "AnyTypeAnnotation" }; } function arrayTypeAnnotation(elementType) { return (0, _validateNode.default)({ type: "ArrayTypeAnnotation", elementType }); } function booleanTypeAnnotation() { return { type: "BooleanTypeAnnotation" }; } function booleanLiteralTypeAnnotation(value) { return (0, _validateNode.default)({ type: "BooleanLiteralTypeAnnotation", value }); } function nullLiteralTypeAnnotation() { return { type: "NullLiteralTypeAnnotation" }; } function classImplements(id, typeParameters = null) { return (0, _validateNode.default)({ type: "ClassImplements", id, typeParameters }); } function declareClass(id, typeParameters = null, _extends = null, body) { return (0, _validateNode.default)({ type: "DeclareClass", id, typeParameters, extends: _extends, body }); } function declareFunction(id) { return (0, _validateNode.default)({ type: "DeclareFunction", id }); } function declareInterface(id, typeParameters = null, _extends = null, body) { return (0, _validateNode.default)({ type: "DeclareInterface", id, typeParameters, extends: _extends, body }); } function declareModule(id, body, kind = null) { return (0, _validateNode.default)({ type: "DeclareModule", id, body, kind }); } function declareModuleExports(typeAnnotation) { return (0, _validateNode.default)({ type: "DeclareModuleExports", typeAnnotation }); } function declareTypeAlias(id, typeParameters = null, right) { return (0, _validateNode.default)({ type: "DeclareTypeAlias", id, typeParameters, right }); } function declareOpaqueType(id, typeParameters = null, supertype = null) { return (0, _validateNode.default)({ type: "DeclareOpaqueType", id, typeParameters, supertype }); } function declareVariable(id) { return (0, _validateNode.default)({ type: "DeclareVariable", id }); } function declareExportDeclaration(declaration = null, specifiers = null, source = null) { return (0, _validateNode.default)({ type: "DeclareExportDeclaration", declaration, specifiers, source }); } function declareExportAllDeclaration(source) { return (0, _validateNode.default)({ type: "DeclareExportAllDeclaration", source }); } function declaredPredicate(value) { return (0, _validateNode.default)({ type: "DeclaredPredicate", value }); } function existsTypeAnnotation() { return { type: "ExistsTypeAnnotation" }; } function functionTypeAnnotation(typeParameters = null, params, rest = null, returnType) { return (0, _validateNode.default)({ type: "FunctionTypeAnnotation", typeParameters, params, rest, returnType }); } function functionTypeParam(name = null, typeAnnotation) { return (0, _validateNode.default)({ type: "FunctionTypeParam", name, typeAnnotation }); } function genericTypeAnnotation(id, typeParameters = null) { return (0, _validateNode.default)({ type: "GenericTypeAnnotation", id, typeParameters }); } function inferredPredicate() { return { type: "InferredPredicate" }; } function interfaceExtends(id, typeParameters = null) { return (0, _validateNode.default)({ type: "InterfaceExtends", id, typeParameters }); } function interfaceDeclaration(id, typeParameters = null, _extends = null, body) { return (0, _validateNode.default)({ type: "InterfaceDeclaration", id, typeParameters, extends: _extends, body }); } function interfaceTypeAnnotation(_extends = null, body) { return (0, _validateNode.default)({ type: "InterfaceTypeAnnotation", extends: _extends, body }); } function intersectionTypeAnnotation(types) { return (0, _validateNode.default)({ type: "IntersectionTypeAnnotation", types }); } function mixedTypeAnnotation() { return { type: "MixedTypeAnnotation" }; } function emptyTypeAnnotation() { return { type: "EmptyTypeAnnotation" }; } function nullableTypeAnnotation(typeAnnotation) { return (0, _validateNode.default)({ type: "NullableTypeAnnotation", typeAnnotation }); } function numberLiteralTypeAnnotation(value) { return (0, _validateNode.default)({ type: "NumberLiteralTypeAnnotation", value }); } function numberTypeAnnotation() { return { type: "NumberTypeAnnotation" }; } function objectTypeAnnotation(properties, indexers = [], callProperties = [], internalSlots = [], exact = false) { return (0, _validateNode.default)({ type: "ObjectTypeAnnotation", properties, indexers, callProperties, internalSlots, exact }); } function objectTypeInternalSlot(id, value, optional, _static, method) { return (0, _validateNode.default)({ type: "ObjectTypeInternalSlot", id, value, optional, static: _static, method }); } function objectTypeCallProperty(value) { return (0, _validateNode.default)({ type: "ObjectTypeCallProperty", value, static: null }); } function objectTypeIndexer(id = null, key, value, variance = null) { return (0, _validateNode.default)({ type: "ObjectTypeIndexer", id, key, value, variance, static: null }); } function objectTypeProperty(key, value, variance = null) { return (0, _validateNode.default)({ type: "ObjectTypeProperty", key, value, variance, kind: null, method: null, optional: null, proto: null, static: null }); } function objectTypeSpreadProperty(argument) { return (0, _validateNode.default)({ type: "ObjectTypeSpreadProperty", argument }); } function opaqueType(id, typeParameters = null, supertype = null, impltype) { return (0, _validateNode.default)({ type: "OpaqueType", id, typeParameters, supertype, impltype }); } function qualifiedTypeIdentifier(id, qualification) { return (0, _validateNode.default)({ type: "QualifiedTypeIdentifier", id, qualification }); } function stringLiteralTypeAnnotation(value) { return (0, _validateNode.default)({ type: "StringLiteralTypeAnnotation", value }); } function stringTypeAnnotation() { return { type: "StringTypeAnnotation" }; } function symbolTypeAnnotation() { return { type: "SymbolTypeAnnotation" }; } function thisTypeAnnotation() { return { type: "ThisTypeAnnotation" }; } function tupleTypeAnnotation(types) { return (0, _validateNode.default)({ type: "TupleTypeAnnotation", types }); } function typeofTypeAnnotation(argument) { return (0, _validateNode.default)({ type: "TypeofTypeAnnotation", argument }); } function typeAlias(id, typeParameters = null, right) { return (0, _validateNode.default)({ type: "TypeAlias", id, typeParameters, right }); } function typeAnnotation(typeAnnotation) { return (0, _validateNode.default)({ type: "TypeAnnotation", typeAnnotation }); } function typeCastExpression(expression, typeAnnotation) { return (0, _validateNode.default)({ type: "TypeCastExpression", expression, typeAnnotation }); } function typeParameter(bound = null, _default = null, variance = null) { return (0, _validateNode.default)({ type: "TypeParameter", bound, default: _default, variance, name: null }); } function typeParameterDeclaration(params) { return (0, _validateNode.default)({ type: "TypeParameterDeclaration", params }); } function typeParameterInstantiation(params) { return (0, _validateNode.default)({ type: "TypeParameterInstantiation", params }); } function unionTypeAnnotation(types) { return (0, _validateNode.default)({ type: "UnionTypeAnnotation", types }); } function variance(kind) { return (0, _validateNode.default)({ type: "Variance", kind }); } function voidTypeAnnotation() { return { type: "VoidTypeAnnotation" }; } function enumDeclaration(id, body) { return (0, _validateNode.default)({ type: "EnumDeclaration", id, body }); } function enumBooleanBody(members) { return (0, _validateNode.default)({ type: "EnumBooleanBody", members, explicitType: null, hasUnknownMembers: null }); } function enumNumberBody(members) { return (0, _validateNode.default)({ type: "EnumNumberBody", members, explicitType: null, hasUnknownMembers: null }); } function enumStringBody(members) { return (0, _validateNode.default)({ type: "EnumStringBody", members, explicitType: null, hasUnknownMembers: null }); } function enumSymbolBody(members) { return (0, _validateNode.default)({ type: "EnumSymbolBody", members, hasUnknownMembers: null }); } function enumBooleanMember(id) { return (0, _validateNode.default)({ type: "EnumBooleanMember", id, init: null }); } function enumNumberMember(id, init) { return (0, _validateNode.default)({ type: "EnumNumberMember", id, init }); } function enumStringMember(id, init) { return (0, _validateNode.default)({ type: "EnumStringMember", id, init }); } function enumDefaultedMember(id) { return (0, _validateNode.default)({ type: "EnumDefaultedMember", id }); } function indexedAccessType(objectType, indexType) { return (0, _validateNode.default)({ type: "IndexedAccessType", objectType, indexType }); } function optionalIndexedAccessType(objectType, indexType) { return (0, _validateNode.default)({ type: "OptionalIndexedAccessType", objectType, indexType, optional: null }); } function jsxAttribute(name, value = null) { return (0, _validateNode.default)({ type: "JSXAttribute", name, value }); } function jsxClosingElement(name) { return (0, _validateNode.default)({ type: "JSXClosingElement", name }); } function jsxElement(openingElement, closingElement = null, children, selfClosing = null) { return (0, _validateNode.default)({ type: "JSXElement", openingElement, closingElement, children, selfClosing }); } function jsxEmptyExpression() { return { type: "JSXEmptyExpression" }; } function jsxExpressionContainer(expression) { return (0, _validateNode.default)({ type: "JSXExpressionContainer", expression }); } function jsxSpreadChild(expression) { return (0, _validateNode.default)({ type: "JSXSpreadChild", expression }); } function jsxIdentifier(name) { return (0, _validateNode.default)({ type: "JSXIdentifier", name }); } function jsxMemberExpression(object, property) { return (0, _validateNode.default)({ type: "JSXMemberExpression", object, property }); } function jsxNamespacedName(namespace, name) { return (0, _validateNode.default)({ type: "JSXNamespacedName", namespace, name }); } function jsxOpeningElement(name, attributes, selfClosing = false) { return (0, _validateNode.default)({ type: "JSXOpeningElement", name, attributes, selfClosing }); } function jsxSpreadAttribute(argument) { return (0, _validateNode.default)({ type: "JSXSpreadAttribute", argument }); } function jsxText(value) { return (0, _validateNode.default)({ type: "JSXText", value }); } function jsxFragment(openingFragment, closingFragment, children) { return (0, _validateNode.default)({ type: "JSXFragment", openingFragment, closingFragment, children }); } function jsxOpeningFragment() { return { type: "JSXOpeningFragment" }; } function jsxClosingFragment() { return { type: "JSXClosingFragment" }; } function noop() { return { type: "Noop" }; } function placeholder(expectedNode, name) { return (0, _validateNode.default)({ type: "Placeholder", expectedNode, name }); } function v8IntrinsicIdentifier(name) { return (0, _validateNode.default)({ type: "V8IntrinsicIdentifier", name }); } function argumentPlaceholder() { return { type: "ArgumentPlaceholder" }; } function bindExpression(object, callee) { return (0, _validateNode.default)({ type: "BindExpression", object, callee }); } function importAttribute(key, value) { return (0, _validateNode.default)({ type: "ImportAttribute", key, value }); } function decorator(expression) { return (0, _validateNode.default)({ type: "Decorator", expression }); } function doExpression(body, async = false) { return (0, _validateNode.default)({ type: "DoExpression", body, async }); } function exportDefaultSpecifier(exported) { return (0, _validateNode.default)({ type: "ExportDefaultSpecifier", exported }); } function recordExpression(properties) { return (0, _validateNode.default)({ type: "RecordExpression", properties }); } function tupleExpression(elements = []) { return (0, _validateNode.default)({ type: "TupleExpression", elements }); } function decimalLiteral(value) { return (0, _validateNode.default)({ type: "DecimalLiteral", value }); } function moduleExpression(body) { return (0, _validateNode.default)({ type: "ModuleExpression", body }); } function topicReference() { return { type: "TopicReference" }; } function pipelineTopicExpression(expression) { return (0, _validateNode.default)({ type: "PipelineTopicExpression", expression }); } function pipelineBareFunction(callee) { return (0, _validateNode.default)({ type: "PipelineBareFunction", callee }); } function pipelinePrimaryTopicReference() { return { type: "PipelinePrimaryTopicReference" }; } function tsParameterProperty(parameter) { return (0, _validateNode.default)({ type: "TSParameterProperty", parameter }); } function tsDeclareFunction(id = null, typeParameters = null, params, returnType = null) { return (0, _validateNode.default)({ type: "TSDeclareFunction", id, typeParameters, params, returnType }); } function tsDeclareMethod(decorators = null, key, typeParameters = null, params, returnType = null) { return (0, _validateNode.default)({ type: "TSDeclareMethod", decorators, key, typeParameters, params, returnType }); } function tsQualifiedName(left, right) { return (0, _validateNode.default)({ type: "TSQualifiedName", left, right }); } function tsCallSignatureDeclaration(typeParameters = null, parameters, typeAnnotation = null) { return (0, _validateNode.default)({ type: "TSCallSignatureDeclaration", typeParameters, parameters, typeAnnotation }); } function tsConstructSignatureDeclaration(typeParameters = null, parameters, typeAnnotation = null) { return (0, _validateNode.default)({ type: "TSConstructSignatureDeclaration", typeParameters, parameters, typeAnnotation }); } function tsPropertySignature(key, typeAnnotation = null, initializer = null) { return (0, _validateNode.default)({ type: "TSPropertySignature", key, typeAnnotation, initializer, kind: null }); } function tsMethodSignature(key, typeParameters = null, parameters, typeAnnotation = null) { return (0, _validateNode.default)({ type: "TSMethodSignature", key, typeParameters, parameters, typeAnnotation, kind: null }); } function tsIndexSignature(parameters, typeAnnotation = null) { return (0, _validateNode.default)({ type: "TSIndexSignature", parameters, typeAnnotation }); } function tsAnyKeyword() { return { type: "TSAnyKeyword" }; } function tsBooleanKeyword() { return { type: "TSBooleanKeyword" }; } function tsBigIntKeyword() { return { type: "TSBigIntKeyword" }; } function tsIntrinsicKeyword() { return { type: "TSIntrinsicKeyword" }; } function tsNeverKeyword() { return { type: "TSNeverKeyword" }; } function tsNullKeyword() { return { type: "TSNullKeyword" }; } function tsNumberKeyword() { return { type: "TSNumberKeyword" }; } function tsObjectKeyword() { return { type: "TSObjectKeyword" }; } function tsStringKeyword() { return { type: "TSStringKeyword" }; } function tsSymbolKeyword() { return { type: "TSSymbolKeyword" }; } function tsUndefinedKeyword() { return { type: "TSUndefinedKeyword" }; } function tsUnknownKeyword() { return { type: "TSUnknownKeyword" }; } function tsVoidKeyword() { return { type: "TSVoidKeyword" }; } function tsThisType() { return { type: "TSThisType" }; } function tsFunctionType(typeParameters = null, parameters, typeAnnotation = null) { return (0, _validateNode.default)({ type: "TSFunctionType", typeParameters, parameters, typeAnnotation }); } function tsConstructorType(typeParameters = null, parameters, typeAnnotation = null) { return (0, _validateNode.default)({ type: "TSConstructorType", typeParameters, parameters, typeAnnotation }); } function tsTypeReference(typeName, typeParameters = null) { return (0, _validateNode.default)({ type: "TSTypeReference", typeName, typeParameters }); } function tsTypePredicate(parameterName, typeAnnotation = null, asserts = null) { return (0, _validateNode.default)({ type: "TSTypePredicate", parameterName, typeAnnotation, asserts }); } function tsTypeQuery(exprName, typeParameters = null) { return (0, _validateNode.default)({ type: "TSTypeQuery", exprName, typeParameters }); } function tsTypeLiteral(members) { return (0, _validateNode.default)({ type: "TSTypeLiteral", members }); } function tsArrayType(elementType) { return (0, _validateNode.default)({ type: "TSArrayType", elementType }); } function tsTupleType(elementTypes) { return (0, _validateNode.default)({ type: "TSTupleType", elementTypes }); } function tsOptionalType(typeAnnotation) { return (0, _validateNode.default)({ type: "TSOptionalType", typeAnnotation }); } function tsRestType(typeAnnotation) { return (0, _validateNode.default)({ type: "TSRestType", typeAnnotation }); } function tsNamedTupleMember(label, elementType, optional = false) { return (0, _validateNode.default)({ type: "TSNamedTupleMember", label, elementType, optional }); } function tsUnionType(types) { return (0, _validateNode.default)({ type: "TSUnionType", types }); } function tsIntersectionType(types) { return (0, _validateNode.default)({ type: "TSIntersectionType", types }); } function tsConditionalType(checkType, extendsType, trueType, falseType) { return (0, _validateNode.default)({ type: "TSConditionalType", checkType, extendsType, trueType, falseType }); } function tsInferType(typeParameter) { return (0, _validateNode.default)({ type: "TSInferType", typeParameter }); } function tsParenthesizedType(typeAnnotation) { return (0, _validateNode.default)({ type: "TSParenthesizedType", typeAnnotation }); } function tsTypeOperator(typeAnnotation) { return (0, _validateNode.default)({ type: "TSTypeOperator", typeAnnotation, operator: null }); } function tsIndexedAccessType(objectType, indexType) { return (0, _validateNode.default)({ type: "TSIndexedAccessType", objectType, indexType }); } function tsMappedType(typeParameter, typeAnnotation = null, nameType = null) { return (0, _validateNode.default)({ type: "TSMappedType", typeParameter, typeAnnotation, nameType }); } function tsLiteralType(literal) { return (0, _validateNode.default)({ type: "TSLiteralType", literal }); } function tsExpressionWithTypeArguments(expression, typeParameters = null) { return (0, _validateNode.default)({ type: "TSExpressionWithTypeArguments", expression, typeParameters }); } function tsInterfaceDeclaration(id, typeParameters = null, _extends = null, body) { return (0, _validateNode.default)({ type: "TSInterfaceDeclaration", id, typeParameters, extends: _extends, body }); } function tsInterfaceBody(body) { return (0, _validateNode.default)({ type: "TSInterfaceBody", body }); } function tsTypeAliasDeclaration(id, typeParameters = null, typeAnnotation) { return (0, _validateNode.default)({ type: "TSTypeAliasDeclaration", id, typeParameters, typeAnnotation }); } function tsInstantiationExpression(expression, typeParameters = null) { return (0, _validateNode.default)({ type: "TSInstantiationExpression", expression, typeParameters }); } function tsAsExpression(expression, typeAnnotation) { return (0, _validateNode.default)({ type: "TSAsExpression", expression, typeAnnotation }); } function tsTypeAssertion(typeAnnotation, expression) { return (0, _validateNode.default)({ type: "TSTypeAssertion", typeAnnotation, expression }); } function tsEnumDeclaration(id, members) { return (0, _validateNode.default)({ type: "TSEnumDeclaration", id, members }); } function tsEnumMember(id, initializer = null) { return (0, _validateNode.default)({ type: "TSEnumMember", id, initializer }); } function tsModuleDeclaration(id, body) { return (0, _validateNode.default)({ type: "TSModuleDeclaration", id, body }); } function tsModuleBlock(body) { return (0, _validateNode.default)({ type: "TSModuleBlock", body }); } function tsImportType(argument, qualifier = null, typeParameters = null) { return (0, _validateNode.default)({ type: "TSImportType", argument, qualifier, typeParameters }); } function tsImportEqualsDeclaration(id, moduleReference) { return (0, _validateNode.default)({ type: "TSImportEqualsDeclaration", id, moduleReference, isExport: null }); } function tsExternalModuleReference(expression) { return (0, _validateNode.default)({ type: "TSExternalModuleReference", expression }); } function tsNonNullExpression(expression) { return (0, _validateNode.default)({ type: "TSNonNullExpression", expression }); } function tsExportAssignment(expression) { return (0, _validateNode.default)({ type: "TSExportAssignment", expression }); } function tsNamespaceExportDeclaration(id) { return (0, _validateNode.default)({ type: "TSNamespaceExportDeclaration", id }); } function tsTypeAnnotation(typeAnnotation) { return (0, _validateNode.default)({ type: "TSTypeAnnotation", typeAnnotation }); } function tsTypeParameterInstantiation(params) { return (0, _validateNode.default)({ type: "TSTypeParameterInstantiation", params }); } function tsTypeParameterDeclaration(params) { return (0, _validateNode.default)({ type: "TSTypeParameterDeclaration", params }); } function tsTypeParameter(constraint = null, _default = null, name) { return (0, _validateNode.default)({ type: "TSTypeParameter", constraint, default: _default, name }); } function NumberLiteral(value) { console.trace("The node type NumberLiteral has been renamed to NumericLiteral"); return numericLiteral(value); } function RegexLiteral(pattern, flags = "") { console.trace("The node type RegexLiteral has been renamed to RegExpLiteral"); return regExpLiteral(pattern, flags); } function RestProperty(argument) { console.trace("The node type RestProperty has been renamed to RestElement"); return restElement(argument); } function SpreadProperty(argument) { console.trace("The node type SpreadProperty has been renamed to SpreadElement"); return spreadElement(argument); } },{"../validateNode":324}],321:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); Object.defineProperty(exports, "AnyTypeAnnotation", { enumerable: true, get: function () { return _index.anyTypeAnnotation; } }); Object.defineProperty(exports, "ArgumentPlaceholder", { enumerable: true, get: function () { return _index.argumentPlaceholder; } }); Object.defineProperty(exports, "ArrayExpression", { enumerable: true, get: function () { return _index.arrayExpression; } }); Object.defineProperty(exports, "ArrayPattern", { enumerable: true, get: function () { return _index.arrayPattern; } }); Object.defineProperty(exports, "ArrayTypeAnnotation", { enumerable: true, get: function () { return _index.arrayTypeAnnotation; } }); Object.defineProperty(exports, "ArrowFunctionExpression", { enumerable: true, get: function () { return _index.arrowFunctionExpression; } }); Object.defineProperty(exports, "AssignmentExpression", { enumerable: true, get: function () { return _index.assignmentExpression; } }); Object.defineProperty(exports, "AssignmentPattern", { enumerable: true, get: function () { return _index.assignmentPattern; } }); Object.defineProperty(exports, "AwaitExpression", { enumerable: true, get: function () { return _index.awaitExpression; } }); Object.defineProperty(exports, "BigIntLiteral", { enumerable: true, get: function () { return _index.bigIntLiteral; } }); Object.defineProperty(exports, "BinaryExpression", { enumerable: true, get: function () { return _index.binaryExpression; } }); Object.defineProperty(exports, "BindExpression", { enumerable: true, get: function () { return _index.bindExpression; } }); Object.defineProperty(exports, "BlockStatement", { enumerable: true, get: function () { return _index.blockStatement; } }); Object.defineProperty(exports, "BooleanLiteral", { enumerable: true, get: function () { return _index.booleanLiteral; } }); Object.defineProperty(exports, "BooleanLiteralTypeAnnotation", { enumerable: true, get: function () { return _index.booleanLiteralTypeAnnotation; } }); Object.defineProperty(exports, "BooleanTypeAnnotation", { enumerable: true, get: function () { return _index.booleanTypeAnnotation; } }); Object.defineProperty(exports, "BreakStatement", { enumerable: true, get: function () { return _index.breakStatement; } }); Object.defineProperty(exports, "CallExpression", { enumerable: true, get: function () { return _index.callExpression; } }); Object.defineProperty(exports, "CatchClause", { enumerable: true, get: function () { return _index.catchClause; } }); Object.defineProperty(exports, "ClassAccessorProperty", { enumerable: true, get: function () { return _index.classAccessorProperty; } }); Object.defineProperty(exports, "ClassBody", { enumerable: true, get: function () { return _index.classBody; } }); Object.defineProperty(exports, "ClassDeclaration", { enumerable: true, get: function () { return _index.classDeclaration; } }); Object.defineProperty(exports, "ClassExpression", { enumerable: true, get: function () { return _index.classExpression; } }); Object.defineProperty(exports, "ClassImplements", { enumerable: true, get: function () { return _index.classImplements; } }); Object.defineProperty(exports, "ClassMethod", { enumerable: true, get: function () { return _index.classMethod; } }); Object.defineProperty(exports, "ClassPrivateMethod", { enumerable: true, get: function () { return _index.classPrivateMethod; } }); Object.defineProperty(exports, "ClassPrivateProperty", { enumerable: true, get: function () { return _index.classPrivateProperty; } }); Object.defineProperty(exports, "ClassProperty", { enumerable: true, get: function () { return _index.classProperty; } }); Object.defineProperty(exports, "ConditionalExpression", { enumerable: true, get: function () { return _index.conditionalExpression; } }); Object.defineProperty(exports, "ContinueStatement", { enumerable: true, get: function () { return _index.continueStatement; } }); Object.defineProperty(exports, "DebuggerStatement", { enumerable: true, get: function () { return _index.debuggerStatement; } }); Object.defineProperty(exports, "DecimalLiteral", { enumerable: true, get: function () { return _index.decimalLiteral; } }); Object.defineProperty(exports, "DeclareClass", { enumerable: true, get: function () { return _index.declareClass; } }); Object.defineProperty(exports, "DeclareExportAllDeclaration", { enumerable: true, get: function () { return _index.declareExportAllDeclaration; } }); Object.defineProperty(exports, "DeclareExportDeclaration", { enumerable: true, get: function () { return _index.declareExportDeclaration; } }); Object.defineProperty(exports, "DeclareFunction", { enumerable: true, get: function () { return _index.declareFunction; } }); Object.defineProperty(exports, "DeclareInterface", { enumerable: true, get: function () { return _index.declareInterface; } }); Object.defineProperty(exports, "DeclareModule", { enumerable: true, get: function () { return _index.declareModule; } }); Object.defineProperty(exports, "DeclareModuleExports", { enumerable: true, get: function () { return _index.declareModuleExports; } }); Object.defineProperty(exports, "DeclareOpaqueType", { enumerable: true, get: function () { return _index.declareOpaqueType; } }); Object.defineProperty(exports, "DeclareTypeAlias", { enumerable: true, get: function () { return _index.declareTypeAlias; } }); Object.defineProperty(exports, "DeclareVariable", { enumerable: true, get: function () { return _index.declareVariable; } }); Object.defineProperty(exports, "DeclaredPredicate", { enumerable: true, get: function () { return _index.declaredPredicate; } }); Object.defineProperty(exports, "Decorator", { enumerable: true, get: function () { return _index.decorator; } }); Object.defineProperty(exports, "Directive", { enumerable: true, get: function () { return _index.directive; } }); Object.defineProperty(exports, "DirectiveLiteral", { enumerable: true, get: function () { return _index.directiveLiteral; } }); Object.defineProperty(exports, "DoExpression", { enumerable: true, get: function () { return _index.doExpression; } }); Object.defineProperty(exports, "DoWhileStatement", { enumerable: true, get: function () { return _index.doWhileStatement; } }); Object.defineProperty(exports, "EmptyStatement", { enumerable: true, get: function () { return _index.emptyStatement; } }); Object.defineProperty(exports, "EmptyTypeAnnotation", { enumerable: true, get: function () { return _index.emptyTypeAnnotation; } }); Object.defineProperty(exports, "EnumBooleanBody", { enumerable: true, get: function () { return _index.enumBooleanBody; } }); Object.defineProperty(exports, "EnumBooleanMember", { enumerable: true, get: function () { return _index.enumBooleanMember; } }); Object.defineProperty(exports, "EnumDeclaration", { enumerable: true, get: function () { return _index.enumDeclaration; } }); Object.defineProperty(exports, "EnumDefaultedMember", { enumerable: true, get: function () { return _index.enumDefaultedMember; } }); Object.defineProperty(exports, "EnumNumberBody", { enumerable: true, get: function () { return _index.enumNumberBody; } }); Object.defineProperty(exports, "EnumNumberMember", { enumerable: true, get: function () { return _index.enumNumberMember; } }); Object.defineProperty(exports, "EnumStringBody", { enumerable: true, get: function () { return _index.enumStringBody; } }); Object.defineProperty(exports, "EnumStringMember", { enumerable: true, get: function () { return _index.enumStringMember; } }); Object.defineProperty(exports, "EnumSymbolBody", { enumerable: true, get: function () { return _index.enumSymbolBody; } }); Object.defineProperty(exports, "ExistsTypeAnnotation", { enumerable: true, get: function () { return _index.existsTypeAnnotation; } }); Object.defineProperty(exports, "ExportAllDeclaration", { enumerable: true, get: function () { return _index.exportAllDeclaration; } }); Object.defineProperty(exports, "ExportDefaultDeclaration", { enumerable: true, get: function () { return _index.exportDefaultDeclaration; } }); Object.defineProperty(exports, "ExportDefaultSpecifier", { enumerable: true, get: function () { return _index.exportDefaultSpecifier; } }); Object.defineProperty(exports, "ExportNamedDeclaration", { enumerable: true, get: function () { return _index.exportNamedDeclaration; } }); Object.defineProperty(exports, "ExportNamespaceSpecifier", { enumerable: true, get: function () { return _index.exportNamespaceSpecifier; } }); Object.defineProperty(exports, "ExportSpecifier", { enumerable: true, get: function () { return _index.exportSpecifier; } }); Object.defineProperty(exports, "ExpressionStatement", { enumerable: true, get: function () { return _index.expressionStatement; } }); Object.defineProperty(exports, "File", { enumerable: true, get: function () { return _index.file; } }); Object.defineProperty(exports, "ForInStatement", { enumerable: true, get: function () { return _index.forInStatement; } }); Object.defineProperty(exports, "ForOfStatement", { enumerable: true, get: function () { return _index.forOfStatement; } }); Object.defineProperty(exports, "ForStatement", { enumerable: true, get: function () { return _index.forStatement; } }); Object.defineProperty(exports, "FunctionDeclaration", { enumerable: true, get: function () { return _index.functionDeclaration; } }); Object.defineProperty(exports, "FunctionExpression", { enumerable: true, get: function () { return _index.functionExpression; } }); Object.defineProperty(exports, "FunctionTypeAnnotation", { enumerable: true, get: function () { return _index.functionTypeAnnotation; } }); Object.defineProperty(exports, "FunctionTypeParam", { enumerable: true, get: function () { return _index.functionTypeParam; } }); Object.defineProperty(exports, "GenericTypeAnnotation", { enumerable: true, get: function () { return _index.genericTypeAnnotation; } }); Object.defineProperty(exports, "Identifier", { enumerable: true, get: function () { return _index.identifier; } }); Object.defineProperty(exports, "IfStatement", { enumerable: true, get: function () { return _index.ifStatement; } }); Object.defineProperty(exports, "Import", { enumerable: true, get: function () { return _index.import; } }); Object.defineProperty(exports, "ImportAttribute", { enumerable: true, get: function () { return _index.importAttribute; } }); Object.defineProperty(exports, "ImportDeclaration", { enumerable: true, get: function () { return _index.importDeclaration; } }); Object.defineProperty(exports, "ImportDefaultSpecifier", { enumerable: true, get: function () { return _index.importDefaultSpecifier; } }); Object.defineProperty(exports, "ImportNamespaceSpecifier", { enumerable: true, get: function () { return _index.importNamespaceSpecifier; } }); Object.defineProperty(exports, "ImportSpecifier", { enumerable: true, get: function () { return _index.importSpecifier; } }); Object.defineProperty(exports, "IndexedAccessType", { enumerable: true, get: function () { return _index.indexedAccessType; } }); Object.defineProperty(exports, "InferredPredicate", { enumerable: true, get: function () { return _index.inferredPredicate; } }); Object.defineProperty(exports, "InterfaceDeclaration", { enumerable: true, get: function () { return _index.interfaceDeclaration; } }); Object.defineProperty(exports, "InterfaceExtends", { enumerable: true, get: function () { return _index.interfaceExtends; } }); Object.defineProperty(exports, "InterfaceTypeAnnotation", { enumerable: true, get: function () { return _index.interfaceTypeAnnotation; } }); Object.defineProperty(exports, "InterpreterDirective", { enumerable: true, get: function () { return _index.interpreterDirective; } }); Object.defineProperty(exports, "IntersectionTypeAnnotation", { enumerable: true, get: function () { return _index.intersectionTypeAnnotation; } }); Object.defineProperty(exports, "JSXAttribute", { enumerable: true, get: function () { return _index.jsxAttribute; } }); Object.defineProperty(exports, "JSXClosingElement", { enumerable: true, get: function () { return _index.jsxClosingElement; } }); Object.defineProperty(exports, "JSXClosingFragment", { enumerable: true, get: function () { return _index.jsxClosingFragment; } }); Object.defineProperty(exports, "JSXElement", { enumerable: true, get: function () { return _index.jsxElement; } }); Object.defineProperty(exports, "JSXEmptyExpression", { enumerable: true, get: function () { return _index.jsxEmptyExpression; } }); Object.defineProperty(exports, "JSXExpressionContainer", { enumerable: true, get: function () { return _index.jsxExpressionContainer; } }); Object.defineProperty(exports, "JSXFragment", { enumerable: true, get: function () { return _index.jsxFragment; } }); Object.defineProperty(exports, "JSXIdentifier", { enumerable: true, get: function () { return _index.jsxIdentifier; } }); Object.defineProperty(exports, "JSXMemberExpression", { enumerable: true, get: function () { return _index.jsxMemberExpression; } }); Object.defineProperty(exports, "JSXNamespacedName", { enumerable: true, get: function () { return _index.jsxNamespacedName; } }); Object.defineProperty(exports, "JSXOpeningElement", { enumerable: true, get: function () { return _index.jsxOpeningElement; } }); Object.defineProperty(exports, "JSXOpeningFragment", { enumerable: true, get: function () { return _index.jsxOpeningFragment; } }); Object.defineProperty(exports, "JSXSpreadAttribute", { enumerable: true, get: function () { return _index.jsxSpreadAttribute; } }); Object.defineProperty(exports, "JSXSpreadChild", { enumerable: true, get: function () { return _index.jsxSpreadChild; } }); Object.defineProperty(exports, "JSXText", { enumerable: true, get: function () { return _index.jsxText; } }); Object.defineProperty(exports, "LabeledStatement", { enumerable: true, get: function () { return _index.labeledStatement; } }); Object.defineProperty(exports, "LogicalExpression", { enumerable: true, get: function () { return _index.logicalExpression; } }); Object.defineProperty(exports, "MemberExpression", { enumerable: true, get: function () { return _index.memberExpression; } }); Object.defineProperty(exports, "MetaProperty", { enumerable: true, get: function () { return _index.metaProperty; } }); Object.defineProperty(exports, "MixedTypeAnnotation", { enumerable: true, get: function () { return _index.mixedTypeAnnotation; } }); Object.defineProperty(exports, "ModuleExpression", { enumerable: true, get: function () { return _index.moduleExpression; } }); Object.defineProperty(exports, "NewExpression", { enumerable: true, get: function () { return _index.newExpression; } }); Object.defineProperty(exports, "Noop", { enumerable: true, get: function () { return _index.noop; } }); Object.defineProperty(exports, "NullLiteral", { enumerable: true, get: function () { return _index.nullLiteral; } }); Object.defineProperty(exports, "NullLiteralTypeAnnotation", { enumerable: true, get: function () { return _index.nullLiteralTypeAnnotation; } }); Object.defineProperty(exports, "NullableTypeAnnotation", { enumerable: true, get: function () { return _index.nullableTypeAnnotation; } }); Object.defineProperty(exports, "NumberLiteral", { enumerable: true, get: function () { return _index.numberLiteral; } }); Object.defineProperty(exports, "NumberLiteralTypeAnnotation", { enumerable: true, get: function () { return _index.numberLiteralTypeAnnotation; } }); Object.defineProperty(exports, "NumberTypeAnnotation", { enumerable: true, get: function () { return _index.numberTypeAnnotation; } }); Object.defineProperty(exports, "NumericLiteral", { enumerable: true, get: function () { return _index.numericLiteral; } }); Object.defineProperty(exports, "ObjectExpression", { enumerable: true, get: function () { return _index.objectExpression; } }); Object.defineProperty(exports, "ObjectMethod", { enumerable: true, get: function () { return _index.objectMethod; } }); Object.defineProperty(exports, "ObjectPattern", { enumerable: true, get: function () { return _index.objectPattern; } }); Object.defineProperty(exports, "ObjectProperty", { enumerable: true, get: function () { return _index.objectProperty; } }); Object.defineProperty(exports, "ObjectTypeAnnotation", { enumerable: true, get: function () { return _index.objectTypeAnnotation; } }); Object.defineProperty(exports, "ObjectTypeCallProperty", { enumerable: true, get: function () { return _index.objectTypeCallProperty; } }); Object.defineProperty(exports, "ObjectTypeIndexer", { enumerable: true, get: function () { return _index.objectTypeIndexer; } }); Object.defineProperty(exports, "ObjectTypeInternalSlot", { enumerable: true, get: function () { return _index.objectTypeInternalSlot; } }); Object.defineProperty(exports, "ObjectTypeProperty", { enumerable: true, get: function () { return _index.objectTypeProperty; } }); Object.defineProperty(exports, "ObjectTypeSpreadProperty", { enumerable: true, get: function () { return _index.objectTypeSpreadProperty; } }); Object.defineProperty(exports, "OpaqueType", { enumerable: true, get: function () { return _index.opaqueType; } }); Object.defineProperty(exports, "OptionalCallExpression", { enumerable: true, get: function () { return _index.optionalCallExpression; } }); Object.defineProperty(exports, "OptionalIndexedAccessType", { enumerable: true, get: function () { return _index.optionalIndexedAccessType; } }); Object.defineProperty(exports, "OptionalMemberExpression", { enumerable: true, get: function () { return _index.optionalMemberExpression; } }); Object.defineProperty(exports, "ParenthesizedExpression", { enumerable: true, get: function () { return _index.parenthesizedExpression; } }); Object.defineProperty(exports, "PipelineBareFunction", { enumerable: true, get: function () { return _index.pipelineBareFunction; } }); Object.defineProperty(exports, "PipelinePrimaryTopicReference", { enumerable: true, get: function () { return _index.pipelinePrimaryTopicReference; } }); Object.defineProperty(exports, "PipelineTopicExpression", { enumerable: true, get: function () { return _index.pipelineTopicExpression; } }); Object.defineProperty(exports, "Placeholder", { enumerable: true, get: function () { return _index.placeholder; } }); Object.defineProperty(exports, "PrivateName", { enumerable: true, get: function () { return _index.privateName; } }); Object.defineProperty(exports, "Program", { enumerable: true, get: function () { return _index.program; } }); Object.defineProperty(exports, "QualifiedTypeIdentifier", { enumerable: true, get: function () { return _index.qualifiedTypeIdentifier; } }); Object.defineProperty(exports, "RecordExpression", { enumerable: true, get: function () { return _index.recordExpression; } }); Object.defineProperty(exports, "RegExpLiteral", { enumerable: true, get: function () { return _index.regExpLiteral; } }); Object.defineProperty(exports, "RegexLiteral", { enumerable: true, get: function () { return _index.regexLiteral; } }); Object.defineProperty(exports, "RestElement", { enumerable: true, get: function () { return _index.restElement; } }); Object.defineProperty(exports, "RestProperty", { enumerable: true, get: function () { return _index.restProperty; } }); Object.defineProperty(exports, "ReturnStatement", { enumerable: true, get: function () { return _index.returnStatement; } }); Object.defineProperty(exports, "SequenceExpression", { enumerable: true, get: function () { return _index.sequenceExpression; } }); Object.defineProperty(exports, "SpreadElement", { enumerable: true, get: function () { return _index.spreadElement; } }); Object.defineProperty(exports, "SpreadProperty", { enumerable: true, get: function () { return _index.spreadProperty; } }); Object.defineProperty(exports, "StaticBlock", { enumerable: true, get: function () { return _index.staticBlock; } }); Object.defineProperty(exports, "StringLiteral", { enumerable: true, get: function () { return _index.stringLiteral; } }); Object.defineProperty(exports, "StringLiteralTypeAnnotation", { enumerable: true, get: function () { return _index.stringLiteralTypeAnnotation; } }); Object.defineProperty(exports, "StringTypeAnnotation", { enumerable: true, get: function () { return _index.stringTypeAnnotation; } }); Object.defineProperty(exports, "Super", { enumerable: true, get: function () { return _index.super; } }); Object.defineProperty(exports, "SwitchCase", { enumerable: true, get: function () { return _index.switchCase; } }); Object.defineProperty(exports, "SwitchStatement", { enumerable: true, get: function () { return _index.switchStatement; } }); Object.defineProperty(exports, "SymbolTypeAnnotation", { enumerable: true, get: function () { return _index.symbolTypeAnnotation; } }); Object.defineProperty(exports, "TSAnyKeyword", { enumerable: true, get: function () { return _index.tsAnyKeyword; } }); Object.defineProperty(exports, "TSArrayType", { enumerable: true, get: function () { return _index.tsArrayType; } }); Object.defineProperty(exports, "TSAsExpression", { enumerable: true, get: function () { return _index.tsAsExpression; } }); Object.defineProperty(exports, "TSBigIntKeyword", { enumerable: true, get: function () { return _index.tsBigIntKeyword; } }); Object.defineProperty(exports, "TSBooleanKeyword", { enumerable: true, get: function () { return _index.tsBooleanKeyword; } }); Object.defineProperty(exports, "TSCallSignatureDeclaration", { enumerable: true, get: function () { return _index.tsCallSignatureDeclaration; } }); Object.defineProperty(exports, "TSConditionalType", { enumerable: true, get: function () { return _index.tsConditionalType; } }); Object.defineProperty(exports, "TSConstructSignatureDeclaration", { enumerable: true, get: function () { return _index.tsConstructSignatureDeclaration; } }); Object.defineProperty(exports, "TSConstructorType", { enumerable: true, get: function () { return _index.tsConstructorType; } }); Object.defineProperty(exports, "TSDeclareFunction", { enumerable: true, get: function () { return _index.tsDeclareFunction; } }); Object.defineProperty(exports, "TSDeclareMethod", { enumerable: true, get: function () { return _index.tsDeclareMethod; } }); Object.defineProperty(exports, "TSEnumDeclaration", { enumerable: true, get: function () { return _index.tsEnumDeclaration; } }); Object.defineProperty(exports, "TSEnumMember", { enumerable: true, get: function () { return _index.tsEnumMember; } }); Object.defineProperty(exports, "TSExportAssignment", { enumerable: true, get: function () { return _index.tsExportAssignment; } }); Object.defineProperty(exports, "TSExpressionWithTypeArguments", { enumerable: true, get: function () { return _index.tsExpressionWithTypeArguments; } }); Object.defineProperty(exports, "TSExternalModuleReference", { enumerable: true, get: function () { return _index.tsExternalModuleReference; } }); Object.defineProperty(exports, "TSFunctionType", { enumerable: true, get: function () { return _index.tsFunctionType; } }); Object.defineProperty(exports, "TSImportEqualsDeclaration", { enumerable: true, get: function () { return _index.tsImportEqualsDeclaration; } }); Object.defineProperty(exports, "TSImportType", { enumerable: true, get: function () { return _index.tsImportType; } }); Object.defineProperty(exports, "TSIndexSignature", { enumerable: true, get: function () { return _index.tsIndexSignature; } }); Object.defineProperty(exports, "TSIndexedAccessType", { enumerable: true, get: function () { return _index.tsIndexedAccessType; } }); Object.defineProperty(exports, "TSInferType", { enumerable: true, get: function () { return _index.tsInferType; } }); Object.defineProperty(exports, "TSInstantiationExpression", { enumerable: true, get: function () { return _index.tsInstantiationExpression; } }); Object.defineProperty(exports, "TSInterfaceBody", { enumerable: true, get: function () { return _index.tsInterfaceBody; } }); Object.defineProperty(exports, "TSInterfaceDeclaration", { enumerable: true, get: function () { return _index.tsInterfaceDeclaration; } }); Object.defineProperty(exports, "TSIntersectionType", { enumerable: true, get: function () { return _index.tsIntersectionType; } }); Object.defineProperty(exports, "TSIntrinsicKeyword", { enumerable: true, get: function () { return _index.tsIntrinsicKeyword; } }); Object.defineProperty(exports, "TSLiteralType", { enumerable: true, get: function () { return _index.tsLiteralType; } }); Object.defineProperty(exports, "TSMappedType", { enumerable: true, get: function () { return _index.tsMappedType; } }); Object.defineProperty(exports, "TSMethodSignature", { enumerable: true, get: function () { return _index.tsMethodSignature; } }); Object.defineProperty(exports, "TSModuleBlock", { enumerable: true, get: function () { return _index.tsModuleBlock; } }); Object.defineProperty(exports, "TSModuleDeclaration", { enumerable: true, get: function () { return _index.tsModuleDeclaration; } }); Object.defineProperty(exports, "TSNamedTupleMember", { enumerable: true, get: function () { return _index.tsNamedTupleMember; } }); Object.defineProperty(exports, "TSNamespaceExportDeclaration", { enumerable: true, get: function () { return _index.tsNamespaceExportDeclaration; } }); Object.defineProperty(exports, "TSNeverKeyword", { enumerable: true, get: function () { return _index.tsNeverKeyword; } }); Object.defineProperty(exports, "TSNonNullExpression", { enumerable: true, get: function () { return _index.tsNonNullExpression; } }); Object.defineProperty(exports, "TSNullKeyword", { enumerable: true, get: function () { return _index.tsNullKeyword; } }); Object.defineProperty(exports, "TSNumberKeyword", { enumerable: true, get: function () { return _index.tsNumberKeyword; } }); Object.defineProperty(exports, "TSObjectKeyword", { enumerable: true, get: function () { return _index.tsObjectKeyword; } }); Object.defineProperty(exports, "TSOptionalType", { enumerable: true, get: function () { return _index.tsOptionalType; } }); Object.defineProperty(exports, "TSParameterProperty", { enumerable: true, get: function () { return _index.tsParameterProperty; } }); Object.defineProperty(exports, "TSParenthesizedType", { enumerable: true, get: function () { return _index.tsParenthesizedType; } }); Object.defineProperty(exports, "TSPropertySignature", { enumerable: true, get: function () { return _index.tsPropertySignature; } }); Object.defineProperty(exports, "TSQualifiedName", { enumerable: true, get: function () { return _index.tsQualifiedName; } }); Object.defineProperty(exports, "TSRestType", { enumerable: true, get: function () { return _index.tsRestType; } }); Object.defineProperty(exports, "TSStringKeyword", { enumerable: true, get: function () { return _index.tsStringKeyword; } }); Object.defineProperty(exports, "TSSymbolKeyword", { enumerable: true, get: function () { return _index.tsSymbolKeyword; } }); Object.defineProperty(exports, "TSThisType", { enumerable: true, get: function () { return _index.tsThisType; } }); Object.defineProperty(exports, "TSTupleType", { enumerable: true, get: function () { return _index.tsTupleType; } }); Object.defineProperty(exports, "TSTypeAliasDeclaration", { enumerable: true, get: function () { return _index.tsTypeAliasDeclaration; } }); Object.defineProperty(exports, "TSTypeAnnotation", { enumerable: true, get: function () { return _index.tsTypeAnnotation; } }); Object.defineProperty(exports, "TSTypeAssertion", { enumerable: true, get: function () { return _index.tsTypeAssertion; } }); Object.defineProperty(exports, "TSTypeLiteral", { enumerable: true, get: function () { return _index.tsTypeLiteral; } }); Object.defineProperty(exports, "TSTypeOperator", { enumerable: true, get: function () { return _index.tsTypeOperator; } }); Object.defineProperty(exports, "TSTypeParameter", { enumerable: true, get: function () { return _index.tsTypeParameter; } }); Object.defineProperty(exports, "TSTypeParameterDeclaration", { enumerable: true, get: function () { return _index.tsTypeParameterDeclaration; } }); Object.defineProperty(exports, "TSTypeParameterInstantiation", { enumerable: true, get: function () { return _index.tsTypeParameterInstantiation; } }); Object.defineProperty(exports, "TSTypePredicate", { enumerable: true, get: function () { return _index.tsTypePredicate; } }); Object.defineProperty(exports, "TSTypeQuery", { enumerable: true, get: function () { return _index.tsTypeQuery; } }); Object.defineProperty(exports, "TSTypeReference", { enumerable: true, get: function () { return _index.tsTypeReference; } }); Object.defineProperty(exports, "TSUndefinedKeyword", { enumerable: true, get: function () { return _index.tsUndefinedKeyword; } }); Object.defineProperty(exports, "TSUnionType", { enumerable: true, get: function () { return _index.tsUnionType; } }); Object.defineProperty(exports, "TSUnknownKeyword", { enumerable: true, get: function () { return _index.tsUnknownKeyword; } }); Object.defineProperty(exports, "TSVoidKeyword", { enumerable: true, get: function () { return _index.tsVoidKeyword; } }); Object.defineProperty(exports, "TaggedTemplateExpression", { enumerable: true, get: function () { return _index.taggedTemplateExpression; } }); Object.defineProperty(exports, "TemplateElement", { enumerable: true, get: function () { return _index.templateElement; } }); Object.defineProperty(exports, "TemplateLiteral", { enumerable: true, get: function () { return _index.templateLiteral; } }); Object.defineProperty(exports, "ThisExpression", { enumerable: true, get: function () { return _index.thisExpression; } }); Object.defineProperty(exports, "ThisTypeAnnotation", { enumerable: true, get: function () { return _index.thisTypeAnnotation; } }); Object.defineProperty(exports, "ThrowStatement", { enumerable: true, get: function () { return _index.throwStatement; } }); Object.defineProperty(exports, "TopicReference", { enumerable: true, get: function () { return _index.topicReference; } }); Object.defineProperty(exports, "TryStatement", { enumerable: true, get: function () { return _index.tryStatement; } }); Object.defineProperty(exports, "TupleExpression", { enumerable: true, get: function () { return _index.tupleExpression; } }); Object.defineProperty(exports, "TupleTypeAnnotation", { enumerable: true, get: function () { return _index.tupleTypeAnnotation; } }); Object.defineProperty(exports, "TypeAlias", { enumerable: true, get: function () { return _index.typeAlias; } }); Object.defineProperty(exports, "TypeAnnotation", { enumerable: true, get: function () { return _index.typeAnnotation; } }); Object.defineProperty(exports, "TypeCastExpression", { enumerable: true, get: function () { return _index.typeCastExpression; } }); Object.defineProperty(exports, "TypeParameter", { enumerable: true, get: function () { return _index.typeParameter; } }); Object.defineProperty(exports, "TypeParameterDeclaration", { enumerable: true, get: function () { return _index.typeParameterDeclaration; } }); Object.defineProperty(exports, "TypeParameterInstantiation", { enumerable: true, get: function () { return _index.typeParameterInstantiation; } }); Object.defineProperty(exports, "TypeofTypeAnnotation", { enumerable: true, get: function () { return _index.typeofTypeAnnotation; } }); Object.defineProperty(exports, "UnaryExpression", { enumerable: true, get: function () { return _index.unaryExpression; } }); Object.defineProperty(exports, "UnionTypeAnnotation", { enumerable: true, get: function () { return _index.unionTypeAnnotation; } }); Object.defineProperty(exports, "UpdateExpression", { enumerable: true, get: function () { return _index.updateExpression; } }); Object.defineProperty(exports, "V8IntrinsicIdentifier", { enumerable: true, get: function () { return _index.v8IntrinsicIdentifier; } }); Object.defineProperty(exports, "VariableDeclaration", { enumerable: true, get: function () { return _index.variableDeclaration; } }); Object.defineProperty(exports, "VariableDeclarator", { enumerable: true, get: function () { return _index.variableDeclarator; } }); Object.defineProperty(exports, "Variance", { enumerable: true, get: function () { return _index.variance; } }); Object.defineProperty(exports, "VoidTypeAnnotation", { enumerable: true, get: function () { return _index.voidTypeAnnotation; } }); Object.defineProperty(exports, "WhileStatement", { enumerable: true, get: function () { return _index.whileStatement; } }); Object.defineProperty(exports, "WithStatement", { enumerable: true, get: function () { return _index.withStatement; } }); Object.defineProperty(exports, "YieldExpression", { enumerable: true, get: function () { return _index.yieldExpression; } }); var _index = require("./index"); },{"./index":320}],322:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = buildChildren; var _generated = require("../../validators/generated"); var _cleanJSXElementLiteralChild = require("../../utils/react/cleanJSXElementLiteralChild"); function buildChildren(node) { const elements = []; for (let i = 0; i < node.children.length; i++) { let child = node.children[i]; if ((0, _generated.isJSXText)(child)) { (0, _cleanJSXElementLiteralChild.default)(child, elements); continue; } if ((0, _generated.isJSXExpressionContainer)(child)) child = child.expression; if ((0, _generated.isJSXEmptyExpression)(child)) continue; elements.push(child); } return elements; } },{"../../utils/react/cleanJSXElementLiteralChild":372,"../../validators/generated":375}],323:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = createTSUnionType; var _generated = require("../generated"); var _removeTypeDuplicates = require("../../modifications/typescript/removeTypeDuplicates"); var _index = require("../../validators/generated/index"); function createTSUnionType(typeAnnotations) { const types = typeAnnotations.map(type => { return (0, _index.isTSTypeAnnotation)(type) ? type.typeAnnotation : type; }); const flattened = (0, _removeTypeDuplicates.default)(types); if (flattened.length === 1) { return flattened[0]; } else { return (0, _generated.tsUnionType)(flattened); } } },{"../../modifications/typescript/removeTypeDuplicates":366,"../../validators/generated/index":375,"../generated":320}],324:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = validateNode; var _validate = require("../validators/validate"); var _ = require(".."); function validateNode(node) { const keys = _.BUILDER_KEYS[node.type]; for (const key of keys) { (0, _validate.default)(node, key, node[key]); } return node; } },{"..":359,"../validators/validate":394}],325:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = clone; var _cloneNode = require("./cloneNode"); function clone(node) { return (0, _cloneNode.default)(node, false); } },{"./cloneNode":328}],326:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = cloneDeep; var _cloneNode = require("./cloneNode"); function cloneDeep(node) { return (0, _cloneNode.default)(node); } },{"./cloneNode":328}],327:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = cloneDeepWithoutLoc; var _cloneNode = require("./cloneNode"); function cloneDeepWithoutLoc(node) { return (0, _cloneNode.default)(node, true, true); } },{"./cloneNode":328}],328:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = cloneNode; var _definitions = require("../definitions"); var _generated = require("../validators/generated"); const has = Function.call.bind(Object.prototype.hasOwnProperty); function cloneIfNode(obj, deep, withoutLoc, commentsCache) { if (obj && typeof obj.type === "string") { return cloneNodeInternal(obj, deep, withoutLoc, commentsCache); } return obj; } function cloneIfNodeOrArray(obj, deep, withoutLoc, commentsCache) { if (Array.isArray(obj)) { return obj.map(node => cloneIfNode(node, deep, withoutLoc, commentsCache)); } return cloneIfNode(obj, deep, withoutLoc, commentsCache); } function cloneNode(node, deep = true, withoutLoc = false) { return cloneNodeInternal(node, deep, withoutLoc, new Map()); } function cloneNodeInternal(node, deep = true, withoutLoc = false, commentsCache) { if (!node) return node; const { type } = node; const newNode = { type: node.type }; if ((0, _generated.isIdentifier)(node)) { newNode.name = node.name; if (has(node, "optional") && typeof node.optional === "boolean") { newNode.optional = node.optional; } if (has(node, "typeAnnotation")) { newNode.typeAnnotation = deep ? cloneIfNodeOrArray(node.typeAnnotation, true, withoutLoc, commentsCache) : node.typeAnnotation; } } else if (!has(_definitions.NODE_FIELDS, type)) { throw new Error(`Unknown node type: "${type}"`); } else { for (const field of Object.keys(_definitions.NODE_FIELDS[type])) { if (has(node, field)) { if (deep) { newNode[field] = (0, _generated.isFile)(node) && field === "comments" ? maybeCloneComments(node.comments, deep, withoutLoc, commentsCache) : cloneIfNodeOrArray(node[field], true, withoutLoc, commentsCache); } else { newNode[field] = node[field]; } } } } if (has(node, "loc")) { if (withoutLoc) { newNode.loc = null; } else { newNode.loc = node.loc; } } if (has(node, "leadingComments")) { newNode.leadingComments = maybeCloneComments(node.leadingComments, deep, withoutLoc, commentsCache); } if (has(node, "innerComments")) { newNode.innerComments = maybeCloneComments(node.innerComments, deep, withoutLoc, commentsCache); } if (has(node, "trailingComments")) { newNode.trailingComments = maybeCloneComments(node.trailingComments, deep, withoutLoc, commentsCache); } if (has(node, "extra")) { newNode.extra = Object.assign({}, node.extra); } return newNode; } function maybeCloneComments(comments, deep, withoutLoc, commentsCache) { if (!comments || !deep) { return comments; } return comments.map(comment => { const cache = commentsCache.get(comment); if (cache) return cache; const { type, value, loc } = comment; const ret = { type, value, loc }; if (withoutLoc) { ret.loc = null; } commentsCache.set(comment, ret); return ret; }); } },{"../definitions":353,"../validators/generated":375}],329:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = cloneWithoutLoc; var _cloneNode = require("./cloneNode"); function cloneWithoutLoc(node) { return (0, _cloneNode.default)(node, false, true); } },{"./cloneNode":328}],330:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = addComment; var _addComments = require("./addComments"); function addComment(node, type, content, line) { return (0, _addComments.default)(node, type, [{ type: line ? "CommentLine" : "CommentBlock", value: content }]); } },{"./addComments":331}],331:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = addComments; function addComments(node, type, comments) { if (!comments || !node) return node; const key = `${type}Comments`; if (node[key]) { if (type === "leading") { node[key] = comments.concat(node[key]); } else { node[key].push(...comments); } } else { node[key] = comments; } return node; } },{}],332:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = inheritInnerComments; var _inherit = require("../utils/inherit"); function inheritInnerComments(child, parent) { (0, _inherit.default)("innerComments", child, parent); } },{"../utils/inherit":371}],333:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = inheritLeadingComments; var _inherit = require("../utils/inherit"); function inheritLeadingComments(child, parent) { (0, _inherit.default)("leadingComments", child, parent); } },{"../utils/inherit":371}],334:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = inheritTrailingComments; var _inherit = require("../utils/inherit"); function inheritTrailingComments(child, parent) { (0, _inherit.default)("trailingComments", child, parent); } },{"../utils/inherit":371}],335:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = inheritsComments; var _inheritTrailingComments = require("./inheritTrailingComments"); var _inheritLeadingComments = require("./inheritLeadingComments"); var _inheritInnerComments = require("./inheritInnerComments"); function inheritsComments(child, parent) { (0, _inheritTrailingComments.default)(child, parent); (0, _inheritLeadingComments.default)(child, parent); (0, _inheritInnerComments.default)(child, parent); return child; } },{"./inheritInnerComments":332,"./inheritLeadingComments":333,"./inheritTrailingComments":334}],336:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = removeComments; var _constants = require("../constants"); function removeComments(node) { _constants.COMMENT_KEYS.forEach(key => { node[key] = null; }); return node; } },{"../constants":338}],337:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.WHILE_TYPES = exports.USERWHITESPACABLE_TYPES = exports.UNARYLIKE_TYPES = exports.TYPESCRIPT_TYPES = exports.TSTYPE_TYPES = exports.TSTYPEELEMENT_TYPES = exports.TSENTITYNAME_TYPES = exports.TSBASETYPE_TYPES = exports.TERMINATORLESS_TYPES = exports.STATEMENT_TYPES = exports.STANDARDIZED_TYPES = exports.SCOPABLE_TYPES = exports.PUREISH_TYPES = exports.PROPERTY_TYPES = exports.PRIVATE_TYPES = exports.PATTERN_TYPES = exports.PATTERNLIKE_TYPES = exports.OBJECTMEMBER_TYPES = exports.MODULESPECIFIER_TYPES = exports.MODULEDECLARATION_TYPES = exports.MISCELLANEOUS_TYPES = exports.METHOD_TYPES = exports.LVAL_TYPES = exports.LOOP_TYPES = exports.LITERAL_TYPES = exports.JSX_TYPES = exports.IMMUTABLE_TYPES = exports.FUNCTION_TYPES = exports.FUNCTIONPARENT_TYPES = exports.FOR_TYPES = exports.FORXSTATEMENT_TYPES = exports.FLOW_TYPES = exports.FLOWTYPE_TYPES = exports.FLOWPREDICATE_TYPES = exports.FLOWDECLARATION_TYPES = exports.FLOWBASEANNOTATION_TYPES = exports.EXPRESSION_TYPES = exports.EXPRESSIONWRAPPER_TYPES = exports.EXPORTDECLARATION_TYPES = exports.ENUMMEMBER_TYPES = exports.ENUMBODY_TYPES = exports.DECLARATION_TYPES = exports.CONDITIONAL_TYPES = exports.COMPLETIONSTATEMENT_TYPES = exports.CLASS_TYPES = exports.BLOCK_TYPES = exports.BLOCKPARENT_TYPES = exports.BINARY_TYPES = exports.ACCESSOR_TYPES = void 0; var _definitions = require("../../definitions"); const STANDARDIZED_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Standardized"]; exports.STANDARDIZED_TYPES = STANDARDIZED_TYPES; const EXPRESSION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Expression"]; exports.EXPRESSION_TYPES = EXPRESSION_TYPES; const BINARY_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Binary"]; exports.BINARY_TYPES = BINARY_TYPES; const SCOPABLE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Scopable"]; exports.SCOPABLE_TYPES = SCOPABLE_TYPES; const BLOCKPARENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["BlockParent"]; exports.BLOCKPARENT_TYPES = BLOCKPARENT_TYPES; const BLOCK_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Block"]; exports.BLOCK_TYPES = BLOCK_TYPES; const STATEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Statement"]; exports.STATEMENT_TYPES = STATEMENT_TYPES; const TERMINATORLESS_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Terminatorless"]; exports.TERMINATORLESS_TYPES = TERMINATORLESS_TYPES; const COMPLETIONSTATEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["CompletionStatement"]; exports.COMPLETIONSTATEMENT_TYPES = COMPLETIONSTATEMENT_TYPES; const CONDITIONAL_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Conditional"]; exports.CONDITIONAL_TYPES = CONDITIONAL_TYPES; const LOOP_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Loop"]; exports.LOOP_TYPES = LOOP_TYPES; const WHILE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["While"]; exports.WHILE_TYPES = WHILE_TYPES; const EXPRESSIONWRAPPER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ExpressionWrapper"]; exports.EXPRESSIONWRAPPER_TYPES = EXPRESSIONWRAPPER_TYPES; const FOR_TYPES = _definitions.FLIPPED_ALIAS_KEYS["For"]; exports.FOR_TYPES = FOR_TYPES; const FORXSTATEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ForXStatement"]; exports.FORXSTATEMENT_TYPES = FORXSTATEMENT_TYPES; const FUNCTION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Function"]; exports.FUNCTION_TYPES = FUNCTION_TYPES; const FUNCTIONPARENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FunctionParent"]; exports.FUNCTIONPARENT_TYPES = FUNCTIONPARENT_TYPES; const PUREISH_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Pureish"]; exports.PUREISH_TYPES = PUREISH_TYPES; const DECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Declaration"]; exports.DECLARATION_TYPES = DECLARATION_TYPES; const PATTERNLIKE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["PatternLike"]; exports.PATTERNLIKE_TYPES = PATTERNLIKE_TYPES; const LVAL_TYPES = _definitions.FLIPPED_ALIAS_KEYS["LVal"]; exports.LVAL_TYPES = LVAL_TYPES; const TSENTITYNAME_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSEntityName"]; exports.TSENTITYNAME_TYPES = TSENTITYNAME_TYPES; const LITERAL_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Literal"]; exports.LITERAL_TYPES = LITERAL_TYPES; const IMMUTABLE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Immutable"]; exports.IMMUTABLE_TYPES = IMMUTABLE_TYPES; const USERWHITESPACABLE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["UserWhitespacable"]; exports.USERWHITESPACABLE_TYPES = USERWHITESPACABLE_TYPES; const METHOD_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Method"]; exports.METHOD_TYPES = METHOD_TYPES; const OBJECTMEMBER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ObjectMember"]; exports.OBJECTMEMBER_TYPES = OBJECTMEMBER_TYPES; const PROPERTY_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Property"]; exports.PROPERTY_TYPES = PROPERTY_TYPES; const UNARYLIKE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["UnaryLike"]; exports.UNARYLIKE_TYPES = UNARYLIKE_TYPES; const PATTERN_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Pattern"]; exports.PATTERN_TYPES = PATTERN_TYPES; const CLASS_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Class"]; exports.CLASS_TYPES = CLASS_TYPES; const MODULEDECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ModuleDeclaration"]; exports.MODULEDECLARATION_TYPES = MODULEDECLARATION_TYPES; const EXPORTDECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ExportDeclaration"]; exports.EXPORTDECLARATION_TYPES = EXPORTDECLARATION_TYPES; const MODULESPECIFIER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ModuleSpecifier"]; exports.MODULESPECIFIER_TYPES = MODULESPECIFIER_TYPES; const ACCESSOR_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Accessor"]; exports.ACCESSOR_TYPES = ACCESSOR_TYPES; const PRIVATE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Private"]; exports.PRIVATE_TYPES = PRIVATE_TYPES; const FLOW_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Flow"]; exports.FLOW_TYPES = FLOW_TYPES; const FLOWTYPE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowType"]; exports.FLOWTYPE_TYPES = FLOWTYPE_TYPES; const FLOWBASEANNOTATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowBaseAnnotation"]; exports.FLOWBASEANNOTATION_TYPES = FLOWBASEANNOTATION_TYPES; const FLOWDECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowDeclaration"]; exports.FLOWDECLARATION_TYPES = FLOWDECLARATION_TYPES; const FLOWPREDICATE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowPredicate"]; exports.FLOWPREDICATE_TYPES = FLOWPREDICATE_TYPES; const ENUMBODY_TYPES = _definitions.FLIPPED_ALIAS_KEYS["EnumBody"]; exports.ENUMBODY_TYPES = ENUMBODY_TYPES; const ENUMMEMBER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["EnumMember"]; exports.ENUMMEMBER_TYPES = ENUMMEMBER_TYPES; const JSX_TYPES = _definitions.FLIPPED_ALIAS_KEYS["JSX"]; exports.JSX_TYPES = JSX_TYPES; const MISCELLANEOUS_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Miscellaneous"]; exports.MISCELLANEOUS_TYPES = MISCELLANEOUS_TYPES; const TYPESCRIPT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TypeScript"]; exports.TYPESCRIPT_TYPES = TYPESCRIPT_TYPES; const TSTYPEELEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSTypeElement"]; exports.TSTYPEELEMENT_TYPES = TSTYPEELEMENT_TYPES; const TSTYPE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSType"]; exports.TSTYPE_TYPES = TSTYPE_TYPES; const TSBASETYPE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSBaseType"]; exports.TSBASETYPE_TYPES = TSBASETYPE_TYPES; },{"../../definitions":353}],338:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.UPDATE_OPERATORS = exports.UNARY_OPERATORS = exports.STRING_UNARY_OPERATORS = exports.STATEMENT_OR_BLOCK_KEYS = exports.NUMBER_UNARY_OPERATORS = exports.NUMBER_BINARY_OPERATORS = exports.NOT_LOCAL_BINDING = exports.LOGICAL_OPERATORS = exports.INHERIT_KEYS = exports.FOR_INIT_KEYS = exports.FLATTENABLE_KEYS = exports.EQUALITY_BINARY_OPERATORS = exports.COMPARISON_BINARY_OPERATORS = exports.COMMENT_KEYS = exports.BOOLEAN_UNARY_OPERATORS = exports.BOOLEAN_NUMBER_BINARY_OPERATORS = exports.BOOLEAN_BINARY_OPERATORS = exports.BLOCK_SCOPED_SYMBOL = exports.BINARY_OPERATORS = exports.ASSIGNMENT_OPERATORS = void 0; const STATEMENT_OR_BLOCK_KEYS = ["consequent", "body", "alternate"]; exports.STATEMENT_OR_BLOCK_KEYS = STATEMENT_OR_BLOCK_KEYS; const FLATTENABLE_KEYS = ["body", "expressions"]; exports.FLATTENABLE_KEYS = FLATTENABLE_KEYS; const FOR_INIT_KEYS = ["left", "init"]; exports.FOR_INIT_KEYS = FOR_INIT_KEYS; const COMMENT_KEYS = ["leadingComments", "trailingComments", "innerComments"]; exports.COMMENT_KEYS = COMMENT_KEYS; const LOGICAL_OPERATORS = ["||", "&&", "??"]; exports.LOGICAL_OPERATORS = LOGICAL_OPERATORS; const UPDATE_OPERATORS = ["++", "--"]; exports.UPDATE_OPERATORS = UPDATE_OPERATORS; const BOOLEAN_NUMBER_BINARY_OPERATORS = [">", "<", ">=", "<="]; exports.BOOLEAN_NUMBER_BINARY_OPERATORS = BOOLEAN_NUMBER_BINARY_OPERATORS; const EQUALITY_BINARY_OPERATORS = ["==", "===", "!=", "!=="]; exports.EQUALITY_BINARY_OPERATORS = EQUALITY_BINARY_OPERATORS; const COMPARISON_BINARY_OPERATORS = [...EQUALITY_BINARY_OPERATORS, "in", "instanceof"]; exports.COMPARISON_BINARY_OPERATORS = COMPARISON_BINARY_OPERATORS; const BOOLEAN_BINARY_OPERATORS = [...COMPARISON_BINARY_OPERATORS, ...BOOLEAN_NUMBER_BINARY_OPERATORS]; exports.BOOLEAN_BINARY_OPERATORS = BOOLEAN_BINARY_OPERATORS; const NUMBER_BINARY_OPERATORS = ["-", "/", "%", "*", "**", "&", "|", ">>", ">>>", "<<", "^"]; exports.NUMBER_BINARY_OPERATORS = NUMBER_BINARY_OPERATORS; const BINARY_OPERATORS = ["+", ...NUMBER_BINARY_OPERATORS, ...BOOLEAN_BINARY_OPERATORS, "|>"]; exports.BINARY_OPERATORS = BINARY_OPERATORS; const ASSIGNMENT_OPERATORS = ["=", "+=", ...NUMBER_BINARY_OPERATORS.map(op => op + "="), ...LOGICAL_OPERATORS.map(op => op + "=")]; exports.ASSIGNMENT_OPERATORS = ASSIGNMENT_OPERATORS; const BOOLEAN_UNARY_OPERATORS = ["delete", "!"]; exports.BOOLEAN_UNARY_OPERATORS = BOOLEAN_UNARY_OPERATORS; const NUMBER_UNARY_OPERATORS = ["+", "-", "~"]; exports.NUMBER_UNARY_OPERATORS = NUMBER_UNARY_OPERATORS; const STRING_UNARY_OPERATORS = ["typeof"]; exports.STRING_UNARY_OPERATORS = STRING_UNARY_OPERATORS; const UNARY_OPERATORS = ["void", "throw", ...BOOLEAN_UNARY_OPERATORS, ...NUMBER_UNARY_OPERATORS, ...STRING_UNARY_OPERATORS]; exports.UNARY_OPERATORS = UNARY_OPERATORS; const INHERIT_KEYS = { optional: ["typeAnnotation", "typeParameters", "returnType"], force: ["start", "loc", "end"] }; exports.INHERIT_KEYS = INHERIT_KEYS; const BLOCK_SCOPED_SYMBOL = Symbol.for("var used to be block scoped"); exports.BLOCK_SCOPED_SYMBOL = BLOCK_SCOPED_SYMBOL; const NOT_LOCAL_BINDING = Symbol.for("should not be considered a local binding"); exports.NOT_LOCAL_BINDING = NOT_LOCAL_BINDING; },{}],339:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = ensureBlock; var _toBlock = require("./toBlock"); function ensureBlock(node, key = "body") { const result = (0, _toBlock.default)(node[key], node); node[key] = result; return result; } },{"./toBlock":342}],340:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = gatherSequenceExpressions; var _getBindingIdentifiers = require("../retrievers/getBindingIdentifiers"); var _generated = require("../validators/generated"); var _generated2 = require("../builders/generated"); var _cloneNode = require("../clone/cloneNode"); function gatherSequenceExpressions(nodes, scope, declars) { const exprs = []; let ensureLastUndefined = true; for (const node of nodes) { if (!(0, _generated.isEmptyStatement)(node)) { ensureLastUndefined = false; } if ((0, _generated.isExpression)(node)) { exprs.push(node); } else if ((0, _generated.isExpressionStatement)(node)) { exprs.push(node.expression); } else if ((0, _generated.isVariableDeclaration)(node)) { if (node.kind !== "var") return; for (const declar of node.declarations) { const bindings = (0, _getBindingIdentifiers.default)(declar); for (const key of Object.keys(bindings)) { declars.push({ kind: node.kind, id: (0, _cloneNode.default)(bindings[key]) }); } if (declar.init) { exprs.push((0, _generated2.assignmentExpression)("=", declar.id, declar.init)); } } ensureLastUndefined = true; } else if ((0, _generated.isIfStatement)(node)) { const consequent = node.consequent ? gatherSequenceExpressions([node.consequent], scope, declars) : scope.buildUndefinedNode(); const alternate = node.alternate ? gatherSequenceExpressions([node.alternate], scope, declars) : scope.buildUndefinedNode(); if (!consequent || !alternate) return; exprs.push((0, _generated2.conditionalExpression)(node.test, consequent, alternate)); } else if ((0, _generated.isBlockStatement)(node)) { const body = gatherSequenceExpressions(node.body, scope, declars); if (!body) return; exprs.push(body); } else if ((0, _generated.isEmptyStatement)(node)) { if (nodes.indexOf(node) === 0) { ensureLastUndefined = true; } } else { return; } } if (ensureLastUndefined) { exprs.push(scope.buildUndefinedNode()); } if (exprs.length === 1) { return exprs[0]; } else { return (0, _generated2.sequenceExpression)(exprs); } } },{"../builders/generated":320,"../clone/cloneNode":328,"../retrievers/getBindingIdentifiers":367,"../validators/generated":375}],341:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = toBindingIdentifierName; var _toIdentifier = require("./toIdentifier"); function toBindingIdentifierName(name) { name = (0, _toIdentifier.default)(name); if (name === "eval" || name === "arguments") name = "_" + name; return name; } },{"./toIdentifier":345}],342:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = toBlock; var _generated = require("../validators/generated"); var _generated2 = require("../builders/generated"); function toBlock(node, parent) { if ((0, _generated.isBlockStatement)(node)) { return node; } let blockNodes = []; if ((0, _generated.isEmptyStatement)(node)) { blockNodes = []; } else { if (!(0, _generated.isStatement)(node)) { if ((0, _generated.isFunction)(parent)) { node = (0, _generated2.returnStatement)(node); } else { node = (0, _generated2.expressionStatement)(node); } } blockNodes = [node]; } return (0, _generated2.blockStatement)(blockNodes); } },{"../builders/generated":320,"../validators/generated":375}],343:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = toComputedKey; var _generated = require("../validators/generated"); var _generated2 = require("../builders/generated"); function toComputedKey(node, key = node.key || node.property) { if (!node.computed && (0, _generated.isIdentifier)(key)) key = (0, _generated2.stringLiteral)(key.name); return key; } },{"../builders/generated":320,"../validators/generated":375}],344:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = void 0; var _generated = require("../validators/generated"); var _default = toExpression; exports.default = _default; function toExpression(node) { if ((0, _generated.isExpressionStatement)(node)) { node = node.expression; } if ((0, _generated.isExpression)(node)) { return node; } if ((0, _generated.isClass)(node)) { node.type = "ClassExpression"; } else if ((0, _generated.isFunction)(node)) { node.type = "FunctionExpression"; } if (!(0, _generated.isExpression)(node)) { throw new Error(`cannot turn ${node.type} to an expression`); } return node; } },{"../validators/generated":375}],345:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = toIdentifier; var _isValidIdentifier = require("../validators/isValidIdentifier"); var _helperValidatorIdentifier = require("@babel/helper-validator-identifier"); function toIdentifier(input) { input = input + ""; let name = ""; for (const c of input) { name += (0, _helperValidatorIdentifier.isIdentifierChar)(c.codePointAt(0)) ? c : "-"; } name = name.replace(/^[-0-9]+/, ""); name = name.replace(/[-\s]+(.)?/g, function (match, c) { return c ? c.toUpperCase() : ""; }); if (!(0, _isValidIdentifier.default)(name)) { name = `_${name}`; } return name || "_"; } },{"../validators/isValidIdentifier":389,"@babel/helper-validator-identifier":256}],346:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = toKeyAlias; var _generated = require("../validators/generated"); var _cloneNode = require("../clone/cloneNode"); var _removePropertiesDeep = require("../modifications/removePropertiesDeep"); function toKeyAlias(node, key = node.key) { let alias; if (node.kind === "method") { return toKeyAlias.increment() + ""; } else if ((0, _generated.isIdentifier)(key)) { alias = key.name; } else if ((0, _generated.isStringLiteral)(key)) { alias = JSON.stringify(key.value); } else { alias = JSON.stringify((0, _removePropertiesDeep.default)((0, _cloneNode.default)(key))); } if (node.computed) { alias = `[${alias}]`; } if (node.static) { alias = `static:${alias}`; } return alias; } toKeyAlias.uid = 0; toKeyAlias.increment = function () { if (toKeyAlias.uid >= Number.MAX_SAFE_INTEGER) { return toKeyAlias.uid = 0; } else { return toKeyAlias.uid++; } }; },{"../clone/cloneNode":328,"../modifications/removePropertiesDeep":365,"../validators/generated":375}],347:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = toSequenceExpression; var _gatherSequenceExpressions = require("./gatherSequenceExpressions"); function toSequenceExpression(nodes, scope) { if (!(nodes != null && nodes.length)) return; const declars = []; const result = (0, _gatherSequenceExpressions.default)(nodes, scope, declars); if (!result) return; for (const declar of declars) { scope.push(declar); } return result; } },{"./gatherSequenceExpressions":340}],348:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = void 0; var _generated = require("../validators/generated"); var _generated2 = require("../builders/generated"); var _default = toStatement; exports.default = _default; function toStatement(node, ignore) { if ((0, _generated.isStatement)(node)) { return node; } let mustHaveId = false; let newType; if ((0, _generated.isClass)(node)) { mustHaveId = true; newType = "ClassDeclaration"; } else if ((0, _generated.isFunction)(node)) { mustHaveId = true; newType = "FunctionDeclaration"; } else if ((0, _generated.isAssignmentExpression)(node)) { return (0, _generated2.expressionStatement)(node); } if (mustHaveId && !node.id) { newType = false; } if (!newType) { if (ignore) { return false; } else { throw new Error(`cannot turn ${node.type} to a statement`); } } node.type = newType; return node; } },{"../builders/generated":320,"../validators/generated":375}],349:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = void 0; var _isValidIdentifier = require("../validators/isValidIdentifier"); var _generated = require("../builders/generated"); var _default = valueToNode; exports.default = _default; const objectToString = Function.call.bind(Object.prototype.toString); function isRegExp(value) { return objectToString(value) === "[object RegExp]"; } function isPlainObject(value) { if (typeof value !== "object" || value === null || Object.prototype.toString.call(value) !== "[object Object]") { return false; } const proto = Object.getPrototypeOf(value); return proto === null || Object.getPrototypeOf(proto) === null; } function valueToNode(value) { if (value === undefined) { return (0, _generated.identifier)("undefined"); } if (value === true || value === false) { return (0, _generated.booleanLiteral)(value); } if (value === null) { return (0, _generated.nullLiteral)(); } if (typeof value === "string") { return (0, _generated.stringLiteral)(value); } if (typeof value === "number") { let result; if (Number.isFinite(value)) { result = (0, _generated.numericLiteral)(Math.abs(value)); } else { let numerator; if (Number.isNaN(value)) { numerator = (0, _generated.numericLiteral)(0); } else { numerator = (0, _generated.numericLiteral)(1); } result = (0, _generated.binaryExpression)("/", numerator, (0, _generated.numericLiteral)(0)); } if (value < 0 || Object.is(value, -0)) { result = (0, _generated.unaryExpression)("-", result); } return result; } if (isRegExp(value)) { const pattern = value.source; const flags = value.toString().match(/\/([a-z]+|)$/)[1]; return (0, _generated.regExpLiteral)(pattern, flags); } if (Array.isArray(value)) { return (0, _generated.arrayExpression)(value.map(valueToNode)); } if (isPlainObject(value)) { const props = []; for (const key of Object.keys(value)) { let nodeKey; if ((0, _isValidIdentifier.default)(key)) { nodeKey = (0, _generated.identifier)(key); } else { nodeKey = (0, _generated.stringLiteral)(key); } props.push((0, _generated.objectProperty)(nodeKey, valueToNode(value[key]))); } return (0, _generated.objectExpression)(props); } throw new Error("don't know how to turn this value into a node"); } },{"../builders/generated":320,"../validators/isValidIdentifier":389}],350:[function(require,module,exports){ (function (process){(function (){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.patternLikeCommon = exports.functionTypeAnnotationCommon = exports.functionDeclarationCommon = exports.functionCommon = exports.classMethodOrPropertyCommon = exports.classMethodOrDeclareMethodCommon = void 0; var _is = require("../validators/is"); var _isValidIdentifier = require("../validators/isValidIdentifier"); var _helperValidatorIdentifier = require("@babel/helper-validator-identifier"); var _helperStringParser = require("@babel/helper-string-parser"); var _constants = require("../constants"); var _utils = require("./utils"); const defineType = (0, _utils.defineAliasedType)("Standardized"); defineType("ArrayExpression", { fields: { elements: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeOrValueType)("null", "Expression", "SpreadElement"))), default: !process.env.BABEL_TYPES_8_BREAKING ? [] : undefined } }, visitor: ["elements"], aliases: ["Expression"] }); defineType("AssignmentExpression", { fields: { operator: { validate: function () { if (!process.env.BABEL_TYPES_8_BREAKING) { return (0, _utils.assertValueType)("string"); } const identifier = (0, _utils.assertOneOf)(..._constants.ASSIGNMENT_OPERATORS); const pattern = (0, _utils.assertOneOf)("="); return function (node, key, val) { const validator = (0, _is.default)("Pattern", node.left) ? pattern : identifier; validator(node, key, val); }; }() }, left: { validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("LVal") : (0, _utils.assertNodeType)("Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern", "TSAsExpression", "TSTypeAssertion", "TSNonNullExpression") }, right: { validate: (0, _utils.assertNodeType)("Expression") } }, builder: ["operator", "left", "right"], visitor: ["left", "right"], aliases: ["Expression"] }); defineType("BinaryExpression", { builder: ["operator", "left", "right"], fields: { operator: { validate: (0, _utils.assertOneOf)(..._constants.BINARY_OPERATORS) }, left: { validate: function () { const expression = (0, _utils.assertNodeType)("Expression"); const inOp = (0, _utils.assertNodeType)("Expression", "PrivateName"); const validator = Object.assign(function (node, key, val) { const validator = node.operator === "in" ? inOp : expression; validator(node, key, val); }, { oneOfNodeTypes: ["Expression", "PrivateName"] }); return validator; }() }, right: { validate: (0, _utils.assertNodeType)("Expression") } }, visitor: ["left", "right"], aliases: ["Binary", "Expression"] }); defineType("InterpreterDirective", { builder: ["value"], fields: { value: { validate: (0, _utils.assertValueType)("string") } } }); defineType("Directive", { visitor: ["value"], fields: { value: { validate: (0, _utils.assertNodeType)("DirectiveLiteral") } } }); defineType("DirectiveLiteral", { builder: ["value"], fields: { value: { validate: (0, _utils.assertValueType)("string") } } }); defineType("BlockStatement", { builder: ["body", "directives"], visitor: ["directives", "body"], fields: { directives: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Directive"))), default: [] }, body: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement"))) } }, aliases: ["Scopable", "BlockParent", "Block", "Statement"] }); defineType("BreakStatement", { visitor: ["label"], fields: { label: { validate: (0, _utils.assertNodeType)("Identifier"), optional: true } }, aliases: ["Statement", "Terminatorless", "CompletionStatement"] }); defineType("CallExpression", { visitor: ["callee", "arguments", "typeParameters", "typeArguments"], builder: ["callee", "arguments"], aliases: ["Expression"], fields: Object.assign({ callee: { validate: (0, _utils.assertNodeType)("Expression", "Super", "V8IntrinsicIdentifier") }, arguments: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement", "JSXNamespacedName", "ArgumentPlaceholder"))) } }, !process.env.BABEL_TYPES_8_BREAKING ? { optional: { validate: (0, _utils.assertOneOf)(true, false), optional: true } } : {}, { typeArguments: { validate: (0, _utils.assertNodeType)("TypeParameterInstantiation"), optional: true }, typeParameters: { validate: (0, _utils.assertNodeType)("TSTypeParameterInstantiation"), optional: true } }) }); defineType("CatchClause", { visitor: ["param", "body"], fields: { param: { validate: (0, _utils.assertNodeType)("Identifier", "ArrayPattern", "ObjectPattern"), optional: true }, body: { validate: (0, _utils.assertNodeType)("BlockStatement") } }, aliases: ["Scopable", "BlockParent"] }); defineType("ConditionalExpression", { visitor: ["test", "consequent", "alternate"], fields: { test: { validate: (0, _utils.assertNodeType)("Expression") }, consequent: { validate: (0, _utils.assertNodeType)("Expression") }, alternate: { validate: (0, _utils.assertNodeType)("Expression") } }, aliases: ["Expression", "Conditional"] }); defineType("ContinueStatement", { visitor: ["label"], fields: { label: { validate: (0, _utils.assertNodeType)("Identifier"), optional: true } }, aliases: ["Statement", "Terminatorless", "CompletionStatement"] }); defineType("DebuggerStatement", { aliases: ["Statement"] }); defineType("DoWhileStatement", { visitor: ["test", "body"], fields: { test: { validate: (0, _utils.assertNodeType)("Expression") }, body: { validate: (0, _utils.assertNodeType)("Statement") } }, aliases: ["Statement", "BlockParent", "Loop", "While", "Scopable"] }); defineType("EmptyStatement", { aliases: ["Statement"] }); defineType("ExpressionStatement", { visitor: ["expression"], fields: { expression: { validate: (0, _utils.assertNodeType)("Expression") } }, aliases: ["Statement", "ExpressionWrapper"] }); defineType("File", { builder: ["program", "comments", "tokens"], visitor: ["program"], fields: { program: { validate: (0, _utils.assertNodeType)("Program") }, comments: { validate: !process.env.BABEL_TYPES_8_BREAKING ? Object.assign(() => {}, { each: { oneOfNodeTypes: ["CommentBlock", "CommentLine"] } }) : (0, _utils.assertEach)((0, _utils.assertNodeType)("CommentBlock", "CommentLine")), optional: true }, tokens: { validate: (0, _utils.assertEach)(Object.assign(() => {}, { type: "any" })), optional: true } } }); defineType("ForInStatement", { visitor: ["left", "right", "body"], aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop", "ForXStatement"], fields: { left: { validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("VariableDeclaration", "LVal") : (0, _utils.assertNodeType)("VariableDeclaration", "Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern", "TSAsExpression", "TSTypeAssertion", "TSNonNullExpression") }, right: { validate: (0, _utils.assertNodeType)("Expression") }, body: { validate: (0, _utils.assertNodeType)("Statement") } } }); defineType("ForStatement", { visitor: ["init", "test", "update", "body"], aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop"], fields: { init: { validate: (0, _utils.assertNodeType)("VariableDeclaration", "Expression"), optional: true }, test: { validate: (0, _utils.assertNodeType)("Expression"), optional: true }, update: { validate: (0, _utils.assertNodeType)("Expression"), optional: true }, body: { validate: (0, _utils.assertNodeType)("Statement") } } }); const functionCommon = () => ({ params: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Identifier", "Pattern", "RestElement"))) }, generator: { default: false }, async: { default: false } }); exports.functionCommon = functionCommon; const functionTypeAnnotationCommon = () => ({ returnType: { validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"), optional: true }, typeParameters: { validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"), optional: true } }); exports.functionTypeAnnotationCommon = functionTypeAnnotationCommon; const functionDeclarationCommon = () => Object.assign({}, functionCommon(), { declare: { validate: (0, _utils.assertValueType)("boolean"), optional: true }, id: { validate: (0, _utils.assertNodeType)("Identifier"), optional: true } }); exports.functionDeclarationCommon = functionDeclarationCommon; defineType("FunctionDeclaration", { builder: ["id", "params", "body", "generator", "async"], visitor: ["id", "params", "body", "returnType", "typeParameters"], fields: Object.assign({}, functionDeclarationCommon(), functionTypeAnnotationCommon(), { body: { validate: (0, _utils.assertNodeType)("BlockStatement") }, predicate: { validate: (0, _utils.assertNodeType)("DeclaredPredicate", "InferredPredicate"), optional: true } }), aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Statement", "Pureish", "Declaration"], validate: function () { if (!process.env.BABEL_TYPES_8_BREAKING) return () => {}; const identifier = (0, _utils.assertNodeType)("Identifier"); return function (parent, key, node) { if (!(0, _is.default)("ExportDefaultDeclaration", parent)) { identifier(node, "id", node.id); } }; }() }); defineType("FunctionExpression", { inherits: "FunctionDeclaration", aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Expression", "Pureish"], fields: Object.assign({}, functionCommon(), functionTypeAnnotationCommon(), { id: { validate: (0, _utils.assertNodeType)("Identifier"), optional: true }, body: { validate: (0, _utils.assertNodeType)("BlockStatement") }, predicate: { validate: (0, _utils.assertNodeType)("DeclaredPredicate", "InferredPredicate"), optional: true } }) }); const patternLikeCommon = () => ({ typeAnnotation: { validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"), optional: true }, decorators: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))), optional: true } }); exports.patternLikeCommon = patternLikeCommon; defineType("Identifier", { builder: ["name"], visitor: ["typeAnnotation", "decorators"], aliases: ["Expression", "PatternLike", "LVal", "TSEntityName"], fields: Object.assign({}, patternLikeCommon(), { name: { validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), Object.assign(function (node, key, val) { if (!process.env.BABEL_TYPES_8_BREAKING) return; if (!(0, _isValidIdentifier.default)(val, false)) { throw new TypeError(`"${val}" is not a valid identifier name`); } }, { type: "string" })) }, optional: { validate: (0, _utils.assertValueType)("boolean"), optional: true } }), validate(parent, key, node) { if (!process.env.BABEL_TYPES_8_BREAKING) return; const match = /\.(\w+)$/.exec(key); if (!match) return; const [, parentKey] = match; const nonComp = { computed: false }; if (parentKey === "property") { if ((0, _is.default)("MemberExpression", parent, nonComp)) return; if ((0, _is.default)("OptionalMemberExpression", parent, nonComp)) return; } else if (parentKey === "key") { if ((0, _is.default)("Property", parent, nonComp)) return; if ((0, _is.default)("Method", parent, nonComp)) return; } else if (parentKey === "exported") { if ((0, _is.default)("ExportSpecifier", parent)) return; } else if (parentKey === "imported") { if ((0, _is.default)("ImportSpecifier", parent, { imported: node })) return; } else if (parentKey === "meta") { if ((0, _is.default)("MetaProperty", parent, { meta: node })) return; } if (((0, _helperValidatorIdentifier.isKeyword)(node.name) || (0, _helperValidatorIdentifier.isReservedWord)(node.name, false)) && node.name !== "this") { throw new TypeError(`"${node.name}" is not a valid identifier`); } } }); defineType("IfStatement", { visitor: ["test", "consequent", "alternate"], aliases: ["Statement", "Conditional"], fields: { test: { validate: (0, _utils.assertNodeType)("Expression") }, consequent: { validate: (0, _utils.assertNodeType)("Statement") }, alternate: { optional: true, validate: (0, _utils.assertNodeType)("Statement") } } }); defineType("LabeledStatement", { visitor: ["label", "body"], aliases: ["Statement"], fields: { label: { validate: (0, _utils.assertNodeType)("Identifier") }, body: { validate: (0, _utils.assertNodeType)("Statement") } } }); defineType("StringLiteral", { builder: ["value"], fields: { value: { validate: (0, _utils.assertValueType)("string") } }, aliases: ["Expression", "Pureish", "Literal", "Immutable"] }); defineType("NumericLiteral", { builder: ["value"], deprecatedAlias: "NumberLiteral", fields: { value: { validate: (0, _utils.assertValueType)("number") } }, aliases: ["Expression", "Pureish", "Literal", "Immutable"] }); defineType("NullLiteral", { aliases: ["Expression", "Pureish", "Literal", "Immutable"] }); defineType("BooleanLiteral", { builder: ["value"], fields: { value: { validate: (0, _utils.assertValueType)("boolean") } }, aliases: ["Expression", "Pureish", "Literal", "Immutable"] }); defineType("RegExpLiteral", { builder: ["pattern", "flags"], deprecatedAlias: "RegexLiteral", aliases: ["Expression", "Pureish", "Literal"], fields: { pattern: { validate: (0, _utils.assertValueType)("string") }, flags: { validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), Object.assign(function (node, key, val) { if (!process.env.BABEL_TYPES_8_BREAKING) return; const invalid = /[^gimsuy]/.exec(val); if (invalid) { throw new TypeError(`"${invalid[0]}" is not a valid RegExp flag`); } }, { type: "string" })), default: "" } } }); defineType("LogicalExpression", { builder: ["operator", "left", "right"], visitor: ["left", "right"], aliases: ["Binary", "Expression"], fields: { operator: { validate: (0, _utils.assertOneOf)(..._constants.LOGICAL_OPERATORS) }, left: { validate: (0, _utils.assertNodeType)("Expression") }, right: { validate: (0, _utils.assertNodeType)("Expression") } } }); defineType("MemberExpression", { builder: ["object", "property", "computed", ...(!process.env.BABEL_TYPES_8_BREAKING ? ["optional"] : [])], visitor: ["object", "property"], aliases: ["Expression", "LVal"], fields: Object.assign({ object: { validate: (0, _utils.assertNodeType)("Expression", "Super") }, property: { validate: function () { const normal = (0, _utils.assertNodeType)("Identifier", "PrivateName"); const computed = (0, _utils.assertNodeType)("Expression"); const validator = function (node, key, val) { const validator = node.computed ? computed : normal; validator(node, key, val); }; validator.oneOfNodeTypes = ["Expression", "Identifier", "PrivateName"]; return validator; }() }, computed: { default: false } }, !process.env.BABEL_TYPES_8_BREAKING ? { optional: { validate: (0, _utils.assertOneOf)(true, false), optional: true } } : {}) }); defineType("NewExpression", { inherits: "CallExpression" }); defineType("Program", { visitor: ["directives", "body"], builder: ["body", "directives", "sourceType", "interpreter"], fields: { sourceFile: { validate: (0, _utils.assertValueType)("string") }, sourceType: { validate: (0, _utils.assertOneOf)("script", "module"), default: "script" }, interpreter: { validate: (0, _utils.assertNodeType)("InterpreterDirective"), default: null, optional: true }, directives: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Directive"))), default: [] }, body: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement"))) } }, aliases: ["Scopable", "BlockParent", "Block"] }); defineType("ObjectExpression", { visitor: ["properties"], aliases: ["Expression"], fields: { properties: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ObjectMethod", "ObjectProperty", "SpreadElement"))) } } }); defineType("ObjectMethod", { builder: ["kind", "key", "params", "body", "computed", "generator", "async"], fields: Object.assign({}, functionCommon(), functionTypeAnnotationCommon(), { kind: Object.assign({ validate: (0, _utils.assertOneOf)("method", "get", "set") }, !process.env.BABEL_TYPES_8_BREAKING ? { default: "method" } : {}), computed: { default: false }, key: { validate: function () { const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral"); const computed = (0, _utils.assertNodeType)("Expression"); const validator = function (node, key, val) { const validator = node.computed ? computed : normal; validator(node, key, val); }; validator.oneOfNodeTypes = ["Expression", "Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral"]; return validator; }() }, decorators: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))), optional: true }, body: { validate: (0, _utils.assertNodeType)("BlockStatement") } }), visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"], aliases: ["UserWhitespacable", "Function", "Scopable", "BlockParent", "FunctionParent", "Method", "ObjectMember"] }); defineType("ObjectProperty", { builder: ["key", "value", "computed", "shorthand", ...(!process.env.BABEL_TYPES_8_BREAKING ? ["decorators"] : [])], fields: { computed: { default: false }, key: { validate: function () { const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "DecimalLiteral", "PrivateName"); const computed = (0, _utils.assertNodeType)("Expression"); const validator = Object.assign(function (node, key, val) { const validator = node.computed ? computed : normal; validator(node, key, val); }, { oneOfNodeTypes: ["Expression", "Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "DecimalLiteral", "PrivateName"] }); return validator; }() }, value: { validate: (0, _utils.assertNodeType)("Expression", "PatternLike") }, shorthand: { validate: (0, _utils.chain)((0, _utils.assertValueType)("boolean"), Object.assign(function (node, key, val) { if (!process.env.BABEL_TYPES_8_BREAKING) return; if (val && node.computed) { throw new TypeError("Property shorthand of ObjectProperty cannot be true if computed is true"); } }, { type: "boolean" }), function (node, key, val) { if (!process.env.BABEL_TYPES_8_BREAKING) return; if (val && !(0, _is.default)("Identifier", node.key)) { throw new TypeError("Property shorthand of ObjectProperty cannot be true if key is not an Identifier"); } }), default: false }, decorators: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))), optional: true } }, visitor: ["key", "value", "decorators"], aliases: ["UserWhitespacable", "Property", "ObjectMember"], validate: function () { const pattern = (0, _utils.assertNodeType)("Identifier", "Pattern", "TSAsExpression", "TSNonNullExpression", "TSTypeAssertion"); const expression = (0, _utils.assertNodeType)("Expression"); return function (parent, key, node) { if (!process.env.BABEL_TYPES_8_BREAKING) return; const validator = (0, _is.default)("ObjectPattern", parent) ? pattern : expression; validator(node, "value", node.value); }; }() }); defineType("RestElement", { visitor: ["argument", "typeAnnotation"], builder: ["argument"], aliases: ["LVal", "PatternLike"], deprecatedAlias: "RestProperty", fields: Object.assign({}, patternLikeCommon(), { argument: { validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("LVal") : (0, _utils.assertNodeType)("Identifier", "ArrayPattern", "ObjectPattern", "MemberExpression", "TSAsExpression", "TSTypeAssertion", "TSNonNullExpression") }, optional: { validate: (0, _utils.assertValueType)("boolean"), optional: true } }), validate(parent, key) { if (!process.env.BABEL_TYPES_8_BREAKING) return; const match = /(\w+)\[(\d+)\]/.exec(key); if (!match) throw new Error("Internal Babel error: malformed key."); const [, listKey, index] = match; if (parent[listKey].length > +index + 1) { throw new TypeError(`RestElement must be last element of ${listKey}`); } } }); defineType("ReturnStatement", { visitor: ["argument"], aliases: ["Statement", "Terminatorless", "CompletionStatement"], fields: { argument: { validate: (0, _utils.assertNodeType)("Expression"), optional: true } } }); defineType("SequenceExpression", { visitor: ["expressions"], fields: { expressions: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression"))) } }, aliases: ["Expression"] }); defineType("ParenthesizedExpression", { visitor: ["expression"], aliases: ["Expression", "ExpressionWrapper"], fields: { expression: { validate: (0, _utils.assertNodeType)("Expression") } } }); defineType("SwitchCase", { visitor: ["test", "consequent"], fields: { test: { validate: (0, _utils.assertNodeType)("Expression"), optional: true }, consequent: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement"))) } } }); defineType("SwitchStatement", { visitor: ["discriminant", "cases"], aliases: ["Statement", "BlockParent", "Scopable"], fields: { discriminant: { validate: (0, _utils.assertNodeType)("Expression") }, cases: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("SwitchCase"))) } } }); defineType("ThisExpression", { aliases: ["Expression"] }); defineType("ThrowStatement", { visitor: ["argument"], aliases: ["Statement", "Terminatorless", "CompletionStatement"], fields: { argument: { validate: (0, _utils.assertNodeType)("Expression") } } }); defineType("TryStatement", { visitor: ["block", "handler", "finalizer"], aliases: ["Statement"], fields: { block: { validate: (0, _utils.chain)((0, _utils.assertNodeType)("BlockStatement"), Object.assign(function (node) { if (!process.env.BABEL_TYPES_8_BREAKING) return; if (!node.handler && !node.finalizer) { throw new TypeError("TryStatement expects either a handler or finalizer, or both"); } }, { oneOfNodeTypes: ["BlockStatement"] })) }, handler: { optional: true, validate: (0, _utils.assertNodeType)("CatchClause") }, finalizer: { optional: true, validate: (0, _utils.assertNodeType)("BlockStatement") } } }); defineType("UnaryExpression", { builder: ["operator", "argument", "prefix"], fields: { prefix: { default: true }, argument: { validate: (0, _utils.assertNodeType)("Expression") }, operator: { validate: (0, _utils.assertOneOf)(..._constants.UNARY_OPERATORS) } }, visitor: ["argument"], aliases: ["UnaryLike", "Expression"] }); defineType("UpdateExpression", { builder: ["operator", "argument", "prefix"], fields: { prefix: { default: false }, argument: { validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("Expression") : (0, _utils.assertNodeType)("Identifier", "MemberExpression") }, operator: { validate: (0, _utils.assertOneOf)(..._constants.UPDATE_OPERATORS) } }, visitor: ["argument"], aliases: ["Expression"] }); defineType("VariableDeclaration", { builder: ["kind", "declarations"], visitor: ["declarations"], aliases: ["Statement", "Declaration"], fields: { declare: { validate: (0, _utils.assertValueType)("boolean"), optional: true }, kind: { validate: (0, _utils.assertOneOf)("var", "let", "const") }, declarations: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("VariableDeclarator"))) } }, validate(parent, key, node) { if (!process.env.BABEL_TYPES_8_BREAKING) return; if (!(0, _is.default)("ForXStatement", parent, { left: node })) return; if (node.declarations.length !== 1) { throw new TypeError(`Exactly one VariableDeclarator is required in the VariableDeclaration of a ${parent.type}`); } } }); defineType("VariableDeclarator", { visitor: ["id", "init"], fields: { id: { validate: function () { if (!process.env.BABEL_TYPES_8_BREAKING) { return (0, _utils.assertNodeType)("LVal"); } const normal = (0, _utils.assertNodeType)("Identifier", "ArrayPattern", "ObjectPattern"); const without = (0, _utils.assertNodeType)("Identifier"); return function (node, key, val) { const validator = node.init ? normal : without; validator(node, key, val); }; }() }, definite: { optional: true, validate: (0, _utils.assertValueType)("boolean") }, init: { optional: true, validate: (0, _utils.assertNodeType)("Expression") } } }); defineType("WhileStatement", { visitor: ["test", "body"], aliases: ["Statement", "BlockParent", "Loop", "While", "Scopable"], fields: { test: { validate: (0, _utils.assertNodeType)("Expression") }, body: { validate: (0, _utils.assertNodeType)("Statement") } } }); defineType("WithStatement", { visitor: ["object", "body"], aliases: ["Statement"], fields: { object: { validate: (0, _utils.assertNodeType)("Expression") }, body: { validate: (0, _utils.assertNodeType)("Statement") } } }); defineType("AssignmentPattern", { visitor: ["left", "right", "decorators"], builder: ["left", "right"], aliases: ["Pattern", "PatternLike", "LVal"], fields: Object.assign({}, patternLikeCommon(), { left: { validate: (0, _utils.assertNodeType)("Identifier", "ObjectPattern", "ArrayPattern", "MemberExpression", "TSAsExpression", "TSTypeAssertion", "TSNonNullExpression") }, right: { validate: (0, _utils.assertNodeType)("Expression") }, decorators: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))), optional: true } }) }); defineType("ArrayPattern", { visitor: ["elements", "typeAnnotation"], builder: ["elements"], aliases: ["Pattern", "PatternLike", "LVal"], fields: Object.assign({}, patternLikeCommon(), { elements: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeOrValueType)("null", "PatternLike", "LVal"))) }, decorators: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))), optional: true }, optional: { validate: (0, _utils.assertValueType)("boolean"), optional: true } }) }); defineType("ArrowFunctionExpression", { builder: ["params", "body", "async"], visitor: ["params", "body", "returnType", "typeParameters"], aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Expression", "Pureish"], fields: Object.assign({}, functionCommon(), functionTypeAnnotationCommon(), { expression: { validate: (0, _utils.assertValueType)("boolean") }, body: { validate: (0, _utils.assertNodeType)("BlockStatement", "Expression") }, predicate: { validate: (0, _utils.assertNodeType)("DeclaredPredicate", "InferredPredicate"), optional: true } }) }); defineType("ClassBody", { visitor: ["body"], fields: { body: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ClassMethod", "ClassPrivateMethod", "ClassProperty", "ClassPrivateProperty", "ClassAccessorProperty", "TSDeclareMethod", "TSIndexSignature", "StaticBlock"))) } } }); defineType("ClassExpression", { builder: ["id", "superClass", "body", "decorators"], visitor: ["id", "body", "superClass", "mixins", "typeParameters", "superTypeParameters", "implements", "decorators"], aliases: ["Scopable", "Class", "Expression"], fields: { id: { validate: (0, _utils.assertNodeType)("Identifier"), optional: true }, typeParameters: { validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"), optional: true }, body: { validate: (0, _utils.assertNodeType)("ClassBody") }, superClass: { optional: true, validate: (0, _utils.assertNodeType)("Expression") }, superTypeParameters: { validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"), optional: true }, implements: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSExpressionWithTypeArguments", "ClassImplements"))), optional: true }, decorators: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))), optional: true }, mixins: { validate: (0, _utils.assertNodeType)("InterfaceExtends"), optional: true } } }); defineType("ClassDeclaration", { inherits: "ClassExpression", aliases: ["Scopable", "Class", "Statement", "Declaration"], fields: { id: { validate: (0, _utils.assertNodeType)("Identifier") }, typeParameters: { validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"), optional: true }, body: { validate: (0, _utils.assertNodeType)("ClassBody") }, superClass: { optional: true, validate: (0, _utils.assertNodeType)("Expression") }, superTypeParameters: { validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"), optional: true }, implements: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSExpressionWithTypeArguments", "ClassImplements"))), optional: true }, decorators: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))), optional: true }, mixins: { validate: (0, _utils.assertNodeType)("InterfaceExtends"), optional: true }, declare: { validate: (0, _utils.assertValueType)("boolean"), optional: true }, abstract: { validate: (0, _utils.assertValueType)("boolean"), optional: true } }, validate: function () { const identifier = (0, _utils.assertNodeType)("Identifier"); return function (parent, key, node) { if (!process.env.BABEL_TYPES_8_BREAKING) return; if (!(0, _is.default)("ExportDefaultDeclaration", parent)) { identifier(node, "id", node.id); } }; }() }); defineType("ExportAllDeclaration", { visitor: ["source"], aliases: ["Statement", "Declaration", "ModuleDeclaration", "ExportDeclaration"], fields: { source: { validate: (0, _utils.assertNodeType)("StringLiteral") }, exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("type", "value")), assertions: { optional: true, validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportAttribute"))) } } }); defineType("ExportDefaultDeclaration", { visitor: ["declaration"], aliases: ["Statement", "Declaration", "ModuleDeclaration", "ExportDeclaration"], fields: { declaration: { validate: (0, _utils.assertNodeType)("TSDeclareFunction", "FunctionDeclaration", "ClassDeclaration", "Expression") }, exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("value")) } }); defineType("ExportNamedDeclaration", { visitor: ["declaration", "specifiers", "source"], aliases: ["Statement", "Declaration", "ModuleDeclaration", "ExportDeclaration"], fields: { declaration: { optional: true, validate: (0, _utils.chain)((0, _utils.assertNodeType)("Declaration"), Object.assign(function (node, key, val) { if (!process.env.BABEL_TYPES_8_BREAKING) return; if (val && node.specifiers.length) { throw new TypeError("Only declaration or specifiers is allowed on ExportNamedDeclaration"); } }, { oneOfNodeTypes: ["Declaration"] }), function (node, key, val) { if (!process.env.BABEL_TYPES_8_BREAKING) return; if (val && node.source) { throw new TypeError("Cannot export a declaration from a source"); } }) }, assertions: { optional: true, validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportAttribute"))) }, specifiers: { default: [], validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)(function () { const sourced = (0, _utils.assertNodeType)("ExportSpecifier", "ExportDefaultSpecifier", "ExportNamespaceSpecifier"); const sourceless = (0, _utils.assertNodeType)("ExportSpecifier"); if (!process.env.BABEL_TYPES_8_BREAKING) return sourced; return function (node, key, val) { const validator = node.source ? sourced : sourceless; validator(node, key, val); }; }())) }, source: { validate: (0, _utils.assertNodeType)("StringLiteral"), optional: true }, exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("type", "value")) } }); defineType("ExportSpecifier", { visitor: ["local", "exported"], aliases: ["ModuleSpecifier"], fields: { local: { validate: (0, _utils.assertNodeType)("Identifier") }, exported: { validate: (0, _utils.assertNodeType)("Identifier", "StringLiteral") }, exportKind: { validate: (0, _utils.assertOneOf)("type", "value"), optional: true } } }); defineType("ForOfStatement", { visitor: ["left", "right", "body"], builder: ["left", "right", "body", "await"], aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop", "ForXStatement"], fields: { left: { validate: function () { if (!process.env.BABEL_TYPES_8_BREAKING) { return (0, _utils.assertNodeType)("VariableDeclaration", "LVal"); } const declaration = (0, _utils.assertNodeType)("VariableDeclaration"); const lval = (0, _utils.assertNodeType)("Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern", "TSAsExpression", "TSTypeAssertion", "TSNonNullExpression"); return function (node, key, val) { if ((0, _is.default)("VariableDeclaration", val)) { declaration(node, key, val); } else { lval(node, key, val); } }; }() }, right: { validate: (0, _utils.assertNodeType)("Expression") }, body: { validate: (0, _utils.assertNodeType)("Statement") }, await: { default: false } } }); defineType("ImportDeclaration", { visitor: ["specifiers", "source"], aliases: ["Statement", "Declaration", "ModuleDeclaration"], fields: { assertions: { optional: true, validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportAttribute"))) }, specifiers: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportSpecifier", "ImportDefaultSpecifier", "ImportNamespaceSpecifier"))) }, source: { validate: (0, _utils.assertNodeType)("StringLiteral") }, importKind: { validate: (0, _utils.assertOneOf)("type", "typeof", "value"), optional: true } } }); defineType("ImportDefaultSpecifier", { visitor: ["local"], aliases: ["ModuleSpecifier"], fields: { local: { validate: (0, _utils.assertNodeType)("Identifier") } } }); defineType("ImportNamespaceSpecifier", { visitor: ["local"], aliases: ["ModuleSpecifier"], fields: { local: { validate: (0, _utils.assertNodeType)("Identifier") } } }); defineType("ImportSpecifier", { visitor: ["local", "imported"], aliases: ["ModuleSpecifier"], fields: { local: { validate: (0, _utils.assertNodeType)("Identifier") }, imported: { validate: (0, _utils.assertNodeType)("Identifier", "StringLiteral") }, importKind: { validate: (0, _utils.assertOneOf)("type", "typeof", "value"), optional: true } } }); defineType("MetaProperty", { visitor: ["meta", "property"], aliases: ["Expression"], fields: { meta: { validate: (0, _utils.chain)((0, _utils.assertNodeType)("Identifier"), Object.assign(function (node, key, val) { if (!process.env.BABEL_TYPES_8_BREAKING) return; let property; switch (val.name) { case "function": property = "sent"; break; case "new": property = "target"; break; case "import": property = "meta"; break; } if (!(0, _is.default)("Identifier", node.property, { name: property })) { throw new TypeError("Unrecognised MetaProperty"); } }, { oneOfNodeTypes: ["Identifier"] })) }, property: { validate: (0, _utils.assertNodeType)("Identifier") } } }); const classMethodOrPropertyCommon = () => ({ abstract: { validate: (0, _utils.assertValueType)("boolean"), optional: true }, accessibility: { validate: (0, _utils.assertOneOf)("public", "private", "protected"), optional: true }, static: { default: false }, override: { default: false }, computed: { default: false }, optional: { validate: (0, _utils.assertValueType)("boolean"), optional: true }, key: { validate: (0, _utils.chain)(function () { const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral"); const computed = (0, _utils.assertNodeType)("Expression"); return function (node, key, val) { const validator = node.computed ? computed : normal; validator(node, key, val); }; }(), (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "Expression")) } }); exports.classMethodOrPropertyCommon = classMethodOrPropertyCommon; const classMethodOrDeclareMethodCommon = () => Object.assign({}, functionCommon(), classMethodOrPropertyCommon(), { params: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Identifier", "Pattern", "RestElement", "TSParameterProperty"))) }, kind: { validate: (0, _utils.assertOneOf)("get", "set", "method", "constructor"), default: "method" }, access: { validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), (0, _utils.assertOneOf)("public", "private", "protected")), optional: true }, decorators: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))), optional: true } }); exports.classMethodOrDeclareMethodCommon = classMethodOrDeclareMethodCommon; defineType("ClassMethod", { aliases: ["Function", "Scopable", "BlockParent", "FunctionParent", "Method"], builder: ["kind", "key", "params", "body", "computed", "static", "generator", "async"], visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"], fields: Object.assign({}, classMethodOrDeclareMethodCommon(), functionTypeAnnotationCommon(), { body: { validate: (0, _utils.assertNodeType)("BlockStatement") } }) }); defineType("ObjectPattern", { visitor: ["properties", "typeAnnotation", "decorators"], builder: ["properties"], aliases: ["Pattern", "PatternLike", "LVal"], fields: Object.assign({}, patternLikeCommon(), { properties: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("RestElement", "ObjectProperty"))) } }) }); defineType("SpreadElement", { visitor: ["argument"], aliases: ["UnaryLike"], deprecatedAlias: "SpreadProperty", fields: { argument: { validate: (0, _utils.assertNodeType)("Expression") } } }); defineType("Super", { aliases: ["Expression"] }); defineType("TaggedTemplateExpression", { visitor: ["tag", "quasi", "typeParameters"], builder: ["tag", "quasi"], aliases: ["Expression"], fields: { tag: { validate: (0, _utils.assertNodeType)("Expression") }, quasi: { validate: (0, _utils.assertNodeType)("TemplateLiteral") }, typeParameters: { validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"), optional: true } } }); defineType("TemplateElement", { builder: ["value", "tail"], fields: { value: { validate: (0, _utils.chain)((0, _utils.assertShape)({ raw: { validate: (0, _utils.assertValueType)("string") }, cooked: { validate: (0, _utils.assertValueType)("string"), optional: true } }), function templateElementCookedValidator(node) { const raw = node.value.raw; let unterminatedCalled = false; const error = () => { throw new Error("Internal @babel/types error."); }; const { str, firstInvalidLoc } = (0, _helperStringParser.readStringContents)("template", raw, 0, 0, 0, { unterminated() { unterminatedCalled = true; }, strictNumericEscape: error, invalidEscapeSequence: error, numericSeparatorInEscapeSequence: error, unexpectedNumericSeparator: error, invalidDigit: error, invalidCodePoint: error }); if (!unterminatedCalled) throw new Error("Invalid raw"); node.value.cooked = firstInvalidLoc ? null : str; }) }, tail: { default: false } } }); defineType("TemplateLiteral", { visitor: ["quasis", "expressions"], aliases: ["Expression", "Literal"], fields: { quasis: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TemplateElement"))) }, expressions: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "TSType")), function (node, key, val) { if (node.quasis.length !== val.length + 1) { throw new TypeError(`Number of ${node.type} quasis should be exactly one more than the number of expressions.\nExpected ${val.length + 1} quasis but got ${node.quasis.length}`); } }) } } }); defineType("YieldExpression", { builder: ["argument", "delegate"], visitor: ["argument"], aliases: ["Expression", "Terminatorless"], fields: { delegate: { validate: (0, _utils.chain)((0, _utils.assertValueType)("boolean"), Object.assign(function (node, key, val) { if (!process.env.BABEL_TYPES_8_BREAKING) return; if (val && !node.argument) { throw new TypeError("Property delegate of YieldExpression cannot be true if there is no argument"); } }, { type: "boolean" })), default: false }, argument: { optional: true, validate: (0, _utils.assertNodeType)("Expression") } } }); defineType("AwaitExpression", { builder: ["argument"], visitor: ["argument"], aliases: ["Expression", "Terminatorless"], fields: { argument: { validate: (0, _utils.assertNodeType)("Expression") } } }); defineType("Import", { aliases: ["Expression"] }); defineType("BigIntLiteral", { builder: ["value"], fields: { value: { validate: (0, _utils.assertValueType)("string") } }, aliases: ["Expression", "Pureish", "Literal", "Immutable"] }); defineType("ExportNamespaceSpecifier", { visitor: ["exported"], aliases: ["ModuleSpecifier"], fields: { exported: { validate: (0, _utils.assertNodeType)("Identifier") } } }); defineType("OptionalMemberExpression", { builder: ["object", "property", "computed", "optional"], visitor: ["object", "property"], aliases: ["Expression"], fields: { object: { validate: (0, _utils.assertNodeType)("Expression") }, property: { validate: function () { const normal = (0, _utils.assertNodeType)("Identifier"); const computed = (0, _utils.assertNodeType)("Expression"); const validator = Object.assign(function (node, key, val) { const validator = node.computed ? computed : normal; validator(node, key, val); }, { oneOfNodeTypes: ["Expression", "Identifier"] }); return validator; }() }, computed: { default: false }, optional: { validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertValueType)("boolean") : (0, _utils.chain)((0, _utils.assertValueType)("boolean"), (0, _utils.assertOptionalChainStart)()) } } }); defineType("OptionalCallExpression", { visitor: ["callee", "arguments", "typeParameters", "typeArguments"], builder: ["callee", "arguments", "optional"], aliases: ["Expression"], fields: { callee: { validate: (0, _utils.assertNodeType)("Expression") }, arguments: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement", "JSXNamespacedName", "ArgumentPlaceholder"))) }, optional: { validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertValueType)("boolean") : (0, _utils.chain)((0, _utils.assertValueType)("boolean"), (0, _utils.assertOptionalChainStart)()) }, typeArguments: { validate: (0, _utils.assertNodeType)("TypeParameterInstantiation"), optional: true }, typeParameters: { validate: (0, _utils.assertNodeType)("TSTypeParameterInstantiation"), optional: true } } }); defineType("ClassProperty", { visitor: ["key", "value", "typeAnnotation", "decorators"], builder: ["key", "value", "typeAnnotation", "decorators", "computed", "static"], aliases: ["Property"], fields: Object.assign({}, classMethodOrPropertyCommon(), { value: { validate: (0, _utils.assertNodeType)("Expression"), optional: true }, definite: { validate: (0, _utils.assertValueType)("boolean"), optional: true }, typeAnnotation: { validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"), optional: true }, decorators: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))), optional: true }, readonly: { validate: (0, _utils.assertValueType)("boolean"), optional: true }, declare: { validate: (0, _utils.assertValueType)("boolean"), optional: true }, variance: { validate: (0, _utils.assertNodeType)("Variance"), optional: true } }) }); defineType("ClassAccessorProperty", { visitor: ["key", "value", "typeAnnotation", "decorators"], builder: ["key", "value", "typeAnnotation", "decorators", "computed", "static"], aliases: ["Property", "Accessor"], fields: Object.assign({}, classMethodOrPropertyCommon(), { key: { validate: (0, _utils.chain)(function () { const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "PrivateName"); const computed = (0, _utils.assertNodeType)("Expression"); return function (node, key, val) { const validator = node.computed ? computed : normal; validator(node, key, val); }; }(), (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "Expression", "PrivateName")) }, value: { validate: (0, _utils.assertNodeType)("Expression"), optional: true }, definite: { validate: (0, _utils.assertValueType)("boolean"), optional: true }, typeAnnotation: { validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"), optional: true }, decorators: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))), optional: true }, readonly: { validate: (0, _utils.assertValueType)("boolean"), optional: true }, declare: { validate: (0, _utils.assertValueType)("boolean"), optional: true }, variance: { validate: (0, _utils.assertNodeType)("Variance"), optional: true } }) }); defineType("ClassPrivateProperty", { visitor: ["key", "value", "decorators", "typeAnnotation"], builder: ["key", "value", "decorators", "static"], aliases: ["Property", "Private"], fields: { key: { validate: (0, _utils.assertNodeType)("PrivateName") }, value: { validate: (0, _utils.assertNodeType)("Expression"), optional: true }, typeAnnotation: { validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"), optional: true }, decorators: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))), optional: true }, static: { validate: (0, _utils.assertValueType)("boolean"), default: false }, readonly: { validate: (0, _utils.assertValueType)("boolean"), optional: true }, definite: { validate: (0, _utils.assertValueType)("boolean"), optional: true }, variance: { validate: (0, _utils.assertNodeType)("Variance"), optional: true } } }); defineType("ClassPrivateMethod", { builder: ["kind", "key", "params", "body", "static"], visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"], aliases: ["Function", "Scopable", "BlockParent", "FunctionParent", "Method", "Private"], fields: Object.assign({}, classMethodOrDeclareMethodCommon(), functionTypeAnnotationCommon(), { kind: { validate: (0, _utils.assertOneOf)("get", "set", "method"), default: "method" }, key: { validate: (0, _utils.assertNodeType)("PrivateName") }, body: { validate: (0, _utils.assertNodeType)("BlockStatement") } }) }); defineType("PrivateName", { visitor: ["id"], aliases: ["Private"], fields: { id: { validate: (0, _utils.assertNodeType)("Identifier") } } }); defineType("StaticBlock", { visitor: ["body"], fields: { body: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement"))) } }, aliases: ["Scopable", "BlockParent", "FunctionParent"] }); }).call(this)}).call(this,require('_process')) },{"../constants":338,"../validators/is":376,"../validators/isValidIdentifier":389,"./utils":358,"@babel/helper-string-parser":254,"@babel/helper-validator-identifier":256,"_process":460}],351:[function(require,module,exports){ (function (process){(function (){ "use strict"; var _utils = require("./utils"); (0, _utils.default)("ArgumentPlaceholder", {}); (0, _utils.default)("BindExpression", { visitor: ["object", "callee"], aliases: ["Expression"], fields: !process.env.BABEL_TYPES_8_BREAKING ? { object: { validate: Object.assign(() => {}, { oneOfNodeTypes: ["Expression"] }) }, callee: { validate: Object.assign(() => {}, { oneOfNodeTypes: ["Expression"] }) } } : { object: { validate: (0, _utils.assertNodeType)("Expression") }, callee: { validate: (0, _utils.assertNodeType)("Expression") } } }); (0, _utils.default)("ImportAttribute", { visitor: ["key", "value"], fields: { key: { validate: (0, _utils.assertNodeType)("Identifier", "StringLiteral") }, value: { validate: (0, _utils.assertNodeType)("StringLiteral") } } }); (0, _utils.default)("Decorator", { visitor: ["expression"], fields: { expression: { validate: (0, _utils.assertNodeType)("Expression") } } }); (0, _utils.default)("DoExpression", { visitor: ["body"], builder: ["body", "async"], aliases: ["Expression"], fields: { body: { validate: (0, _utils.assertNodeType)("BlockStatement") }, async: { validate: (0, _utils.assertValueType)("boolean"), default: false } } }); (0, _utils.default)("ExportDefaultSpecifier", { visitor: ["exported"], aliases: ["ModuleSpecifier"], fields: { exported: { validate: (0, _utils.assertNodeType)("Identifier") } } }); (0, _utils.default)("RecordExpression", { visitor: ["properties"], aliases: ["Expression"], fields: { properties: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ObjectProperty", "SpreadElement"))) } } }); (0, _utils.default)("TupleExpression", { fields: { elements: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement"))), default: [] } }, visitor: ["elements"], aliases: ["Expression"] }); (0, _utils.default)("DecimalLiteral", { builder: ["value"], fields: { value: { validate: (0, _utils.assertValueType)("string") } }, aliases: ["Expression", "Pureish", "Literal", "Immutable"] }); (0, _utils.default)("ModuleExpression", { visitor: ["body"], fields: { body: { validate: (0, _utils.assertNodeType)("Program") } }, aliases: ["Expression"] }); (0, _utils.default)("TopicReference", { aliases: ["Expression"] }); (0, _utils.default)("PipelineTopicExpression", { builder: ["expression"], visitor: ["expression"], fields: { expression: { validate: (0, _utils.assertNodeType)("Expression") } }, aliases: ["Expression"] }); (0, _utils.default)("PipelineBareFunction", { builder: ["callee"], visitor: ["callee"], fields: { callee: { validate: (0, _utils.assertNodeType)("Expression") } }, aliases: ["Expression"] }); (0, _utils.default)("PipelinePrimaryTopicReference", { aliases: ["Expression"] }); }).call(this)}).call(this,require('_process')) },{"./utils":358,"_process":460}],352:[function(require,module,exports){ "use strict"; var _utils = require("./utils"); const defineType = (0, _utils.defineAliasedType)("Flow"); const defineInterfaceishType = name => { defineType(name, { builder: ["id", "typeParameters", "extends", "body"], visitor: ["id", "typeParameters", "extends", "mixins", "implements", "body"], aliases: ["FlowDeclaration", "Statement", "Declaration"], fields: { id: (0, _utils.validateType)("Identifier"), typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"), extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")), mixins: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")), implements: (0, _utils.validateOptional)((0, _utils.arrayOfType)("ClassImplements")), body: (0, _utils.validateType)("ObjectTypeAnnotation") } }); }; defineType("AnyTypeAnnotation", { aliases: ["FlowType", "FlowBaseAnnotation"] }); defineType("ArrayTypeAnnotation", { visitor: ["elementType"], aliases: ["FlowType"], fields: { elementType: (0, _utils.validateType)("FlowType") } }); defineType("BooleanTypeAnnotation", { aliases: ["FlowType", "FlowBaseAnnotation"] }); defineType("BooleanLiteralTypeAnnotation", { builder: ["value"], aliases: ["FlowType"], fields: { value: (0, _utils.validate)((0, _utils.assertValueType)("boolean")) } }); defineType("NullLiteralTypeAnnotation", { aliases: ["FlowType", "FlowBaseAnnotation"] }); defineType("ClassImplements", { visitor: ["id", "typeParameters"], fields: { id: (0, _utils.validateType)("Identifier"), typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation") } }); defineInterfaceishType("DeclareClass"); defineType("DeclareFunction", { visitor: ["id"], aliases: ["FlowDeclaration", "Statement", "Declaration"], fields: { id: (0, _utils.validateType)("Identifier"), predicate: (0, _utils.validateOptionalType)("DeclaredPredicate") } }); defineInterfaceishType("DeclareInterface"); defineType("DeclareModule", { builder: ["id", "body", "kind"], visitor: ["id", "body"], aliases: ["FlowDeclaration", "Statement", "Declaration"], fields: { id: (0, _utils.validateType)(["Identifier", "StringLiteral"]), body: (0, _utils.validateType)("BlockStatement"), kind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("CommonJS", "ES")) } }); defineType("DeclareModuleExports", { visitor: ["typeAnnotation"], aliases: ["FlowDeclaration", "Statement", "Declaration"], fields: { typeAnnotation: (0, _utils.validateType)("TypeAnnotation") } }); defineType("DeclareTypeAlias", { visitor: ["id", "typeParameters", "right"], aliases: ["FlowDeclaration", "Statement", "Declaration"], fields: { id: (0, _utils.validateType)("Identifier"), typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"), right: (0, _utils.validateType)("FlowType") } }); defineType("DeclareOpaqueType", { visitor: ["id", "typeParameters", "supertype"], aliases: ["FlowDeclaration", "Statement", "Declaration"], fields: { id: (0, _utils.validateType)("Identifier"), typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"), supertype: (0, _utils.validateOptionalType)("FlowType"), impltype: (0, _utils.validateOptionalType)("FlowType") } }); defineType("DeclareVariable", { visitor: ["id"], aliases: ["FlowDeclaration", "Statement", "Declaration"], fields: { id: (0, _utils.validateType)("Identifier") } }); defineType("DeclareExportDeclaration", { visitor: ["declaration", "specifiers", "source"], aliases: ["FlowDeclaration", "Statement", "Declaration"], fields: { declaration: (0, _utils.validateOptionalType)("Flow"), specifiers: (0, _utils.validateOptional)((0, _utils.arrayOfType)(["ExportSpecifier", "ExportNamespaceSpecifier"])), source: (0, _utils.validateOptionalType)("StringLiteral"), default: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean")) } }); defineType("DeclareExportAllDeclaration", { visitor: ["source"], aliases: ["FlowDeclaration", "Statement", "Declaration"], fields: { source: (0, _utils.validateType)("StringLiteral"), exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("type", "value")) } }); defineType("DeclaredPredicate", { visitor: ["value"], aliases: ["FlowPredicate"], fields: { value: (0, _utils.validateType)("Flow") } }); defineType("ExistsTypeAnnotation", { aliases: ["FlowType"] }); defineType("FunctionTypeAnnotation", { visitor: ["typeParameters", "params", "rest", "returnType"], aliases: ["FlowType"], fields: { typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"), params: (0, _utils.validate)((0, _utils.arrayOfType)("FunctionTypeParam")), rest: (0, _utils.validateOptionalType)("FunctionTypeParam"), this: (0, _utils.validateOptionalType)("FunctionTypeParam"), returnType: (0, _utils.validateType)("FlowType") } }); defineType("FunctionTypeParam", { visitor: ["name", "typeAnnotation"], fields: { name: (0, _utils.validateOptionalType)("Identifier"), typeAnnotation: (0, _utils.validateType)("FlowType"), optional: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean")) } }); defineType("GenericTypeAnnotation", { visitor: ["id", "typeParameters"], aliases: ["FlowType"], fields: { id: (0, _utils.validateType)(["Identifier", "QualifiedTypeIdentifier"]), typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation") } }); defineType("InferredPredicate", { aliases: ["FlowPredicate"] }); defineType("InterfaceExtends", { visitor: ["id", "typeParameters"], fields: { id: (0, _utils.validateType)(["Identifier", "QualifiedTypeIdentifier"]), typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation") } }); defineInterfaceishType("InterfaceDeclaration"); defineType("InterfaceTypeAnnotation", { visitor: ["extends", "body"], aliases: ["FlowType"], fields: { extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")), body: (0, _utils.validateType)("ObjectTypeAnnotation") } }); defineType("IntersectionTypeAnnotation", { visitor: ["types"], aliases: ["FlowType"], fields: { types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType")) } }); defineType("MixedTypeAnnotation", { aliases: ["FlowType", "FlowBaseAnnotation"] }); defineType("EmptyTypeAnnotation", { aliases: ["FlowType", "FlowBaseAnnotation"] }); defineType("NullableTypeAnnotation", { visitor: ["typeAnnotation"], aliases: ["FlowType"], fields: { typeAnnotation: (0, _utils.validateType)("FlowType") } }); defineType("NumberLiteralTypeAnnotation", { builder: ["value"], aliases: ["FlowType"], fields: { value: (0, _utils.validate)((0, _utils.assertValueType)("number")) } }); defineType("NumberTypeAnnotation", { aliases: ["FlowType", "FlowBaseAnnotation"] }); defineType("ObjectTypeAnnotation", { visitor: ["properties", "indexers", "callProperties", "internalSlots"], aliases: ["FlowType"], builder: ["properties", "indexers", "callProperties", "internalSlots", "exact"], fields: { properties: (0, _utils.validate)((0, _utils.arrayOfType)(["ObjectTypeProperty", "ObjectTypeSpreadProperty"])), indexers: { validate: (0, _utils.arrayOfType)("ObjectTypeIndexer"), optional: true, default: [] }, callProperties: { validate: (0, _utils.arrayOfType)("ObjectTypeCallProperty"), optional: true, default: [] }, internalSlots: { validate: (0, _utils.arrayOfType)("ObjectTypeInternalSlot"), optional: true, default: [] }, exact: { validate: (0, _utils.assertValueType)("boolean"), default: false }, inexact: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean")) } }); defineType("ObjectTypeInternalSlot", { visitor: ["id", "value", "optional", "static", "method"], aliases: ["UserWhitespacable"], fields: { id: (0, _utils.validateType)("Identifier"), value: (0, _utils.validateType)("FlowType"), optional: (0, _utils.validate)((0, _utils.assertValueType)("boolean")), static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")), method: (0, _utils.validate)((0, _utils.assertValueType)("boolean")) } }); defineType("ObjectTypeCallProperty", { visitor: ["value"], aliases: ["UserWhitespacable"], fields: { value: (0, _utils.validateType)("FlowType"), static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")) } }); defineType("ObjectTypeIndexer", { visitor: ["id", "key", "value", "variance"], aliases: ["UserWhitespacable"], fields: { id: (0, _utils.validateOptionalType)("Identifier"), key: (0, _utils.validateType)("FlowType"), value: (0, _utils.validateType)("FlowType"), static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")), variance: (0, _utils.validateOptionalType)("Variance") } }); defineType("ObjectTypeProperty", { visitor: ["key", "value", "variance"], aliases: ["UserWhitespacable"], fields: { key: (0, _utils.validateType)(["Identifier", "StringLiteral"]), value: (0, _utils.validateType)("FlowType"), kind: (0, _utils.validate)((0, _utils.assertOneOf)("init", "get", "set")), static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")), proto: (0, _utils.validate)((0, _utils.assertValueType)("boolean")), optional: (0, _utils.validate)((0, _utils.assertValueType)("boolean")), variance: (0, _utils.validateOptionalType)("Variance"), method: (0, _utils.validate)((0, _utils.assertValueType)("boolean")) } }); defineType("ObjectTypeSpreadProperty", { visitor: ["argument"], aliases: ["UserWhitespacable"], fields: { argument: (0, _utils.validateType)("FlowType") } }); defineType("OpaqueType", { visitor: ["id", "typeParameters", "supertype", "impltype"], aliases: ["FlowDeclaration", "Statement", "Declaration"], fields: { id: (0, _utils.validateType)("Identifier"), typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"), supertype: (0, _utils.validateOptionalType)("FlowType"), impltype: (0, _utils.validateType)("FlowType") } }); defineType("QualifiedTypeIdentifier", { visitor: ["id", "qualification"], fields: { id: (0, _utils.validateType)("Identifier"), qualification: (0, _utils.validateType)(["Identifier", "QualifiedTypeIdentifier"]) } }); defineType("StringLiteralTypeAnnotation", { builder: ["value"], aliases: ["FlowType"], fields: { value: (0, _utils.validate)((0, _utils.assertValueType)("string")) } }); defineType("StringTypeAnnotation", { aliases: ["FlowType", "FlowBaseAnnotation"] }); defineType("SymbolTypeAnnotation", { aliases: ["FlowType", "FlowBaseAnnotation"] }); defineType("ThisTypeAnnotation", { aliases: ["FlowType", "FlowBaseAnnotation"] }); defineType("TupleTypeAnnotation", { visitor: ["types"], aliases: ["FlowType"], fields: { types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType")) } }); defineType("TypeofTypeAnnotation", { visitor: ["argument"], aliases: ["FlowType"], fields: { argument: (0, _utils.validateType)("FlowType") } }); defineType("TypeAlias", { visitor: ["id", "typeParameters", "right"], aliases: ["FlowDeclaration", "Statement", "Declaration"], fields: { id: (0, _utils.validateType)("Identifier"), typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"), right: (0, _utils.validateType)("FlowType") } }); defineType("TypeAnnotation", { visitor: ["typeAnnotation"], fields: { typeAnnotation: (0, _utils.validateType)("FlowType") } }); defineType("TypeCastExpression", { visitor: ["expression", "typeAnnotation"], aliases: ["ExpressionWrapper", "Expression"], fields: { expression: (0, _utils.validateType)("Expression"), typeAnnotation: (0, _utils.validateType)("TypeAnnotation") } }); defineType("TypeParameter", { visitor: ["bound", "default", "variance"], fields: { name: (0, _utils.validate)((0, _utils.assertValueType)("string")), bound: (0, _utils.validateOptionalType)("TypeAnnotation"), default: (0, _utils.validateOptionalType)("FlowType"), variance: (0, _utils.validateOptionalType)("Variance") } }); defineType("TypeParameterDeclaration", { visitor: ["params"], fields: { params: (0, _utils.validate)((0, _utils.arrayOfType)("TypeParameter")) } }); defineType("TypeParameterInstantiation", { visitor: ["params"], fields: { params: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType")) } }); defineType("UnionTypeAnnotation", { visitor: ["types"], aliases: ["FlowType"], fields: { types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType")) } }); defineType("Variance", { builder: ["kind"], fields: { kind: (0, _utils.validate)((0, _utils.assertOneOf)("minus", "plus")) } }); defineType("VoidTypeAnnotation", { aliases: ["FlowType", "FlowBaseAnnotation"] }); defineType("EnumDeclaration", { aliases: ["Statement", "Declaration"], visitor: ["id", "body"], fields: { id: (0, _utils.validateType)("Identifier"), body: (0, _utils.validateType)(["EnumBooleanBody", "EnumNumberBody", "EnumStringBody", "EnumSymbolBody"]) } }); defineType("EnumBooleanBody", { aliases: ["EnumBody"], visitor: ["members"], fields: { explicitType: (0, _utils.validate)((0, _utils.assertValueType)("boolean")), members: (0, _utils.validateArrayOfType)("EnumBooleanMember"), hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)("boolean")) } }); defineType("EnumNumberBody", { aliases: ["EnumBody"], visitor: ["members"], fields: { explicitType: (0, _utils.validate)((0, _utils.assertValueType)("boolean")), members: (0, _utils.validateArrayOfType)("EnumNumberMember"), hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)("boolean")) } }); defineType("EnumStringBody", { aliases: ["EnumBody"], visitor: ["members"], fields: { explicitType: (0, _utils.validate)((0, _utils.assertValueType)("boolean")), members: (0, _utils.validateArrayOfType)(["EnumStringMember", "EnumDefaultedMember"]), hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)("boolean")) } }); defineType("EnumSymbolBody", { aliases: ["EnumBody"], visitor: ["members"], fields: { members: (0, _utils.validateArrayOfType)("EnumDefaultedMember"), hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)("boolean")) } }); defineType("EnumBooleanMember", { aliases: ["EnumMember"], visitor: ["id"], fields: { id: (0, _utils.validateType)("Identifier"), init: (0, _utils.validateType)("BooleanLiteral") } }); defineType("EnumNumberMember", { aliases: ["EnumMember"], visitor: ["id", "init"], fields: { id: (0, _utils.validateType)("Identifier"), init: (0, _utils.validateType)("NumericLiteral") } }); defineType("EnumStringMember", { aliases: ["EnumMember"], visitor: ["id", "init"], fields: { id: (0, _utils.validateType)("Identifier"), init: (0, _utils.validateType)("StringLiteral") } }); defineType("EnumDefaultedMember", { aliases: ["EnumMember"], visitor: ["id"], fields: { id: (0, _utils.validateType)("Identifier") } }); defineType("IndexedAccessType", { visitor: ["objectType", "indexType"], aliases: ["FlowType"], fields: { objectType: (0, _utils.validateType)("FlowType"), indexType: (0, _utils.validateType)("FlowType") } }); defineType("OptionalIndexedAccessType", { visitor: ["objectType", "indexType"], aliases: ["FlowType"], fields: { objectType: (0, _utils.validateType)("FlowType"), indexType: (0, _utils.validateType)("FlowType"), optional: (0, _utils.validate)((0, _utils.assertValueType)("boolean")) } }); },{"./utils":358}],353:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); Object.defineProperty(exports, "ALIAS_KEYS", { enumerable: true, get: function () { return _utils.ALIAS_KEYS; } }); Object.defineProperty(exports, "BUILDER_KEYS", { enumerable: true, get: function () { return _utils.BUILDER_KEYS; } }); Object.defineProperty(exports, "DEPRECATED_KEYS", { enumerable: true, get: function () { return _utils.DEPRECATED_KEYS; } }); Object.defineProperty(exports, "FLIPPED_ALIAS_KEYS", { enumerable: true, get: function () { return _utils.FLIPPED_ALIAS_KEYS; } }); Object.defineProperty(exports, "NODE_FIELDS", { enumerable: true, get: function () { return _utils.NODE_FIELDS; } }); Object.defineProperty(exports, "NODE_PARENT_VALIDATIONS", { enumerable: true, get: function () { return _utils.NODE_PARENT_VALIDATIONS; } }); Object.defineProperty(exports, "PLACEHOLDERS", { enumerable: true, get: function () { return _placeholders.PLACEHOLDERS; } }); Object.defineProperty(exports, "PLACEHOLDERS_ALIAS", { enumerable: true, get: function () { return _placeholders.PLACEHOLDERS_ALIAS; } }); Object.defineProperty(exports, "PLACEHOLDERS_FLIPPED_ALIAS", { enumerable: true, get: function () { return _placeholders.PLACEHOLDERS_FLIPPED_ALIAS; } }); exports.TYPES = void 0; Object.defineProperty(exports, "VISITOR_KEYS", { enumerable: true, get: function () { return _utils.VISITOR_KEYS; } }); var _toFastProperties = require("to-fast-properties"); require("./core"); require("./flow"); require("./jsx"); require("./misc"); require("./experimental"); require("./typescript"); var _utils = require("./utils"); var _placeholders = require("./placeholders"); _toFastProperties(_utils.VISITOR_KEYS); _toFastProperties(_utils.ALIAS_KEYS); _toFastProperties(_utils.FLIPPED_ALIAS_KEYS); _toFastProperties(_utils.NODE_FIELDS); _toFastProperties(_utils.BUILDER_KEYS); _toFastProperties(_utils.DEPRECATED_KEYS); _toFastProperties(_placeholders.PLACEHOLDERS_ALIAS); _toFastProperties(_placeholders.PLACEHOLDERS_FLIPPED_ALIAS); const TYPES = [].concat(Object.keys(_utils.VISITOR_KEYS), Object.keys(_utils.FLIPPED_ALIAS_KEYS), Object.keys(_utils.DEPRECATED_KEYS)); exports.TYPES = TYPES; },{"./core":350,"./experimental":351,"./flow":352,"./jsx":354,"./misc":355,"./placeholders":356,"./typescript":357,"./utils":358,"to-fast-properties":540}],354:[function(require,module,exports){ "use strict"; var _utils = require("./utils"); const defineType = (0, _utils.defineAliasedType)("JSX"); defineType("JSXAttribute", { visitor: ["name", "value"], aliases: ["Immutable"], fields: { name: { validate: (0, _utils.assertNodeType)("JSXIdentifier", "JSXNamespacedName") }, value: { optional: true, validate: (0, _utils.assertNodeType)("JSXElement", "JSXFragment", "StringLiteral", "JSXExpressionContainer") } } }); defineType("JSXClosingElement", { visitor: ["name"], aliases: ["Immutable"], fields: { name: { validate: (0, _utils.assertNodeType)("JSXIdentifier", "JSXMemberExpression", "JSXNamespacedName") } } }); defineType("JSXElement", { builder: ["openingElement", "closingElement", "children", "selfClosing"], visitor: ["openingElement", "children", "closingElement"], aliases: ["Immutable", "Expression"], fields: Object.assign({ openingElement: { validate: (0, _utils.assertNodeType)("JSXOpeningElement") }, closingElement: { optional: true, validate: (0, _utils.assertNodeType)("JSXClosingElement") }, children: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("JSXText", "JSXExpressionContainer", "JSXSpreadChild", "JSXElement", "JSXFragment"))) } }, { selfClosing: { validate: (0, _utils.assertValueType)("boolean"), optional: true } }) }); defineType("JSXEmptyExpression", {}); defineType("JSXExpressionContainer", { visitor: ["expression"], aliases: ["Immutable"], fields: { expression: { validate: (0, _utils.assertNodeType)("Expression", "JSXEmptyExpression") } } }); defineType("JSXSpreadChild", { visitor: ["expression"], aliases: ["Immutable"], fields: { expression: { validate: (0, _utils.assertNodeType)("Expression") } } }); defineType("JSXIdentifier", { builder: ["name"], fields: { name: { validate: (0, _utils.assertValueType)("string") } } }); defineType("JSXMemberExpression", { visitor: ["object", "property"], fields: { object: { validate: (0, _utils.assertNodeType)("JSXMemberExpression", "JSXIdentifier") }, property: { validate: (0, _utils.assertNodeType)("JSXIdentifier") } } }); defineType("JSXNamespacedName", { visitor: ["namespace", "name"], fields: { namespace: { validate: (0, _utils.assertNodeType)("JSXIdentifier") }, name: { validate: (0, _utils.assertNodeType)("JSXIdentifier") } } }); defineType("JSXOpeningElement", { builder: ["name", "attributes", "selfClosing"], visitor: ["name", "attributes"], aliases: ["Immutable"], fields: { name: { validate: (0, _utils.assertNodeType)("JSXIdentifier", "JSXMemberExpression", "JSXNamespacedName") }, selfClosing: { default: false }, attributes: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("JSXAttribute", "JSXSpreadAttribute"))) }, typeParameters: { validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"), optional: true } } }); defineType("JSXSpreadAttribute", { visitor: ["argument"], fields: { argument: { validate: (0, _utils.assertNodeType)("Expression") } } }); defineType("JSXText", { aliases: ["Immutable"], builder: ["value"], fields: { value: { validate: (0, _utils.assertValueType)("string") } } }); defineType("JSXFragment", { builder: ["openingFragment", "closingFragment", "children"], visitor: ["openingFragment", "children", "closingFragment"], aliases: ["Immutable", "Expression"], fields: { openingFragment: { validate: (0, _utils.assertNodeType)("JSXOpeningFragment") }, closingFragment: { validate: (0, _utils.assertNodeType)("JSXClosingFragment") }, children: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("JSXText", "JSXExpressionContainer", "JSXSpreadChild", "JSXElement", "JSXFragment"))) } } }); defineType("JSXOpeningFragment", { aliases: ["Immutable"] }); defineType("JSXClosingFragment", { aliases: ["Immutable"] }); },{"./utils":358}],355:[function(require,module,exports){ "use strict"; var _utils = require("./utils"); var _placeholders = require("./placeholders"); const defineType = (0, _utils.defineAliasedType)("Miscellaneous"); { defineType("Noop", { visitor: [] }); } defineType("Placeholder", { visitor: [], builder: ["expectedNode", "name"], fields: { name: { validate: (0, _utils.assertNodeType)("Identifier") }, expectedNode: { validate: (0, _utils.assertOneOf)(..._placeholders.PLACEHOLDERS) } } }); defineType("V8IntrinsicIdentifier", { builder: ["name"], fields: { name: { validate: (0, _utils.assertValueType)("string") } } }); },{"./placeholders":356,"./utils":358}],356:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.PLACEHOLDERS_FLIPPED_ALIAS = exports.PLACEHOLDERS_ALIAS = exports.PLACEHOLDERS = void 0; var _utils = require("./utils"); const PLACEHOLDERS = ["Identifier", "StringLiteral", "Expression", "Statement", "Declaration", "BlockStatement", "ClassBody", "Pattern"]; exports.PLACEHOLDERS = PLACEHOLDERS; const PLACEHOLDERS_ALIAS = { Declaration: ["Statement"], Pattern: ["PatternLike", "LVal"] }; exports.PLACEHOLDERS_ALIAS = PLACEHOLDERS_ALIAS; for (const type of PLACEHOLDERS) { const alias = _utils.ALIAS_KEYS[type]; if (alias != null && alias.length) PLACEHOLDERS_ALIAS[type] = alias; } const PLACEHOLDERS_FLIPPED_ALIAS = {}; exports.PLACEHOLDERS_FLIPPED_ALIAS = PLACEHOLDERS_FLIPPED_ALIAS; Object.keys(PLACEHOLDERS_ALIAS).forEach(type => { PLACEHOLDERS_ALIAS[type].forEach(alias => { if (!Object.hasOwnProperty.call(PLACEHOLDERS_FLIPPED_ALIAS, alias)) { PLACEHOLDERS_FLIPPED_ALIAS[alias] = []; } PLACEHOLDERS_FLIPPED_ALIAS[alias].push(type); }); }); },{"./utils":358}],357:[function(require,module,exports){ "use strict"; var _utils = require("./utils"); var _core = require("./core"); var _is = require("../validators/is"); const defineType = (0, _utils.defineAliasedType)("TypeScript"); const bool = (0, _utils.assertValueType)("boolean"); const tSFunctionTypeAnnotationCommon = () => ({ returnType: { validate: (0, _utils.assertNodeType)("TSTypeAnnotation", "Noop"), optional: true }, typeParameters: { validate: (0, _utils.assertNodeType)("TSTypeParameterDeclaration", "Noop"), optional: true } }); defineType("TSParameterProperty", { aliases: ["LVal"], visitor: ["parameter"], fields: { accessibility: { validate: (0, _utils.assertOneOf)("public", "private", "protected"), optional: true }, readonly: { validate: (0, _utils.assertValueType)("boolean"), optional: true }, parameter: { validate: (0, _utils.assertNodeType)("Identifier", "AssignmentPattern") }, override: { validate: (0, _utils.assertValueType)("boolean"), optional: true }, decorators: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))), optional: true } } }); defineType("TSDeclareFunction", { aliases: ["Statement", "Declaration"], visitor: ["id", "typeParameters", "params", "returnType"], fields: Object.assign({}, (0, _core.functionDeclarationCommon)(), tSFunctionTypeAnnotationCommon()) }); defineType("TSDeclareMethod", { visitor: ["decorators", "key", "typeParameters", "params", "returnType"], fields: Object.assign({}, (0, _core.classMethodOrDeclareMethodCommon)(), tSFunctionTypeAnnotationCommon()) }); defineType("TSQualifiedName", { aliases: ["TSEntityName"], visitor: ["left", "right"], fields: { left: (0, _utils.validateType)("TSEntityName"), right: (0, _utils.validateType)("Identifier") } }); const signatureDeclarationCommon = () => ({ typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"), ["parameters"]: (0, _utils.validateArrayOfType)(["Identifier", "RestElement"]), ["typeAnnotation"]: (0, _utils.validateOptionalType)("TSTypeAnnotation") }); const callConstructSignatureDeclaration = { aliases: ["TSTypeElement"], visitor: ["typeParameters", "parameters", "typeAnnotation"], fields: signatureDeclarationCommon() }; defineType("TSCallSignatureDeclaration", callConstructSignatureDeclaration); defineType("TSConstructSignatureDeclaration", callConstructSignatureDeclaration); const namedTypeElementCommon = () => ({ key: (0, _utils.validateType)("Expression"), computed: { default: false }, optional: (0, _utils.validateOptional)(bool) }); defineType("TSPropertySignature", { aliases: ["TSTypeElement"], visitor: ["key", "typeAnnotation", "initializer"], fields: Object.assign({}, namedTypeElementCommon(), { readonly: (0, _utils.validateOptional)(bool), typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation"), initializer: (0, _utils.validateOptionalType)("Expression"), kind: { validate: (0, _utils.assertOneOf)("get", "set") } }) }); defineType("TSMethodSignature", { aliases: ["TSTypeElement"], visitor: ["key", "typeParameters", "parameters", "typeAnnotation"], fields: Object.assign({}, signatureDeclarationCommon(), namedTypeElementCommon(), { kind: { validate: (0, _utils.assertOneOf)("method", "get", "set") } }) }); defineType("TSIndexSignature", { aliases: ["TSTypeElement"], visitor: ["parameters", "typeAnnotation"], fields: { readonly: (0, _utils.validateOptional)(bool), static: (0, _utils.validateOptional)(bool), parameters: (0, _utils.validateArrayOfType)("Identifier"), typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation") } }); const tsKeywordTypes = ["TSAnyKeyword", "TSBooleanKeyword", "TSBigIntKeyword", "TSIntrinsicKeyword", "TSNeverKeyword", "TSNullKeyword", "TSNumberKeyword", "TSObjectKeyword", "TSStringKeyword", "TSSymbolKeyword", "TSUndefinedKeyword", "TSUnknownKeyword", "TSVoidKeyword"]; for (const type of tsKeywordTypes) { defineType(type, { aliases: ["TSType", "TSBaseType"], visitor: [], fields: {} }); } defineType("TSThisType", { aliases: ["TSType", "TSBaseType"], visitor: [], fields: {} }); const fnOrCtrBase = { aliases: ["TSType"], visitor: ["typeParameters", "parameters", "typeAnnotation"] }; defineType("TSFunctionType", Object.assign({}, fnOrCtrBase, { fields: signatureDeclarationCommon() })); defineType("TSConstructorType", Object.assign({}, fnOrCtrBase, { fields: Object.assign({}, signatureDeclarationCommon(), { abstract: (0, _utils.validateOptional)(bool) }) })); defineType("TSTypeReference", { aliases: ["TSType"], visitor: ["typeName", "typeParameters"], fields: { typeName: (0, _utils.validateType)("TSEntityName"), typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation") } }); defineType("TSTypePredicate", { aliases: ["TSType"], visitor: ["parameterName", "typeAnnotation"], builder: ["parameterName", "typeAnnotation", "asserts"], fields: { parameterName: (0, _utils.validateType)(["Identifier", "TSThisType"]), typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation"), asserts: (0, _utils.validateOptional)(bool) } }); defineType("TSTypeQuery", { aliases: ["TSType"], visitor: ["exprName", "typeParameters"], fields: { exprName: (0, _utils.validateType)(["TSEntityName", "TSImportType"]), typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation") } }); defineType("TSTypeLiteral", { aliases: ["TSType"], visitor: ["members"], fields: { members: (0, _utils.validateArrayOfType)("TSTypeElement") } }); defineType("TSArrayType", { aliases: ["TSType"], visitor: ["elementType"], fields: { elementType: (0, _utils.validateType)("TSType") } }); defineType("TSTupleType", { aliases: ["TSType"], visitor: ["elementTypes"], fields: { elementTypes: (0, _utils.validateArrayOfType)(["TSType", "TSNamedTupleMember"]) } }); defineType("TSOptionalType", { aliases: ["TSType"], visitor: ["typeAnnotation"], fields: { typeAnnotation: (0, _utils.validateType)("TSType") } }); defineType("TSRestType", { aliases: ["TSType"], visitor: ["typeAnnotation"], fields: { typeAnnotation: (0, _utils.validateType)("TSType") } }); defineType("TSNamedTupleMember", { visitor: ["label", "elementType"], builder: ["label", "elementType", "optional"], fields: { label: (0, _utils.validateType)("Identifier"), optional: { validate: bool, default: false }, elementType: (0, _utils.validateType)("TSType") } }); const unionOrIntersection = { aliases: ["TSType"], visitor: ["types"], fields: { types: (0, _utils.validateArrayOfType)("TSType") } }; defineType("TSUnionType", unionOrIntersection); defineType("TSIntersectionType", unionOrIntersection); defineType("TSConditionalType", { aliases: ["TSType"], visitor: ["checkType", "extendsType", "trueType", "falseType"], fields: { checkType: (0, _utils.validateType)("TSType"), extendsType: (0, _utils.validateType)("TSType"), trueType: (0, _utils.validateType)("TSType"), falseType: (0, _utils.validateType)("TSType") } }); defineType("TSInferType", { aliases: ["TSType"], visitor: ["typeParameter"], fields: { typeParameter: (0, _utils.validateType)("TSTypeParameter") } }); defineType("TSParenthesizedType", { aliases: ["TSType"], visitor: ["typeAnnotation"], fields: { typeAnnotation: (0, _utils.validateType)("TSType") } }); defineType("TSTypeOperator", { aliases: ["TSType"], visitor: ["typeAnnotation"], fields: { operator: (0, _utils.validate)((0, _utils.assertValueType)("string")), typeAnnotation: (0, _utils.validateType)("TSType") } }); defineType("TSIndexedAccessType", { aliases: ["TSType"], visitor: ["objectType", "indexType"], fields: { objectType: (0, _utils.validateType)("TSType"), indexType: (0, _utils.validateType)("TSType") } }); defineType("TSMappedType", { aliases: ["TSType"], visitor: ["typeParameter", "typeAnnotation", "nameType"], fields: { readonly: (0, _utils.validateOptional)((0, _utils.assertOneOf)(true, false, "+", "-")), typeParameter: (0, _utils.validateType)("TSTypeParameter"), optional: (0, _utils.validateOptional)((0, _utils.assertOneOf)(true, false, "+", "-")), typeAnnotation: (0, _utils.validateOptionalType)("TSType"), nameType: (0, _utils.validateOptionalType)("TSType") } }); defineType("TSLiteralType", { aliases: ["TSType", "TSBaseType"], visitor: ["literal"], fields: { literal: { validate: function () { const unaryExpression = (0, _utils.assertNodeType)("NumericLiteral", "BigIntLiteral"); const unaryOperator = (0, _utils.assertOneOf)("-"); const literal = (0, _utils.assertNodeType)("NumericLiteral", "StringLiteral", "BooleanLiteral", "BigIntLiteral", "TemplateLiteral"); function validator(parent, key, node) { if ((0, _is.default)("UnaryExpression", node)) { unaryOperator(node, "operator", node.operator); unaryExpression(node, "argument", node.argument); } else { literal(parent, key, node); } } validator.oneOfNodeTypes = ["NumericLiteral", "StringLiteral", "BooleanLiteral", "BigIntLiteral", "TemplateLiteral", "UnaryExpression"]; return validator; }() } } }); defineType("TSExpressionWithTypeArguments", { aliases: ["TSType"], visitor: ["expression", "typeParameters"], fields: { expression: (0, _utils.validateType)("TSEntityName"), typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation") } }); defineType("TSInterfaceDeclaration", { aliases: ["Statement", "Declaration"], visitor: ["id", "typeParameters", "extends", "body"], fields: { declare: (0, _utils.validateOptional)(bool), id: (0, _utils.validateType)("Identifier"), typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"), extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("TSExpressionWithTypeArguments")), body: (0, _utils.validateType)("TSInterfaceBody") } }); defineType("TSInterfaceBody", { visitor: ["body"], fields: { body: (0, _utils.validateArrayOfType)("TSTypeElement") } }); defineType("TSTypeAliasDeclaration", { aliases: ["Statement", "Declaration"], visitor: ["id", "typeParameters", "typeAnnotation"], fields: { declare: (0, _utils.validateOptional)(bool), id: (0, _utils.validateType)("Identifier"), typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"), typeAnnotation: (0, _utils.validateType)("TSType") } }); defineType("TSInstantiationExpression", { aliases: ["Expression"], visitor: ["expression", "typeParameters"], fields: { expression: (0, _utils.validateType)("Expression"), typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation") } }); defineType("TSAsExpression", { aliases: ["Expression", "LVal", "PatternLike"], visitor: ["expression", "typeAnnotation"], fields: { expression: (0, _utils.validateType)("Expression"), typeAnnotation: (0, _utils.validateType)("TSType") } }); defineType("TSTypeAssertion", { aliases: ["Expression", "LVal", "PatternLike"], visitor: ["typeAnnotation", "expression"], fields: { typeAnnotation: (0, _utils.validateType)("TSType"), expression: (0, _utils.validateType)("Expression") } }); defineType("TSEnumDeclaration", { aliases: ["Statement", "Declaration"], visitor: ["id", "members"], fields: { declare: (0, _utils.validateOptional)(bool), const: (0, _utils.validateOptional)(bool), id: (0, _utils.validateType)("Identifier"), members: (0, _utils.validateArrayOfType)("TSEnumMember"), initializer: (0, _utils.validateOptionalType)("Expression") } }); defineType("TSEnumMember", { visitor: ["id", "initializer"], fields: { id: (0, _utils.validateType)(["Identifier", "StringLiteral"]), initializer: (0, _utils.validateOptionalType)("Expression") } }); defineType("TSModuleDeclaration", { aliases: ["Statement", "Declaration"], visitor: ["id", "body"], fields: { declare: (0, _utils.validateOptional)(bool), global: (0, _utils.validateOptional)(bool), id: (0, _utils.validateType)(["Identifier", "StringLiteral"]), body: (0, _utils.validateType)(["TSModuleBlock", "TSModuleDeclaration"]) } }); defineType("TSModuleBlock", { aliases: ["Scopable", "Block", "BlockParent", "FunctionParent"], visitor: ["body"], fields: { body: (0, _utils.validateArrayOfType)("Statement") } }); defineType("TSImportType", { aliases: ["TSType"], visitor: ["argument", "qualifier", "typeParameters"], fields: { argument: (0, _utils.validateType)("StringLiteral"), qualifier: (0, _utils.validateOptionalType)("TSEntityName"), typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation") } }); defineType("TSImportEqualsDeclaration", { aliases: ["Statement"], visitor: ["id", "moduleReference"], fields: { isExport: (0, _utils.validate)(bool), id: (0, _utils.validateType)("Identifier"), moduleReference: (0, _utils.validateType)(["TSEntityName", "TSExternalModuleReference"]), importKind: { validate: (0, _utils.assertOneOf)("type", "value"), optional: true } } }); defineType("TSExternalModuleReference", { visitor: ["expression"], fields: { expression: (0, _utils.validateType)("StringLiteral") } }); defineType("TSNonNullExpression", { aliases: ["Expression", "LVal", "PatternLike"], visitor: ["expression"], fields: { expression: (0, _utils.validateType)("Expression") } }); defineType("TSExportAssignment", { aliases: ["Statement"], visitor: ["expression"], fields: { expression: (0, _utils.validateType)("Expression") } }); defineType("TSNamespaceExportDeclaration", { aliases: ["Statement"], visitor: ["id"], fields: { id: (0, _utils.validateType)("Identifier") } }); defineType("TSTypeAnnotation", { visitor: ["typeAnnotation"], fields: { typeAnnotation: { validate: (0, _utils.assertNodeType)("TSType") } } }); defineType("TSTypeParameterInstantiation", { visitor: ["params"], fields: { params: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSType"))) } } }); defineType("TSTypeParameterDeclaration", { visitor: ["params"], fields: { params: { validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSTypeParameter"))) } } }); defineType("TSTypeParameter", { builder: ["constraint", "default", "name"], visitor: ["constraint", "default"], fields: { name: { validate: (0, _utils.assertValueType)("string") }, in: { validate: (0, _utils.assertValueType)("boolean"), optional: true }, out: { validate: (0, _utils.assertValueType)("boolean"), optional: true }, constraint: { validate: (0, _utils.assertNodeType)("TSType"), optional: true }, default: { validate: (0, _utils.assertNodeType)("TSType"), optional: true } } }); },{"../validators/is":376,"./core":350,"./utils":358}],358:[function(require,module,exports){ (function (process){(function (){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.VISITOR_KEYS = exports.NODE_PARENT_VALIDATIONS = exports.NODE_FIELDS = exports.FLIPPED_ALIAS_KEYS = exports.DEPRECATED_KEYS = exports.BUILDER_KEYS = exports.ALIAS_KEYS = void 0; exports.arrayOf = arrayOf; exports.arrayOfType = arrayOfType; exports.assertEach = assertEach; exports.assertNodeOrValueType = assertNodeOrValueType; exports.assertNodeType = assertNodeType; exports.assertOneOf = assertOneOf; exports.assertOptionalChainStart = assertOptionalChainStart; exports.assertShape = assertShape; exports.assertValueType = assertValueType; exports.chain = chain; exports.default = defineType; exports.defineAliasedType = defineAliasedType; exports.typeIs = typeIs; exports.validate = validate; exports.validateArrayOfType = validateArrayOfType; exports.validateOptional = validateOptional; exports.validateOptionalType = validateOptionalType; exports.validateType = validateType; var _is = require("../validators/is"); var _validate = require("../validators/validate"); const VISITOR_KEYS = {}; exports.VISITOR_KEYS = VISITOR_KEYS; const ALIAS_KEYS = {}; exports.ALIAS_KEYS = ALIAS_KEYS; const FLIPPED_ALIAS_KEYS = {}; exports.FLIPPED_ALIAS_KEYS = FLIPPED_ALIAS_KEYS; const NODE_FIELDS = {}; exports.NODE_FIELDS = NODE_FIELDS; const BUILDER_KEYS = {}; exports.BUILDER_KEYS = BUILDER_KEYS; const DEPRECATED_KEYS = {}; exports.DEPRECATED_KEYS = DEPRECATED_KEYS; const NODE_PARENT_VALIDATIONS = {}; exports.NODE_PARENT_VALIDATIONS = NODE_PARENT_VALIDATIONS; function getType(val) { if (Array.isArray(val)) { return "array"; } else if (val === null) { return "null"; } else { return typeof val; } } function validate(validate) { return { validate }; } function typeIs(typeName) { return typeof typeName === "string" ? assertNodeType(typeName) : assertNodeType(...typeName); } function validateType(typeName) { return validate(typeIs(typeName)); } function validateOptional(validate) { return { validate, optional: true }; } function validateOptionalType(typeName) { return { validate: typeIs(typeName), optional: true }; } function arrayOf(elementType) { return chain(assertValueType("array"), assertEach(elementType)); } function arrayOfType(typeName) { return arrayOf(typeIs(typeName)); } function validateArrayOfType(typeName) { return validate(arrayOfType(typeName)); } function assertEach(callback) { function validator(node, key, val) { if (!Array.isArray(val)) return; for (let i = 0; i < val.length; i++) { const subkey = `${key}[${i}]`; const v = val[i]; callback(node, subkey, v); if (process.env.BABEL_TYPES_8_BREAKING) (0, _validate.validateChild)(node, subkey, v); } } validator.each = callback; return validator; } function assertOneOf(...values) { function validate(node, key, val) { if (values.indexOf(val) < 0) { throw new TypeError(`Property ${key} expected value to be one of ${JSON.stringify(values)} but got ${JSON.stringify(val)}`); } } validate.oneOf = values; return validate; } function assertNodeType(...types) { function validate(node, key, val) { for (const type of types) { if ((0, _is.default)(type, val)) { (0, _validate.validateChild)(node, key, val); return; } } throw new TypeError(`Property ${key} of ${node.type} expected node to be of a type ${JSON.stringify(types)} but instead got ${JSON.stringify(val == null ? void 0 : val.type)}`); } validate.oneOfNodeTypes = types; return validate; } function assertNodeOrValueType(...types) { function validate(node, key, val) { for (const type of types) { if (getType(val) === type || (0, _is.default)(type, val)) { (0, _validate.validateChild)(node, key, val); return; } } throw new TypeError(`Property ${key} of ${node.type} expected node to be of a type ${JSON.stringify(types)} but instead got ${JSON.stringify(val == null ? void 0 : val.type)}`); } validate.oneOfNodeOrValueTypes = types; return validate; } function assertValueType(type) { function validate(node, key, val) { const valid = getType(val) === type; if (!valid) { throw new TypeError(`Property ${key} expected type of ${type} but got ${getType(val)}`); } } validate.type = type; return validate; } function assertShape(shape) { function validate(node, key, val) { const errors = []; for (const property of Object.keys(shape)) { try { (0, _validate.validateField)(node, property, val[property], shape[property]); } catch (error) { if (error instanceof TypeError) { errors.push(error.message); continue; } throw error; } } if (errors.length) { throw new TypeError(`Property ${key} of ${node.type} expected to have the following:\n${errors.join("\n")}`); } } validate.shapeOf = shape; return validate; } function assertOptionalChainStart() { function validate(node) { var _current; let current = node; while (node) { const { type } = current; if (type === "OptionalCallExpression") { if (current.optional) return; current = current.callee; continue; } if (type === "OptionalMemberExpression") { if (current.optional) return; current = current.object; continue; } break; } throw new TypeError(`Non-optional ${node.type} must chain from an optional OptionalMemberExpression or OptionalCallExpression. Found chain from ${(_current = current) == null ? void 0 : _current.type}`); } return validate; } function chain(...fns) { function validate(...args) { for (const fn of fns) { fn(...args); } } validate.chainOf = fns; if (fns.length >= 2 && "type" in fns[0] && fns[0].type === "array" && !("each" in fns[1])) { throw new Error(`An assertValueType("array") validator can only be followed by an assertEach(...) validator.`); } return validate; } const validTypeOpts = ["aliases", "builder", "deprecatedAlias", "fields", "inherits", "visitor", "validate"]; const validFieldKeys = ["default", "optional", "validate"]; function defineAliasedType(...aliases) { return (type, opts = {}) => { let defined = opts.aliases; if (!defined) { var _store$opts$inherits$, _defined; if (opts.inherits) defined = (_store$opts$inherits$ = store[opts.inherits].aliases) == null ? void 0 : _store$opts$inherits$.slice(); (_defined = defined) != null ? _defined : defined = []; opts.aliases = defined; } const additional = aliases.filter(a => !defined.includes(a)); defined.unshift(...additional); return defineType(type, opts); }; } function defineType(type, opts = {}) { const inherits = opts.inherits && store[opts.inherits] || {}; let fields = opts.fields; if (!fields) { fields = {}; if (inherits.fields) { const keys = Object.getOwnPropertyNames(inherits.fields); for (const key of keys) { const field = inherits.fields[key]; const def = field.default; if (Array.isArray(def) ? def.length > 0 : def && typeof def === "object") { throw new Error("field defaults can only be primitives or empty arrays currently"); } fields[key] = { default: Array.isArray(def) ? [] : def, optional: field.optional, validate: field.validate }; } } } const visitor = opts.visitor || inherits.visitor || []; const aliases = opts.aliases || inherits.aliases || []; const builder = opts.builder || inherits.builder || opts.visitor || []; for (const k of Object.keys(opts)) { if (validTypeOpts.indexOf(k) === -1) { throw new Error(`Unknown type option "${k}" on ${type}`); } } if (opts.deprecatedAlias) { DEPRECATED_KEYS[opts.deprecatedAlias] = type; } for (const key of visitor.concat(builder)) { fields[key] = fields[key] || {}; } for (const key of Object.keys(fields)) { const field = fields[key]; if (field.default !== undefined && builder.indexOf(key) === -1) { field.optional = true; } if (field.default === undefined) { field.default = null; } else if (!field.validate && field.default != null) { field.validate = assertValueType(getType(field.default)); } for (const k of Object.keys(field)) { if (validFieldKeys.indexOf(k) === -1) { throw new Error(`Unknown field key "${k}" on ${type}.${key}`); } } } VISITOR_KEYS[type] = opts.visitor = visitor; BUILDER_KEYS[type] = opts.builder = builder; NODE_FIELDS[type] = opts.fields = fields; ALIAS_KEYS[type] = opts.aliases = aliases; aliases.forEach(alias => { FLIPPED_ALIAS_KEYS[alias] = FLIPPED_ALIAS_KEYS[alias] || []; FLIPPED_ALIAS_KEYS[alias].push(type); }); if (opts.validate) { NODE_PARENT_VALIDATIONS[type] = opts.validate; } store[type] = opts; } const store = {}; }).call(this)}).call(this,require('_process')) },{"../validators/is":376,"../validators/validate":394,"_process":460}],359:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); var _exportNames = { react: true, assertNode: true, createTypeAnnotationBasedOnTypeof: true, createUnionTypeAnnotation: true, createFlowUnionType: true, createTSUnionType: true, cloneNode: true, clone: true, cloneDeep: true, cloneDeepWithoutLoc: true, cloneWithoutLoc: true, addComment: true, addComments: true, inheritInnerComments: true, inheritLeadingComments: true, inheritsComments: true, inheritTrailingComments: true, removeComments: true, ensureBlock: true, toBindingIdentifierName: true, toBlock: true, toComputedKey: true, toExpression: true, toIdentifier: true, toKeyAlias: true, toSequenceExpression: true, toStatement: true, valueToNode: true, appendToMemberExpression: true, inherits: true, prependToMemberExpression: true, removeProperties: true, removePropertiesDeep: true, removeTypeDuplicates: true, getBindingIdentifiers: true, getOuterBindingIdentifiers: true, traverse: true, traverseFast: true, shallowEqual: true, is: true, isBinding: true, isBlockScoped: true, isImmutable: true, isLet: true, isNode: true, isNodesEquivalent: true, isPlaceholderType: true, isReferenced: true, isScope: true, isSpecifierDefault: true, isType: true, isValidES3Identifier: true, isValidIdentifier: true, isVar: true, matchesPattern: true, validate: true, buildMatchMemberExpression: true }; Object.defineProperty(exports, "addComment", { enumerable: true, get: function () { return _addComment.default; } }); Object.defineProperty(exports, "addComments", { enumerable: true, get: function () { return _addComments.default; } }); Object.defineProperty(exports, "appendToMemberExpression", { enumerable: true, get: function () { return _appendToMemberExpression.default; } }); Object.defineProperty(exports, "assertNode", { enumerable: true, get: function () { return _assertNode.default; } }); Object.defineProperty(exports, "buildMatchMemberExpression", { enumerable: true, get: function () { return _buildMatchMemberExpression.default; } }); Object.defineProperty(exports, "clone", { enumerable: true, get: function () { return _clone.default; } }); Object.defineProperty(exports, "cloneDeep", { enumerable: true, get: function () { return _cloneDeep.default; } }); Object.defineProperty(exports, "cloneDeepWithoutLoc", { enumerable: true, get: function () { return _cloneDeepWithoutLoc.default; } }); Object.defineProperty(exports, "cloneNode", { enumerable: true, get: function () { return _cloneNode.default; } }); Object.defineProperty(exports, "cloneWithoutLoc", { enumerable: true, get: function () { return _cloneWithoutLoc.default; } }); Object.defineProperty(exports, "createFlowUnionType", { enumerable: true, get: function () { return _createFlowUnionType.default; } }); Object.defineProperty(exports, "createTSUnionType", { enumerable: true, get: function () { return _createTSUnionType.default; } }); Object.defineProperty(exports, "createTypeAnnotationBasedOnTypeof", { enumerable: true, get: function () { return _createTypeAnnotationBasedOnTypeof.default; } }); Object.defineProperty(exports, "createUnionTypeAnnotation", { enumerable: true, get: function () { return _createFlowUnionType.default; } }); Object.defineProperty(exports, "ensureBlock", { enumerable: true, get: function () { return _ensureBlock.default; } }); Object.defineProperty(exports, "getBindingIdentifiers", { enumerable: true, get: function () { return _getBindingIdentifiers.default; } }); Object.defineProperty(exports, "getOuterBindingIdentifiers", { enumerable: true, get: function () { return _getOuterBindingIdentifiers.default; } }); Object.defineProperty(exports, "inheritInnerComments", { enumerable: true, get: function () { return _inheritInnerComments.default; } }); Object.defineProperty(exports, "inheritLeadingComments", { enumerable: true, get: function () { return _inheritLeadingComments.default; } }); Object.defineProperty(exports, "inheritTrailingComments", { enumerable: true, get: function () { return _inheritTrailingComments.default; } }); Object.defineProperty(exports, "inherits", { enumerable: true, get: function () { return _inherits.default; } }); Object.defineProperty(exports, "inheritsComments", { enumerable: true, get: function () { return _inheritsComments.default; } }); Object.defineProperty(exports, "is", { enumerable: true, get: function () { return _is.default; } }); Object.defineProperty(exports, "isBinding", { enumerable: true, get: function () { return _isBinding.default; } }); Object.defineProperty(exports, "isBlockScoped", { enumerable: true, get: function () { return _isBlockScoped.default; } }); Object.defineProperty(exports, "isImmutable", { enumerable: true, get: function () { return _isImmutable.default; } }); Object.defineProperty(exports, "isLet", { enumerable: true, get: function () { return _isLet.default; } }); Object.defineProperty(exports, "isNode", { enumerable: true, get: function () { return _isNode.default; } }); Object.defineProperty(exports, "isNodesEquivalent", { enumerable: true, get: function () { return _isNodesEquivalent.default; } }); Object.defineProperty(exports, "isPlaceholderType", { enumerable: true, get: function () { return _isPlaceholderType.default; } }); Object.defineProperty(exports, "isReferenced", { enumerable: true, get: function () { return _isReferenced.default; } }); Object.defineProperty(exports, "isScope", { enumerable: true, get: function () { return _isScope.default; } }); Object.defineProperty(exports, "isSpecifierDefault", { enumerable: true, get: function () { return _isSpecifierDefault.default; } }); Object.defineProperty(exports, "isType", { enumerable: true, get: function () { return _isType.default; } }); Object.defineProperty(exports, "isValidES3Identifier", { enumerable: true, get: function () { return _isValidES3Identifier.default; } }); Object.defineProperty(exports, "isValidIdentifier", { enumerable: true, get: function () { return _isValidIdentifier.default; } }); Object.defineProperty(exports, "isVar", { enumerable: true, get: function () { return _isVar.default; } }); Object.defineProperty(exports, "matchesPattern", { enumerable: true, get: function () { return _matchesPattern.default; } }); Object.defineProperty(exports, "prependToMemberExpression", { enumerable: true, get: function () { return _prependToMemberExpression.default; } }); exports.react = void 0; Object.defineProperty(exports, "removeComments", { enumerable: true, get: function () { return _removeComments.default; } }); Object.defineProperty(exports, "removeProperties", { enumerable: true, get: function () { return _removeProperties.default; } }); Object.defineProperty(exports, "removePropertiesDeep", { enumerable: true, get: function () { return _removePropertiesDeep.default; } }); Object.defineProperty(exports, "removeTypeDuplicates", { enumerable: true, get: function () { return _removeTypeDuplicates.default; } }); Object.defineProperty(exports, "shallowEqual", { enumerable: true, get: function () { return _shallowEqual.default; } }); Object.defineProperty(exports, "toBindingIdentifierName", { enumerable: true, get: function () { return _toBindingIdentifierName.default; } }); Object.defineProperty(exports, "toBlock", { enumerable: true, get: function () { return _toBlock.default; } }); Object.defineProperty(exports, "toComputedKey", { enumerable: true, get: function () { return _toComputedKey.default; } }); Object.defineProperty(exports, "toExpression", { enumerable: true, get: function () { return _toExpression.default; } }); Object.defineProperty(exports, "toIdentifier", { enumerable: true, get: function () { return _toIdentifier.default; } }); Object.defineProperty(exports, "toKeyAlias", { enumerable: true, get: function () { return _toKeyAlias.default; } }); Object.defineProperty(exports, "toSequenceExpression", { enumerable: true, get: function () { return _toSequenceExpression.default; } }); Object.defineProperty(exports, "toStatement", { enumerable: true, get: function () { return _toStatement.default; } }); Object.defineProperty(exports, "traverse", { enumerable: true, get: function () { return _traverse.default; } }); Object.defineProperty(exports, "traverseFast", { enumerable: true, get: function () { return _traverseFast.default; } }); Object.defineProperty(exports, "validate", { enumerable: true, get: function () { return _validate.default; } }); Object.defineProperty(exports, "valueToNode", { enumerable: true, get: function () { return _valueToNode.default; } }); var _isReactComponent = require("./validators/react/isReactComponent"); var _isCompatTag = require("./validators/react/isCompatTag"); var _buildChildren = require("./builders/react/buildChildren"); var _assertNode = require("./asserts/assertNode"); var _generated = require("./asserts/generated"); Object.keys(_generated).forEach(function (key) { if (key === "default" || key === "__esModule") return; if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; if (key in exports && exports[key] === _generated[key]) return; Object.defineProperty(exports, key, { enumerable: true, get: function () { return _generated[key]; } }); }); var _createTypeAnnotationBasedOnTypeof = require("./builders/flow/createTypeAnnotationBasedOnTypeof"); var _createFlowUnionType = require("./builders/flow/createFlowUnionType"); var _createTSUnionType = require("./builders/typescript/createTSUnionType"); var _generated2 = require("./builders/generated"); Object.keys(_generated2).forEach(function (key) { if (key === "default" || key === "__esModule") return; if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; if (key in exports && exports[key] === _generated2[key]) return; Object.defineProperty(exports, key, { enumerable: true, get: function () { return _generated2[key]; } }); }); var _uppercase = require("./builders/generated/uppercase"); Object.keys(_uppercase).forEach(function (key) { if (key === "default" || key === "__esModule") return; if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; if (key in exports && exports[key] === _uppercase[key]) return; Object.defineProperty(exports, key, { enumerable: true, get: function () { return _uppercase[key]; } }); }); var _cloneNode = require("./clone/cloneNode"); var _clone = require("./clone/clone"); var _cloneDeep = require("./clone/cloneDeep"); var _cloneDeepWithoutLoc = require("./clone/cloneDeepWithoutLoc"); var _cloneWithoutLoc = require("./clone/cloneWithoutLoc"); var _addComment = require("./comments/addComment"); var _addComments = require("./comments/addComments"); var _inheritInnerComments = require("./comments/inheritInnerComments"); var _inheritLeadingComments = require("./comments/inheritLeadingComments"); var _inheritsComments = require("./comments/inheritsComments"); var _inheritTrailingComments = require("./comments/inheritTrailingComments"); var _removeComments = require("./comments/removeComments"); var _generated3 = require("./constants/generated"); Object.keys(_generated3).forEach(function (key) { if (key === "default" || key === "__esModule") return; if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; if (key in exports && exports[key] === _generated3[key]) return; Object.defineProperty(exports, key, { enumerable: true, get: function () { return _generated3[key]; } }); }); var _constants = require("./constants"); Object.keys(_constants).forEach(function (key) { if (key === "default" || key === "__esModule") return; if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; if (key in exports && exports[key] === _constants[key]) return; Object.defineProperty(exports, key, { enumerable: true, get: function () { return _constants[key]; } }); }); var _ensureBlock = require("./converters/ensureBlock"); var _toBindingIdentifierName = require("./converters/toBindingIdentifierName"); var _toBlock = require("./converters/toBlock"); var _toComputedKey = require("./converters/toComputedKey"); var _toExpression = require("./converters/toExpression"); var _toIdentifier = require("./converters/toIdentifier"); var _toKeyAlias = require("./converters/toKeyAlias"); var _toSequenceExpression = require("./converters/toSequenceExpression"); var _toStatement = require("./converters/toStatement"); var _valueToNode = require("./converters/valueToNode"); var _definitions = require("./definitions"); Object.keys(_definitions).forEach(function (key) { if (key === "default" || key === "__esModule") return; if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; if (key in exports && exports[key] === _definitions[key]) return; Object.defineProperty(exports, key, { enumerable: true, get: function () { return _definitions[key]; } }); }); var _appendToMemberExpression = require("./modifications/appendToMemberExpression"); var _inherits = require("./modifications/inherits"); var _prependToMemberExpression = require("./modifications/prependToMemberExpression"); var _removeProperties = require("./modifications/removeProperties"); var _removePropertiesDeep = require("./modifications/removePropertiesDeep"); var _removeTypeDuplicates = require("./modifications/flow/removeTypeDuplicates"); var _getBindingIdentifiers = require("./retrievers/getBindingIdentifiers"); var _getOuterBindingIdentifiers = require("./retrievers/getOuterBindingIdentifiers"); var _traverse = require("./traverse/traverse"); Object.keys(_traverse).forEach(function (key) { if (key === "default" || key === "__esModule") return; if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; if (key in exports && exports[key] === _traverse[key]) return; Object.defineProperty(exports, key, { enumerable: true, get: function () { return _traverse[key]; } }); }); var _traverseFast = require("./traverse/traverseFast"); var _shallowEqual = require("./utils/shallowEqual"); var _is = require("./validators/is"); var _isBinding = require("./validators/isBinding"); var _isBlockScoped = require("./validators/isBlockScoped"); var _isImmutable = require("./validators/isImmutable"); var _isLet = require("./validators/isLet"); var _isNode = require("./validators/isNode"); var _isNodesEquivalent = require("./validators/isNodesEquivalent"); var _isPlaceholderType = require("./validators/isPlaceholderType"); var _isReferenced = require("./validators/isReferenced"); var _isScope = require("./validators/isScope"); var _isSpecifierDefault = require("./validators/isSpecifierDefault"); var _isType = require("./validators/isType"); var _isValidES3Identifier = require("./validators/isValidES3Identifier"); var _isValidIdentifier = require("./validators/isValidIdentifier"); var _isVar = require("./validators/isVar"); var _matchesPattern = require("./validators/matchesPattern"); var _validate = require("./validators/validate"); var _buildMatchMemberExpression = require("./validators/buildMatchMemberExpression"); var _generated4 = require("./validators/generated"); Object.keys(_generated4).forEach(function (key) { if (key === "default" || key === "__esModule") return; if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; if (key in exports && exports[key] === _generated4[key]) return; Object.defineProperty(exports, key, { enumerable: true, get: function () { return _generated4[key]; } }); }); var _generated5 = require("./ast-types/generated"); Object.keys(_generated5).forEach(function (key) { if (key === "default" || key === "__esModule") return; if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; if (key in exports && exports[key] === _generated5[key]) return; Object.defineProperty(exports, key, { enumerable: true, get: function () { return _generated5[key]; } }); }); const react = { isReactComponent: _isReactComponent.default, isCompatTag: _isCompatTag.default, buildChildren: _buildChildren.default }; exports.react = react; },{"./asserts/assertNode":315,"./asserts/generated":316,"./ast-types/generated":317,"./builders/flow/createFlowUnionType":318,"./builders/flow/createTypeAnnotationBasedOnTypeof":319,"./builders/generated":320,"./builders/generated/uppercase":321,"./builders/react/buildChildren":322,"./builders/typescript/createTSUnionType":323,"./clone/clone":325,"./clone/cloneDeep":326,"./clone/cloneDeepWithoutLoc":327,"./clone/cloneNode":328,"./clone/cloneWithoutLoc":329,"./comments/addComment":330,"./comments/addComments":331,"./comments/inheritInnerComments":332,"./comments/inheritLeadingComments":333,"./comments/inheritTrailingComments":334,"./comments/inheritsComments":335,"./comments/removeComments":336,"./constants":338,"./constants/generated":337,"./converters/ensureBlock":339,"./converters/toBindingIdentifierName":341,"./converters/toBlock":342,"./converters/toComputedKey":343,"./converters/toExpression":344,"./converters/toIdentifier":345,"./converters/toKeyAlias":346,"./converters/toSequenceExpression":347,"./converters/toStatement":348,"./converters/valueToNode":349,"./definitions":353,"./modifications/appendToMemberExpression":360,"./modifications/flow/removeTypeDuplicates":361,"./modifications/inherits":362,"./modifications/prependToMemberExpression":363,"./modifications/removeProperties":364,"./modifications/removePropertiesDeep":365,"./retrievers/getBindingIdentifiers":367,"./retrievers/getOuterBindingIdentifiers":368,"./traverse/traverse":369,"./traverse/traverseFast":370,"./utils/shallowEqual":373,"./validators/buildMatchMemberExpression":374,"./validators/generated":375,"./validators/is":376,"./validators/isBinding":377,"./validators/isBlockScoped":378,"./validators/isImmutable":379,"./validators/isLet":380,"./validators/isNode":381,"./validators/isNodesEquivalent":382,"./validators/isPlaceholderType":383,"./validators/isReferenced":384,"./validators/isScope":385,"./validators/isSpecifierDefault":386,"./validators/isType":387,"./validators/isValidES3Identifier":388,"./validators/isValidIdentifier":389,"./validators/isVar":390,"./validators/matchesPattern":391,"./validators/react/isCompatTag":392,"./validators/react/isReactComponent":393,"./validators/validate":394}],360:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = appendToMemberExpression; var _generated = require("../builders/generated"); function appendToMemberExpression(member, append, computed = false) { member.object = (0, _generated.memberExpression)(member.object, member.property, member.computed); member.property = append; member.computed = !!computed; return member; } },{"../builders/generated":320}],361:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = removeTypeDuplicates; var _generated = require("../../validators/generated"); function getQualifiedName(node) { return (0, _generated.isIdentifier)(node) ? node.name : `${node.id.name}.${getQualifiedName(node.qualification)}`; } function removeTypeDuplicates(nodes) { const generics = new Map(); const bases = new Map(); const typeGroups = new Set(); const types = []; for (let i = 0; i < nodes.length; i++) { const node = nodes[i]; if (!node) continue; if (types.indexOf(node) >= 0) { continue; } if ((0, _generated.isAnyTypeAnnotation)(node)) { return [node]; } if ((0, _generated.isFlowBaseAnnotation)(node)) { bases.set(node.type, node); continue; } if ((0, _generated.isUnionTypeAnnotation)(node)) { if (!typeGroups.has(node.types)) { nodes = nodes.concat(node.types); typeGroups.add(node.types); } continue; } if ((0, _generated.isGenericTypeAnnotation)(node)) { const name = getQualifiedName(node.id); if (generics.has(name)) { let existing = generics.get(name); if (existing.typeParameters) { if (node.typeParameters) { existing.typeParameters.params = removeTypeDuplicates(existing.typeParameters.params.concat(node.typeParameters.params)); } } else { existing = node.typeParameters; } } else { generics.set(name, node); } continue; } types.push(node); } for (const [, baseType] of bases) { types.push(baseType); } for (const [, genericName] of generics) { types.push(genericName); } return types; } },{"../../validators/generated":375}],362:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = inherits; var _constants = require("../constants"); var _inheritsComments = require("../comments/inheritsComments"); function inherits(child, parent) { if (!child || !parent) return child; for (const key of _constants.INHERIT_KEYS.optional) { if (child[key] == null) { child[key] = parent[key]; } } for (const key of Object.keys(parent)) { if (key[0] === "_" && key !== "__clone") { child[key] = parent[key]; } } for (const key of _constants.INHERIT_KEYS.force) { child[key] = parent[key]; } (0, _inheritsComments.default)(child, parent); return child; } },{"../comments/inheritsComments":335,"../constants":338}],363:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = prependToMemberExpression; var _generated = require("../builders/generated"); var _ = require(".."); function prependToMemberExpression(member, prepend) { if ((0, _.isSuper)(member.object)) { throw new Error("Cannot prepend node to super property access (`super.foo`)."); } member.object = (0, _generated.memberExpression)(prepend, member.object); return member; } },{"..":359,"../builders/generated":320}],364:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = removeProperties; var _constants = require("../constants"); const CLEAR_KEYS = ["tokens", "start", "end", "loc", "raw", "rawValue"]; const CLEAR_KEYS_PLUS_COMMENTS = [..._constants.COMMENT_KEYS, "comments", ...CLEAR_KEYS]; function removeProperties(node, opts = {}) { const map = opts.preserveComments ? CLEAR_KEYS : CLEAR_KEYS_PLUS_COMMENTS; for (const key of map) { if (node[key] != null) node[key] = undefined; } for (const key of Object.keys(node)) { if (key[0] === "_" && node[key] != null) node[key] = undefined; } const symbols = Object.getOwnPropertySymbols(node); for (const sym of symbols) { node[sym] = null; } } },{"../constants":338}],365:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = removePropertiesDeep; var _traverseFast = require("../traverse/traverseFast"); var _removeProperties = require("./removeProperties"); function removePropertiesDeep(tree, opts) { (0, _traverseFast.default)(tree, _removeProperties.default, opts); return tree; } },{"../traverse/traverseFast":370,"./removeProperties":364}],366:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = removeTypeDuplicates; var _generated = require("../../validators/generated"); function getQualifiedName(node) { return (0, _generated.isIdentifier)(node) ? node.name : `${node.right.name}.${getQualifiedName(node.left)}`; } function removeTypeDuplicates(nodes) { const generics = new Map(); const bases = new Map(); const typeGroups = new Set(); const types = []; for (let i = 0; i < nodes.length; i++) { const node = nodes[i]; if (!node) continue; if (types.indexOf(node) >= 0) { continue; } if ((0, _generated.isTSAnyKeyword)(node)) { return [node]; } if ((0, _generated.isTSBaseType)(node)) { bases.set(node.type, node); continue; } if ((0, _generated.isTSUnionType)(node)) { if (!typeGroups.has(node.types)) { nodes.push(...node.types); typeGroups.add(node.types); } continue; } if ((0, _generated.isTSTypeReference)(node) && node.typeParameters) { const name = getQualifiedName(node.typeName); if (generics.has(name)) { let existing = generics.get(name); if (existing.typeParameters) { if (node.typeParameters) { existing.typeParameters.params = removeTypeDuplicates(existing.typeParameters.params.concat(node.typeParameters.params)); } } else { existing = node.typeParameters; } } else { generics.set(name, node); } continue; } types.push(node); } for (const [, baseType] of bases) { types.push(baseType); } for (const [, genericName] of generics) { types.push(genericName); } return types; } },{"../../validators/generated":375}],367:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = getBindingIdentifiers; var _generated = require("../validators/generated"); function getBindingIdentifiers(node, duplicates, outerOnly) { const search = [].concat(node); const ids = Object.create(null); while (search.length) { const id = search.shift(); if (!id) continue; const keys = getBindingIdentifiers.keys[id.type]; if ((0, _generated.isIdentifier)(id)) { if (duplicates) { const _ids = ids[id.name] = ids[id.name] || []; _ids.push(id); } else { ids[id.name] = id; } continue; } if ((0, _generated.isExportDeclaration)(id) && !(0, _generated.isExportAllDeclaration)(id)) { if ((0, _generated.isDeclaration)(id.declaration)) { search.push(id.declaration); } continue; } if (outerOnly) { if ((0, _generated.isFunctionDeclaration)(id)) { search.push(id.id); continue; } if ((0, _generated.isFunctionExpression)(id)) { continue; } } if (keys) { for (let i = 0; i < keys.length; i++) { const key = keys[i]; const nodes = id[key]; if (nodes) { Array.isArray(nodes) ? search.push(...nodes) : search.push(nodes); } } } } return ids; } getBindingIdentifiers.keys = { DeclareClass: ["id"], DeclareFunction: ["id"], DeclareModule: ["id"], DeclareVariable: ["id"], DeclareInterface: ["id"], DeclareTypeAlias: ["id"], DeclareOpaqueType: ["id"], InterfaceDeclaration: ["id"], TypeAlias: ["id"], OpaqueType: ["id"], CatchClause: ["param"], LabeledStatement: ["label"], UnaryExpression: ["argument"], AssignmentExpression: ["left"], ImportSpecifier: ["local"], ImportNamespaceSpecifier: ["local"], ImportDefaultSpecifier: ["local"], ImportDeclaration: ["specifiers"], ExportSpecifier: ["exported"], ExportNamespaceSpecifier: ["exported"], ExportDefaultSpecifier: ["exported"], FunctionDeclaration: ["id", "params"], FunctionExpression: ["id", "params"], ArrowFunctionExpression: ["params"], ObjectMethod: ["params"], ClassMethod: ["params"], ClassPrivateMethod: ["params"], ForInStatement: ["left"], ForOfStatement: ["left"], ClassDeclaration: ["id"], ClassExpression: ["id"], RestElement: ["argument"], UpdateExpression: ["argument"], ObjectProperty: ["value"], AssignmentPattern: ["left"], ArrayPattern: ["elements"], ObjectPattern: ["properties"], VariableDeclaration: ["declarations"], VariableDeclarator: ["id"] }; },{"../validators/generated":375}],368:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = void 0; var _getBindingIdentifiers = require("./getBindingIdentifiers"); var _default = getOuterBindingIdentifiers; exports.default = _default; function getOuterBindingIdentifiers(node, duplicates) { return (0, _getBindingIdentifiers.default)(node, duplicates, true); } },{"./getBindingIdentifiers":367}],369:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = traverse; var _definitions = require("../definitions"); function traverse(node, handlers, state) { if (typeof handlers === "function") { handlers = { enter: handlers }; } const { enter, exit } = handlers; traverseSimpleImpl(node, enter, exit, state, []); } function traverseSimpleImpl(node, enter, exit, state, ancestors) { const keys = _definitions.VISITOR_KEYS[node.type]; if (!keys) return; if (enter) enter(node, ancestors, state); for (const key of keys) { const subNode = node[key]; if (Array.isArray(subNode)) { for (let i = 0; i < subNode.length; i++) { const child = subNode[i]; if (!child) continue; ancestors.push({ node, key, index: i }); traverseSimpleImpl(child, enter, exit, state, ancestors); ancestors.pop(); } } else if (subNode) { ancestors.push({ node, key }); traverseSimpleImpl(subNode, enter, exit, state, ancestors); ancestors.pop(); } } if (exit) exit(node, ancestors, state); } },{"../definitions":353}],370:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = traverseFast; var _definitions = require("../definitions"); function traverseFast(node, enter, opts) { if (!node) return; const keys = _definitions.VISITOR_KEYS[node.type]; if (!keys) return; opts = opts || {}; enter(node, opts); for (const key of keys) { const subNode = node[key]; if (Array.isArray(subNode)) { for (const node of subNode) { traverseFast(node, enter, opts); } } else { traverseFast(subNode, enter, opts); } } } },{"../definitions":353}],371:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = inherit; function inherit(key, child, parent) { if (child && parent) { child[key] = Array.from(new Set([].concat(child[key], parent[key]).filter(Boolean))); } } },{}],372:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = cleanJSXElementLiteralChild; var _generated = require("../../builders/generated"); function cleanJSXElementLiteralChild(child, args) { const lines = child.value.split(/\r\n|\n|\r/); let lastNonEmptyLine = 0; for (let i = 0; i < lines.length; i++) { if (lines[i].match(/[^ \t]/)) { lastNonEmptyLine = i; } } let str = ""; for (let i = 0; i < lines.length; i++) { const line = lines[i]; const isFirstLine = i === 0; const isLastLine = i === lines.length - 1; const isLastNonEmptyLine = i === lastNonEmptyLine; let trimmedLine = line.replace(/\t/g, " "); if (!isFirstLine) { trimmedLine = trimmedLine.replace(/^[ ]+/, ""); } if (!isLastLine) { trimmedLine = trimmedLine.replace(/[ ]+$/, ""); } if (trimmedLine) { if (!isLastNonEmptyLine) { trimmedLine += " "; } str += trimmedLine; } } if (str) args.push((0, _generated.stringLiteral)(str)); } },{"../../builders/generated":320}],373:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = shallowEqual; function shallowEqual(actual, expected) { const keys = Object.keys(expected); for (const key of keys) { if (actual[key] !== expected[key]) { return false; } } return true; } },{}],374:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = buildMatchMemberExpression; var _matchesPattern = require("./matchesPattern"); function buildMatchMemberExpression(match, allowPartial) { const parts = match.split("."); return member => (0, _matchesPattern.default)(member, parts, allowPartial); } },{"./matchesPattern":391}],375:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.isAccessor = isAccessor; exports.isAnyTypeAnnotation = isAnyTypeAnnotation; exports.isArgumentPlaceholder = isArgumentPlaceholder; exports.isArrayExpression = isArrayExpression; exports.isArrayPattern = isArrayPattern; exports.isArrayTypeAnnotation = isArrayTypeAnnotation; exports.isArrowFunctionExpression = isArrowFunctionExpression; exports.isAssignmentExpression = isAssignmentExpression; exports.isAssignmentPattern = isAssignmentPattern; exports.isAwaitExpression = isAwaitExpression; exports.isBigIntLiteral = isBigIntLiteral; exports.isBinary = isBinary; exports.isBinaryExpression = isBinaryExpression; exports.isBindExpression = isBindExpression; exports.isBlock = isBlock; exports.isBlockParent = isBlockParent; exports.isBlockStatement = isBlockStatement; exports.isBooleanLiteral = isBooleanLiteral; exports.isBooleanLiteralTypeAnnotation = isBooleanLiteralTypeAnnotation; exports.isBooleanTypeAnnotation = isBooleanTypeAnnotation; exports.isBreakStatement = isBreakStatement; exports.isCallExpression = isCallExpression; exports.isCatchClause = isCatchClause; exports.isClass = isClass; exports.isClassAccessorProperty = isClassAccessorProperty; exports.isClassBody = isClassBody; exports.isClassDeclaration = isClassDeclaration; exports.isClassExpression = isClassExpression; exports.isClassImplements = isClassImplements; exports.isClassMethod = isClassMethod; exports.isClassPrivateMethod = isClassPrivateMethod; exports.isClassPrivateProperty = isClassPrivateProperty; exports.isClassProperty = isClassProperty; exports.isCompletionStatement = isCompletionStatement; exports.isConditional = isConditional; exports.isConditionalExpression = isConditionalExpression; exports.isContinueStatement = isContinueStatement; exports.isDebuggerStatement = isDebuggerStatement; exports.isDecimalLiteral = isDecimalLiteral; exports.isDeclaration = isDeclaration; exports.isDeclareClass = isDeclareClass; exports.isDeclareExportAllDeclaration = isDeclareExportAllDeclaration; exports.isDeclareExportDeclaration = isDeclareExportDeclaration; exports.isDeclareFunction = isDeclareFunction; exports.isDeclareInterface = isDeclareInterface; exports.isDeclareModule = isDeclareModule; exports.isDeclareModuleExports = isDeclareModuleExports; exports.isDeclareOpaqueType = isDeclareOpaqueType; exports.isDeclareTypeAlias = isDeclareTypeAlias; exports.isDeclareVariable = isDeclareVariable; exports.isDeclaredPredicate = isDeclaredPredicate; exports.isDecorator = isDecorator; exports.isDirective = isDirective; exports.isDirectiveLiteral = isDirectiveLiteral; exports.isDoExpression = isDoExpression; exports.isDoWhileStatement = isDoWhileStatement; exports.isEmptyStatement = isEmptyStatement; exports.isEmptyTypeAnnotation = isEmptyTypeAnnotation; exports.isEnumBody = isEnumBody; exports.isEnumBooleanBody = isEnumBooleanBody; exports.isEnumBooleanMember = isEnumBooleanMember; exports.isEnumDeclaration = isEnumDeclaration; exports.isEnumDefaultedMember = isEnumDefaultedMember; exports.isEnumMember = isEnumMember; exports.isEnumNumberBody = isEnumNumberBody; exports.isEnumNumberMember = isEnumNumberMember; exports.isEnumStringBody = isEnumStringBody; exports.isEnumStringMember = isEnumStringMember; exports.isEnumSymbolBody = isEnumSymbolBody; exports.isExistsTypeAnnotation = isExistsTypeAnnotation; exports.isExportAllDeclaration = isExportAllDeclaration; exports.isExportDeclaration = isExportDeclaration; exports.isExportDefaultDeclaration = isExportDefaultDeclaration; exports.isExportDefaultSpecifier = isExportDefaultSpecifier; exports.isExportNamedDeclaration = isExportNamedDeclaration; exports.isExportNamespaceSpecifier = isExportNamespaceSpecifier; exports.isExportSpecifier = isExportSpecifier; exports.isExpression = isExpression; exports.isExpressionStatement = isExpressionStatement; exports.isExpressionWrapper = isExpressionWrapper; exports.isFile = isFile; exports.isFlow = isFlow; exports.isFlowBaseAnnotation = isFlowBaseAnnotation; exports.isFlowDeclaration = isFlowDeclaration; exports.isFlowPredicate = isFlowPredicate; exports.isFlowType = isFlowType; exports.isFor = isFor; exports.isForInStatement = isForInStatement; exports.isForOfStatement = isForOfStatement; exports.isForStatement = isForStatement; exports.isForXStatement = isForXStatement; exports.isFunction = isFunction; exports.isFunctionDeclaration = isFunctionDeclaration; exports.isFunctionExpression = isFunctionExpression; exports.isFunctionParent = isFunctionParent; exports.isFunctionTypeAnnotation = isFunctionTypeAnnotation; exports.isFunctionTypeParam = isFunctionTypeParam; exports.isGenericTypeAnnotation = isGenericTypeAnnotation; exports.isIdentifier = isIdentifier; exports.isIfStatement = isIfStatement; exports.isImmutable = isImmutable; exports.isImport = isImport; exports.isImportAttribute = isImportAttribute; exports.isImportDeclaration = isImportDeclaration; exports.isImportDefaultSpecifier = isImportDefaultSpecifier; exports.isImportNamespaceSpecifier = isImportNamespaceSpecifier; exports.isImportSpecifier = isImportSpecifier; exports.isIndexedAccessType = isIndexedAccessType; exports.isInferredPredicate = isInferredPredicate; exports.isInterfaceDeclaration = isInterfaceDeclaration; exports.isInterfaceExtends = isInterfaceExtends; exports.isInterfaceTypeAnnotation = isInterfaceTypeAnnotation; exports.isInterpreterDirective = isInterpreterDirective; exports.isIntersectionTypeAnnotation = isIntersectionTypeAnnotation; exports.isJSX = isJSX; exports.isJSXAttribute = isJSXAttribute; exports.isJSXClosingElement = isJSXClosingElement; exports.isJSXClosingFragment = isJSXClosingFragment; exports.isJSXElement = isJSXElement; exports.isJSXEmptyExpression = isJSXEmptyExpression; exports.isJSXExpressionContainer = isJSXExpressionContainer; exports.isJSXFragment = isJSXFragment; exports.isJSXIdentifier = isJSXIdentifier; exports.isJSXMemberExpression = isJSXMemberExpression; exports.isJSXNamespacedName = isJSXNamespacedName; exports.isJSXOpeningElement = isJSXOpeningElement; exports.isJSXOpeningFragment = isJSXOpeningFragment; exports.isJSXSpreadAttribute = isJSXSpreadAttribute; exports.isJSXSpreadChild = isJSXSpreadChild; exports.isJSXText = isJSXText; exports.isLVal = isLVal; exports.isLabeledStatement = isLabeledStatement; exports.isLiteral = isLiteral; exports.isLogicalExpression = isLogicalExpression; exports.isLoop = isLoop; exports.isMemberExpression = isMemberExpression; exports.isMetaProperty = isMetaProperty; exports.isMethod = isMethod; exports.isMiscellaneous = isMiscellaneous; exports.isMixedTypeAnnotation = isMixedTypeAnnotation; exports.isModuleDeclaration = isModuleDeclaration; exports.isModuleExpression = isModuleExpression; exports.isModuleSpecifier = isModuleSpecifier; exports.isNewExpression = isNewExpression; exports.isNoop = isNoop; exports.isNullLiteral = isNullLiteral; exports.isNullLiteralTypeAnnotation = isNullLiteralTypeAnnotation; exports.isNullableTypeAnnotation = isNullableTypeAnnotation; exports.isNumberLiteral = isNumberLiteral; exports.isNumberLiteralTypeAnnotation = isNumberLiteralTypeAnnotation; exports.isNumberTypeAnnotation = isNumberTypeAnnotation; exports.isNumericLiteral = isNumericLiteral; exports.isObjectExpression = isObjectExpression; exports.isObjectMember = isObjectMember; exports.isObjectMethod = isObjectMethod; exports.isObjectPattern = isObjectPattern; exports.isObjectProperty = isObjectProperty; exports.isObjectTypeAnnotation = isObjectTypeAnnotation; exports.isObjectTypeCallProperty = isObjectTypeCallProperty; exports.isObjectTypeIndexer = isObjectTypeIndexer; exports.isObjectTypeInternalSlot = isObjectTypeInternalSlot; exports.isObjectTypeProperty = isObjectTypeProperty; exports.isObjectTypeSpreadProperty = isObjectTypeSpreadProperty; exports.isOpaqueType = isOpaqueType; exports.isOptionalCallExpression = isOptionalCallExpression; exports.isOptionalIndexedAccessType = isOptionalIndexedAccessType; exports.isOptionalMemberExpression = isOptionalMemberExpression; exports.isParenthesizedExpression = isParenthesizedExpression; exports.isPattern = isPattern; exports.isPatternLike = isPatternLike; exports.isPipelineBareFunction = isPipelineBareFunction; exports.isPipelinePrimaryTopicReference = isPipelinePrimaryTopicReference; exports.isPipelineTopicExpression = isPipelineTopicExpression; exports.isPlaceholder = isPlaceholder; exports.isPrivate = isPrivate; exports.isPrivateName = isPrivateName; exports.isProgram = isProgram; exports.isProperty = isProperty; exports.isPureish = isPureish; exports.isQualifiedTypeIdentifier = isQualifiedTypeIdentifier; exports.isRecordExpression = isRecordExpression; exports.isRegExpLiteral = isRegExpLiteral; exports.isRegexLiteral = isRegexLiteral; exports.isRestElement = isRestElement; exports.isRestProperty = isRestProperty; exports.isReturnStatement = isReturnStatement; exports.isScopable = isScopable; exports.isSequenceExpression = isSequenceExpression; exports.isSpreadElement = isSpreadElement; exports.isSpreadProperty = isSpreadProperty; exports.isStandardized = isStandardized; exports.isStatement = isStatement; exports.isStaticBlock = isStaticBlock; exports.isStringLiteral = isStringLiteral; exports.isStringLiteralTypeAnnotation = isStringLiteralTypeAnnotation; exports.isStringTypeAnnotation = isStringTypeAnnotation; exports.isSuper = isSuper; exports.isSwitchCase = isSwitchCase; exports.isSwitchStatement = isSwitchStatement; exports.isSymbolTypeAnnotation = isSymbolTypeAnnotation; exports.isTSAnyKeyword = isTSAnyKeyword; exports.isTSArrayType = isTSArrayType; exports.isTSAsExpression = isTSAsExpression; exports.isTSBaseType = isTSBaseType; exports.isTSBigIntKeyword = isTSBigIntKeyword; exports.isTSBooleanKeyword = isTSBooleanKeyword; exports.isTSCallSignatureDeclaration = isTSCallSignatureDeclaration; exports.isTSConditionalType = isTSConditionalType; exports.isTSConstructSignatureDeclaration = isTSConstructSignatureDeclaration; exports.isTSConstructorType = isTSConstructorType; exports.isTSDeclareFunction = isTSDeclareFunction; exports.isTSDeclareMethod = isTSDeclareMethod; exports.isTSEntityName = isTSEntityName; exports.isTSEnumDeclaration = isTSEnumDeclaration; exports.isTSEnumMember = isTSEnumMember; exports.isTSExportAssignment = isTSExportAssignment; exports.isTSExpressionWithTypeArguments = isTSExpressionWithTypeArguments; exports.isTSExternalModuleReference = isTSExternalModuleReference; exports.isTSFunctionType = isTSFunctionType; exports.isTSImportEqualsDeclaration = isTSImportEqualsDeclaration; exports.isTSImportType = isTSImportType; exports.isTSIndexSignature = isTSIndexSignature; exports.isTSIndexedAccessType = isTSIndexedAccessType; exports.isTSInferType = isTSInferType; exports.isTSInstantiationExpression = isTSInstantiationExpression; exports.isTSInterfaceBody = isTSInterfaceBody; exports.isTSInterfaceDeclaration = isTSInterfaceDeclaration; exports.isTSIntersectionType = isTSIntersectionType; exports.isTSIntrinsicKeyword = isTSIntrinsicKeyword; exports.isTSLiteralType = isTSLiteralType; exports.isTSMappedType = isTSMappedType; exports.isTSMethodSignature = isTSMethodSignature; exports.isTSModuleBlock = isTSModuleBlock; exports.isTSModuleDeclaration = isTSModuleDeclaration; exports.isTSNamedTupleMember = isTSNamedTupleMember; exports.isTSNamespaceExportDeclaration = isTSNamespaceExportDeclaration; exports.isTSNeverKeyword = isTSNeverKeyword; exports.isTSNonNullExpression = isTSNonNullExpression; exports.isTSNullKeyword = isTSNullKeyword; exports.isTSNumberKeyword = isTSNumberKeyword; exports.isTSObjectKeyword = isTSObjectKeyword; exports.isTSOptionalType = isTSOptionalType; exports.isTSParameterProperty = isTSParameterProperty; exports.isTSParenthesizedType = isTSParenthesizedType; exports.isTSPropertySignature = isTSPropertySignature; exports.isTSQualifiedName = isTSQualifiedName; exports.isTSRestType = isTSRestType; exports.isTSStringKeyword = isTSStringKeyword; exports.isTSSymbolKeyword = isTSSymbolKeyword; exports.isTSThisType = isTSThisType; exports.isTSTupleType = isTSTupleType; exports.isTSType = isTSType; exports.isTSTypeAliasDeclaration = isTSTypeAliasDeclaration; exports.isTSTypeAnnotation = isTSTypeAnnotation; exports.isTSTypeAssertion = isTSTypeAssertion; exports.isTSTypeElement = isTSTypeElement; exports.isTSTypeLiteral = isTSTypeLiteral; exports.isTSTypeOperator = isTSTypeOperator; exports.isTSTypeParameter = isTSTypeParameter; exports.isTSTypeParameterDeclaration = isTSTypeParameterDeclaration; exports.isTSTypeParameterInstantiation = isTSTypeParameterInstantiation; exports.isTSTypePredicate = isTSTypePredicate; exports.isTSTypeQuery = isTSTypeQuery; exports.isTSTypeReference = isTSTypeReference; exports.isTSUndefinedKeyword = isTSUndefinedKeyword; exports.isTSUnionType = isTSUnionType; exports.isTSUnknownKeyword = isTSUnknownKeyword; exports.isTSVoidKeyword = isTSVoidKeyword; exports.isTaggedTemplateExpression = isTaggedTemplateExpression; exports.isTemplateElement = isTemplateElement; exports.isTemplateLiteral = isTemplateLiteral; exports.isTerminatorless = isTerminatorless; exports.isThisExpression = isThisExpression; exports.isThisTypeAnnotation = isThisTypeAnnotation; exports.isThrowStatement = isThrowStatement; exports.isTopicReference = isTopicReference; exports.isTryStatement = isTryStatement; exports.isTupleExpression = isTupleExpression; exports.isTupleTypeAnnotation = isTupleTypeAnnotation; exports.isTypeAlias = isTypeAlias; exports.isTypeAnnotation = isTypeAnnotation; exports.isTypeCastExpression = isTypeCastExpression; exports.isTypeParameter = isTypeParameter; exports.isTypeParameterDeclaration = isTypeParameterDeclaration; exports.isTypeParameterInstantiation = isTypeParameterInstantiation; exports.isTypeScript = isTypeScript; exports.isTypeofTypeAnnotation = isTypeofTypeAnnotation; exports.isUnaryExpression = isUnaryExpression; exports.isUnaryLike = isUnaryLike; exports.isUnionTypeAnnotation = isUnionTypeAnnotation; exports.isUpdateExpression = isUpdateExpression; exports.isUserWhitespacable = isUserWhitespacable; exports.isV8IntrinsicIdentifier = isV8IntrinsicIdentifier; exports.isVariableDeclaration = isVariableDeclaration; exports.isVariableDeclarator = isVariableDeclarator; exports.isVariance = isVariance; exports.isVoidTypeAnnotation = isVoidTypeAnnotation; exports.isWhile = isWhile; exports.isWhileStatement = isWhileStatement; exports.isWithStatement = isWithStatement; exports.isYieldExpression = isYieldExpression; var _shallowEqual = require("../../utils/shallowEqual"); function isArrayExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ArrayExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isAssignmentExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "AssignmentExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isBinaryExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "BinaryExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isInterpreterDirective(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "InterpreterDirective") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isDirective(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "Directive") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isDirectiveLiteral(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "DirectiveLiteral") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isBlockStatement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "BlockStatement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isBreakStatement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "BreakStatement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isCallExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "CallExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isCatchClause(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "CatchClause") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isConditionalExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ConditionalExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isContinueStatement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ContinueStatement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isDebuggerStatement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "DebuggerStatement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isDoWhileStatement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "DoWhileStatement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isEmptyStatement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "EmptyStatement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isExpressionStatement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ExpressionStatement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isFile(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "File") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isForInStatement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ForInStatement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isForStatement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ForStatement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isFunctionDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "FunctionDeclaration") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isFunctionExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "FunctionExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isIdentifier(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "Identifier") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isIfStatement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "IfStatement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isLabeledStatement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "LabeledStatement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isStringLiteral(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "StringLiteral") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isNumericLiteral(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "NumericLiteral") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isNullLiteral(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "NullLiteral") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isBooleanLiteral(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "BooleanLiteral") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isRegExpLiteral(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "RegExpLiteral") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isLogicalExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "LogicalExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isMemberExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "MemberExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isNewExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "NewExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isProgram(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "Program") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isObjectExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ObjectExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isObjectMethod(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ObjectMethod") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isObjectProperty(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ObjectProperty") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isRestElement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "RestElement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isReturnStatement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ReturnStatement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isSequenceExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "SequenceExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isParenthesizedExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ParenthesizedExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isSwitchCase(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "SwitchCase") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isSwitchStatement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "SwitchStatement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isThisExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ThisExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isThrowStatement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ThrowStatement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTryStatement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TryStatement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isUnaryExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "UnaryExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isUpdateExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "UpdateExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isVariableDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "VariableDeclaration") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isVariableDeclarator(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "VariableDeclarator") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isWhileStatement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "WhileStatement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isWithStatement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "WithStatement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isAssignmentPattern(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "AssignmentPattern") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isArrayPattern(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ArrayPattern") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isArrowFunctionExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ArrowFunctionExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isClassBody(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ClassBody") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isClassExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ClassExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isClassDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ClassDeclaration") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isExportAllDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ExportAllDeclaration") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isExportDefaultDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ExportDefaultDeclaration") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isExportNamedDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ExportNamedDeclaration") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isExportSpecifier(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ExportSpecifier") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isForOfStatement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ForOfStatement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isImportDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ImportDeclaration") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isImportDefaultSpecifier(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ImportDefaultSpecifier") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isImportNamespaceSpecifier(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ImportNamespaceSpecifier") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isImportSpecifier(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ImportSpecifier") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isMetaProperty(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "MetaProperty") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isClassMethod(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ClassMethod") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isObjectPattern(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ObjectPattern") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isSpreadElement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "SpreadElement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isSuper(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "Super") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTaggedTemplateExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TaggedTemplateExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTemplateElement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TemplateElement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTemplateLiteral(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TemplateLiteral") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isYieldExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "YieldExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isAwaitExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "AwaitExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isImport(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "Import") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isBigIntLiteral(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "BigIntLiteral") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isExportNamespaceSpecifier(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ExportNamespaceSpecifier") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isOptionalMemberExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "OptionalMemberExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isOptionalCallExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "OptionalCallExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isClassProperty(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ClassProperty") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isClassAccessorProperty(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ClassAccessorProperty") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isClassPrivateProperty(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ClassPrivateProperty") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isClassPrivateMethod(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ClassPrivateMethod") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isPrivateName(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "PrivateName") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isStaticBlock(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "StaticBlock") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isAnyTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "AnyTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isArrayTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ArrayTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isBooleanTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "BooleanTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isBooleanLiteralTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "BooleanLiteralTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isNullLiteralTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "NullLiteralTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isClassImplements(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ClassImplements") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isDeclareClass(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "DeclareClass") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isDeclareFunction(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "DeclareFunction") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isDeclareInterface(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "DeclareInterface") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isDeclareModule(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "DeclareModule") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isDeclareModuleExports(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "DeclareModuleExports") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isDeclareTypeAlias(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "DeclareTypeAlias") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isDeclareOpaqueType(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "DeclareOpaqueType") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isDeclareVariable(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "DeclareVariable") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isDeclareExportDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "DeclareExportDeclaration") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isDeclareExportAllDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "DeclareExportAllDeclaration") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isDeclaredPredicate(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "DeclaredPredicate") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isExistsTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ExistsTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isFunctionTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "FunctionTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isFunctionTypeParam(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "FunctionTypeParam") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isGenericTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "GenericTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isInferredPredicate(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "InferredPredicate") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isInterfaceExtends(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "InterfaceExtends") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isInterfaceDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "InterfaceDeclaration") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isInterfaceTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "InterfaceTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isIntersectionTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "IntersectionTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isMixedTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "MixedTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isEmptyTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "EmptyTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isNullableTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "NullableTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isNumberLiteralTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "NumberLiteralTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isNumberTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "NumberTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isObjectTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ObjectTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isObjectTypeInternalSlot(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ObjectTypeInternalSlot") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isObjectTypeCallProperty(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ObjectTypeCallProperty") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isObjectTypeIndexer(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ObjectTypeIndexer") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isObjectTypeProperty(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ObjectTypeProperty") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isObjectTypeSpreadProperty(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ObjectTypeSpreadProperty") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isOpaqueType(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "OpaqueType") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isQualifiedTypeIdentifier(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "QualifiedTypeIdentifier") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isStringLiteralTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "StringLiteralTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isStringTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "StringTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isSymbolTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "SymbolTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isThisTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ThisTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTupleTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TupleTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTypeofTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TypeofTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTypeAlias(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TypeAlias") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTypeCastExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TypeCastExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTypeParameter(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TypeParameter") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTypeParameterDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TypeParameterDeclaration") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTypeParameterInstantiation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TypeParameterInstantiation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isUnionTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "UnionTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isVariance(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "Variance") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isVoidTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "VoidTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isEnumDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "EnumDeclaration") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isEnumBooleanBody(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "EnumBooleanBody") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isEnumNumberBody(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "EnumNumberBody") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isEnumStringBody(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "EnumStringBody") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isEnumSymbolBody(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "EnumSymbolBody") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isEnumBooleanMember(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "EnumBooleanMember") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isEnumNumberMember(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "EnumNumberMember") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isEnumStringMember(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "EnumStringMember") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isEnumDefaultedMember(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "EnumDefaultedMember") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isIndexedAccessType(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "IndexedAccessType") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isOptionalIndexedAccessType(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "OptionalIndexedAccessType") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isJSXAttribute(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "JSXAttribute") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isJSXClosingElement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "JSXClosingElement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isJSXElement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "JSXElement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isJSXEmptyExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "JSXEmptyExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isJSXExpressionContainer(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "JSXExpressionContainer") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isJSXSpreadChild(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "JSXSpreadChild") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isJSXIdentifier(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "JSXIdentifier") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isJSXMemberExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "JSXMemberExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isJSXNamespacedName(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "JSXNamespacedName") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isJSXOpeningElement(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "JSXOpeningElement") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isJSXSpreadAttribute(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "JSXSpreadAttribute") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isJSXText(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "JSXText") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isJSXFragment(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "JSXFragment") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isJSXOpeningFragment(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "JSXOpeningFragment") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isJSXClosingFragment(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "JSXClosingFragment") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isNoop(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "Noop") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isPlaceholder(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "Placeholder") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isV8IntrinsicIdentifier(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "V8IntrinsicIdentifier") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isArgumentPlaceholder(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ArgumentPlaceholder") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isBindExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "BindExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isImportAttribute(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ImportAttribute") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isDecorator(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "Decorator") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isDoExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "DoExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isExportDefaultSpecifier(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ExportDefaultSpecifier") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isRecordExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "RecordExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTupleExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TupleExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isDecimalLiteral(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "DecimalLiteral") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isModuleExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "ModuleExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTopicReference(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TopicReference") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isPipelineTopicExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "PipelineTopicExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isPipelineBareFunction(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "PipelineBareFunction") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isPipelinePrimaryTopicReference(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "PipelinePrimaryTopicReference") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSParameterProperty(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSParameterProperty") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSDeclareFunction(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSDeclareFunction") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSDeclareMethod(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSDeclareMethod") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSQualifiedName(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSQualifiedName") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSCallSignatureDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSCallSignatureDeclaration") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSConstructSignatureDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSConstructSignatureDeclaration") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSPropertySignature(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSPropertySignature") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSMethodSignature(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSMethodSignature") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSIndexSignature(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSIndexSignature") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSAnyKeyword(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSAnyKeyword") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSBooleanKeyword(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSBooleanKeyword") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSBigIntKeyword(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSBigIntKeyword") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSIntrinsicKeyword(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSIntrinsicKeyword") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSNeverKeyword(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSNeverKeyword") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSNullKeyword(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSNullKeyword") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSNumberKeyword(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSNumberKeyword") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSObjectKeyword(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSObjectKeyword") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSStringKeyword(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSStringKeyword") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSSymbolKeyword(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSSymbolKeyword") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSUndefinedKeyword(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSUndefinedKeyword") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSUnknownKeyword(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSUnknownKeyword") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSVoidKeyword(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSVoidKeyword") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSThisType(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSThisType") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSFunctionType(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSFunctionType") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSConstructorType(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSConstructorType") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSTypeReference(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSTypeReference") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSTypePredicate(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSTypePredicate") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSTypeQuery(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSTypeQuery") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSTypeLiteral(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSTypeLiteral") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSArrayType(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSArrayType") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSTupleType(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSTupleType") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSOptionalType(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSOptionalType") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSRestType(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSRestType") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSNamedTupleMember(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSNamedTupleMember") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSUnionType(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSUnionType") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSIntersectionType(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSIntersectionType") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSConditionalType(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSConditionalType") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSInferType(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSInferType") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSParenthesizedType(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSParenthesizedType") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSTypeOperator(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSTypeOperator") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSIndexedAccessType(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSIndexedAccessType") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSMappedType(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSMappedType") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSLiteralType(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSLiteralType") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSExpressionWithTypeArguments(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSExpressionWithTypeArguments") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSInterfaceDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSInterfaceDeclaration") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSInterfaceBody(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSInterfaceBody") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSTypeAliasDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSTypeAliasDeclaration") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSInstantiationExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSInstantiationExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSAsExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSAsExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSTypeAssertion(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSTypeAssertion") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSEnumDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSEnumDeclaration") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSEnumMember(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSEnumMember") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSModuleDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSModuleDeclaration") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSModuleBlock(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSModuleBlock") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSImportType(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSImportType") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSImportEqualsDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSImportEqualsDeclaration") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSExternalModuleReference(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSExternalModuleReference") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSNonNullExpression(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSNonNullExpression") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSExportAssignment(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSExportAssignment") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSNamespaceExportDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSNamespaceExportDeclaration") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSTypeAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSTypeAnnotation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSTypeParameterInstantiation(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSTypeParameterInstantiation") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSTypeParameterDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSTypeParameterDeclaration") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSTypeParameter(node, opts) { if (!node) return false; const nodeType = node.type; if (nodeType === "TSTypeParameter") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isStandardized(node, opts) { if (!node) return false; const nodeType = node.type; if ("ArrayExpression" === nodeType || "AssignmentExpression" === nodeType || "BinaryExpression" === nodeType || "InterpreterDirective" === nodeType || "Directive" === nodeType || "DirectiveLiteral" === nodeType || "BlockStatement" === nodeType || "BreakStatement" === nodeType || "CallExpression" === nodeType || "CatchClause" === nodeType || "ConditionalExpression" === nodeType || "ContinueStatement" === nodeType || "DebuggerStatement" === nodeType || "DoWhileStatement" === nodeType || "EmptyStatement" === nodeType || "ExpressionStatement" === nodeType || "File" === nodeType || "ForInStatement" === nodeType || "ForStatement" === nodeType || "FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "Identifier" === nodeType || "IfStatement" === nodeType || "LabeledStatement" === nodeType || "StringLiteral" === nodeType || "NumericLiteral" === nodeType || "NullLiteral" === nodeType || "BooleanLiteral" === nodeType || "RegExpLiteral" === nodeType || "LogicalExpression" === nodeType || "MemberExpression" === nodeType || "NewExpression" === nodeType || "Program" === nodeType || "ObjectExpression" === nodeType || "ObjectMethod" === nodeType || "ObjectProperty" === nodeType || "RestElement" === nodeType || "ReturnStatement" === nodeType || "SequenceExpression" === nodeType || "ParenthesizedExpression" === nodeType || "SwitchCase" === nodeType || "SwitchStatement" === nodeType || "ThisExpression" === nodeType || "ThrowStatement" === nodeType || "TryStatement" === nodeType || "UnaryExpression" === nodeType || "UpdateExpression" === nodeType || "VariableDeclaration" === nodeType || "VariableDeclarator" === nodeType || "WhileStatement" === nodeType || "WithStatement" === nodeType || "AssignmentPattern" === nodeType || "ArrayPattern" === nodeType || "ArrowFunctionExpression" === nodeType || "ClassBody" === nodeType || "ClassExpression" === nodeType || "ClassDeclaration" === nodeType || "ExportAllDeclaration" === nodeType || "ExportDefaultDeclaration" === nodeType || "ExportNamedDeclaration" === nodeType || "ExportSpecifier" === nodeType || "ForOfStatement" === nodeType || "ImportDeclaration" === nodeType || "ImportDefaultSpecifier" === nodeType || "ImportNamespaceSpecifier" === nodeType || "ImportSpecifier" === nodeType || "MetaProperty" === nodeType || "ClassMethod" === nodeType || "ObjectPattern" === nodeType || "SpreadElement" === nodeType || "Super" === nodeType || "TaggedTemplateExpression" === nodeType || "TemplateElement" === nodeType || "TemplateLiteral" === nodeType || "YieldExpression" === nodeType || "AwaitExpression" === nodeType || "Import" === nodeType || "BigIntLiteral" === nodeType || "ExportNamespaceSpecifier" === nodeType || "OptionalMemberExpression" === nodeType || "OptionalCallExpression" === nodeType || "ClassProperty" === nodeType || "ClassAccessorProperty" === nodeType || "ClassPrivateProperty" === nodeType || "ClassPrivateMethod" === nodeType || "PrivateName" === nodeType || "StaticBlock" === nodeType || nodeType === "Placeholder" && ("Identifier" === node.expectedNode || "StringLiteral" === node.expectedNode || "BlockStatement" === node.expectedNode || "ClassBody" === node.expectedNode)) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isExpression(node, opts) { if (!node) return false; const nodeType = node.type; if ("ArrayExpression" === nodeType || "AssignmentExpression" === nodeType || "BinaryExpression" === nodeType || "CallExpression" === nodeType || "ConditionalExpression" === nodeType || "FunctionExpression" === nodeType || "Identifier" === nodeType || "StringLiteral" === nodeType || "NumericLiteral" === nodeType || "NullLiteral" === nodeType || "BooleanLiteral" === nodeType || "RegExpLiteral" === nodeType || "LogicalExpression" === nodeType || "MemberExpression" === nodeType || "NewExpression" === nodeType || "ObjectExpression" === nodeType || "SequenceExpression" === nodeType || "ParenthesizedExpression" === nodeType || "ThisExpression" === nodeType || "UnaryExpression" === nodeType || "UpdateExpression" === nodeType || "ArrowFunctionExpression" === nodeType || "ClassExpression" === nodeType || "MetaProperty" === nodeType || "Super" === nodeType || "TaggedTemplateExpression" === nodeType || "TemplateLiteral" === nodeType || "YieldExpression" === nodeType || "AwaitExpression" === nodeType || "Import" === nodeType || "BigIntLiteral" === nodeType || "OptionalMemberExpression" === nodeType || "OptionalCallExpression" === nodeType || "TypeCastExpression" === nodeType || "JSXElement" === nodeType || "JSXFragment" === nodeType || "BindExpression" === nodeType || "DoExpression" === nodeType || "RecordExpression" === nodeType || "TupleExpression" === nodeType || "DecimalLiteral" === nodeType || "ModuleExpression" === nodeType || "TopicReference" === nodeType || "PipelineTopicExpression" === nodeType || "PipelineBareFunction" === nodeType || "PipelinePrimaryTopicReference" === nodeType || "TSInstantiationExpression" === nodeType || "TSAsExpression" === nodeType || "TSTypeAssertion" === nodeType || "TSNonNullExpression" === nodeType || nodeType === "Placeholder" && ("Expression" === node.expectedNode || "Identifier" === node.expectedNode || "StringLiteral" === node.expectedNode)) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isBinary(node, opts) { if (!node) return false; const nodeType = node.type; if ("BinaryExpression" === nodeType || "LogicalExpression" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isScopable(node, opts) { if (!node) return false; const nodeType = node.type; if ("BlockStatement" === nodeType || "CatchClause" === nodeType || "DoWhileStatement" === nodeType || "ForInStatement" === nodeType || "ForStatement" === nodeType || "FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "Program" === nodeType || "ObjectMethod" === nodeType || "SwitchStatement" === nodeType || "WhileStatement" === nodeType || "ArrowFunctionExpression" === nodeType || "ClassExpression" === nodeType || "ClassDeclaration" === nodeType || "ForOfStatement" === nodeType || "ClassMethod" === nodeType || "ClassPrivateMethod" === nodeType || "StaticBlock" === nodeType || "TSModuleBlock" === nodeType || nodeType === "Placeholder" && "BlockStatement" === node.expectedNode) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isBlockParent(node, opts) { if (!node) return false; const nodeType = node.type; if ("BlockStatement" === nodeType || "CatchClause" === nodeType || "DoWhileStatement" === nodeType || "ForInStatement" === nodeType || "ForStatement" === nodeType || "FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "Program" === nodeType || "ObjectMethod" === nodeType || "SwitchStatement" === nodeType || "WhileStatement" === nodeType || "ArrowFunctionExpression" === nodeType || "ForOfStatement" === nodeType || "ClassMethod" === nodeType || "ClassPrivateMethod" === nodeType || "StaticBlock" === nodeType || "TSModuleBlock" === nodeType || nodeType === "Placeholder" && "BlockStatement" === node.expectedNode) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isBlock(node, opts) { if (!node) return false; const nodeType = node.type; if ("BlockStatement" === nodeType || "Program" === nodeType || "TSModuleBlock" === nodeType || nodeType === "Placeholder" && "BlockStatement" === node.expectedNode) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isStatement(node, opts) { if (!node) return false; const nodeType = node.type; if ("BlockStatement" === nodeType || "BreakStatement" === nodeType || "ContinueStatement" === nodeType || "DebuggerStatement" === nodeType || "DoWhileStatement" === nodeType || "EmptyStatement" === nodeType || "ExpressionStatement" === nodeType || "ForInStatement" === nodeType || "ForStatement" === nodeType || "FunctionDeclaration" === nodeType || "IfStatement" === nodeType || "LabeledStatement" === nodeType || "ReturnStatement" === nodeType || "SwitchStatement" === nodeType || "ThrowStatement" === nodeType || "TryStatement" === nodeType || "VariableDeclaration" === nodeType || "WhileStatement" === nodeType || "WithStatement" === nodeType || "ClassDeclaration" === nodeType || "ExportAllDeclaration" === nodeType || "ExportDefaultDeclaration" === nodeType || "ExportNamedDeclaration" === nodeType || "ForOfStatement" === nodeType || "ImportDeclaration" === nodeType || "DeclareClass" === nodeType || "DeclareFunction" === nodeType || "DeclareInterface" === nodeType || "DeclareModule" === nodeType || "DeclareModuleExports" === nodeType || "DeclareTypeAlias" === nodeType || "DeclareOpaqueType" === nodeType || "DeclareVariable" === nodeType || "DeclareExportDeclaration" === nodeType || "DeclareExportAllDeclaration" === nodeType || "InterfaceDeclaration" === nodeType || "OpaqueType" === nodeType || "TypeAlias" === nodeType || "EnumDeclaration" === nodeType || "TSDeclareFunction" === nodeType || "TSInterfaceDeclaration" === nodeType || "TSTypeAliasDeclaration" === nodeType || "TSEnumDeclaration" === nodeType || "TSModuleDeclaration" === nodeType || "TSImportEqualsDeclaration" === nodeType || "TSExportAssignment" === nodeType || "TSNamespaceExportDeclaration" === nodeType || nodeType === "Placeholder" && ("Statement" === node.expectedNode || "Declaration" === node.expectedNode || "BlockStatement" === node.expectedNode)) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTerminatorless(node, opts) { if (!node) return false; const nodeType = node.type; if ("BreakStatement" === nodeType || "ContinueStatement" === nodeType || "ReturnStatement" === nodeType || "ThrowStatement" === nodeType || "YieldExpression" === nodeType || "AwaitExpression" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isCompletionStatement(node, opts) { if (!node) return false; const nodeType = node.type; if ("BreakStatement" === nodeType || "ContinueStatement" === nodeType || "ReturnStatement" === nodeType || "ThrowStatement" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isConditional(node, opts) { if (!node) return false; const nodeType = node.type; if ("ConditionalExpression" === nodeType || "IfStatement" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isLoop(node, opts) { if (!node) return false; const nodeType = node.type; if ("DoWhileStatement" === nodeType || "ForInStatement" === nodeType || "ForStatement" === nodeType || "WhileStatement" === nodeType || "ForOfStatement" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isWhile(node, opts) { if (!node) return false; const nodeType = node.type; if ("DoWhileStatement" === nodeType || "WhileStatement" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isExpressionWrapper(node, opts) { if (!node) return false; const nodeType = node.type; if ("ExpressionStatement" === nodeType || "ParenthesizedExpression" === nodeType || "TypeCastExpression" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isFor(node, opts) { if (!node) return false; const nodeType = node.type; if ("ForInStatement" === nodeType || "ForStatement" === nodeType || "ForOfStatement" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isForXStatement(node, opts) { if (!node) return false; const nodeType = node.type; if ("ForInStatement" === nodeType || "ForOfStatement" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isFunction(node, opts) { if (!node) return false; const nodeType = node.type; if ("FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "ObjectMethod" === nodeType || "ArrowFunctionExpression" === nodeType || "ClassMethod" === nodeType || "ClassPrivateMethod" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isFunctionParent(node, opts) { if (!node) return false; const nodeType = node.type; if ("FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "ObjectMethod" === nodeType || "ArrowFunctionExpression" === nodeType || "ClassMethod" === nodeType || "ClassPrivateMethod" === nodeType || "StaticBlock" === nodeType || "TSModuleBlock" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isPureish(node, opts) { if (!node) return false; const nodeType = node.type; if ("FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "StringLiteral" === nodeType || "NumericLiteral" === nodeType || "NullLiteral" === nodeType || "BooleanLiteral" === nodeType || "RegExpLiteral" === nodeType || "ArrowFunctionExpression" === nodeType || "BigIntLiteral" === nodeType || "DecimalLiteral" === nodeType || nodeType === "Placeholder" && "StringLiteral" === node.expectedNode) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if ("FunctionDeclaration" === nodeType || "VariableDeclaration" === nodeType || "ClassDeclaration" === nodeType || "ExportAllDeclaration" === nodeType || "ExportDefaultDeclaration" === nodeType || "ExportNamedDeclaration" === nodeType || "ImportDeclaration" === nodeType || "DeclareClass" === nodeType || "DeclareFunction" === nodeType || "DeclareInterface" === nodeType || "DeclareModule" === nodeType || "DeclareModuleExports" === nodeType || "DeclareTypeAlias" === nodeType || "DeclareOpaqueType" === nodeType || "DeclareVariable" === nodeType || "DeclareExportDeclaration" === nodeType || "DeclareExportAllDeclaration" === nodeType || "InterfaceDeclaration" === nodeType || "OpaqueType" === nodeType || "TypeAlias" === nodeType || "EnumDeclaration" === nodeType || "TSDeclareFunction" === nodeType || "TSInterfaceDeclaration" === nodeType || "TSTypeAliasDeclaration" === nodeType || "TSEnumDeclaration" === nodeType || "TSModuleDeclaration" === nodeType || nodeType === "Placeholder" && "Declaration" === node.expectedNode) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isPatternLike(node, opts) { if (!node) return false; const nodeType = node.type; if ("Identifier" === nodeType || "RestElement" === nodeType || "AssignmentPattern" === nodeType || "ArrayPattern" === nodeType || "ObjectPattern" === nodeType || "TSAsExpression" === nodeType || "TSTypeAssertion" === nodeType || "TSNonNullExpression" === nodeType || nodeType === "Placeholder" && ("Pattern" === node.expectedNode || "Identifier" === node.expectedNode)) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isLVal(node, opts) { if (!node) return false; const nodeType = node.type; if ("Identifier" === nodeType || "MemberExpression" === nodeType || "RestElement" === nodeType || "AssignmentPattern" === nodeType || "ArrayPattern" === nodeType || "ObjectPattern" === nodeType || "TSParameterProperty" === nodeType || "TSAsExpression" === nodeType || "TSTypeAssertion" === nodeType || "TSNonNullExpression" === nodeType || nodeType === "Placeholder" && ("Pattern" === node.expectedNode || "Identifier" === node.expectedNode)) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSEntityName(node, opts) { if (!node) return false; const nodeType = node.type; if ("Identifier" === nodeType || "TSQualifiedName" === nodeType || nodeType === "Placeholder" && "Identifier" === node.expectedNode) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isLiteral(node, opts) { if (!node) return false; const nodeType = node.type; if ("StringLiteral" === nodeType || "NumericLiteral" === nodeType || "NullLiteral" === nodeType || "BooleanLiteral" === nodeType || "RegExpLiteral" === nodeType || "TemplateLiteral" === nodeType || "BigIntLiteral" === nodeType || "DecimalLiteral" === nodeType || nodeType === "Placeholder" && "StringLiteral" === node.expectedNode) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isImmutable(node, opts) { if (!node) return false; const nodeType = node.type; if ("StringLiteral" === nodeType || "NumericLiteral" === nodeType || "NullLiteral" === nodeType || "BooleanLiteral" === nodeType || "BigIntLiteral" === nodeType || "JSXAttribute" === nodeType || "JSXClosingElement" === nodeType || "JSXElement" === nodeType || "JSXExpressionContainer" === nodeType || "JSXSpreadChild" === nodeType || "JSXOpeningElement" === nodeType || "JSXText" === nodeType || "JSXFragment" === nodeType || "JSXOpeningFragment" === nodeType || "JSXClosingFragment" === nodeType || "DecimalLiteral" === nodeType || nodeType === "Placeholder" && "StringLiteral" === node.expectedNode) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isUserWhitespacable(node, opts) { if (!node) return false; const nodeType = node.type; if ("ObjectMethod" === nodeType || "ObjectProperty" === nodeType || "ObjectTypeInternalSlot" === nodeType || "ObjectTypeCallProperty" === nodeType || "ObjectTypeIndexer" === nodeType || "ObjectTypeProperty" === nodeType || "ObjectTypeSpreadProperty" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isMethod(node, opts) { if (!node) return false; const nodeType = node.type; if ("ObjectMethod" === nodeType || "ClassMethod" === nodeType || "ClassPrivateMethod" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isObjectMember(node, opts) { if (!node) return false; const nodeType = node.type; if ("ObjectMethod" === nodeType || "ObjectProperty" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isProperty(node, opts) { if (!node) return false; const nodeType = node.type; if ("ObjectProperty" === nodeType || "ClassProperty" === nodeType || "ClassAccessorProperty" === nodeType || "ClassPrivateProperty" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isUnaryLike(node, opts) { if (!node) return false; const nodeType = node.type; if ("UnaryExpression" === nodeType || "SpreadElement" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isPattern(node, opts) { if (!node) return false; const nodeType = node.type; if ("AssignmentPattern" === nodeType || "ArrayPattern" === nodeType || "ObjectPattern" === nodeType || nodeType === "Placeholder" && "Pattern" === node.expectedNode) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isClass(node, opts) { if (!node) return false; const nodeType = node.type; if ("ClassExpression" === nodeType || "ClassDeclaration" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isModuleDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if ("ExportAllDeclaration" === nodeType || "ExportDefaultDeclaration" === nodeType || "ExportNamedDeclaration" === nodeType || "ImportDeclaration" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isExportDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if ("ExportAllDeclaration" === nodeType || "ExportDefaultDeclaration" === nodeType || "ExportNamedDeclaration" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isModuleSpecifier(node, opts) { if (!node) return false; const nodeType = node.type; if ("ExportSpecifier" === nodeType || "ImportDefaultSpecifier" === nodeType || "ImportNamespaceSpecifier" === nodeType || "ImportSpecifier" === nodeType || "ExportNamespaceSpecifier" === nodeType || "ExportDefaultSpecifier" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isAccessor(node, opts) { if (!node) return false; const nodeType = node.type; if ("ClassAccessorProperty" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isPrivate(node, opts) { if (!node) return false; const nodeType = node.type; if ("ClassPrivateProperty" === nodeType || "ClassPrivateMethod" === nodeType || "PrivateName" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isFlow(node, opts) { if (!node) return false; const nodeType = node.type; if ("AnyTypeAnnotation" === nodeType || "ArrayTypeAnnotation" === nodeType || "BooleanTypeAnnotation" === nodeType || "BooleanLiteralTypeAnnotation" === nodeType || "NullLiteralTypeAnnotation" === nodeType || "ClassImplements" === nodeType || "DeclareClass" === nodeType || "DeclareFunction" === nodeType || "DeclareInterface" === nodeType || "DeclareModule" === nodeType || "DeclareModuleExports" === nodeType || "DeclareTypeAlias" === nodeType || "DeclareOpaqueType" === nodeType || "DeclareVariable" === nodeType || "DeclareExportDeclaration" === nodeType || "DeclareExportAllDeclaration" === nodeType || "DeclaredPredicate" === nodeType || "ExistsTypeAnnotation" === nodeType || "FunctionTypeAnnotation" === nodeType || "FunctionTypeParam" === nodeType || "GenericTypeAnnotation" === nodeType || "InferredPredicate" === nodeType || "InterfaceExtends" === nodeType || "InterfaceDeclaration" === nodeType || "InterfaceTypeAnnotation" === nodeType || "IntersectionTypeAnnotation" === nodeType || "MixedTypeAnnotation" === nodeType || "EmptyTypeAnnotation" === nodeType || "NullableTypeAnnotation" === nodeType || "NumberLiteralTypeAnnotation" === nodeType || "NumberTypeAnnotation" === nodeType || "ObjectTypeAnnotation" === nodeType || "ObjectTypeInternalSlot" === nodeType || "ObjectTypeCallProperty" === nodeType || "ObjectTypeIndexer" === nodeType || "ObjectTypeProperty" === nodeType || "ObjectTypeSpreadProperty" === nodeType || "OpaqueType" === nodeType || "QualifiedTypeIdentifier" === nodeType || "StringLiteralTypeAnnotation" === nodeType || "StringTypeAnnotation" === nodeType || "SymbolTypeAnnotation" === nodeType || "ThisTypeAnnotation" === nodeType || "TupleTypeAnnotation" === nodeType || "TypeofTypeAnnotation" === nodeType || "TypeAlias" === nodeType || "TypeAnnotation" === nodeType || "TypeCastExpression" === nodeType || "TypeParameter" === nodeType || "TypeParameterDeclaration" === nodeType || "TypeParameterInstantiation" === nodeType || "UnionTypeAnnotation" === nodeType || "Variance" === nodeType || "VoidTypeAnnotation" === nodeType || "EnumDeclaration" === nodeType || "EnumBooleanBody" === nodeType || "EnumNumberBody" === nodeType || "EnumStringBody" === nodeType || "EnumSymbolBody" === nodeType || "EnumBooleanMember" === nodeType || "EnumNumberMember" === nodeType || "EnumStringMember" === nodeType || "EnumDefaultedMember" === nodeType || "IndexedAccessType" === nodeType || "OptionalIndexedAccessType" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isFlowType(node, opts) { if (!node) return false; const nodeType = node.type; if ("AnyTypeAnnotation" === nodeType || "ArrayTypeAnnotation" === nodeType || "BooleanTypeAnnotation" === nodeType || "BooleanLiteralTypeAnnotation" === nodeType || "NullLiteralTypeAnnotation" === nodeType || "ExistsTypeAnnotation" === nodeType || "FunctionTypeAnnotation" === nodeType || "GenericTypeAnnotation" === nodeType || "InterfaceTypeAnnotation" === nodeType || "IntersectionTypeAnnotation" === nodeType || "MixedTypeAnnotation" === nodeType || "EmptyTypeAnnotation" === nodeType || "NullableTypeAnnotation" === nodeType || "NumberLiteralTypeAnnotation" === nodeType || "NumberTypeAnnotation" === nodeType || "ObjectTypeAnnotation" === nodeType || "StringLiteralTypeAnnotation" === nodeType || "StringTypeAnnotation" === nodeType || "SymbolTypeAnnotation" === nodeType || "ThisTypeAnnotation" === nodeType || "TupleTypeAnnotation" === nodeType || "TypeofTypeAnnotation" === nodeType || "UnionTypeAnnotation" === nodeType || "VoidTypeAnnotation" === nodeType || "IndexedAccessType" === nodeType || "OptionalIndexedAccessType" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isFlowBaseAnnotation(node, opts) { if (!node) return false; const nodeType = node.type; if ("AnyTypeAnnotation" === nodeType || "BooleanTypeAnnotation" === nodeType || "NullLiteralTypeAnnotation" === nodeType || "MixedTypeAnnotation" === nodeType || "EmptyTypeAnnotation" === nodeType || "NumberTypeAnnotation" === nodeType || "StringTypeAnnotation" === nodeType || "SymbolTypeAnnotation" === nodeType || "ThisTypeAnnotation" === nodeType || "VoidTypeAnnotation" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isFlowDeclaration(node, opts) { if (!node) return false; const nodeType = node.type; if ("DeclareClass" === nodeType || "DeclareFunction" === nodeType || "DeclareInterface" === nodeType || "DeclareModule" === nodeType || "DeclareModuleExports" === nodeType || "DeclareTypeAlias" === nodeType || "DeclareOpaqueType" === nodeType || "DeclareVariable" === nodeType || "DeclareExportDeclaration" === nodeType || "DeclareExportAllDeclaration" === nodeType || "InterfaceDeclaration" === nodeType || "OpaqueType" === nodeType || "TypeAlias" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isFlowPredicate(node, opts) { if (!node) return false; const nodeType = node.type; if ("DeclaredPredicate" === nodeType || "InferredPredicate" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isEnumBody(node, opts) { if (!node) return false; const nodeType = node.type; if ("EnumBooleanBody" === nodeType || "EnumNumberBody" === nodeType || "EnumStringBody" === nodeType || "EnumSymbolBody" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isEnumMember(node, opts) { if (!node) return false; const nodeType = node.type; if ("EnumBooleanMember" === nodeType || "EnumNumberMember" === nodeType || "EnumStringMember" === nodeType || "EnumDefaultedMember" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isJSX(node, opts) { if (!node) return false; const nodeType = node.type; if ("JSXAttribute" === nodeType || "JSXClosingElement" === nodeType || "JSXElement" === nodeType || "JSXEmptyExpression" === nodeType || "JSXExpressionContainer" === nodeType || "JSXSpreadChild" === nodeType || "JSXIdentifier" === nodeType || "JSXMemberExpression" === nodeType || "JSXNamespacedName" === nodeType || "JSXOpeningElement" === nodeType || "JSXSpreadAttribute" === nodeType || "JSXText" === nodeType || "JSXFragment" === nodeType || "JSXOpeningFragment" === nodeType || "JSXClosingFragment" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isMiscellaneous(node, opts) { if (!node) return false; const nodeType = node.type; if ("Noop" === nodeType || "Placeholder" === nodeType || "V8IntrinsicIdentifier" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTypeScript(node, opts) { if (!node) return false; const nodeType = node.type; if ("TSParameterProperty" === nodeType || "TSDeclareFunction" === nodeType || "TSDeclareMethod" === nodeType || "TSQualifiedName" === nodeType || "TSCallSignatureDeclaration" === nodeType || "TSConstructSignatureDeclaration" === nodeType || "TSPropertySignature" === nodeType || "TSMethodSignature" === nodeType || "TSIndexSignature" === nodeType || "TSAnyKeyword" === nodeType || "TSBooleanKeyword" === nodeType || "TSBigIntKeyword" === nodeType || "TSIntrinsicKeyword" === nodeType || "TSNeverKeyword" === nodeType || "TSNullKeyword" === nodeType || "TSNumberKeyword" === nodeType || "TSObjectKeyword" === nodeType || "TSStringKeyword" === nodeType || "TSSymbolKeyword" === nodeType || "TSUndefinedKeyword" === nodeType || "TSUnknownKeyword" === nodeType || "TSVoidKeyword" === nodeType || "TSThisType" === nodeType || "TSFunctionType" === nodeType || "TSConstructorType" === nodeType || "TSTypeReference" === nodeType || "TSTypePredicate" === nodeType || "TSTypeQuery" === nodeType || "TSTypeLiteral" === nodeType || "TSArrayType" === nodeType || "TSTupleType" === nodeType || "TSOptionalType" === nodeType || "TSRestType" === nodeType || "TSNamedTupleMember" === nodeType || "TSUnionType" === nodeType || "TSIntersectionType" === nodeType || "TSConditionalType" === nodeType || "TSInferType" === nodeType || "TSParenthesizedType" === nodeType || "TSTypeOperator" === nodeType || "TSIndexedAccessType" === nodeType || "TSMappedType" === nodeType || "TSLiteralType" === nodeType || "TSExpressionWithTypeArguments" === nodeType || "TSInterfaceDeclaration" === nodeType || "TSInterfaceBody" === nodeType || "TSTypeAliasDeclaration" === nodeType || "TSInstantiationExpression" === nodeType || "TSAsExpression" === nodeType || "TSTypeAssertion" === nodeType || "TSEnumDeclaration" === nodeType || "TSEnumMember" === nodeType || "TSModuleDeclaration" === nodeType || "TSModuleBlock" === nodeType || "TSImportType" === nodeType || "TSImportEqualsDeclaration" === nodeType || "TSExternalModuleReference" === nodeType || "TSNonNullExpression" === nodeType || "TSExportAssignment" === nodeType || "TSNamespaceExportDeclaration" === nodeType || "TSTypeAnnotation" === nodeType || "TSTypeParameterInstantiation" === nodeType || "TSTypeParameterDeclaration" === nodeType || "TSTypeParameter" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSTypeElement(node, opts) { if (!node) return false; const nodeType = node.type; if ("TSCallSignatureDeclaration" === nodeType || "TSConstructSignatureDeclaration" === nodeType || "TSPropertySignature" === nodeType || "TSMethodSignature" === nodeType || "TSIndexSignature" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSType(node, opts) { if (!node) return false; const nodeType = node.type; if ("TSAnyKeyword" === nodeType || "TSBooleanKeyword" === nodeType || "TSBigIntKeyword" === nodeType || "TSIntrinsicKeyword" === nodeType || "TSNeverKeyword" === nodeType || "TSNullKeyword" === nodeType || "TSNumberKeyword" === nodeType || "TSObjectKeyword" === nodeType || "TSStringKeyword" === nodeType || "TSSymbolKeyword" === nodeType || "TSUndefinedKeyword" === nodeType || "TSUnknownKeyword" === nodeType || "TSVoidKeyword" === nodeType || "TSThisType" === nodeType || "TSFunctionType" === nodeType || "TSConstructorType" === nodeType || "TSTypeReference" === nodeType || "TSTypePredicate" === nodeType || "TSTypeQuery" === nodeType || "TSTypeLiteral" === nodeType || "TSArrayType" === nodeType || "TSTupleType" === nodeType || "TSOptionalType" === nodeType || "TSRestType" === nodeType || "TSUnionType" === nodeType || "TSIntersectionType" === nodeType || "TSConditionalType" === nodeType || "TSInferType" === nodeType || "TSParenthesizedType" === nodeType || "TSTypeOperator" === nodeType || "TSIndexedAccessType" === nodeType || "TSMappedType" === nodeType || "TSLiteralType" === nodeType || "TSExpressionWithTypeArguments" === nodeType || "TSImportType" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isTSBaseType(node, opts) { if (!node) return false; const nodeType = node.type; if ("TSAnyKeyword" === nodeType || "TSBooleanKeyword" === nodeType || "TSBigIntKeyword" === nodeType || "TSIntrinsicKeyword" === nodeType || "TSNeverKeyword" === nodeType || "TSNullKeyword" === nodeType || "TSNumberKeyword" === nodeType || "TSObjectKeyword" === nodeType || "TSStringKeyword" === nodeType || "TSSymbolKeyword" === nodeType || "TSUndefinedKeyword" === nodeType || "TSUnknownKeyword" === nodeType || "TSVoidKeyword" === nodeType || "TSThisType" === nodeType || "TSLiteralType" === nodeType) { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isNumberLiteral(node, opts) { console.trace("The node type NumberLiteral has been renamed to NumericLiteral"); if (!node) return false; const nodeType = node.type; if (nodeType === "NumberLiteral") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isRegexLiteral(node, opts) { console.trace("The node type RegexLiteral has been renamed to RegExpLiteral"); if (!node) return false; const nodeType = node.type; if (nodeType === "RegexLiteral") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isRestProperty(node, opts) { console.trace("The node type RestProperty has been renamed to RestElement"); if (!node) return false; const nodeType = node.type; if (nodeType === "RestProperty") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } function isSpreadProperty(node, opts) { console.trace("The node type SpreadProperty has been renamed to SpreadElement"); if (!node) return false; const nodeType = node.type; if (nodeType === "SpreadProperty") { if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } return false; } },{"../../utils/shallowEqual":373}],376:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = is; var _shallowEqual = require("../utils/shallowEqual"); var _isType = require("./isType"); var _isPlaceholderType = require("./isPlaceholderType"); var _definitions = require("../definitions"); function is(type, node, opts) { if (!node) return false; const matches = (0, _isType.default)(node.type, type); if (!matches) { if (!opts && node.type === "Placeholder" && type in _definitions.FLIPPED_ALIAS_KEYS) { return (0, _isPlaceholderType.default)(node.expectedNode, type); } return false; } if (typeof opts === "undefined") { return true; } else { return (0, _shallowEqual.default)(node, opts); } } },{"../definitions":353,"../utils/shallowEqual":373,"./isPlaceholderType":383,"./isType":387}],377:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = isBinding; var _getBindingIdentifiers = require("../retrievers/getBindingIdentifiers"); function isBinding(node, parent, grandparent) { if (grandparent && node.type === "Identifier" && parent.type === "ObjectProperty" && grandparent.type === "ObjectExpression") { return false; } const keys = _getBindingIdentifiers.default.keys[parent.type]; if (keys) { for (let i = 0; i < keys.length; i++) { const key = keys[i]; const val = parent[key]; if (Array.isArray(val)) { if (val.indexOf(node) >= 0) return true; } else { if (val === node) return true; } } } return false; } },{"../retrievers/getBindingIdentifiers":367}],378:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = isBlockScoped; var _generated = require("./generated"); var _isLet = require("./isLet"); function isBlockScoped(node) { return (0, _generated.isFunctionDeclaration)(node) || (0, _generated.isClassDeclaration)(node) || (0, _isLet.default)(node); } },{"./generated":375,"./isLet":380}],379:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = isImmutable; var _isType = require("./isType"); var _generated = require("./generated"); function isImmutable(node) { if ((0, _isType.default)(node.type, "Immutable")) return true; if ((0, _generated.isIdentifier)(node)) { if (node.name === "undefined") { return true; } else { return false; } } return false; } },{"./generated":375,"./isType":387}],380:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = isLet; var _generated = require("./generated"); var _constants = require("../constants"); function isLet(node) { return (0, _generated.isVariableDeclaration)(node) && (node.kind !== "var" || node[_constants.BLOCK_SCOPED_SYMBOL]); } },{"../constants":338,"./generated":375}],381:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = isNode; var _definitions = require("../definitions"); function isNode(node) { return !!(node && _definitions.VISITOR_KEYS[node.type]); } },{"../definitions":353}],382:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = isNodesEquivalent; var _definitions = require("../definitions"); function isNodesEquivalent(a, b) { if (typeof a !== "object" || typeof b !== "object" || a == null || b == null) { return a === b; } if (a.type !== b.type) { return false; } const fields = Object.keys(_definitions.NODE_FIELDS[a.type] || a.type); const visitorKeys = _definitions.VISITOR_KEYS[a.type]; for (const field of fields) { const val_a = a[field]; const val_b = b[field]; if (typeof val_a !== typeof val_b) { return false; } if (val_a == null && val_b == null) { continue; } else if (val_a == null || val_b == null) { return false; } if (Array.isArray(val_a)) { if (!Array.isArray(val_b)) { return false; } if (val_a.length !== val_b.length) { return false; } for (let i = 0; i < val_a.length; i++) { if (!isNodesEquivalent(val_a[i], val_b[i])) { return false; } } continue; } if (typeof val_a === "object" && !(visitorKeys != null && visitorKeys.includes(field))) { for (const key of Object.keys(val_a)) { if (val_a[key] !== val_b[key]) { return false; } } continue; } if (!isNodesEquivalent(val_a, val_b)) { return false; } } return true; } },{"../definitions":353}],383:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = isPlaceholderType; var _definitions = require("../definitions"); function isPlaceholderType(placeholderType, targetType) { if (placeholderType === targetType) return true; const aliases = _definitions.PLACEHOLDERS_ALIAS[placeholderType]; if (aliases) { for (const alias of aliases) { if (targetType === alias) return true; } } return false; } },{"../definitions":353}],384:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = isReferenced; function isReferenced(node, parent, grandparent) { switch (parent.type) { case "MemberExpression": case "OptionalMemberExpression": if (parent.property === node) { return !!parent.computed; } return parent.object === node; case "JSXMemberExpression": return parent.object === node; case "VariableDeclarator": return parent.init === node; case "ArrowFunctionExpression": return parent.body === node; case "PrivateName": return false; case "ClassMethod": case "ClassPrivateMethod": case "ObjectMethod": if (parent.key === node) { return !!parent.computed; } return false; case "ObjectProperty": if (parent.key === node) { return !!parent.computed; } return !grandparent || grandparent.type !== "ObjectPattern"; case "ClassProperty": case "ClassAccessorProperty": if (parent.key === node) { return !!parent.computed; } return true; case "ClassPrivateProperty": return parent.key !== node; case "ClassDeclaration": case "ClassExpression": return parent.superClass === node; case "AssignmentExpression": return parent.right === node; case "AssignmentPattern": return parent.right === node; case "LabeledStatement": return false; case "CatchClause": return false; case "RestElement": return false; case "BreakStatement": case "ContinueStatement": return false; case "FunctionDeclaration": case "FunctionExpression": return false; case "ExportNamespaceSpecifier": case "ExportDefaultSpecifier": return false; case "ExportSpecifier": if (grandparent != null && grandparent.source) { return false; } return parent.local === node; case "ImportDefaultSpecifier": case "ImportNamespaceSpecifier": case "ImportSpecifier": return false; case "ImportAttribute": return false; case "JSXAttribute": return false; case "ObjectPattern": case "ArrayPattern": return false; case "MetaProperty": return false; case "ObjectTypeProperty": return parent.key !== node; case "TSEnumMember": return parent.id !== node; case "TSPropertySignature": if (parent.key === node) { return !!parent.computed; } return true; } return true; } },{}],385:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = isScope; var _generated = require("./generated"); function isScope(node, parent) { if ((0, _generated.isBlockStatement)(node) && ((0, _generated.isFunction)(parent) || (0, _generated.isCatchClause)(parent))) { return false; } if ((0, _generated.isPattern)(node) && ((0, _generated.isFunction)(parent) || (0, _generated.isCatchClause)(parent))) { return true; } return (0, _generated.isScopable)(node); } },{"./generated":375}],386:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = isSpecifierDefault; var _generated = require("./generated"); function isSpecifierDefault(specifier) { return (0, _generated.isImportDefaultSpecifier)(specifier) || (0, _generated.isIdentifier)(specifier.imported || specifier.exported, { name: "default" }); } },{"./generated":375}],387:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = isType; var _definitions = require("../definitions"); function isType(nodeType, targetType) { if (nodeType === targetType) return true; if (_definitions.ALIAS_KEYS[targetType]) return false; const aliases = _definitions.FLIPPED_ALIAS_KEYS[targetType]; if (aliases) { if (aliases[0] === nodeType) return true; for (const alias of aliases) { if (nodeType === alias) return true; } } return false; } },{"../definitions":353}],388:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = isValidES3Identifier; var _isValidIdentifier = require("./isValidIdentifier"); const RESERVED_WORDS_ES3_ONLY = new Set(["abstract", "boolean", "byte", "char", "double", "enum", "final", "float", "goto", "implements", "int", "interface", "long", "native", "package", "private", "protected", "public", "short", "static", "synchronized", "throws", "transient", "volatile"]); function isValidES3Identifier(name) { return (0, _isValidIdentifier.default)(name) && !RESERVED_WORDS_ES3_ONLY.has(name); } },{"./isValidIdentifier":389}],389:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = isValidIdentifier; var _helperValidatorIdentifier = require("@babel/helper-validator-identifier"); function isValidIdentifier(name, reserved = true) { if (typeof name !== "string") return false; if (reserved) { if ((0, _helperValidatorIdentifier.isKeyword)(name) || (0, _helperValidatorIdentifier.isStrictReservedWord)(name, true)) { return false; } } return (0, _helperValidatorIdentifier.isIdentifierName)(name); } },{"@babel/helper-validator-identifier":256}],390:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = isVar; var _generated = require("./generated"); var _constants = require("../constants"); function isVar(node) { return (0, _generated.isVariableDeclaration)(node, { kind: "var" }) && !node[_constants.BLOCK_SCOPED_SYMBOL]; } },{"../constants":338,"./generated":375}],391:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = matchesPattern; var _generated = require("./generated"); function matchesPattern(member, match, allowPartial) { if (!(0, _generated.isMemberExpression)(member)) return false; const parts = Array.isArray(match) ? match : match.split("."); const nodes = []; let node; for (node = member; (0, _generated.isMemberExpression)(node); node = node.object) { nodes.push(node.property); } nodes.push(node); if (nodes.length < parts.length) return false; if (!allowPartial && nodes.length > parts.length) return false; for (let i = 0, j = nodes.length - 1; i < parts.length; i++, j--) { const node = nodes[j]; let value; if ((0, _generated.isIdentifier)(node)) { value = node.name; } else if ((0, _generated.isStringLiteral)(node)) { value = node.value; } else if ((0, _generated.isThisExpression)(node)) { value = "this"; } else { return false; } if (parts[i] !== value) return false; } return true; } },{"./generated":375}],392:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = isCompatTag; function isCompatTag(tagName) { return !!tagName && /^[a-z]/.test(tagName); } },{}],393:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = void 0; var _buildMatchMemberExpression = require("../buildMatchMemberExpression"); const isReactComponent = (0, _buildMatchMemberExpression.default)("React.Component"); var _default = isReactComponent; exports.default = _default; },{"../buildMatchMemberExpression":374}],394:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = validate; exports.validateChild = validateChild; exports.validateField = validateField; var _definitions = require("../definitions"); function validate(node, key, val) { if (!node) return; const fields = _definitions.NODE_FIELDS[node.type]; if (!fields) return; const field = fields[key]; validateField(node, key, val, field); validateChild(node, key, val); } function validateField(node, key, val, field) { if (!(field != null && field.validate)) return; if (field.optional && val == null) return; field.validate(node, key, val); } function validateChild(node, key, val) { if (val == null) return; const validate = _definitions.NODE_PARENT_VALIDATIONS[val.type]; if (!validate) return; validate(node, key, val); } },{"../definitions":353}],395:[function(require,module,exports){ (function (global, factory) { typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@jridgewell/set-array'), require('@jridgewell/sourcemap-codec'), require('@jridgewell/trace-mapping')) : typeof define === 'function' && define.amd ? define(['exports', '@jridgewell/set-array', '@jridgewell/sourcemap-codec', '@jridgewell/trace-mapping'], factory) : (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.genMapping = {}, global.setArray, global.sourcemapCodec, global.traceMapping)); })(this, (function (exports, setArray, sourcemapCodec, traceMapping) { 'use strict'; const COLUMN = 0; const SOURCES_INDEX = 1; const SOURCE_LINE = 2; const SOURCE_COLUMN = 3; const NAMES_INDEX = 4; const NO_NAME = -1; /** * A low-level API to associate a generated position with an original source position. Line and * column here are 0-based, unlike `addMapping`. */ exports.addSegment = void 0; /** * A high-level API to associate a generated position with an original source position. Line is * 1-based, but column is 0-based, due to legacy behavior in `source-map` library. */ exports.addMapping = void 0; /** * Same as `addSegment`, but will only add the segment if it generates useful information in the * resulting map. This only works correctly if segments are added **in order**, meaning you should * not add a segment with a lower generated line/column than one that came before. */ exports.maybeAddSegment = void 0; /** * Same as `addMapping`, but will only add the mapping if it generates useful information in the * resulting map. This only works correctly if mappings are added **in order**, meaning you should * not add a mapping with a lower generated line/column than one that came before. */ exports.maybeAddMapping = void 0; /** * Adds/removes the content of the source file to the source map. */ exports.setSourceContent = void 0; /** * Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects * a sourcemap, or to JSON.stringify. */ exports.toDecodedMap = void 0; /** * Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects * a sourcemap, or to JSON.stringify. */ exports.toEncodedMap = void 0; /** * Constructs a new GenMapping, using the already present mappings of the input. */ exports.fromMap = void 0; /** * Returns an array of high-level mapping objects for every recorded segment, which could then be * passed to the `source-map` library. */ exports.allMappings = void 0; // This split declaration is only so that terser can elminiate the static initialization block. let addSegmentInternal; /** * Provides the state to generate a sourcemap. */ class GenMapping { constructor({ file, sourceRoot } = {}) { this._names = new setArray.SetArray(); this._sources = new setArray.SetArray(); this._sourcesContent = []; this._mappings = []; this.file = file; this.sourceRoot = sourceRoot; } } (() => { exports.addSegment = (map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) => { return addSegmentInternal(false, map, genLine, genColumn, source, sourceLine, sourceColumn, name, content); }; exports.maybeAddSegment = (map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) => { return addSegmentInternal(true, map, genLine, genColumn, source, sourceLine, sourceColumn, name, content); }; exports.addMapping = (map, mapping) => { return addMappingInternal(false, map, mapping); }; exports.maybeAddMapping = (map, mapping) => { return addMappingInternal(true, map, mapping); }; exports.setSourceContent = (map, source, content) => { const { _sources: sources, _sourcesContent: sourcesContent } = map; sourcesContent[setArray.put(sources, source)] = content; }; exports.toDecodedMap = (map) => { const { file, sourceRoot, _mappings: mappings, _sources: sources, _sourcesContent: sourcesContent, _names: names, } = map; removeEmptyFinalLines(mappings); return { version: 3, file: file || undefined, names: names.array, sourceRoot: sourceRoot || undefined, sources: sources.array, sourcesContent, mappings, }; }; exports.toEncodedMap = (map) => { const decoded = exports.toDecodedMap(map); return Object.assign(Object.assign({}, decoded), { mappings: sourcemapCodec.encode(decoded.mappings) }); }; exports.allMappings = (map) => { const out = []; const { _mappings: mappings, _sources: sources, _names: names } = map; for (let i = 0; i < mappings.length; i++) { const line = mappings[i]; for (let j = 0; j < line.length; j++) { const seg = line[j]; const generated = { line: i + 1, column: seg[COLUMN] }; let source = undefined; let original = undefined; let name = undefined; if (seg.length !== 1) { source = sources.array[seg[SOURCES_INDEX]]; original = { line: seg[SOURCE_LINE] + 1, column: seg[SOURCE_COLUMN] }; if (seg.length === 5) name = names.array[seg[NAMES_INDEX]]; } out.push({ generated, source, original, name }); } } return out; }; exports.fromMap = (input) => { const map = new traceMapping.TraceMap(input); const gen = new GenMapping({ file: map.file, sourceRoot: map.sourceRoot }); putAll(gen._names, map.names); putAll(gen._sources, map.sources); gen._sourcesContent = map.sourcesContent || map.sources.map(() => null); gen._mappings = traceMapping.decodedMappings(map); return gen; }; // Internal helpers addSegmentInternal = (skipable, map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) => { const { _mappings: mappings, _sources: sources, _sourcesContent: sourcesContent, _names: names, } = map; const line = getLine(mappings, genLine); const index = getColumnIndex(line, genColumn); if (!source) { if (skipable && skipSourceless(line, index)) return; return insert(line, index, [genColumn]); } const sourcesIndex = setArray.put(sources, source); const namesIndex = name ? setArray.put(names, name) : NO_NAME; if (sourcesIndex === sourcesContent.length) sourcesContent[sourcesIndex] = content !== null && content !== void 0 ? content : null; if (skipable && skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex)) { return; } return insert(line, index, name ? [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex] : [genColumn, sourcesIndex, sourceLine, sourceColumn]); }; })(); function getLine(mappings, index) { for (let i = mappings.length; i <= index; i++) { mappings[i] = []; } return mappings[index]; } function getColumnIndex(line, genColumn) { let index = line.length; for (let i = index - 1; i >= 0; index = i--) { const current = line[i]; if (genColumn >= current[COLUMN]) break; } return index; } function insert(array, index, value) { for (let i = array.length; i > index; i--) { array[i] = array[i - 1]; } array[index] = value; } function removeEmptyFinalLines(mappings) { const { length } = mappings; let len = length; for (let i = len - 1; i >= 0; len = i, i--) { if (mappings[i].length > 0) break; } if (len < length) mappings.length = len; } function putAll(strarr, array) { for (let i = 0; i < array.length; i++) setArray.put(strarr, array[i]); } function skipSourceless(line, index) { // The start of a line is already sourceless, so adding a sourceless segment to the beginning // doesn't generate any useful information. if (index === 0) return true; const prev = line[index - 1]; // If the previous segment is also sourceless, then adding another sourceless segment doesn't // genrate any new information. Else, this segment will end the source/named segment and point to // a sourceless position, which is useful. return prev.length === 1; } function skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex) { // A source/named segment at the start of a line gives position at that genColumn if (index === 0) return false; const prev = line[index - 1]; // If the previous segment is sourceless, then we're transitioning to a source. if (prev.length === 1) return false; // If the previous segment maps to the exact same source position, then this segment doesn't // provide any new position information. return (sourcesIndex === prev[SOURCES_INDEX] && sourceLine === prev[SOURCE_LINE] && sourceColumn === prev[SOURCE_COLUMN] && namesIndex === (prev.length === 5 ? prev[NAMES_INDEX] : NO_NAME)); } function addMappingInternal(skipable, map, mapping) { const { generated, source, original, name, content } = mapping; if (!source) { return addSegmentInternal(skipable, map, generated.line - 1, generated.column, null, null, null, null, null); } const s = source; return addSegmentInternal(skipable, map, generated.line - 1, generated.column, s, original.line - 1, original.column, name, content); } exports.GenMapping = GenMapping; Object.defineProperty(exports, '__esModule', { value: true }); })); },{"@jridgewell/set-array":397,"@jridgewell/sourcemap-codec":398,"@jridgewell/trace-mapping":399}],396:[function(require,module,exports){ (function (global, factory) { typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : typeof define === 'function' && define.amd ? define(factory) : (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.resolveURI = factory()); })(this, (function () { 'use strict'; // Matches the scheme of a URL, eg "http://" const schemeRegex = /^[\w+.-]+:\/\//; /** * Matches the parts of a URL: * 1. Scheme, including ":", guaranteed. * 2. User/password, including "@", optional. * 3. Host, guaranteed. * 4. Port, including ":", optional. * 5. Path, including "/", optional. * 6. Query, including "?", optional. * 7. Hash, including "#", optional. */ const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/; /** * File URLs are weird. They dont' need the regular `//` in the scheme, they may or may not start * with a leading `/`, they can have a domain (but only if they don't start with a Windows drive). * * 1. Host, optional. * 2. Path, which may include "/", guaranteed. * 3. Query, including "?", optional. * 4. Hash, including "#", optional. */ const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i; var UrlType; (function (UrlType) { UrlType[UrlType["Empty"] = 1] = "Empty"; UrlType[UrlType["Hash"] = 2] = "Hash"; UrlType[UrlType["Query"] = 3] = "Query"; UrlType[UrlType["RelativePath"] = 4] = "RelativePath"; UrlType[UrlType["AbsolutePath"] = 5] = "AbsolutePath"; UrlType[UrlType["SchemeRelative"] = 6] = "SchemeRelative"; UrlType[UrlType["Absolute"] = 7] = "Absolute"; })(UrlType || (UrlType = {})); function isAbsoluteUrl(input) { return schemeRegex.test(input); } function isSchemeRelativeUrl(input) { return input.startsWith('//'); } function isAbsolutePath(input) { return input.startsWith('/'); } function isFileUrl(input) { return input.startsWith('file:'); } function isRelative(input) { return /^[.?#]/.test(input); } function parseAbsoluteUrl(input) { const match = urlRegex.exec(input); return makeUrl(match[1], match[2] || '', match[3], match[4] || '', match[5] || '/', match[6] || '', match[7] || ''); } function parseFileUrl(input) { const match = fileRegex.exec(input); const path = match[2]; return makeUrl('file:', '', match[1] || '', '', isAbsolutePath(path) ? path : '/' + path, match[3] || '', match[4] || ''); } function makeUrl(scheme, user, host, port, path, query, hash) { return { scheme, user, host, port, path, query, hash, type: UrlType.Absolute, }; } function parseUrl(input) { if (isSchemeRelativeUrl(input)) { const url = parseAbsoluteUrl('http:' + input); url.scheme = ''; url.type = UrlType.SchemeRelative; return url; } if (isAbsolutePath(input)) { const url = parseAbsoluteUrl('http://foo.com' + input); url.scheme = ''; url.host = ''; url.type = UrlType.AbsolutePath; return url; } if (isFileUrl(input)) return parseFileUrl(input); if (isAbsoluteUrl(input)) return parseAbsoluteUrl(input); const url = parseAbsoluteUrl('http://foo.com/' + input); url.scheme = ''; url.host = ''; url.type = input ? input.startsWith('?') ? UrlType.Query : input.startsWith('#') ? UrlType.Hash : UrlType.RelativePath : UrlType.Empty; return url; } function stripPathFilename(path) { // If a path ends with a parent directory "..", then it's a relative path with excess parent // paths. It's not a file, so we can't strip it. if (path.endsWith('/..')) return path; const index = path.lastIndexOf('/'); return path.slice(0, index + 1); } function mergePaths(url, base) { normalizePath(base, base.type); // If the path is just a "/", then it was an empty path to begin with (remember, we're a relative // path). if (url.path === '/') { url.path = base.path; } else { // Resolution happens relative to the base path's directory, not the file. url.path = stripPathFilename(base.path) + url.path; } } /** * The path can have empty directories "//", unneeded parents "foo/..", or current directory * "foo/.". We need to normalize to a standard representation. */ function normalizePath(url, type) { const rel = type <= UrlType.RelativePath; const pieces = url.path.split('/'); // We need to preserve the first piece always, so that we output a leading slash. The item at // pieces[0] is an empty string. let pointer = 1; // Positive is the number of real directories we've output, used for popping a parent directory. // Eg, "foo/bar/.." will have a positive 2, and we can decrement to be left with just "foo". let positive = 0; // We need to keep a trailing slash if we encounter an empty directory (eg, splitting "foo/" will // generate `["foo", ""]` pieces). And, if we pop a parent directory. But once we encounter a // real directory, we won't need to append, unless the other conditions happen again. let addTrailingSlash = false; for (let i = 1; i < pieces.length; i++) { const piece = pieces[i]; // An empty directory, could be a trailing slash, or just a double "//" in the path. if (!piece) { addTrailingSlash = true; continue; } // If we encounter a real directory, then we don't need to append anymore. addTrailingSlash = false; // A current directory, which we can always drop. if (piece === '.') continue; // A parent directory, we need to see if there are any real directories we can pop. Else, we // have an excess of parents, and we'll need to keep the "..". if (piece === '..') { if (positive) { addTrailingSlash = true; positive--; pointer--; } else if (rel) { // If we're in a relativePath, then we need to keep the excess parents. Else, in an absolute // URL, protocol relative URL, or an absolute path, we don't need to keep excess. pieces[pointer++] = piece; } continue; } // We've encountered a real directory. Move it to the next insertion pointer, which accounts for // any popped or dropped directories. pieces[pointer++] = piece; positive++; } let path = ''; for (let i = 1; i < pointer; i++) { path += '/' + pieces[i]; } if (!path || (addTrailingSlash && !path.endsWith('/..'))) { path += '/'; } url.path = path; } /** * Attempts to resolve `input` URL/path relative to `base`. */ function resolve(input, base) { if (!input && !base) return ''; const url = parseUrl(input); let inputType = url.type; if (base && inputType !== UrlType.Absolute) { const baseUrl = parseUrl(base); const baseType = baseUrl.type; switch (inputType) { case UrlType.Empty: url.hash = baseUrl.hash; // fall through case UrlType.Hash: url.query = baseUrl.query; // fall through case UrlType.Query: case UrlType.RelativePath: mergePaths(url, baseUrl); // fall through case UrlType.AbsolutePath: // The host, user, and port are joined, you can't copy one without the others. url.user = baseUrl.user; url.host = baseUrl.host; url.port = baseUrl.port; // fall through case UrlType.SchemeRelative: // The input doesn't have a schema at least, so we need to copy at least that over. url.scheme = baseUrl.scheme; } if (baseType > inputType) inputType = baseType; } normalizePath(url, inputType); const queryHash = url.query + url.hash; switch (inputType) { // This is impossible, because of the empty checks at the start of the function. // case UrlType.Empty: case UrlType.Hash: case UrlType.Query: return queryHash; case UrlType.RelativePath: { // The first char is always a "/", and we need it to be relative. const path = url.path.slice(1); if (!path) return queryHash || '.'; if (isRelative(base || input) && !isRelative(path)) { // If base started with a leading ".", or there is no base and input started with a ".", // then we need to ensure that the relative path starts with a ".". We don't know if // relative starts with a "..", though, so check before prepending. return './' + path + queryHash; } return path + queryHash; } case UrlType.AbsolutePath: return url.path + queryHash; default: return url.scheme + '//' + url.user + url.host + url.port + url.path + queryHash; } } return resolve; })); },{}],397:[function(require,module,exports){ (function (global, factory) { typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : typeof define === 'function' && define.amd ? define(['exports'], factory) : (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.setArray = {})); })(this, (function (exports) { 'use strict'; /** * Gets the index associated with `key` in the backing array, if it is already present. */ exports.get = void 0; /** * Puts `key` into the backing array, if it is not already present. Returns * the index of the `key` in the backing array. */ exports.put = void 0; /** * Pops the last added item out of the SetArray. */ exports.pop = void 0; /** * SetArray acts like a `Set` (allowing only one occurrence of a string `key`), but provides the * index of the `key` in the backing array. * * This is designed to allow synchronizing a second array with the contents of the backing array, * like how in a sourcemap `sourcesContent[i]` is the source content associated with `source[i]`, * and there are never duplicates. */ class SetArray { constructor() { this._indexes = { __proto__: null }; this.array = []; } } (() => { exports.get = (strarr, key) => strarr._indexes[key]; exports.put = (strarr, key) => { // The key may or may not be present. If it is present, it's a number. const index = exports.get(strarr, key); if (index !== undefined) return index; const { array, _indexes: indexes } = strarr; return (indexes[key] = array.push(key) - 1); }; exports.pop = (strarr) => { const { array, _indexes: indexes } = strarr; if (array.length === 0) return; const last = array.pop(); indexes[last] = undefined; }; })(); exports.SetArray = SetArray; Object.defineProperty(exports, '__esModule', { value: true }); })); },{}],398:[function(require,module,exports){ (function (Buffer){(function (){ (function (global, factory) { typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : typeof define === 'function' && define.amd ? define(['exports'], factory) : (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.sourcemapCodec = {})); })(this, (function (exports) { 'use strict'; const comma = ','.charCodeAt(0); const semicolon = ';'.charCodeAt(0); const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; const intToChar = new Uint8Array(64); // 64 possible chars. const charToInt = new Uint8Array(128); // z is 122 in ASCII for (let i = 0; i < chars.length; i++) { const c = chars.charCodeAt(i); intToChar[i] = c; charToInt[c] = i; } // Provide a fallback for older environments. const td = typeof TextDecoder !== 'undefined' ? /* #__PURE__ */ new TextDecoder() : typeof Buffer !== 'undefined' ? { decode(buf) { const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength); return out.toString(); }, } : { decode(buf) { let out = ''; for (let i = 0; i < buf.length; i++) { out += String.fromCharCode(buf[i]); } return out; }, }; function decode(mappings) { const state = new Int32Array(5); const decoded = []; let index = 0; do { const semi = indexOf(mappings, index); const line = []; let sorted = true; let lastCol = 0; state[0] = 0; for (let i = index; i < semi; i++) { let seg; i = decodeInteger(mappings, i, state, 0); // genColumn const col = state[0]; if (col < lastCol) sorted = false; lastCol = col; if (hasMoreVlq(mappings, i, semi)) { i = decodeInteger(mappings, i, state, 1); // sourcesIndex i = decodeInteger(mappings, i, state, 2); // sourceLine i = decodeInteger(mappings, i, state, 3); // sourceColumn if (hasMoreVlq(mappings, i, semi)) { i = decodeInteger(mappings, i, state, 4); // namesIndex seg = [col, state[1], state[2], state[3], state[4]]; } else { seg = [col, state[1], state[2], state[3]]; } } else { seg = [col]; } line.push(seg); } if (!sorted) sort(line); decoded.push(line); index = semi + 1; } while (index <= mappings.length); return decoded; } function indexOf(mappings, index) { const idx = mappings.indexOf(';', index); return idx === -1 ? mappings.length : idx; } function decodeInteger(mappings, pos, state, j) { let value = 0; let shift = 0; let integer = 0; do { const c = mappings.charCodeAt(pos++); integer = charToInt[c]; value |= (integer & 31) << shift; shift += 5; } while (integer & 32); const shouldNegate = value & 1; value >>>= 1; if (shouldNegate) { value = -0x80000000 | -value; } state[j] += value; return pos; } function hasMoreVlq(mappings, i, length) { if (i >= length) return false; return mappings.charCodeAt(i) !== comma; } function sort(line) { line.sort(sortComparator); } function sortComparator(a, b) { return a[0] - b[0]; } function encode(decoded) { const state = new Int32Array(5); const bufLength = 1024 * 16; const subLength = bufLength - 36; const buf = new Uint8Array(bufLength); const sub = buf.subarray(0, subLength); let pos = 0; let out = ''; for (let i = 0; i < decoded.length; i++) { const line = decoded[i]; if (i > 0) { if (pos === bufLength) { out += td.decode(buf); pos = 0; } buf[pos++] = semicolon; } if (line.length === 0) continue; state[0] = 0; for (let j = 0; j < line.length; j++) { const segment = line[j]; // We can push up to 5 ints, each int can take at most 7 chars, and we // may push a comma. if (pos > subLength) { out += td.decode(sub); buf.copyWithin(0, subLength, pos); pos -= subLength; } if (j > 0) buf[pos++] = comma; pos = encodeInteger(buf, pos, state, segment, 0); // genColumn if (segment.length === 1) continue; pos = encodeInteger(buf, pos, state, segment, 1); // sourcesIndex pos = encodeInteger(buf, pos, state, segment, 2); // sourceLine pos = encodeInteger(buf, pos, state, segment, 3); // sourceColumn if (segment.length === 4) continue; pos = encodeInteger(buf, pos, state, segment, 4); // namesIndex } } return out + td.decode(buf.subarray(0, pos)); } function encodeInteger(buf, pos, state, segment, j) { const next = segment[j]; let num = next - state[j]; state[j] = next; num = num < 0 ? (-num << 1) | 1 : num << 1; do { let clamped = num & 0b011111; num >>>= 5; if (num > 0) clamped |= 0b100000; buf[pos++] = intToChar[clamped]; } while (num > 0); return pos; } exports.decode = decode; exports.encode = encode; Object.defineProperty(exports, '__esModule', { value: true }); })); }).call(this)}).call(this,require("buffer").Buffer) },{"buffer":414}],399:[function(require,module,exports){ (function (global, factory) { typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@jridgewell/sourcemap-codec'), require('@jridgewell/resolve-uri')) : typeof define === 'function' && define.amd ? define(['exports', '@jridgewell/sourcemap-codec', '@jridgewell/resolve-uri'], factory) : (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.traceMapping = {}, global.sourcemapCodec, global.resolveURI)); })(this, (function (exports, sourcemapCodec, resolveUri) { 'use strict'; function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; } var resolveUri__default = /*#__PURE__*/_interopDefaultLegacy(resolveUri); function resolve(input, base) { // The base is always treated as a directory, if it's not empty. // https://github.com/mozilla/source-map/blob/8cb3ee57/lib/util.js#L327 // https://github.com/chromium/chromium/blob/da4adbb3/third_party/blink/renderer/devtools/front_end/sdk/SourceMap.js#L400-L401 if (base && !base.endsWith('/')) base += '/'; return resolveUri__default["default"](input, base); } /** * Removes everything after the last "/", but leaves the slash. */ function stripFilename(path) { if (!path) return ''; const index = path.lastIndexOf('/'); return path.slice(0, index + 1); } const COLUMN = 0; const SOURCES_INDEX = 1; const SOURCE_LINE = 2; const SOURCE_COLUMN = 3; const NAMES_INDEX = 4; const REV_GENERATED_LINE = 1; const REV_GENERATED_COLUMN = 2; function maybeSort(mappings, owned) { const unsortedIndex = nextUnsortedSegmentLine(mappings, 0); if (unsortedIndex === mappings.length) return mappings; // If we own the array (meaning we parsed it from JSON), then we're free to directly mutate it. If // not, we do not want to modify the consumer's input array. if (!owned) mappings = mappings.slice(); for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) { mappings[i] = sortSegments(mappings[i], owned); } return mappings; } function nextUnsortedSegmentLine(mappings, start) { for (let i = start; i < mappings.length; i++) { if (!isSorted(mappings[i])) return i; } return mappings.length; } function isSorted(line) { for (let j = 1; j < line.length; j++) { if (line[j][COLUMN] < line[j - 1][COLUMN]) { return false; } } return true; } function sortSegments(line, owned) { if (!owned) line = line.slice(); return line.sort(sortComparator); } function sortComparator(a, b) { return a[COLUMN] - b[COLUMN]; } let found = false; /** * A binary search implementation that returns the index if a match is found. * If no match is found, then the left-index (the index associated with the item that comes just * before the desired index) is returned. To maintain proper sort order, a splice would happen at * the next index: * * ```js * const array = [1, 3]; * const needle = 2; * const index = binarySearch(array, needle, (item, needle) => item - needle); * * assert.equal(index, 0); * array.splice(index + 1, 0, needle); * assert.deepEqual(array, [1, 2, 3]); * ``` */ function binarySearch(haystack, needle, low, high) { while (low <= high) { const mid = low + ((high - low) >> 1); const cmp = haystack[mid][COLUMN] - needle; if (cmp === 0) { found = true; return mid; } if (cmp < 0) { low = mid + 1; } else { high = mid - 1; } } found = false; return low - 1; } function upperBound(haystack, needle, index) { for (let i = index + 1; i < haystack.length; index = i++) { if (haystack[i][COLUMN] !== needle) break; } return index; } function lowerBound(haystack, needle, index) { for (let i = index - 1; i >= 0; index = i--) { if (haystack[i][COLUMN] !== needle) break; } return index; } function memoizedState() { return { lastKey: -1, lastNeedle: -1, lastIndex: -1, }; } /** * This overly complicated beast is just to record the last tested line/column and the resulting * index, allowing us to skip a few tests if mappings are monotonically increasing. */ function memoizedBinarySearch(haystack, needle, state, key) { const { lastKey, lastNeedle, lastIndex } = state; let low = 0; let high = haystack.length - 1; if (key === lastKey) { if (needle === lastNeedle) { found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle; return lastIndex; } if (needle >= lastNeedle) { // lastIndex may be -1 if the previous needle was not found. low = lastIndex === -1 ? 0 : lastIndex; } else { high = lastIndex; } } state.lastKey = key; state.lastNeedle = needle; return (state.lastIndex = binarySearch(haystack, needle, low, high)); } // Rebuilds the original source files, with mappings that are ordered by source line/column instead // of generated line/column. function buildBySources(decoded, memos) { const sources = memos.map(buildNullArray); for (let i = 0; i < decoded.length; i++) { const line = decoded[i]; for (let j = 0; j < line.length; j++) { const seg = line[j]; if (seg.length === 1) continue; const sourceIndex = seg[SOURCES_INDEX]; const sourceLine = seg[SOURCE_LINE]; const sourceColumn = seg[SOURCE_COLUMN]; const originalSource = sources[sourceIndex]; const originalLine = (originalSource[sourceLine] || (originalSource[sourceLine] = [])); const memo = memos[sourceIndex]; // The binary search either found a match, or it found the left-index just before where the // segment should go. Either way, we want to insert after that. And there may be multiple // generated segments associated with an original location, so there may need to move several // indexes before we find where we need to insert. const index = upperBound(originalLine, sourceColumn, memoizedBinarySearch(originalLine, sourceColumn, memo, sourceLine)); insert(originalLine, (memo.lastIndex = index + 1), [sourceColumn, i, seg[COLUMN]]); } } return sources; } function insert(array, index, value) { for (let i = array.length; i > index; i--) { array[i] = array[i - 1]; } array[index] = value; } // Null arrays allow us to use ordered index keys without actually allocating contiguous memory like // a real array. We use a null-prototype object to avoid prototype pollution and deoptimizations. // Numeric properties on objects are magically sorted in ascending order by the engine regardless of // the insertion order. So, by setting any numeric keys, even out of order, we'll get ascending // order when iterating with for-in. function buildNullArray() { return { __proto__: null }; } const AnyMap = function (map, mapUrl) { const parsed = typeof map === 'string' ? JSON.parse(map) : map; if (!('sections' in parsed)) return new TraceMap(parsed, mapUrl); const mappings = []; const sources = []; const sourcesContent = []; const names = []; recurse(parsed, mapUrl, mappings, sources, sourcesContent, names, 0, 0, Infinity, Infinity); const joined = { version: 3, file: parsed.file, names, sources, sourcesContent, mappings, }; return exports.presortedDecodedMap(joined); }; function recurse(input, mapUrl, mappings, sources, sourcesContent, names, lineOffset, columnOffset, stopLine, stopColumn) { const { sections } = input; for (let i = 0; i < sections.length; i++) { const { map, offset } = sections[i]; let sl = stopLine; let sc = stopColumn; if (i + 1 < sections.length) { const nextOffset = sections[i + 1].offset; sl = Math.min(stopLine, lineOffset + nextOffset.line); if (sl === stopLine) { sc = Math.min(stopColumn, columnOffset + nextOffset.column); } else if (sl < stopLine) { sc = columnOffset + nextOffset.column; } } addSection(map, mapUrl, mappings, sources, sourcesContent, names, lineOffset + offset.line, columnOffset + offset.column, sl, sc); } } function addSection(input, mapUrl, mappings, sources, sourcesContent, names, lineOffset, columnOffset, stopLine, stopColumn) { if ('sections' in input) return recurse(...arguments); const map = new TraceMap(input, mapUrl); const sourcesOffset = sources.length; const namesOffset = names.length; const decoded = exports.decodedMappings(map); const { resolvedSources, sourcesContent: contents } = map; append(sources, resolvedSources); append(names, map.names); if (contents) append(sourcesContent, contents); else for (let i = 0; i < resolvedSources.length; i++) sourcesContent.push(null); for (let i = 0; i < decoded.length; i++) { const lineI = lineOffset + i; // We can only add so many lines before we step into the range that the next section's map // controls. When we get to the last line, then we'll start checking the segments to see if // they've crossed into the column range. But it may not have any columns that overstep, so we // still need to check that we don't overstep lines, too. if (lineI > stopLine) return; // The out line may already exist in mappings (if we're continuing the line started by a // previous section). Or, we may have jumped ahead several lines to start this section. const out = getLine(mappings, lineI); // On the 0th loop, the section's column offset shifts us forward. On all other lines (since the // map can be multiple lines), it doesn't. const cOffset = i === 0 ? columnOffset : 0; const line = decoded[i]; for (let j = 0; j < line.length; j++) { const seg = line[j]; const column = cOffset + seg[COLUMN]; // If this segment steps into the column range that the next section's map controls, we need // to stop early. if (lineI === stopLine && column >= stopColumn) return; if (seg.length === 1) { out.push([column]); continue; } const sourcesIndex = sourcesOffset + seg[SOURCES_INDEX]; const sourceLine = seg[SOURCE_LINE]; const sourceColumn = seg[SOURCE_COLUMN]; out.push(seg.length === 4 ? [column, sourcesIndex, sourceLine, sourceColumn] : [column, sourcesIndex, sourceLine, sourceColumn, namesOffset + seg[NAMES_INDEX]]); } } } function append(arr, other) { for (let i = 0; i < other.length; i++) arr.push(other[i]); } function getLine(arr, index) { for (let i = arr.length; i <= index; i++) arr[i] = []; return arr[index]; } const LINE_GTR_ZERO = '`line` must be greater than 0 (lines start at line 1)'; const COL_GTR_EQ_ZERO = '`column` must be greater than or equal to 0 (columns start at column 0)'; const LEAST_UPPER_BOUND = -1; const GREATEST_LOWER_BOUND = 1; const ALL_BOUND = 0; /** * Returns the encoded (VLQ string) form of the SourceMap's mappings field. */ exports.encodedMappings = void 0; /** * Returns the decoded (array of lines of segments) form of the SourceMap's mappings field. */ exports.decodedMappings = void 0; /** * A low-level API to find the segment associated with a generated line/column (think, from a * stack trace). Line and column here are 0-based, unlike `originalPositionFor`. */ exports.traceSegment = void 0; /** * A higher-level API to find the source/line/column associated with a generated line/column * (think, from a stack trace). Line is 1-based, but column is 0-based, due to legacy behavior in * `source-map` library. */ exports.originalPositionFor = void 0; /** * Finds the generated line/column position of the provided source/line/column source position. */ exports.generatedPositionFor = void 0; /** * Finds all generated line/column positions of the provided source/line/column source position. */ exports.allGeneratedPositionsFor = void 0; /** * Iterates each mapping in generated position order. */ exports.eachMapping = void 0; /** * Retrieves the source content for a particular source, if its found. Returns null if not. */ exports.sourceContentFor = void 0; /** * A helper that skips sorting of the input map's mappings array, which can be expensive for larger * maps. */ exports.presortedDecodedMap = void 0; /** * Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects * a sourcemap, or to JSON.stringify. */ exports.decodedMap = void 0; /** * Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects * a sourcemap, or to JSON.stringify. */ exports.encodedMap = void 0; class TraceMap { constructor(map, mapUrl) { const isString = typeof map === 'string'; if (!isString && map._decodedMemo) return map; const parsed = (isString ? JSON.parse(map) : map); const { version, file, names, sourceRoot, sources, sourcesContent } = parsed; this.version = version; this.file = file; this.names = names; this.sourceRoot = sourceRoot; this.sources = sources; this.sourcesContent = sourcesContent; const from = resolve(sourceRoot || '', stripFilename(mapUrl)); this.resolvedSources = sources.map((s) => resolve(s || '', from)); const { mappings } = parsed; if (typeof mappings === 'string') { this._encoded = mappings; this._decoded = undefined; } else { this._encoded = undefined; this._decoded = maybeSort(mappings, isString); } this._decodedMemo = memoizedState(); this._bySources = undefined; this._bySourceMemos = undefined; } } (() => { exports.encodedMappings = (map) => { var _a; return ((_a = map._encoded) !== null && _a !== void 0 ? _a : (map._encoded = sourcemapCodec.encode(map._decoded))); }; exports.decodedMappings = (map) => { return (map._decoded || (map._decoded = sourcemapCodec.decode(map._encoded))); }; exports.traceSegment = (map, line, column) => { const decoded = exports.decodedMappings(map); // It's common for parent source maps to have pointers to lines that have no // mapping (like a "//# sourceMappingURL=") at the end of the child file. if (line >= decoded.length) return null; const segments = decoded[line]; const index = traceSegmentInternal(segments, map._decodedMemo, line, column, GREATEST_LOWER_BOUND); return index === -1 ? null : segments[index]; }; exports.originalPositionFor = (map, { line, column, bias }) => { line--; if (line < 0) throw new Error(LINE_GTR_ZERO); if (column < 0) throw new Error(COL_GTR_EQ_ZERO); const decoded = exports.decodedMappings(map); // It's common for parent source maps to have pointers to lines that have no // mapping (like a "//# sourceMappingURL=") at the end of the child file. if (line >= decoded.length) return OMapping(null, null, null, null); const segments = decoded[line]; const index = traceSegmentInternal(segments, map._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND); if (index === -1) return OMapping(null, null, null, null); const segment = segments[index]; if (segment.length === 1) return OMapping(null, null, null, null); const { names, resolvedSources } = map; return OMapping(resolvedSources[segment[SOURCES_INDEX]], segment[SOURCE_LINE] + 1, segment[SOURCE_COLUMN], segment.length === 5 ? names[segment[NAMES_INDEX]] : null); }; exports.allGeneratedPositionsFor = (map, { source, line, column }) => { return generatedPosition(map, source, line, column, ALL_BOUND); }; exports.generatedPositionFor = (map, { source, line, column, bias }) => { return generatedPosition(map, source, line, column, bias || GREATEST_LOWER_BOUND); }; exports.eachMapping = (map, cb) => { const decoded = exports.decodedMappings(map); const { names, resolvedSources } = map; for (let i = 0; i < decoded.length; i++) { const line = decoded[i]; for (let j = 0; j < line.length; j++) { const seg = line[j]; const generatedLine = i + 1; const generatedColumn = seg[0]; let source = null; let originalLine = null; let originalColumn = null; let name = null; if (seg.length !== 1) { source = resolvedSources[seg[1]]; originalLine = seg[2] + 1; originalColumn = seg[3]; } if (seg.length === 5) name = names[seg[4]]; cb({ generatedLine, generatedColumn, source, originalLine, originalColumn, name, }); } } }; exports.sourceContentFor = (map, source) => { const { sources, resolvedSources, sourcesContent } = map; if (sourcesContent == null) return null; let index = sources.indexOf(source); if (index === -1) index = resolvedSources.indexOf(source); return index === -1 ? null : sourcesContent[index]; }; exports.presortedDecodedMap = (map, mapUrl) => { const tracer = new TraceMap(clone(map, []), mapUrl); tracer._decoded = map.mappings; return tracer; }; exports.decodedMap = (map) => { return clone(map, exports.decodedMappings(map)); }; exports.encodedMap = (map) => { return clone(map, exports.encodedMappings(map)); }; function generatedPosition(map, source, line, column, bias) { line--; if (line < 0) throw new Error(LINE_GTR_ZERO); if (column < 0) throw new Error(COL_GTR_EQ_ZERO); const { sources, resolvedSources } = map; let sourceIndex = sources.indexOf(source); if (sourceIndex === -1) sourceIndex = resolvedSources.indexOf(source); if (sourceIndex === -1) return bias === ALL_BOUND ? [] : GMapping(null, null); const generated = (map._bySources || (map._bySources = buildBySources(exports.decodedMappings(map), (map._bySourceMemos = sources.map(memoizedState))))); const segments = generated[sourceIndex][line]; if (segments == null) return bias === ALL_BOUND ? [] : GMapping(null, null); const memo = map._bySourceMemos[sourceIndex]; if (bias === ALL_BOUND) return sliceGeneratedPositions(segments, memo, line, column); const index = traceSegmentInternal(segments, memo, line, column, bias); if (index === -1) return GMapping(null, null); const segment = segments[index]; return GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]); } })(); function clone(map, mappings) { return { version: map.version, file: map.file, names: map.names, sourceRoot: map.sourceRoot, sources: map.sources, sourcesContent: map.sourcesContent, mappings, }; } function OMapping(source, line, column, name) { return { source, line, column, name }; } function GMapping(line, column) { return { line, column }; } function traceSegmentInternal(segments, memo, line, column, bias) { let index = memoizedBinarySearch(segments, column, memo, line); if (found) { index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index); } else if (bias === LEAST_UPPER_BOUND) index++; if (index === -1 || index === segments.length) return -1; return index; } function sliceGeneratedPositions(segments, memo, line, column) { let min = traceSegmentInternal(segments, memo, line, column, GREATEST_LOWER_BOUND); if (min === -1) return []; // We may have found the segment that started at an earlier column. If this is the case, then we // need to slice all generated segments that match _that_ column, because all such segments span // to our desired column. const matchedColumn = found ? column : segments[min][COLUMN]; // The binary search is not guaranteed to find the lower bound when a match wasn't found. if (!found) min = lowerBound(segments, matchedColumn, min); const max = upperBound(segments, matchedColumn, min); const result = []; for (; min <= max; min++) { const segment = segments[min]; result.push(GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN])); } return result; } exports.AnyMap = AnyMap; exports.GREATEST_LOWER_BOUND = GREATEST_LOWER_BOUND; exports.LEAST_UPPER_BOUND = LEAST_UPPER_BOUND; exports.TraceMap = TraceMap; Object.defineProperty(exports, '__esModule', { value: true }); })); },{"@jridgewell/resolve-uri":396,"@jridgewell/sourcemap-codec":398}],400:[function(require,module,exports){ 'use strict'; const colorConvert = require('color-convert'); const wrapAnsi16 = (fn, offset) => function () { const code = fn.apply(colorConvert, arguments); return `\u001B[${code + offset}m`; }; const wrapAnsi256 = (fn, offset) => function () { const code = fn.apply(colorConvert, arguments); return `\u001B[${38 + offset};5;${code}m`; }; const wrapAnsi16m = (fn, offset) => function () { const rgb = fn.apply(colorConvert, arguments); return `\u001B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`; }; function assembleStyles() { const codes = new Map(); const styles = { modifier: { reset: [0, 0], // 21 isn't widely supported and 22 does the same thing bold: [1, 22], dim: [2, 22], italic: [3, 23], underline: [4, 24], inverse: [7, 27], hidden: [8, 28], strikethrough: [9, 29] }, color: { black: [30, 39], red: [31, 39], green: [32, 39], yellow: [33, 39], blue: [34, 39], magenta: [35, 39], cyan: [36, 39], white: [37, 39], gray: [90, 39], // Bright color redBright: [91, 39], greenBright: [92, 39], yellowBright: [93, 39], blueBright: [94, 39], magentaBright: [95, 39], cyanBright: [96, 39], whiteBright: [97, 39] }, bgColor: { bgBlack: [40, 49], bgRed: [41, 49], bgGreen: [42, 49], bgYellow: [43, 49], bgBlue: [44, 49], bgMagenta: [45, 49], bgCyan: [46, 49], bgWhite: [47, 49], // Bright color bgBlackBright: [100, 49], bgRedBright: [101, 49], bgGreenBright: [102, 49], bgYellowBright: [103, 49], bgBlueBright: [104, 49], bgMagentaBright: [105, 49], bgCyanBright: [106, 49], bgWhiteBright: [107, 49] } }; // Fix humans styles.color.grey = styles.color.gray; for (const groupName of Object.keys(styles)) { const group = styles[groupName]; for (const styleName of Object.keys(group)) { const style = group[styleName]; styles[styleName] = { open: `\u001B[${style[0]}m`, close: `\u001B[${style[1]}m` }; group[styleName] = styles[styleName]; codes.set(style[0], style[1]); } Object.defineProperty(styles, groupName, { value: group, enumerable: false }); Object.defineProperty(styles, 'codes', { value: codes, enumerable: false }); } const ansi2ansi = n => n; const rgb2rgb = (r, g, b) => [r, g, b]; styles.color.close = '\u001B[39m'; styles.bgColor.close = '\u001B[49m'; styles.color.ansi = { ansi: wrapAnsi16(ansi2ansi, 0) }; styles.color.ansi256 = { ansi256: wrapAnsi256(ansi2ansi, 0) }; styles.color.ansi16m = { rgb: wrapAnsi16m(rgb2rgb, 0) }; styles.bgColor.ansi = { ansi: wrapAnsi16(ansi2ansi, 10) }; styles.bgColor.ansi256 = { ansi256: wrapAnsi256(ansi2ansi, 10) }; styles.bgColor.ansi16m = { rgb: wrapAnsi16m(rgb2rgb, 10) }; for (let key of Object.keys(colorConvert)) { if (typeof colorConvert[key] !== 'object') { continue; } const suite = colorConvert[key]; if (key === 'ansi16') { key = 'ansi'; } if ('ansi16' in suite) { styles.color.ansi[key] = wrapAnsi16(suite.ansi16, 0); styles.bgColor.ansi[key] = wrapAnsi16(suite.ansi16, 10); } if ('ansi256' in suite) { styles.color.ansi256[key] = wrapAnsi256(suite.ansi256, 0); styles.bgColor.ansi256[key] = wrapAnsi256(suite.ansi256, 10); } if ('rgb' in suite) { styles.color.ansi16m[key] = wrapAnsi16m(suite.rgb, 0); styles.bgColor.ansi16m[key] = wrapAnsi16m(suite.rgb, 10); } } return styles; } // Make the export immutable Object.defineProperty(module, 'exports', { enumerable: true, get: assembleStyles }); },{"color-convert":426}],401:[function(require,module,exports){ /** * Array#filter. * * @param {Array} arr * @param {Function} fn * @param {Object=} self * @return {Array} * @throw TypeError */ module.exports = function (arr, fn, self) { if (arr.filter) return arr.filter(fn, self); if (void 0 === arr || null === arr) throw new TypeError; if ('function' != typeof fn) throw new TypeError; var ret = []; for (var i = 0; i < arr.length; i++) { if (!hasOwn.call(arr, i)) continue; var val = arr[i]; if (fn.call(self, val, i, arr)) ret.push(val); } return ret; }; var hasOwn = Object.prototype.hasOwnProperty; },{}],402:[function(require,module,exports){ (function (global){(function (){ 'use strict'; var objectAssign = require('object-assign'); // compare and isBuffer taken from https://github.com/feross/buffer/blob/680e9e5e488f22aac27599a57dc844a6315928dd/index.js // original notice: /*! * The buffer module from node.js, for the browser. * * @author Feross Aboukhadijeh * @license MIT */ function compare(a, b) { if (a === b) { return 0; } var x = a.length; var y = b.length; for (var i = 0, len = Math.min(x, y); i < len; ++i) { if (a[i] !== b[i]) { x = a[i]; y = b[i]; break; } } if (x < y) { return -1; } if (y < x) { return 1; } return 0; } function isBuffer(b) { if (global.Buffer && typeof global.Buffer.isBuffer === 'function') { return global.Buffer.isBuffer(b); } return !!(b != null && b._isBuffer); } // based on node assert, original notice: // NB: The URL to the CommonJS spec is kept just for tradition. // node-assert has evolved a lot since then, both in API and behavior. // http://wiki.commonjs.org/wiki/Unit_Testing/1.0 // // THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8! // // Originally from narwhal.js (http://narwhaljs.org) // Copyright (c) 2009 Thomas Robinson <280north.com> // // 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 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. var util = require('util/'); var hasOwn = Object.prototype.hasOwnProperty; var pSlice = Array.prototype.slice; var functionsHaveNames = (function () { return function foo() {}.name === 'foo'; }()); function pToString (obj) { return Object.prototype.toString.call(obj); } function isView(arrbuf) { if (isBuffer(arrbuf)) { return false; } if (typeof global.ArrayBuffer !== 'function') { return false; } if (typeof ArrayBuffer.isView === 'function') { return ArrayBuffer.isView(arrbuf); } if (!arrbuf) { return false; } if (arrbuf instanceof DataView) { return true; } if (arrbuf.buffer && arrbuf.buffer instanceof ArrayBuffer) { return true; } return false; } // 1. The assert module provides functions that throw // AssertionError's when particular conditions are not met. The // assert module must conform to the following interface. var assert = module.exports = ok; // 2. The AssertionError is defined in assert. // new assert.AssertionError({ message: message, // actual: actual, // expected: expected }) var regex = /\s*function\s+([^\(\s]*)\s*/; // based on https://github.com/ljharb/function.prototype.name/blob/adeeeec8bfcc6068b187d7d9fb3d5bb1d3a30899/implementation.js function getName(func) { if (!util.isFunction(func)) { return; } if (functionsHaveNames) { return func.name; } var str = func.toString(); var match = str.match(regex); return match && match[1]; } assert.AssertionError = function AssertionError(options) { this.name = 'AssertionError'; this.actual = options.actual; this.expected = options.expected; this.operator = options.operator; if (options.message) { this.message = options.message; this.generatedMessage = false; } else { this.message = getMessage(this); this.generatedMessage = true; } var stackStartFunction = options.stackStartFunction || fail; if (Error.captureStackTrace) { Error.captureStackTrace(this, stackStartFunction); } else { // non v8 browsers so we can have a stacktrace var err = new Error(); if (err.stack) { var out = err.stack; // try to strip useless frames var fn_name = getName(stackStartFunction); var idx = out.indexOf('\n' + fn_name); if (idx >= 0) { // once we have located the function frame // we need to strip out everything before it (and its line) var next_line = out.indexOf('\n', idx + 1); out = out.substring(next_line + 1); } this.stack = out; } } }; // assert.AssertionError instanceof Error util.inherits(assert.AssertionError, Error); function truncate(s, n) { if (typeof s === 'string') { return s.length < n ? s : s.slice(0, n); } else { return s; } } function inspect(something) { if (functionsHaveNames || !util.isFunction(something)) { return util.inspect(something); } var rawname = getName(something); var name = rawname ? ': ' + rawname : ''; return '[Function' + name + ']'; } function getMessage(self) { return truncate(inspect(self.actual), 128) + ' ' + self.operator + ' ' + truncate(inspect(self.expected), 128); } // At present only the three keys mentioned above are used and // understood by the spec. Implementations or sub modules can pass // other keys to the AssertionError's constructor - they will be // ignored. // 3. All of the following functions must throw an AssertionError // when a corresponding condition is not met, with a message that // may be undefined if not provided. All assertion methods provide // both the actual and expected values to the assertion error for // display purposes. function fail(actual, expected, message, operator, stackStartFunction) { throw new assert.AssertionError({ message: message, actual: actual, expected: expected, operator: operator, stackStartFunction: stackStartFunction }); } // EXTENSION! allows for well behaved errors defined elsewhere. assert.fail = fail; // 4. Pure assertion tests whether a value is truthy, as determined // by !!guard. // assert.ok(guard, message_opt); // This statement is equivalent to assert.equal(true, !!guard, // message_opt);. To test strictly for the value true, use // assert.strictEqual(true, guard, message_opt);. function ok(value, message) { if (!value) fail(value, true, message, '==', assert.ok); } assert.ok = ok; // 5. The equality assertion tests shallow, coercive equality with // ==. // assert.equal(actual, expected, message_opt); assert.equal = function equal(actual, expected, message) { if (actual != expected) fail(actual, expected, message, '==', assert.equal); }; // 6. The non-equality assertion tests for whether two objects are not equal // with != assert.notEqual(actual, expected, message_opt); assert.notEqual = function notEqual(actual, expected, message) { if (actual == expected) { fail(actual, expected, message, '!=', assert.notEqual); } }; // 7. The equivalence assertion tests a deep equality relation. // assert.deepEqual(actual, expected, message_opt); assert.deepEqual = function deepEqual(actual, expected, message) { if (!_deepEqual(actual, expected, false)) { fail(actual, expected, message, 'deepEqual', assert.deepEqual); } }; assert.deepStrictEqual = function deepStrictEqual(actual, expected, message) { if (!_deepEqual(actual, expected, true)) { fail(actual, expected, message, 'deepStrictEqual', assert.deepStrictEqual); } }; function _deepEqual(actual, expected, strict, memos) { // 7.1. All identical values are equivalent, as determined by ===. if (actual === expected) { return true; } else if (isBuffer(actual) && isBuffer(expected)) { return compare(actual, expected) === 0; // 7.2. If the expected value is a Date object, the actual value is // equivalent if it is also a Date object that refers to the same time. } else if (util.isDate(actual) && util.isDate(expected)) { return actual.getTime() === expected.getTime(); // 7.3 If the expected value is a RegExp object, the actual value is // equivalent if it is also a RegExp object with the same source and // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`). } else if (util.isRegExp(actual) && util.isRegExp(expected)) { return actual.source === expected.source && actual.global === expected.global && actual.multiline === expected.multiline && actual.lastIndex === expected.lastIndex && actual.ignoreCase === expected.ignoreCase; // 7.4. Other pairs that do not both pass typeof value == 'object', // equivalence is determined by ==. } else if ((actual === null || typeof actual !== 'object') && (expected === null || typeof expected !== 'object')) { return strict ? actual === expected : actual == expected; // If both values are instances of typed arrays, wrap their underlying // ArrayBuffers in a Buffer each to increase performance // This optimization requires the arrays to have the same type as checked by // Object.prototype.toString (aka pToString). Never perform binary // comparisons for Float*Arrays, though, since e.g. +0 === -0 but their // bit patterns are not identical. } else if (isView(actual) && isView(expected) && pToString(actual) === pToString(expected) && !(actual instanceof Float32Array || actual instanceof Float64Array)) { return compare(new Uint8Array(actual.buffer), new Uint8Array(expected.buffer)) === 0; // 7.5 For all other Object pairs, including Array objects, equivalence is // determined by having the same number of owned properties (as verified // with Object.prototype.hasOwnProperty.call), the same set of keys // (although not necessarily the same order), equivalent values for every // corresponding key, and an identical 'prototype' property. Note: this // accounts for both named and indexed properties on Arrays. } else if (isBuffer(actual) !== isBuffer(expected)) { return false; } else { memos = memos || {actual: [], expected: []}; var actualIndex = memos.actual.indexOf(actual); if (actualIndex !== -1) { if (actualIndex === memos.expected.indexOf(expected)) { return true; } } memos.actual.push(actual); memos.expected.push(expected); return objEquiv(actual, expected, strict, memos); } } function isArguments(object) { return Object.prototype.toString.call(object) == '[object Arguments]'; } function objEquiv(a, b, strict, actualVisitedObjects) { if (a === null || a === undefined || b === null || b === undefined) return false; // if one is a primitive, the other must be same if (util.isPrimitive(a) || util.isPrimitive(b)) return a === b; if (strict && Object.getPrototypeOf(a) !== Object.getPrototypeOf(b)) return false; var aIsArgs = isArguments(a); var bIsArgs = isArguments(b); if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs)) return false; if (aIsArgs) { a = pSlice.call(a); b = pSlice.call(b); return _deepEqual(a, b, strict); } var ka = objectKeys(a); var kb = objectKeys(b); var key, i; // having the same number of owned properties (keys incorporates // hasOwnProperty) if (ka.length !== kb.length) return false; //the same set of keys (although not necessarily the same order), ka.sort(); kb.sort(); //~~~cheap key test for (i = ka.length - 1; i >= 0; i--) { if (ka[i] !== kb[i]) return false; } //equivalent values for every corresponding key, and //~~~possibly expensive deep test for (i = ka.length - 1; i >= 0; i--) { key = ka[i]; if (!_deepEqual(a[key], b[key], strict, actualVisitedObjects)) return false; } return true; } // 8. The non-equivalence assertion tests for any deep inequality. // assert.notDeepEqual(actual, expected, message_opt); assert.notDeepEqual = function notDeepEqual(actual, expected, message) { if (_deepEqual(actual, expected, false)) { fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual); } }; assert.notDeepStrictEqual = notDeepStrictEqual; function notDeepStrictEqual(actual, expected, message) { if (_deepEqual(actual, expected, true)) { fail(actual, expected, message, 'notDeepStrictEqual', notDeepStrictEqual); } } // 9. The strict equality assertion tests strict equality, as determined by ===. // assert.strictEqual(actual, expected, message_opt); assert.strictEqual = function strictEqual(actual, expected, message) { if (actual !== expected) { fail(actual, expected, message, '===', assert.strictEqual); } }; // 10. The strict non-equality assertion tests for strict inequality, as // determined by !==. assert.notStrictEqual(actual, expected, message_opt); assert.notStrictEqual = function notStrictEqual(actual, expected, message) { if (actual === expected) { fail(actual, expected, message, '!==', assert.notStrictEqual); } }; function expectedException(actual, expected) { if (!actual || !expected) { return false; } if (Object.prototype.toString.call(expected) == '[object RegExp]') { return expected.test(actual); } try { if (actual instanceof expected) { return true; } } catch (e) { // Ignore. The instanceof check doesn't work for arrow functions. } if (Error.isPrototypeOf(expected)) { return false; } return expected.call({}, actual) === true; } function _tryBlock(block) { var error; try { block(); } catch (e) { error = e; } return error; } function _throws(shouldThrow, block, expected, message) { var actual; if (typeof block !== 'function') { throw new TypeError('"block" argument must be a function'); } if (typeof expected === 'string') { message = expected; expected = null; } actual = _tryBlock(block); message = (expected && expected.name ? ' (' + expected.name + ').' : '.') + (message ? ' ' + message : '.'); if (shouldThrow && !actual) { fail(actual, expected, 'Missing expected exception' + message); } var userProvidedMessage = typeof message === 'string'; var isUnwantedException = !shouldThrow && util.isError(actual); var isUnexpectedException = !shouldThrow && actual && !expected; if ((isUnwantedException && userProvidedMessage && expectedException(actual, expected)) || isUnexpectedException) { fail(actual, expected, 'Got unwanted exception' + message); } if ((shouldThrow && actual && expected && !expectedException(actual, expected)) || (!shouldThrow && actual)) { throw actual; } } // 11. Expected to throw an error: // assert.throws(block, Error_opt, message_opt); assert.throws = function(block, /*optional*/error, /*optional*/message) { _throws(true, block, error, message); }; // EXTENSION! This is annoying to write outside this module. assert.doesNotThrow = function(block, /*optional*/error, /*optional*/message) { _throws(false, block, error, message); }; assert.ifError = function(err) { if (err) throw err; }; // Expose a strict only variant of assert function strict(value, message) { if (!value) fail(value, true, message, '==', strict); } assert.strict = objectAssign(strict, assert, { equal: assert.strictEqual, deepEqual: assert.deepStrictEqual, notEqual: assert.notStrictEqual, notDeepEqual: assert.notDeepStrictEqual }); assert.strict.strict = assert.strict; var objectKeys = Object.keys || function (obj) { var keys = []; for (var key in obj) { if (hasOwn.call(obj, key)) keys.push(key); } return keys; }; }).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) },{"object-assign":457,"util/":405}],403:[function(require,module,exports){ if (typeof Object.create === 'function') { // implementation from standard node.js 'util' module module.exports = function inherits(ctor, superCtor) { ctor.super_ = superCtor ctor.prototype = Object.create(superCtor.prototype, { constructor: { value: ctor, enumerable: false, writable: true, configurable: true } }); }; } else { // old school shim for old browsers module.exports = function inherits(ctor, superCtor) { ctor.super_ = superCtor var TempCtor = function () {} TempCtor.prototype = superCtor.prototype ctor.prototype = new TempCtor() ctor.prototype.constructor = ctor } } },{}],404:[function(require,module,exports){ module.exports = function isBuffer(arg) { return arg && typeof arg === 'object' && typeof arg.copy === 'function' && typeof arg.fill === 'function' && typeof arg.readUInt8 === 'function'; } },{}],405:[function(require,module,exports){ (function (process,global){(function (){ // Copyright Joyent, Inc. and other Node contributors. // // 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. var formatRegExp = /%[sdj%]/g; exports.format = function(f) { if (!isString(f)) { var objects = []; for (var i = 0; i < arguments.length; i++) { objects.push(inspect(arguments[i])); } return objects.join(' '); } var i = 1; var args = arguments; var len = args.length; var str = String(f).replace(formatRegExp, function(x) { if (x === '%%') return '%'; if (i >= len) return x; switch (x) { case '%s': return String(args[i++]); case '%d': return Number(args[i++]); case '%j': try { return JSON.stringify(args[i++]); } catch (_) { return '[Circular]'; } default: return x; } }); for (var x = args[i]; i < len; x = args[++i]) { if (isNull(x) || !isObject(x)) { str += ' ' + x; } else { str += ' ' + inspect(x); } } return str; }; // Mark that a method should not be used. // Returns a modified function which warns once by default. // If --no-deprecation is set, then it is a no-op. exports.deprecate = function(fn, msg) { // Allow for deprecating things in the process of starting up. if (isUndefined(global.process)) { return function() { return exports.deprecate(fn, msg).apply(this, arguments); }; } if (process.noDeprecation === true) { return fn; } var warned = false; function deprecated() { if (!warned) { if (process.throwDeprecation) { throw new Error(msg); } else if (process.traceDeprecation) { console.trace(msg); } else { console.error(msg); } warned = true; } return fn.apply(this, arguments); } return deprecated; }; var debugs = {}; var debugEnviron; exports.debuglog = function(set) { if (isUndefined(debugEnviron)) debugEnviron = process.env.NODE_DEBUG || ''; set = set.toUpperCase(); if (!debugs[set]) { if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) { var pid = process.pid; debugs[set] = function() { var msg = exports.format.apply(exports, arguments); console.error('%s %d: %s', set, pid, msg); }; } else { debugs[set] = function() {}; } } return debugs[set]; }; /** * Echos the value of a value. Trys to print the value out * in the best way possible given the different types. * * @param {Object} obj The object to print out. * @param {Object} opts Optional options object that alters the output. */ /* legacy: obj, showHidden, depth, colors*/ function inspect(obj, opts) { // default options var ctx = { seen: [], stylize: stylizeNoColor }; // legacy... if (arguments.length >= 3) ctx.depth = arguments[2]; if (arguments.length >= 4) ctx.colors = arguments[3]; if (isBoolean(opts)) { // legacy... ctx.showHidden = opts; } else if (opts) { // got an "options" object exports._extend(ctx, opts); } // set default options if (isUndefined(ctx.showHidden)) ctx.showHidden = false; if (isUndefined(ctx.depth)) ctx.depth = 2; if (isUndefined(ctx.colors)) ctx.colors = false; if (isUndefined(ctx.customInspect)) ctx.customInspect = true; if (ctx.colors) ctx.stylize = stylizeWithColor; return formatValue(ctx, obj, ctx.depth); } exports.inspect = inspect; // http://en.wikipedia.org/wiki/ANSI_escape_code#graphics inspect.colors = { 'bold' : [1, 22], 'italic' : [3, 23], 'underline' : [4, 24], 'inverse' : [7, 27], 'white' : [37, 39], 'grey' : [90, 39], 'black' : [30, 39], 'blue' : [34, 39], 'cyan' : [36, 39], 'green' : [32, 39], 'magenta' : [35, 39], 'red' : [31, 39], 'yellow' : [33, 39] }; // Don't use 'blue' not visible on cmd.exe inspect.styles = { 'special': 'cyan', 'number': 'yellow', 'boolean': 'yellow', 'undefined': 'grey', 'null': 'bold', 'string': 'green', 'date': 'magenta', // "name": intentionally not styling 'regexp': 'red' }; function stylizeWithColor(str, styleType) { var style = inspect.styles[styleType]; if (style) { return '\u001b[' + inspect.colors[style][0] + 'm' + str + '\u001b[' + inspect.colors[style][1] + 'm'; } else { return str; } } function stylizeNoColor(str, styleType) { return str; } function arrayToHash(array) { var hash = {}; array.forEach(function(val, idx) { hash[val] = true; }); return hash; } function formatValue(ctx, value, recurseTimes) { // Provide a hook for user-specified inspect functions. // Check that value is an object with an inspect function on it if (ctx.customInspect && value && isFunction(value.inspect) && // Filter out the util module, it's inspect function is special value.inspect !== exports.inspect && // Also filter out any prototype objects using the circular check. !(value.constructor && value.constructor.prototype === value)) { var ret = value.inspect(recurseTimes, ctx); if (!isString(ret)) { ret = formatValue(ctx, ret, recurseTimes); } return ret; } // Primitive types cannot have properties var primitive = formatPrimitive(ctx, value); if (primitive) { return primitive; } // Look up the keys of the object. var keys = Object.keys(value); var visibleKeys = arrayToHash(keys); if (ctx.showHidden) { keys = Object.getOwnPropertyNames(value); } // IE doesn't make error fields non-enumerable // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx if (isError(value) && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) { return formatError(value); } // Some type of object without properties can be shortcutted. if (keys.length === 0) { if (isFunction(value)) { var name = value.name ? ': ' + value.name : ''; return ctx.stylize('[Function' + name + ']', 'special'); } if (isRegExp(value)) { return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); } if (isDate(value)) { return ctx.stylize(Date.prototype.toString.call(value), 'date'); } if (isError(value)) { return formatError(value); } } var base = '', array = false, braces = ['{', '}']; // Make Array say that they are Array if (isArray(value)) { array = true; braces = ['[', ']']; } // Make functions say that they are functions if (isFunction(value)) { var n = value.name ? ': ' + value.name : ''; base = ' [Function' + n + ']'; } // Make RegExps say that they are RegExps if (isRegExp(value)) { base = ' ' + RegExp.prototype.toString.call(value); } // Make dates with properties first say the date if (isDate(value)) { base = ' ' + Date.prototype.toUTCString.call(value); } // Make error with message first say the error if (isError(value)) { base = ' ' + formatError(value); } if (keys.length === 0 && (!array || value.length == 0)) { return braces[0] + base + braces[1]; } if (recurseTimes < 0) { if (isRegExp(value)) { return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); } else { return ctx.stylize('[Object]', 'special'); } } ctx.seen.push(value); var output; if (array) { output = formatArray(ctx, value, recurseTimes, visibleKeys, keys); } else { output = keys.map(function(key) { return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array); }); } ctx.seen.pop(); return reduceToSingleString(output, base, braces); } function formatPrimitive(ctx, value) { if (isUndefined(value)) return ctx.stylize('undefined', 'undefined'); if (isString(value)) { var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '') .replace(/'/g, "\\'") .replace(/\\"/g, '"') + '\''; return ctx.stylize(simple, 'string'); } if (isNumber(value)) return ctx.stylize('' + value, 'number'); if (isBoolean(value)) return ctx.stylize('' + value, 'boolean'); // For some reason typeof null is "object", so special case here. if (isNull(value)) return ctx.stylize('null', 'null'); } function formatError(value) { return '[' + Error.prototype.toString.call(value) + ']'; } function formatArray(ctx, value, recurseTimes, visibleKeys, keys) { var output = []; for (var i = 0, l = value.length; i < l; ++i) { if (hasOwnProperty(value, String(i))) { output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, String(i), true)); } else { output.push(''); } } keys.forEach(function(key) { if (!key.match(/^\d+$/)) { output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, key, true)); } }); return output; } function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) { var name, str, desc; desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] }; if (desc.get) { if (desc.set) { str = ctx.stylize('[Getter/Setter]', 'special'); } else { str = ctx.stylize('[Getter]', 'special'); } } else { if (desc.set) { str = ctx.stylize('[Setter]', 'special'); } } if (!hasOwnProperty(visibleKeys, key)) { name = '[' + key + ']'; } if (!str) { if (ctx.seen.indexOf(desc.value) < 0) { if (isNull(recurseTimes)) { str = formatValue(ctx, desc.value, null); } else { str = formatValue(ctx, desc.value, recurseTimes - 1); } if (str.indexOf('\n') > -1) { if (array) { str = str.split('\n').map(function(line) { return ' ' + line; }).join('\n').substr(2); } else { str = '\n' + str.split('\n').map(function(line) { return ' ' + line; }).join('\n'); } } } else { str = ctx.stylize('[Circular]', 'special'); } } if (isUndefined(name)) { if (array && key.match(/^\d+$/)) { return str; } name = JSON.stringify('' + key); if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) { name = name.substr(1, name.length - 2); name = ctx.stylize(name, 'name'); } else { name = name.replace(/'/g, "\\'") .replace(/\\"/g, '"') .replace(/(^"|"$)/g, "'"); name = ctx.stylize(name, 'string'); } } return name + ': ' + str; } function reduceToSingleString(output, base, braces) { var numLinesEst = 0; var length = output.reduce(function(prev, cur) { numLinesEst++; if (cur.indexOf('\n') >= 0) numLinesEst++; return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1; }, 0); if (length > 60) { return braces[0] + (base === '' ? '' : base + '\n ') + ' ' + output.join(',\n ') + ' ' + braces[1]; } return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1]; } // NOTE: These type checking functions intentionally don't use `instanceof` // because it is fragile and can be easily faked with `Object.create()`. function isArray(ar) { return Array.isArray(ar); } exports.isArray = isArray; function isBoolean(arg) { return typeof arg === 'boolean'; } exports.isBoolean = isBoolean; function isNull(arg) { return arg === null; } exports.isNull = isNull; function isNullOrUndefined(arg) { return arg == null; } exports.isNullOrUndefined = isNullOrUndefined; function isNumber(arg) { return typeof arg === 'number'; } exports.isNumber = isNumber; function isString(arg) { return typeof arg === 'string'; } exports.isString = isString; function isSymbol(arg) { return typeof arg === 'symbol'; } exports.isSymbol = isSymbol; function isUndefined(arg) { return arg === void 0; } exports.isUndefined = isUndefined; function isRegExp(re) { return isObject(re) && objectToString(re) === '[object RegExp]'; } exports.isRegExp = isRegExp; function isObject(arg) { return typeof arg === 'object' && arg !== null; } exports.isObject = isObject; function isDate(d) { return isObject(d) && objectToString(d) === '[object Date]'; } exports.isDate = isDate; function isError(e) { return isObject(e) && (objectToString(e) === '[object Error]' || e instanceof Error); } exports.isError = isError; function isFunction(arg) { return typeof arg === 'function'; } exports.isFunction = isFunction; function isPrimitive(arg) { return arg === null || typeof arg === 'boolean' || typeof arg === 'number' || typeof arg === 'string' || typeof arg === 'symbol' || // ES6 symbol typeof arg === 'undefined'; } exports.isPrimitive = isPrimitive; exports.isBuffer = require('./support/isBuffer'); function objectToString(o) { return Object.prototype.toString.call(o); } function pad(n) { return n < 10 ? '0' + n.toString(10) : n.toString(10); } var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']; // 26 Feb 16:19:34 function timestamp() { var d = new Date(); var time = [pad(d.getHours()), pad(d.getMinutes()), pad(d.getSeconds())].join(':'); return [d.getDate(), months[d.getMonth()], time].join(' '); } // log is just a thin wrapper to console.log that prepends a timestamp exports.log = function() { console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments)); }; /** * Inherit the prototype methods from one constructor into another. * * The Function.prototype.inherits from lang.js rewritten as a standalone * function (not on Function.prototype). NOTE: If this file is to be loaded * during bootstrapping this function needs to be rewritten using some native * functions as prototype setup using normal JavaScript does not work as * expected during bootstrapping (see mirror.js in r114903). * * @param {function} ctor Constructor function which needs to inherit the * prototype. * @param {function} superCtor Constructor function to inherit prototype from. */ exports.inherits = require('inherits'); exports._extend = function(origin, add) { // Don't do anything if add isn't an object if (!add || !isObject(add)) return origin; var keys = Object.keys(add); var i = keys.length; while (i--) { origin[keys[i]] = add[keys[i]]; } return origin; }; function hasOwnProperty(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); } }).call(this)}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) },{"./support/isBuffer":404,"_process":460,"inherits":403}],406:[function(require,module,exports){ (function (global){(function (){ 'use strict'; var filter = require('array-filter'); module.exports = function availableTypedArrays() { return filter([ 'BigInt64Array', 'BigUint64Array', 'Float32Array', 'Float64Array', 'Int16Array', 'Int32Array', 'Int8Array', 'Uint16Array', 'Uint32Array', 'Uint8Array', 'Uint8ClampedArray' ], function (typedArray) { return typeof global[typedArray] === 'function'; }); }; }).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) },{"array-filter":401}],407:[function(require,module,exports){ 'use strict' exports.byteLength = byteLength exports.toByteArray = toByteArray exports.fromByteArray = fromByteArray var lookup = [] var revLookup = [] var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/' for (var i = 0, len = code.length; i < len; ++i) { lookup[i] = code[i] revLookup[code.charCodeAt(i)] = i } // Support decoding URL-safe base64 strings, as Node.js does. // See: https://en.wikipedia.org/wiki/Base64#URL_applications revLookup['-'.charCodeAt(0)] = 62 revLookup['_'.charCodeAt(0)] = 63 function getLens (b64) { var len = b64.length if (len % 4 > 0) { throw new Error('Invalid string. Length must be a multiple of 4') } // Trim off extra bytes after placeholder bytes are found // See: https://github.com/beatgammit/base64-js/issues/42 var validLen = b64.indexOf('=') if (validLen === -1) validLen = len var placeHoldersLen = validLen === len ? 0 : 4 - (validLen % 4) return [validLen, placeHoldersLen] } // base64 is 4/3 + up to two characters of the original data function byteLength (b64) { var lens = getLens(b64) var validLen = lens[0] var placeHoldersLen = lens[1] return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen } function _byteLength (b64, validLen, placeHoldersLen) { return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen } function toByteArray (b64) { var tmp var lens = getLens(b64) var validLen = lens[0] var placeHoldersLen = lens[1] var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen)) var curByte = 0 // if there are placeholders, only get up to the last complete 4 chars var len = placeHoldersLen > 0 ? validLen - 4 : validLen var i for (i = 0; i < len; i += 4) { tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)] arr[curByte++] = (tmp >> 16) & 0xFF arr[curByte++] = (tmp >> 8) & 0xFF arr[curByte++] = tmp & 0xFF } if (placeHoldersLen === 2) { tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4) arr[curByte++] = tmp & 0xFF } if (placeHoldersLen === 1) { tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2) arr[curByte++] = (tmp >> 8) & 0xFF arr[curByte++] = tmp & 0xFF } return arr } function tripletToBase64 (num) { return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F] } function encodeChunk (uint8, start, end) { var tmp var output = [] for (var i = start; i < end; i += 3) { tmp = ((uint8[i] << 16) & 0xFF0000) + ((uint8[i + 1] << 8) & 0xFF00) + (uint8[i + 2] & 0xFF) output.push(tripletToBase64(tmp)) } return output.join('') } function fromByteArray (uint8) { var tmp var len = uint8.length var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes var parts = [] var maxChunkLength = 16383 // must be multiple of 3 // go through the array every three bytes, we'll deal with trailing stuff later for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) { parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength))) } // pad the end with zeros, but make sure to not forget the extra bytes if (extraBytes === 1) { tmp = uint8[len - 1] parts.push( lookup[tmp >> 2] + lookup[(tmp << 4) & 0x3F] + '==' ) } else if (extraBytes === 2) { tmp = (uint8[len - 2] << 8) + uint8[len - 1] parts.push( lookup[tmp >> 10] + lookup[(tmp >> 4) & 0x3F] + lookup[(tmp << 2) & 0x3F] + '=' ) } return parts.join('') } },{}],408:[function(require,module,exports){ arguments[4][9][0].apply(exports,arguments) },{"dup":9}],409:[function(require,module,exports){ arguments[4][9][0].apply(exports,arguments) },{"dup":9}],410:[function(require,module,exports){ 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 are not supported ' + 'in client-side build of Browserslist' ) }, loadFeature: function loadFeature() { throw new BrowserslistError( 'Supports queries are not available in client-side build of Browserslist' ) }, currentNode: function currentNode(resolve, context) { return resolve(['maintained node versions'], context)[0] }, parseConfig: noop, readConfig: noop, findConfig: noop, clearCaches: noop, oldDataWarning: noop } },{"./error":411}],411:[function(require,module,exports){ 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 },{}],412:[function(require,module,exports){ (function (process){(function (){ var jsReleases = require('node-releases/data/processed/envs.json') var agents = require('caniuse-lite/dist/unpacker/agents').agents var jsEOL = require('node-releases/data/release-schedule/release-schedule.json') var path = require('path') var e2c = require('electron-to-chromium/versions') var BrowserslistError = require('./error') var parse = require('./parse') var env = require('./node') // Will load browser.js in webpack var YEAR = 365.259641 * 24 * 60 * 60 * 1000 var ANDROID_EVERGREEN_FIRST = 37 // Helpers function isVersionsMatch(versionA, versionB) { return (versionA + '.').indexOf(versionB + '.') === 0 } function isEolReleased(name) { var version = name.slice(1) return browserslist.nodeVersions.some(function (i) { return isVersionsMatch(i, version) }) } function normalize(versions) { return versions.filter(function (version) { return typeof version === 'string' }) } function normalizeElectron(version) { var versionToUse = version if (version.split('.').length === 3) { versionToUse = version.split('.').slice(0, -1).join('.') } return versionToUse } 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 majorVersions = uniq(released.map(getMajor)) var minimum = majorVersions[majorVersions.length - number] if (!minimum) { return released } 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 } 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 generateSemverFilter(sign, version) { version = version.split('.').map(parseSimpleInt) version[1] = version[1] || 0 version[2] = version[2] || 0 if (sign === '>') { return function (v) { v = v.split('.').map(parseSimpleInt) return compareSemver(v, version) > 0 } } else if (sign === '>=') { return function (v) { v = v.split('.').map(parseSimpleInt) return compareSemver(v, version) >= 0 } } else if (sign === '<') { return function (v) { v = v.split('.').map(parseSimpleInt) return compareSemver(version, v) > 0 } } else { return function (v) { v = v.split('.').map(parseSimpleInt) return compareSemver(version, v) >= 0 } } } function parseSimpleInt(x) { return parseInt(x) } function compare(a, b) { if (a < b) return -1 if (a > b) return +1 return 0 } function compareSemver(a, b) { return ( compare(parseInt(a[0]), parseInt(b[0])) || compare(parseInt(a[1] || '0'), parseInt(b[1] || '0')) || compare(parseInt(a[2] || '0'), parseInt(b[2] || '0')) ) } // this follows the npm-like semver behavior function semverFilterLoose(operator, range) { range = range.split('.').map(parseSimpleInt) if (typeof range[1] === 'undefined') { range[1] = 'x' } // ignore any patch version because we only return minor versions // range[2] = 'x' switch (operator) { case '<=': return function (version) { version = version.split('.').map(parseSimpleInt) return compareSemverLoose(version, range) <= 0 } case '>=': default: return function (version) { version = version.split('.').map(parseSimpleInt) return compareSemverLoose(version, range) >= 0 } } } // this follows the npm-like semver behavior function compareSemverLoose(version, range) { if (version[0] !== range[0]) { return version[0] < range[0] ? -1 : +1 } if (range[1] === 'x') { return 0 } if (version[1] !== range[1]) { return version[1] < range[1] ? -1 : +1 } return 0 } function resolveVersion(data, version) { if (data.versions.indexOf(version) !== -1) { return version } else if (browserslist.versionAliases[data.name][version]) { return browserslist.versionAliases[data.name][version] } else { return false } } function normalizeVersion(data, version) { var resolved = resolveVersion(data, version) if (resolved) { return resolved } else if (data.versions.length === 1) { return data.versions[0] } else { return false } } function filterByYear(since, context) { since = since / 1000 return Object.keys(agents).reduce(function (selected, name) { var data = byName(name, context) if (!data) return selected var versions = Object.keys(data.releaseDate).filter(function (v) { var date = data.releaseDate[v] return date !== null && date >= since }) return selected.concat(versions.map(nameMapper(data.name))) }, []) } function cloneData(data) { return { name: data.name, versions: data.versions, released: data.released, releaseDate: data.releaseDate } } function mapVersions(data, map) { data.versions = data.versions.map(function (i) { return map[i] || i }) data.released = data.released.map(function (i) { return map[i] || i }) var fixedDate = {} for (var i in data.releaseDate) { fixedDate[map[i] || i] = data.releaseDate[i] } data.releaseDate = fixedDate return data } function byName(name, context) { name = name.toLowerCase() name = browserslist.aliases[name] || name if (context.mobileToDesktop && browserslist.desktopNames[name]) { var desktop = browserslist.data[browserslist.desktopNames[name]] if (name === 'android') { return normalizeAndroidData(cloneData(browserslist.data[name]), desktop) } else { var cloned = cloneData(desktop) cloned.name = name if (name === 'op_mob') { cloned = mapVersions(cloned, { '10.0-10.1': '10' }) } return cloned } } return browserslist.data[name] } function normalizeAndroidVersions(androidVersions, chromeVersions) { var firstEvergreen = ANDROID_EVERGREEN_FIRST var last = chromeVersions[chromeVersions.length - 1] return androidVersions .filter(function (version) { return /^(?:[2-4]\.|[34]$)/.test(version) }) .concat(chromeVersions.slice(firstEvergreen - last - 1)) } function normalizeAndroidData(android, chrome) { android.released = normalizeAndroidVersions(android.released, chrome.released) android.versions = normalizeAndroidVersions(android.versions, chrome.versions) return android } function checkName(name, context) { var data = byName(name, context) if (!data) throw new BrowserslistError('Unknown browser ' + name) return data } function unknownQuery(query) { return new BrowserslistError( 'Unknown browser query `' + query + '`. ' + 'Maybe you are using old Browserslist or made typo in query.' ) } function filterAndroid(list, versions, context) { if (context.mobileToDesktop) return list var released = browserslist.data.android.released var last = released[released.length - 1] var diff = last - ANDROID_EVERGREEN_FIRST - versions if (diff > 0) { return list.slice(-1) } else { return list.slice(diff - 1) } } function resolve(queries, context) { return parse(QUERIES, queries).reduce(function (result, node, index) { if (node.not && index === 0) { throw new BrowserslistError( 'Write any browsers query (for instance, `defaults`) ' + 'before `' + node.query + '`' ) } var type = QUERIES[node.type] var array = type.select.call(browserslist, context, node).map(function (j) { var parts = j.split(' ') if (parts[1] === '0') { return parts[0] + ' ' + byName(parts[0], context).versions[0] } else { return j } }) if (node.compose === 'and') { if (node.not) { return result.filter(function (j) { return array.indexOf(j) === -1 }) } else { return result.filter(function (j) { return array.indexOf(j) !== -1 }) } } else { if (node.not) { var filter = {} array.forEach(function (j) { filter[j] = true }) return result.filter(function (j) { return !filter[j] }) } return result.concat(array) } }, []) } function prepareOpts(opts) { if (typeof opts === 'undefined') opts = {} if (typeof opts.path === 'undefined') { opts.path = path.resolve ? path.resolve('.') : '.' } return opts } function prepareQueries(queries, opts) { if (typeof queries === 'undefined' || queries === null) { var config = browserslist.loadConfig(opts) if (config) { queries = config } else { queries = browserslist.defaults } } return queries } function checkQueries(queries) { if (!(typeof queries === 'string' || Array.isArray(queries))) { throw new BrowserslistError( 'Browser queries must be an array or string. Got ' + typeof queries + '.' ) } } var cache = {} function browserslist(queries, opts) { opts = prepareOpts(opts) queries = prepareQueries(queries, opts) checkQueries(queries) var context = { ignoreUnknownVersions: opts.ignoreUnknownVersions, dangerousExtend: opts.dangerousExtend, mobileToDesktop: opts.mobileToDesktop, path: opts.path, env: opts.env } env.oldDataWarning(browserslist.data) var stats = env.getStat(opts, browserslist.data) if (stats) { context.customUsage = {} for (var browser in stats) { fillUsage(context.customUsage, browser, stats[browser]) } } var cacheKey = JSON.stringify([queries, context]) if (cache[cacheKey]) return cache[cacheKey] var result = uniq(resolve(queries, context)).sort(function (name1, name2) { name1 = name1.split(' ') name2 = name2.split(' ') if (name1[0] === name2[0]) { // assumptions on caniuse data // 1) version ranges never overlaps // 2) if version is not a range, it never contains `-` var version1 = name1[1].split('-')[0] var version2 = name2[1].split('-')[0] return compareSemver(version2.split('.'), version1.split('.')) } else { return compare(name1[0], name2[0]) } }) if (!process.env.BROWSERSLIST_DISABLE_CACHE) { cache[cacheKey] = result } return result } browserslist.parse = function (queries, opts) { opts = prepareOpts(opts) queries = prepareQueries(queries, opts) checkQueries(queries) return parse(QUERIES, queries) } // Will be filled by Can I Use data below browserslist.cache = {} 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' } // Can I Use only provides a few versions for some browsers (e.g. and_chr). // Fallback to a similar browser for unknown versions browserslist.desktopNames = { and_chr: 'chrome', and_ff: 'firefox', ie_mob: 'ie', op_mob: 'opera', android: 'chrome' // has extra processing logic } // 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 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, browserslist.data) 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) } function nodeQuery(context, node) { var matched = browserslist.nodeVersions.filter(function (i) { return isVersionsMatch(i, node.version) }) if (matched.length === 0) { if (context.ignoreUnknownVersions) { return [] } else { throw new BrowserslistError( 'Unknown version ' + node.version + ' of Node.js' ) } } return ['node ' + matched[matched.length - 1]] } function sinceQuery(context, node) { var year = parseInt(node.year) var month = parseInt(node.month || '01') - 1 var day = parseInt(node.day || '01') return filterByYear(Date.UTC(year, month, day, 0, 0, 0), context) } function coverQuery(context, node) { var coverage = parseFloat(node.coverage) var usage = browserslist.usage.global if (node.place) { if (node.place.match(/^my\s+stats$/i)) { if (!context.customUsage) { throw new BrowserslistError('Custom usage statistics was not provided') } usage = context.customUsage } else { var place if (node.place.length === 2) { place = node.place.toUpperCase() } else { place = node.place.toLowerCase() } env.loadCountry(browserslist.usage, place, browserslist.data) 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 } var QUERIES = { last_major_versions: { matches: ['versions'], regexp: /^last\s+(\d+)\s+major\s+versions?$/i, select: function (context, node) { return Object.keys(agents).reduce(function (selected, name) { var data = byName(name, context) if (!data) return selected var list = getMajorVersions(data.released, node.versions) list = list.map(nameMapper(data.name)) if (data.name === 'android') { list = filterAndroid(list, node.versions, context) } return selected.concat(list) }, []) } }, last_versions: { matches: ['versions'], regexp: /^last\s+(\d+)\s+versions?$/i, select: function (context, node) { return Object.keys(agents).reduce(function (selected, name) { var data = byName(name, context) if (!data) return selected var list = data.released.slice(-node.versions) list = list.map(nameMapper(data.name)) if (data.name === 'android') { list = filterAndroid(list, node.versions, context) } return selected.concat(list) }, []) } }, last_electron_major_versions: { matches: ['versions'], regexp: /^last\s+(\d+)\s+electron\s+major\s+versions?$/i, select: function (context, node) { var validVersions = getMajorVersions(Object.keys(e2c), node.versions) return validVersions.map(function (i) { return 'chrome ' + e2c[i] }) } }, last_node_major_versions: { matches: ['versions'], regexp: /^last\s+(\d+)\s+node\s+major\s+versions?$/i, select: function (context, node) { return getMajorVersions(browserslist.nodeVersions, node.versions).map( function (version) { return 'node ' + version } ) } }, last_browser_major_versions: { matches: ['versions', 'browser'], regexp: /^last\s+(\d+)\s+(\w+)\s+major\s+versions?$/i, select: function (context, node) { var data = checkName(node.browser, context) var validVersions = getMajorVersions(data.released, node.versions) var list = validVersions.map(nameMapper(data.name)) if (data.name === 'android') { list = filterAndroid(list, node.versions, context) } return list } }, last_electron_versions: { matches: ['versions'], regexp: /^last\s+(\d+)\s+electron\s+versions?$/i, select: function (context, node) { return Object.keys(e2c) .slice(-node.versions) .map(function (i) { return 'chrome ' + e2c[i] }) } }, last_node_versions: { matches: ['versions'], regexp: /^last\s+(\d+)\s+node\s+versions?$/i, select: function (context, node) { return browserslist.nodeVersions .slice(-node.versions) .map(function (version) { return 'node ' + version }) } }, last_browser_versions: { matches: ['versions', 'browser'], regexp: /^last\s+(\d+)\s+(\w+)\s+versions?$/i, select: function (context, node) { var data = checkName(node.browser, context) var list = data.released.slice(-node.versions).map(nameMapper(data.name)) if (data.name === 'android') { list = filterAndroid(list, node.versions, context) } return list } }, unreleased_versions: { matches: [], regexp: /^unreleased\s+versions$/i, select: function (context) { return Object.keys(agents).reduce(function (selected, name) { var data = byName(name, context) if (!data) return selected var list = data.versions.filter(function (v) { return data.released.indexOf(v) === -1 }) list = list.map(nameMapper(data.name)) return selected.concat(list) }, []) } }, unreleased_electron_versions: { matches: [], regexp: /^unreleased\s+electron\s+versions?$/i, select: function () { return [] } }, unreleased_browser_versions: { matches: ['browser'], regexp: /^unreleased\s+(\w+)\s+versions?$/i, select: function (context, node) { var data = checkName(node.browser, context) return data.versions .filter(function (v) { return data.released.indexOf(v) === -1 }) .map(nameMapper(data.name)) } }, last_years: { matches: ['years'], regexp: /^last\s+(\d*.?\d+)\s+years?$/i, select: function (context, node) { return filterByYear(Date.now() - YEAR * node.years, context) } }, since_y: { matches: ['year'], regexp: /^since (\d+)$/i, select: sinceQuery }, since_y_m: { matches: ['year', 'month'], regexp: /^since (\d+)-(\d+)$/i, select: sinceQuery }, since_y_m_d: { matches: ['year', 'month', 'day'], regexp: /^since (\d+)-(\d+)-(\d+)$/i, select: sinceQuery }, popularity: { matches: ['sign', 'popularity'], regexp: /^(>=?|<=?)\s*(\d+|\d+\.\d+|\.\d+)%$/, select: function (context, node) { var popularity = parseFloat(node.popularity) var usage = browserslist.usage.global return Object.keys(usage).reduce(function (result, version) { if (node.sign === '>') { if (usage[version] > popularity) { result.push(version) } } else if (node.sign === '<') { if (usage[version] < popularity) { result.push(version) } } else if (node.sign === '<=') { if (usage[version] <= popularity) { result.push(version) } } else if (usage[version] >= popularity) { result.push(version) } return result }, []) } }, popularity_in_my_stats: { matches: ['sign', 'popularity'], regexp: /^(>=?|<=?)\s*(\d+|\d+\.\d+|\.\d+)%\s+in\s+my\s+stats$/, select: function (context, node) { var popularity = parseFloat(node.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) { var percentage = usage[version] if (percentage == null) { return result } if (node.sign === '>') { if (percentage > popularity) { result.push(version) } } else if (node.sign === '<') { if (percentage < popularity) { result.push(version) } } else if (node.sign === '<=') { if (percentage <= popularity) { result.push(version) } } else if (percentage >= popularity) { result.push(version) } return result }, []) } }, popularity_in_config_stats: { matches: ['sign', 'popularity', 'config'], regexp: /^(>=?|<=?)\s*(\d+|\d+\.\d+|\.\d+)%\s+in\s+(\S+)\s+stats$/, select: function (context, node) { var popularity = parseFloat(node.popularity) var stats = env.loadStat(context, node.config, browserslist.data) if (stats) { context.customUsage = {} for (var browser in stats) { fillUsage(context.customUsage, browser, stats[browser]) } } if (!context.customUsage) { throw new BrowserslistError('Custom usage statistics was not provided') } var usage = context.customUsage return Object.keys(usage).reduce(function (result, version) { var percentage = usage[version] if (percentage == null) { return result } if (node.sign === '>') { if (percentage > popularity) { result.push(version) } } else if (node.sign === '<') { if (percentage < popularity) { result.push(version) } } else if (node.sign === '<=') { if (percentage <= popularity) { result.push(version) } } else if (percentage >= popularity) { result.push(version) } return result }, []) } }, popularity_in_place: { matches: ['sign', 'popularity', 'place'], regexp: /^(>=?|<=?)\s*(\d+|\d+\.\d+|\.\d+)%\s+in\s+((alt-)?\w\w)$/, select: function (context, node) { var popularity = parseFloat(node.popularity) var place = node.place if (place.length === 2) { place = place.toUpperCase() } else { place = place.toLowerCase() } env.loadCountry(browserslist.usage, place, browserslist.data) var usage = browserslist.usage[place] return Object.keys(usage).reduce(function (result, version) { var percentage = usage[version] if (percentage == null) { return result } if (node.sign === '>') { if (percentage > popularity) { result.push(version) } } else if (node.sign === '<') { if (percentage < popularity) { result.push(version) } } else if (node.sign === '<=') { if (percentage <= popularity) { result.push(version) } } else if (percentage >= popularity) { result.push(version) } return result }, []) } }, cover: { matches: ['coverage'], regexp: /^cover\s+(\d+|\d+\.\d+|\.\d+)%$/i, select: coverQuery }, cover_in: { matches: ['coverage', 'place'], regexp: /^cover\s+(\d+|\d+\.\d+|\.\d+)%\s+in\s+(my\s+stats|(alt-)?\w\w)$/i, select: coverQuery }, supports: { matches: ['feature'], regexp: /^supports\s+([\w-]+)$/, select: function (context, node) { env.loadFeature(browserslist.cache, node.feature) var features = browserslist.cache[node.feature] return Object.keys(features).reduce(function (result, version) { var flags = features[version] if (flags.indexOf('y') >= 0 || flags.indexOf('a') >= 0) { result.push(version) } return result }, []) } }, electron_range: { matches: ['from', 'to'], regexp: /^electron\s+([\d.]+)\s*-\s*([\d.]+)$/i, select: function (context, node) { var fromToUse = normalizeElectron(node.from) var toToUse = normalizeElectron(node.to) var from = parseFloat(node.from) var to = parseFloat(node.to) if (!e2c[fromToUse]) { throw new BrowserslistError('Unknown version ' + from + ' of electron') } if (!e2c[toToUse]) { throw new BrowserslistError('Unknown version ' + to + ' of electron') } return Object.keys(e2c) .filter(function (i) { var parsed = parseFloat(i) return parsed >= from && parsed <= to }) .map(function (i) { return 'chrome ' + e2c[i] }) } }, node_range: { matches: ['from', 'to'], regexp: /^node\s+([\d.]+)\s*-\s*([\d.]+)$/i, select: function (context, node) { return browserslist.nodeVersions .filter(semverFilterLoose('>=', node.from)) .filter(semverFilterLoose('<=', node.to)) .map(function (v) { return 'node ' + v }) } }, browser_range: { matches: ['browser', 'from', 'to'], regexp: /^(\w+)\s+([\d.]+)\s*-\s*([\d.]+)$/i, select: function (context, node) { var data = checkName(node.browser, context) var from = parseFloat(normalizeVersion(data, node.from) || node.from) var to = parseFloat(normalizeVersion(data, node.to) || node.to) function filter(v) { var parsed = parseFloat(v) return parsed >= from && parsed <= to } return data.released.filter(filter).map(nameMapper(data.name)) } }, electron_ray: { matches: ['sign', 'version'], regexp: /^electron\s*(>=?|<=?)\s*([\d.]+)$/i, select: function (context, node) { var versionToUse = normalizeElectron(node.version) return Object.keys(e2c) .filter(generateFilter(node.sign, versionToUse)) .map(function (i) { return 'chrome ' + e2c[i] }) } }, node_ray: { matches: ['sign', 'version'], regexp: /^node\s*(>=?|<=?)\s*([\d.]+)$/i, select: function (context, node) { return browserslist.nodeVersions .filter(generateSemverFilter(node.sign, node.version)) .map(function (v) { return 'node ' + v }) } }, browser_ray: { matches: ['browser', 'sign', 'version'], regexp: /^(\w+)\s*(>=?|<=?)\s*([\d.]+)$/, select: function (context, node) { var version = node.version var data = checkName(node.browser, context) var alias = browserslist.versionAliases[data.name][version] if (alias) version = alias return data.released .filter(generateFilter(node.sign, version)) .map(function (v) { return data.name + ' ' + v }) } }, firefox_esr: { matches: [], regexp: /^(firefox|ff|fx)\s+esr$/i, select: function () { return ['firefox 102'] } }, opera_mini_all: { matches: [], regexp: /(operamini|op_mini)\s+all/i, select: function () { return ['op_mini all'] } }, electron_version: { matches: ['version'], regexp: /^electron\s+([\d.]+)$/i, select: function (context, node) { var versionToUse = normalizeElectron(node.version) var chrome = e2c[versionToUse] if (!chrome) { throw new BrowserslistError( 'Unknown version ' + node.version + ' of electron' ) } return ['chrome ' + chrome] } }, node_major_version: { matches: ['version'], regexp: /^node\s+(\d+)$/i, select: nodeQuery }, node_minor_version: { matches: ['version'], regexp: /^node\s+(\d+\.\d+)$/i, select: nodeQuery }, node_patch_version: { matches: ['version'], regexp: /^node\s+(\d+\.\d+\.\d+)$/i, select: nodeQuery }, current_node: { matches: [], regexp: /^current\s+node$/i, select: function (context) { return [env.currentNode(resolve, context)] } }, maintained_node: { matches: [], regexp: /^maintained\s+node\s+versions$/i, select: function (context) { var now = Date.now() var queries = Object.keys(jsEOL) .filter(function (key) { return ( now < Date.parse(jsEOL[key].end) && now > Date.parse(jsEOL[key].start) && isEolReleased(key) ) }) .map(function (key) { return 'node ' + key.slice(1) }) return resolve(queries, context) } }, phantomjs_1_9: { matches: [], regexp: /^phantomjs\s+1.9$/i, select: function () { return ['safari 5'] } }, phantomjs_2_1: { matches: [], regexp: /^phantomjs\s+2.1$/i, select: function () { return ['safari 6'] } }, browser_version: { matches: ['browser', 'version'], regexp: /^(\w+)\s+(tp|[\d.]+)$/i, select: function (context, node) { var version = node.version if (/^tp$/i.test(version)) version = 'TP' var data = checkName(node.browser, context) 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 ' + node.browser ) } } return [data.name + ' ' + version] } }, browserslist_config: { matches: [], regexp: /^browserslist config$/i, select: function (context) { return browserslist(undefined, context) } }, extends: { matches: ['config'], regexp: /^extends (.+)$/i, select: function (context, node) { return resolve(env.loadQueries(context, node.config), context) } }, defaults: { matches: [], regexp: /^defaults$/i, select: function (context) { return resolve(browserslist.defaults, context) } }, dead: { matches: [], regexp: /^dead$/i, select: function (context) { var dead = [ 'Baidu >= 0', 'ie <= 11', 'ie_mob <= 11', 'bb <= 10', 'op_mob <= 12.1', 'samsung 4' ] return resolve(dead, context) } }, unknown: { matches: [], regexp: /^(\w+)$/i, select: function (context, node) { if (byName(node.query, context)) { throw new BrowserslistError( 'Specify versions in Browserslist query for browser ' + node.query ) } else { throw unknownQuery(node.query) } } } } // 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 } } } } browserslist.versionAliases.op_mob['59'] = '58' browserslist.nodeVersions = jsReleases.map(function (release) { return release.version }) })() module.exports = browserslist }).call(this)}).call(this,require('_process')) },{"./error":411,"./node":410,"./parse":413,"_process":460,"caniuse-lite/dist/unpacker/agents":420,"electron-to-chromium/versions":432,"node-releases/data/processed/envs.json":455,"node-releases/data/release-schedule/release-schedule.json":456,"path":408}],413:[function(require,module,exports){ var AND_REGEXP = /^\s+and\s+(.*)/i var OR_REGEXP = /^(?:,\s*|\s+or\s+)(.*)/i function flatten(array) { if (!Array.isArray(array)) return [array] return array.reduce(function (a, b) { return a.concat(flatten(b)) }, []) } function find(string, predicate) { for (var n = 1, max = string.length; n <= max; n++) { var parsed = string.substr(-n, n) if (predicate(parsed, n, max)) { return string.slice(0, -n) } } return '' } function matchQuery(all, query) { var node = { query: query } if (query.indexOf('not ') === 0) { node.not = true query = query.slice(4) } for (var name in all) { var type = all[name] var match = query.match(type.regexp) if (match) { node.type = name for (var i = 0; i < type.matches.length; i++) { node[type.matches[i]] = match[i + 1] } return node } } node.type = 'unknown' return node } function matchBlock(all, string, qs) { var node return find(string, function (parsed, n, max) { if (AND_REGEXP.test(parsed)) { node = matchQuery(all, parsed.match(AND_REGEXP)[1]) node.compose = 'and' qs.unshift(node) return true } else if (OR_REGEXP.test(parsed)) { node = matchQuery(all, parsed.match(OR_REGEXP)[1]) node.compose = 'or' qs.unshift(node) return true } else if (n === max) { node = matchQuery(all, parsed.trim()) node.compose = 'or' qs.unshift(node) return true } return false }) } module.exports = function parse(all, queries) { if (!Array.isArray(queries)) queries = [queries] return flatten( queries.map(function (block) { var qs = [] do { block = matchBlock(all, block, qs) } while (block) return qs }) ) } },{}],414:[function(require,module,exports){ (function (Buffer){(function (){ /*! * The buffer module from node.js, for the browser. * * @author Feross Aboukhadijeh * @license MIT */ /* eslint-disable no-proto */ 'use strict' var base64 = require('base64-js') var ieee754 = require('ieee754') exports.Buffer = Buffer exports.SlowBuffer = SlowBuffer exports.INSPECT_MAX_BYTES = 50 var K_MAX_LENGTH = 0x7fffffff exports.kMaxLength = K_MAX_LENGTH /** * If `Buffer.TYPED_ARRAY_SUPPORT`: * === true Use Uint8Array implementation (fastest) * === false Print warning and recommend using `buffer` v4.x which has an Object * implementation (most compatible, even IE6) * * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+, * Opera 11.6+, iOS 4.2+. * * We report that the browser does not support typed arrays if the are not subclassable * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array` * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support * for __proto__ and has a buggy typed array implementation. */ Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport() if (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' && typeof console.error === 'function') { console.error( 'This browser lacks typed array (Uint8Array) support which is required by ' + '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.' ) } function typedArraySupport () { // Can typed array instances can be augmented? try { var arr = new Uint8Array(1) arr.__proto__ = { __proto__: Uint8Array.prototype, foo: function () { return 42 } } return arr.foo() === 42 } catch (e) { return false } } Object.defineProperty(Buffer.prototype, 'parent', { enumerable: true, get: function () { if (!Buffer.isBuffer(this)) return undefined return this.buffer } }) Object.defineProperty(Buffer.prototype, 'offset', { enumerable: true, get: function () { if (!Buffer.isBuffer(this)) return undefined return this.byteOffset } }) function createBuffer (length) { if (length > K_MAX_LENGTH) { throw new RangeError('The value "' + length + '" is invalid for option "size"') } // Return an augmented `Uint8Array` instance var buf = new Uint8Array(length) buf.__proto__ = Buffer.prototype return buf } /** * The Buffer constructor returns instances of `Uint8Array` that have their * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of * `Uint8Array`, so the returned instances will have all the node `Buffer` methods * and the `Uint8Array` methods. Square bracket notation works as expected -- it * returns a single octet. * * The `Uint8Array` prototype remains unmodified. */ function Buffer (arg, encodingOrOffset, length) { // Common case. if (typeof arg === 'number') { if (typeof encodingOrOffset === 'string') { throw new TypeError( 'The "string" argument must be of type string. Received type number' ) } return allocUnsafe(arg) } return from(arg, encodingOrOffset, length) } // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97 if (typeof Symbol !== 'undefined' && Symbol.species != null && Buffer[Symbol.species] === Buffer) { Object.defineProperty(Buffer, Symbol.species, { value: null, configurable: true, enumerable: false, writable: false }) } Buffer.poolSize = 8192 // not used by this implementation function from (value, encodingOrOffset, length) { if (typeof value === 'string') { return fromString(value, encodingOrOffset) } if (ArrayBuffer.isView(value)) { return fromArrayLike(value) } if (value == null) { throw TypeError( 'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' + 'or Array-like Object. Received type ' + (typeof value) ) } if (isInstance(value, ArrayBuffer) || (value && isInstance(value.buffer, ArrayBuffer))) { return fromArrayBuffer(value, encodingOrOffset, length) } if (typeof value === 'number') { throw new TypeError( 'The "value" argument must not be of type number. Received type number' ) } var valueOf = value.valueOf && value.valueOf() if (valueOf != null && valueOf !== value) { return Buffer.from(valueOf, encodingOrOffset, length) } var b = fromObject(value) if (b) return b if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] === 'function') { return Buffer.from( value[Symbol.toPrimitive]('string'), encodingOrOffset, length ) } throw new TypeError( 'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' + 'or Array-like Object. Received type ' + (typeof value) ) } /** * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError * if value is a number. * Buffer.from(str[, encoding]) * Buffer.from(array) * Buffer.from(buffer) * Buffer.from(arrayBuffer[, byteOffset[, length]]) **/ Buffer.from = function (value, encodingOrOffset, length) { return from(value, encodingOrOffset, length) } // Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug: // https://github.com/feross/buffer/pull/148 Buffer.prototype.__proto__ = Uint8Array.prototype Buffer.__proto__ = Uint8Array function assertSize (size) { if (typeof size !== 'number') { throw new TypeError('"size" argument must be of type number') } else if (size < 0) { throw new RangeError('The value "' + size + '" is invalid for option "size"') } } function alloc (size, fill, encoding) { assertSize(size) if (size <= 0) { return createBuffer(size) } if (fill !== undefined) { // Only pay attention to encoding if it's a string. This // prevents accidentally sending in a number that would // be interpretted as a start offset. return typeof encoding === 'string' ? createBuffer(size).fill(fill, encoding) : createBuffer(size).fill(fill) } return createBuffer(size) } /** * Creates a new filled Buffer instance. * alloc(size[, fill[, encoding]]) **/ Buffer.alloc = function (size, fill, encoding) { return alloc(size, fill, encoding) } function allocUnsafe (size) { assertSize(size) return createBuffer(size < 0 ? 0 : checked(size) | 0) } /** * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance. * */ Buffer.allocUnsafe = function (size) { return allocUnsafe(size) } /** * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance. */ Buffer.allocUnsafeSlow = function (size) { return allocUnsafe(size) } function fromString (string, encoding) { if (typeof encoding !== 'string' || encoding === '') { encoding = 'utf8' } if (!Buffer.isEncoding(encoding)) { throw new TypeError('Unknown encoding: ' + encoding) } var length = byteLength(string, encoding) | 0 var buf = createBuffer(length) var actual = buf.write(string, encoding) if (actual !== length) { // Writing a hex string, for example, that contains invalid characters will // cause everything after the first invalid character to be ignored. (e.g. // 'abxxcd' will be treated as 'ab') buf = buf.slice(0, actual) } return buf } function fromArrayLike (array) { var length = array.length < 0 ? 0 : checked(array.length) | 0 var buf = createBuffer(length) for (var i = 0; i < length; i += 1) { buf[i] = array[i] & 255 } return buf } function fromArrayBuffer (array, byteOffset, length) { if (byteOffset < 0 || array.byteLength < byteOffset) { throw new RangeError('"offset" is outside of buffer bounds') } if (array.byteLength < byteOffset + (length || 0)) { throw new RangeError('"length" is outside of buffer bounds') } var buf if (byteOffset === undefined && length === undefined) { buf = new Uint8Array(array) } else if (length === undefined) { buf = new Uint8Array(array, byteOffset) } else { buf = new Uint8Array(array, byteOffset, length) } // Return an augmented `Uint8Array` instance buf.__proto__ = Buffer.prototype return buf } function fromObject (obj) { if (Buffer.isBuffer(obj)) { var len = checked(obj.length) | 0 var buf = createBuffer(len) if (buf.length === 0) { return buf } obj.copy(buf, 0, 0, len) return buf } if (obj.length !== undefined) { if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) { return createBuffer(0) } return fromArrayLike(obj) } if (obj.type === 'Buffer' && Array.isArray(obj.data)) { return fromArrayLike(obj.data) } } function checked (length) { // Note: cannot use `length < K_MAX_LENGTH` here because that fails when // length is NaN (which is otherwise coerced to zero.) if (length >= K_MAX_LENGTH) { throw new RangeError('Attempt to allocate Buffer larger than maximum ' + 'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes') } return length | 0 } function SlowBuffer (length) { if (+length != length) { // eslint-disable-line eqeqeq length = 0 } return Buffer.alloc(+length) } Buffer.isBuffer = function isBuffer (b) { return b != null && b._isBuffer === true && b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false } Buffer.compare = function compare (a, b) { if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength) if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength) if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) { throw new TypeError( 'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array' ) } if (a === b) return 0 var x = a.length var y = b.length for (var i = 0, len = Math.min(x, y); i < len; ++i) { if (a[i] !== b[i]) { x = a[i] y = b[i] break } } if (x < y) return -1 if (y < x) return 1 return 0 } Buffer.isEncoding = function isEncoding (encoding) { switch (String(encoding).toLowerCase()) { case 'hex': case 'utf8': case 'utf-8': case 'ascii': case 'latin1': case 'binary': case 'base64': case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': return true default: return false } } Buffer.concat = function concat (list, length) { if (!Array.isArray(list)) { throw new TypeError('"list" argument must be an Array of Buffers') } if (list.length === 0) { return Buffer.alloc(0) } var i if (length === undefined) { length = 0 for (i = 0; i < list.length; ++i) { length += list[i].length } } var buffer = Buffer.allocUnsafe(length) var pos = 0 for (i = 0; i < list.length; ++i) { var buf = list[i] if (isInstance(buf, Uint8Array)) { buf = Buffer.from(buf) } if (!Buffer.isBuffer(buf)) { throw new TypeError('"list" argument must be an Array of Buffers') } buf.copy(buffer, pos) pos += buf.length } return buffer } function byteLength (string, encoding) { if (Buffer.isBuffer(string)) { return string.length } if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) { return string.byteLength } if (typeof string !== 'string') { throw new TypeError( 'The "string" argument must be one of type string, Buffer, or ArrayBuffer. ' + 'Received type ' + typeof string ) } var len = string.length var mustMatch = (arguments.length > 2 && arguments[2] === true) if (!mustMatch && len === 0) return 0 // Use a for loop to avoid recursion var loweredCase = false for (;;) { switch (encoding) { case 'ascii': case 'latin1': case 'binary': return len case 'utf8': case 'utf-8': return utf8ToBytes(string).length case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': return len * 2 case 'hex': return len >>> 1 case 'base64': return base64ToBytes(string).length default: if (loweredCase) { return mustMatch ? -1 : utf8ToBytes(string).length // assume utf8 } encoding = ('' + encoding).toLowerCase() loweredCase = true } } } Buffer.byteLength = byteLength function slowToString (encoding, start, end) { var loweredCase = false // No need to verify that "this.length <= MAX_UINT32" since it's a read-only // property of a typed array. // This behaves neither like String nor Uint8Array in that we set start/end // to their upper/lower bounds if the value passed is out of range. // undefined is handled specially as per ECMA-262 6th Edition, // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization. if (start === undefined || start < 0) { start = 0 } // Return early if start > this.length. Done here to prevent potential uint32 // coercion fail below. if (start > this.length) { return '' } if (end === undefined || end > this.length) { end = this.length } if (end <= 0) { return '' } // Force coersion to uint32. This will also coerce falsey/NaN values to 0. end >>>= 0 start >>>= 0 if (end <= start) { return '' } if (!encoding) encoding = 'utf8' while (true) { switch (encoding) { case 'hex': return hexSlice(this, start, end) case 'utf8': case 'utf-8': return utf8Slice(this, start, end) case 'ascii': return asciiSlice(this, start, end) case 'latin1': case 'binary': return latin1Slice(this, start, end) case 'base64': return base64Slice(this, start, end) case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': return utf16leSlice(this, start, end) default: if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) encoding = (encoding + '').toLowerCase() loweredCase = true } } } // This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package) // to detect a Buffer instance. It's not possible to use `instanceof Buffer` // reliably in a browserify context because there could be multiple different // copies of the 'buffer' package in use. This method works even for Buffer // instances that were created from another copy of the `buffer` package. // See: https://github.com/feross/buffer/issues/154 Buffer.prototype._isBuffer = true function swap (b, n, m) { var i = b[n] b[n] = b[m] b[m] = i } Buffer.prototype.swap16 = function swap16 () { var len = this.length if (len % 2 !== 0) { throw new RangeError('Buffer size must be a multiple of 16-bits') } for (var i = 0; i < len; i += 2) { swap(this, i, i + 1) } return this } Buffer.prototype.swap32 = function swap32 () { var len = this.length if (len % 4 !== 0) { throw new RangeError('Buffer size must be a multiple of 32-bits') } for (var i = 0; i < len; i += 4) { swap(this, i, i + 3) swap(this, i + 1, i + 2) } return this } Buffer.prototype.swap64 = function swap64 () { var len = this.length if (len % 8 !== 0) { throw new RangeError('Buffer size must be a multiple of 64-bits') } for (var i = 0; i < len; i += 8) { swap(this, i, i + 7) swap(this, i + 1, i + 6) swap(this, i + 2, i + 5) swap(this, i + 3, i + 4) } return this } Buffer.prototype.toString = function toString () { var length = this.length if (length === 0) return '' if (arguments.length === 0) return utf8Slice(this, 0, length) return slowToString.apply(this, arguments) } Buffer.prototype.toLocaleString = Buffer.prototype.toString Buffer.prototype.equals = function equals (b) { if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer') if (this === b) return true return Buffer.compare(this, b) === 0 } Buffer.prototype.inspect = function inspect () { var str = '' var max = exports.INSPECT_MAX_BYTES str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim() if (this.length > max) str += ' ... ' return '' } Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) { if (isInstance(target, Uint8Array)) { target = Buffer.from(target, target.offset, target.byteLength) } if (!Buffer.isBuffer(target)) { throw new TypeError( 'The "target" argument must be one of type Buffer or Uint8Array. ' + 'Received type ' + (typeof target) ) } if (start === undefined) { start = 0 } if (end === undefined) { end = target ? target.length : 0 } if (thisStart === undefined) { thisStart = 0 } if (thisEnd === undefined) { thisEnd = this.length } if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) { throw new RangeError('out of range index') } if (thisStart >= thisEnd && start >= end) { return 0 } if (thisStart >= thisEnd) { return -1 } if (start >= end) { return 1 } start >>>= 0 end >>>= 0 thisStart >>>= 0 thisEnd >>>= 0 if (this === target) return 0 var x = thisEnd - thisStart var y = end - start var len = Math.min(x, y) var thisCopy = this.slice(thisStart, thisEnd) var targetCopy = target.slice(start, end) for (var i = 0; i < len; ++i) { if (thisCopy[i] !== targetCopy[i]) { x = thisCopy[i] y = targetCopy[i] break } } if (x < y) return -1 if (y < x) return 1 return 0 } // Finds either the first index of `val` in `buffer` at offset >= `byteOffset`, // OR the last index of `val` in `buffer` at offset <= `byteOffset`. // // Arguments: // - buffer - a Buffer to search // - val - a string, Buffer, or number // - byteOffset - an index into `buffer`; will be clamped to an int32 // - encoding - an optional encoding, relevant is val is a string // - dir - true for indexOf, false for lastIndexOf function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) { // Empty buffer means no match if (buffer.length === 0) return -1 // Normalize byteOffset if (typeof byteOffset === 'string') { encoding = byteOffset byteOffset = 0 } else if (byteOffset > 0x7fffffff) { byteOffset = 0x7fffffff } else if (byteOffset < -0x80000000) { byteOffset = -0x80000000 } byteOffset = +byteOffset // Coerce to Number. if (numberIsNaN(byteOffset)) { // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer byteOffset = dir ? 0 : (buffer.length - 1) } // Normalize byteOffset: negative offsets start from the end of the buffer if (byteOffset < 0) byteOffset = buffer.length + byteOffset if (byteOffset >= buffer.length) { if (dir) return -1 else byteOffset = buffer.length - 1 } else if (byteOffset < 0) { if (dir) byteOffset = 0 else return -1 } // Normalize val if (typeof val === 'string') { val = Buffer.from(val, encoding) } // Finally, search either indexOf (if dir is true) or lastIndexOf if (Buffer.isBuffer(val)) { // Special case: looking for empty string/buffer always fails if (val.length === 0) { return -1 } return arrayIndexOf(buffer, val, byteOffset, encoding, dir) } else if (typeof val === 'number') { val = val & 0xFF // Search for a byte value [0-255] if (typeof Uint8Array.prototype.indexOf === 'function') { if (dir) { return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset) } else { return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset) } } return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir) } throw new TypeError('val must be string, number or Buffer') } function arrayIndexOf (arr, val, byteOffset, encoding, dir) { var indexSize = 1 var arrLength = arr.length var valLength = val.length if (encoding !== undefined) { encoding = String(encoding).toLowerCase() if (encoding === 'ucs2' || encoding === 'ucs-2' || encoding === 'utf16le' || encoding === 'utf-16le') { if (arr.length < 2 || val.length < 2) { return -1 } indexSize = 2 arrLength /= 2 valLength /= 2 byteOffset /= 2 } } function read (buf, i) { if (indexSize === 1) { return buf[i] } else { return buf.readUInt16BE(i * indexSize) } } var i if (dir) { var foundIndex = -1 for (i = byteOffset; i < arrLength; i++) { if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) { if (foundIndex === -1) foundIndex = i if (i - foundIndex + 1 === valLength) return foundIndex * indexSize } else { if (foundIndex !== -1) i -= i - foundIndex foundIndex = -1 } } } else { if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength for (i = byteOffset; i >= 0; i--) { var found = true for (var j = 0; j < valLength; j++) { if (read(arr, i + j) !== read(val, j)) { found = false break } } if (found) return i } } return -1 } Buffer.prototype.includes = function includes (val, byteOffset, encoding) { return this.indexOf(val, byteOffset, encoding) !== -1 } Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) { return bidirectionalIndexOf(this, val, byteOffset, encoding, true) } Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) { return bidirectionalIndexOf(this, val, byteOffset, encoding, false) } function hexWrite (buf, string, offset, length) { offset = Number(offset) || 0 var remaining = buf.length - offset if (!length) { length = remaining } else { length = Number(length) if (length > remaining) { length = remaining } } var strLen = string.length if (length > strLen / 2) { length = strLen / 2 } for (var i = 0; i < length; ++i) { var parsed = parseInt(string.substr(i * 2, 2), 16) if (numberIsNaN(parsed)) return i buf[offset + i] = parsed } return i } function utf8Write (buf, string, offset, length) { return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length) } function asciiWrite (buf, string, offset, length) { return blitBuffer(asciiToBytes(string), buf, offset, length) } function latin1Write (buf, string, offset, length) { return asciiWrite(buf, string, offset, length) } function base64Write (buf, string, offset, length) { return blitBuffer(base64ToBytes(string), buf, offset, length) } function ucs2Write (buf, string, offset, length) { return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length) } Buffer.prototype.write = function write (string, offset, length, encoding) { // Buffer#write(string) if (offset === undefined) { encoding = 'utf8' length = this.length offset = 0 // Buffer#write(string, encoding) } else if (length === undefined && typeof offset === 'string') { encoding = offset length = this.length offset = 0 // Buffer#write(string, offset[, length][, encoding]) } else if (isFinite(offset)) { offset = offset >>> 0 if (isFinite(length)) { length = length >>> 0 if (encoding === undefined) encoding = 'utf8' } else { encoding = length length = undefined } } else { throw new Error( 'Buffer.write(string, encoding, offset[, length]) is no longer supported' ) } var remaining = this.length - offset if (length === undefined || length > remaining) length = remaining if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) { throw new RangeError('Attempt to write outside buffer bounds') } if (!encoding) encoding = 'utf8' var loweredCase = false for (;;) { switch (encoding) { case 'hex': return hexWrite(this, string, offset, length) case 'utf8': case 'utf-8': return utf8Write(this, string, offset, length) case 'ascii': return asciiWrite(this, string, offset, length) case 'latin1': case 'binary': return latin1Write(this, string, offset, length) case 'base64': // Warning: maxLength not taken into account in base64Write return base64Write(this, string, offset, length) case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': return ucs2Write(this, string, offset, length) default: if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) encoding = ('' + encoding).toLowerCase() loweredCase = true } } } Buffer.prototype.toJSON = function toJSON () { return { type: 'Buffer', data: Array.prototype.slice.call(this._arr || this, 0) } } function base64Slice (buf, start, end) { if (start === 0 && end === buf.length) { return base64.fromByteArray(buf) } else { return base64.fromByteArray(buf.slice(start, end)) } } function utf8Slice (buf, start, end) { end = Math.min(buf.length, end) var res = [] var i = start while (i < end) { var firstByte = buf[i] var codePoint = null var bytesPerSequence = (firstByte > 0xEF) ? 4 : (firstByte > 0xDF) ? 3 : (firstByte > 0xBF) ? 2 : 1 if (i + bytesPerSequence <= end) { var secondByte, thirdByte, fourthByte, tempCodePoint switch (bytesPerSequence) { case 1: if (firstByte < 0x80) { codePoint = firstByte } break case 2: secondByte = buf[i + 1] if ((secondByte & 0xC0) === 0x80) { tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F) if (tempCodePoint > 0x7F) { codePoint = tempCodePoint } } break case 3: secondByte = buf[i + 1] thirdByte = buf[i + 2] if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) { tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F) if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) { codePoint = tempCodePoint } } break case 4: secondByte = buf[i + 1] thirdByte = buf[i + 2] fourthByte = buf[i + 3] if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) { tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F) if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) { codePoint = tempCodePoint } } } } if (codePoint === null) { // we did not generate a valid codePoint so insert a // replacement char (U+FFFD) and advance only 1 byte codePoint = 0xFFFD bytesPerSequence = 1 } else if (codePoint > 0xFFFF) { // encode to utf16 (surrogate pair dance) codePoint -= 0x10000 res.push(codePoint >>> 10 & 0x3FF | 0xD800) codePoint = 0xDC00 | codePoint & 0x3FF } res.push(codePoint) i += bytesPerSequence } return decodeCodePointsArray(res) } // Based on http://stackoverflow.com/a/22747272/680742, the browser with // the lowest limit is Chrome, with 0x10000 args. // We go 1 magnitude less, for safety var MAX_ARGUMENTS_LENGTH = 0x1000 function decodeCodePointsArray (codePoints) { var len = codePoints.length if (len <= MAX_ARGUMENTS_LENGTH) { return String.fromCharCode.apply(String, codePoints) // avoid extra slice() } // Decode in chunks to avoid "call stack size exceeded". var res = '' var i = 0 while (i < len) { res += String.fromCharCode.apply( String, codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH) ) } return res } function asciiSlice (buf, start, end) { var ret = '' end = Math.min(buf.length, end) for (var i = start; i < end; ++i) { ret += String.fromCharCode(buf[i] & 0x7F) } return ret } function latin1Slice (buf, start, end) { var ret = '' end = Math.min(buf.length, end) for (var i = start; i < end; ++i) { ret += String.fromCharCode(buf[i]) } return ret } function hexSlice (buf, start, end) { var len = buf.length if (!start || start < 0) start = 0 if (!end || end < 0 || end > len) end = len var out = '' for (var i = start; i < end; ++i) { out += toHex(buf[i]) } return out } function utf16leSlice (buf, start, end) { var bytes = buf.slice(start, end) var res = '' for (var i = 0; i < bytes.length; i += 2) { res += String.fromCharCode(bytes[i] + (bytes[i + 1] * 256)) } return res } Buffer.prototype.slice = function slice (start, end) { var len = this.length start = ~~start end = end === undefined ? len : ~~end if (start < 0) { start += len if (start < 0) start = 0 } else if (start > len) { start = len } if (end < 0) { end += len if (end < 0) end = 0 } else if (end > len) { end = len } if (end < start) end = start var newBuf = this.subarray(start, end) // Return an augmented `Uint8Array` instance newBuf.__proto__ = Buffer.prototype return newBuf } /* * Need to make sure that buffer isn't trying to write out of bounds. */ function checkOffset (offset, ext, length) { if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint') if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length') } Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) { offset = offset >>> 0 byteLength = byteLength >>> 0 if (!noAssert) checkOffset(offset, byteLength, this.length) var val = this[offset] var mul = 1 var i = 0 while (++i < byteLength && (mul *= 0x100)) { val += this[offset + i] * mul } return val } Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) { offset = offset >>> 0 byteLength = byteLength >>> 0 if (!noAssert) { checkOffset(offset, byteLength, this.length) } var val = this[offset + --byteLength] var mul = 1 while (byteLength > 0 && (mul *= 0x100)) { val += this[offset + --byteLength] * mul } return val } Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) { offset = offset >>> 0 if (!noAssert) checkOffset(offset, 1, this.length) return this[offset] } Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) { offset = offset >>> 0 if (!noAssert) checkOffset(offset, 2, this.length) return this[offset] | (this[offset + 1] << 8) } Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) { offset = offset >>> 0 if (!noAssert) checkOffset(offset, 2, this.length) return (this[offset] << 8) | this[offset + 1] } Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) { offset = offset >>> 0 if (!noAssert) checkOffset(offset, 4, this.length) return ((this[offset]) | (this[offset + 1] << 8) | (this[offset + 2] << 16)) + (this[offset + 3] * 0x1000000) } Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) { offset = offset >>> 0 if (!noAssert) checkOffset(offset, 4, this.length) return (this[offset] * 0x1000000) + ((this[offset + 1] << 16) | (this[offset + 2] << 8) | this[offset + 3]) } Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) { offset = offset >>> 0 byteLength = byteLength >>> 0 if (!noAssert) checkOffset(offset, byteLength, this.length) var val = this[offset] var mul = 1 var i = 0 while (++i < byteLength && (mul *= 0x100)) { val += this[offset + i] * mul } mul *= 0x80 if (val >= mul) val -= Math.pow(2, 8 * byteLength) return val } Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) { offset = offset >>> 0 byteLength = byteLength >>> 0 if (!noAssert) checkOffset(offset, byteLength, this.length) var i = byteLength var mul = 1 var val = this[offset + --i] while (i > 0 && (mul *= 0x100)) { val += this[offset + --i] * mul } mul *= 0x80 if (val >= mul) val -= Math.pow(2, 8 * byteLength) return val } Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) { offset = offset >>> 0 if (!noAssert) checkOffset(offset, 1, this.length) if (!(this[offset] & 0x80)) return (this[offset]) return ((0xff - this[offset] + 1) * -1) } Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) { offset = offset >>> 0 if (!noAssert) checkOffset(offset, 2, this.length) var val = this[offset] | (this[offset + 1] << 8) return (val & 0x8000) ? val | 0xFFFF0000 : val } Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) { offset = offset >>> 0 if (!noAssert) checkOffset(offset, 2, this.length) var val = this[offset + 1] | (this[offset] << 8) return (val & 0x8000) ? val | 0xFFFF0000 : val } Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) { offset = offset >>> 0 if (!noAssert) checkOffset(offset, 4, this.length) return (this[offset]) | (this[offset + 1] << 8) | (this[offset + 2] << 16) | (this[offset + 3] << 24) } Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) { offset = offset >>> 0 if (!noAssert) checkOffset(offset, 4, this.length) return (this[offset] << 24) | (this[offset + 1] << 16) | (this[offset + 2] << 8) | (this[offset + 3]) } Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) { offset = offset >>> 0 if (!noAssert) checkOffset(offset, 4, this.length) return ieee754.read(this, offset, true, 23, 4) } Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) { offset = offset >>> 0 if (!noAssert) checkOffset(offset, 4, this.length) return ieee754.read(this, offset, false, 23, 4) } Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) { offset = offset >>> 0 if (!noAssert) checkOffset(offset, 8, this.length) return ieee754.read(this, offset, true, 52, 8) } Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) { offset = offset >>> 0 if (!noAssert) checkOffset(offset, 8, this.length) return ieee754.read(this, offset, false, 52, 8) } function checkInt (buf, value, offset, ext, max, min) { if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance') if (value > max || value < min) throw new RangeError('"value" argument is out of bounds') if (offset + ext > buf.length) throw new RangeError('Index out of range') } Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) { value = +value offset = offset >>> 0 byteLength = byteLength >>> 0 if (!noAssert) { var maxBytes = Math.pow(2, 8 * byteLength) - 1 checkInt(this, value, offset, byteLength, maxBytes, 0) } var mul = 1 var i = 0 this[offset] = value & 0xFF while (++i < byteLength && (mul *= 0x100)) { this[offset + i] = (value / mul) & 0xFF } return offset + byteLength } Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) { value = +value offset = offset >>> 0 byteLength = byteLength >>> 0 if (!noAssert) { var maxBytes = Math.pow(2, 8 * byteLength) - 1 checkInt(this, value, offset, byteLength, maxBytes, 0) } var i = byteLength - 1 var mul = 1 this[offset + i] = value & 0xFF while (--i >= 0 && (mul *= 0x100)) { this[offset + i] = (value / mul) & 0xFF } return offset + byteLength } Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) { value = +value offset = offset >>> 0 if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0) this[offset] = (value & 0xff) return offset + 1 } Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) { value = +value offset = offset >>> 0 if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0) this[offset] = (value & 0xff) this[offset + 1] = (value >>> 8) return offset + 2 } Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) { value = +value offset = offset >>> 0 if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0) this[offset] = (value >>> 8) this[offset + 1] = (value & 0xff) return offset + 2 } Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) { value = +value offset = offset >>> 0 if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0) this[offset + 3] = (value >>> 24) this[offset + 2] = (value >>> 16) this[offset + 1] = (value >>> 8) this[offset] = (value & 0xff) return offset + 4 } Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) { value = +value offset = offset >>> 0 if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0) this[offset] = (value >>> 24) this[offset + 1] = (value >>> 16) this[offset + 2] = (value >>> 8) this[offset + 3] = (value & 0xff) return offset + 4 } Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) { value = +value offset = offset >>> 0 if (!noAssert) { var limit = Math.pow(2, (8 * byteLength) - 1) checkInt(this, value, offset, byteLength, limit - 1, -limit) } var i = 0 var mul = 1 var sub = 0 this[offset] = value & 0xFF while (++i < byteLength && (mul *= 0x100)) { if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) { sub = 1 } this[offset + i] = ((value / mul) >> 0) - sub & 0xFF } return offset + byteLength } Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) { value = +value offset = offset >>> 0 if (!noAssert) { var limit = Math.pow(2, (8 * byteLength) - 1) checkInt(this, value, offset, byteLength, limit - 1, -limit) } var i = byteLength - 1 var mul = 1 var sub = 0 this[offset + i] = value & 0xFF while (--i >= 0 && (mul *= 0x100)) { if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) { sub = 1 } this[offset + i] = ((value / mul) >> 0) - sub & 0xFF } return offset + byteLength } Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) { value = +value offset = offset >>> 0 if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80) if (value < 0) value = 0xff + value + 1 this[offset] = (value & 0xff) return offset + 1 } Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) { value = +value offset = offset >>> 0 if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000) this[offset] = (value & 0xff) this[offset + 1] = (value >>> 8) return offset + 2 } Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) { value = +value offset = offset >>> 0 if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000) this[offset] = (value >>> 8) this[offset + 1] = (value & 0xff) return offset + 2 } Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) { value = +value offset = offset >>> 0 if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000) this[offset] = (value & 0xff) this[offset + 1] = (value >>> 8) this[offset + 2] = (value >>> 16) this[offset + 3] = (value >>> 24) return offset + 4 } Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) { value = +value offset = offset >>> 0 if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000) if (value < 0) value = 0xffffffff + value + 1 this[offset] = (value >>> 24) this[offset + 1] = (value >>> 16) this[offset + 2] = (value >>> 8) this[offset + 3] = (value & 0xff) return offset + 4 } function checkIEEE754 (buf, value, offset, ext, max, min) { if (offset + ext > buf.length) throw new RangeError('Index out of range') if (offset < 0) throw new RangeError('Index out of range') } function writeFloat (buf, value, offset, littleEndian, noAssert) { value = +value offset = offset >>> 0 if (!noAssert) { checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38) } ieee754.write(buf, value, offset, littleEndian, 23, 4) return offset + 4 } Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) { return writeFloat(this, value, offset, true, noAssert) } Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) { return writeFloat(this, value, offset, false, noAssert) } function writeDouble (buf, value, offset, littleEndian, noAssert) { value = +value offset = offset >>> 0 if (!noAssert) { checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308) } ieee754.write(buf, value, offset, littleEndian, 52, 8) return offset + 8 } Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) { return writeDouble(this, value, offset, true, noAssert) } Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) { return writeDouble(this, value, offset, false, noAssert) } // copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length) Buffer.prototype.copy = function copy (target, targetStart, start, end) { if (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer') if (!start) start = 0 if (!end && end !== 0) end = this.length if (targetStart >= target.length) targetStart = target.length if (!targetStart) targetStart = 0 if (end > 0 && end < start) end = start // Copy 0 bytes; we're done if (end === start) return 0 if (target.length === 0 || this.length === 0) return 0 // Fatal error conditions if (targetStart < 0) { throw new RangeError('targetStart out of bounds') } if (start < 0 || start >= this.length) throw new RangeError('Index out of range') if (end < 0) throw new RangeError('sourceEnd out of bounds') // Are we oob? if (end > this.length) end = this.length if (target.length - targetStart < end - start) { end = target.length - targetStart + start } var len = end - start if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') { // Use built-in when available, missing from IE11 this.copyWithin(targetStart, start, end) } else if (this === target && start < targetStart && targetStart < end) { // descending copy from end for (var i = len - 1; i >= 0; --i) { target[i + targetStart] = this[i + start] } } else { Uint8Array.prototype.set.call( target, this.subarray(start, end), targetStart ) } return len } // Usage: // buffer.fill(number[, offset[, end]]) // buffer.fill(buffer[, offset[, end]]) // buffer.fill(string[, offset[, end]][, encoding]) Buffer.prototype.fill = function fill (val, start, end, encoding) { // Handle string cases: if (typeof val === 'string') { if (typeof start === 'string') { encoding = start start = 0 end = this.length } else if (typeof end === 'string') { encoding = end end = this.length } if (encoding !== undefined && typeof encoding !== 'string') { throw new TypeError('encoding must be a string') } if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) { throw new TypeError('Unknown encoding: ' + encoding) } if (val.length === 1) { var code = val.charCodeAt(0) if ((encoding === 'utf8' && code < 128) || encoding === 'latin1') { // Fast path: If `val` fits into a single byte, use that numeric value. val = code } } } else if (typeof val === 'number') { val = val & 255 } // Invalid ranges are not set to a default, so can range check early. if (start < 0 || this.length < start || this.length < end) { throw new RangeError('Out of range index') } if (end <= start) { return this } start = start >>> 0 end = end === undefined ? this.length : end >>> 0 if (!val) val = 0 var i if (typeof val === 'number') { for (i = start; i < end; ++i) { this[i] = val } } else { var bytes = Buffer.isBuffer(val) ? val : Buffer.from(val, encoding) var len = bytes.length if (len === 0) { throw new TypeError('The value "' + val + '" is invalid for argument "value"') } for (i = 0; i < end - start; ++i) { this[i + start] = bytes[i % len] } } return this } // HELPER FUNCTIONS // ================ var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g function base64clean (str) { // Node takes equal signs as end of the Base64 encoding str = str.split('=')[0] // Node strips out invalid characters like \n and \t from the string, base64-js does not str = str.trim().replace(INVALID_BASE64_RE, '') // Node converts strings with length < 2 to '' if (str.length < 2) return '' // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not while (str.length % 4 !== 0) { str = str + '=' } return str } function toHex (n) { if (n < 16) return '0' + n.toString(16) return n.toString(16) } function utf8ToBytes (string, units) { units = units || Infinity var codePoint var length = string.length var leadSurrogate = null var bytes = [] for (var i = 0; i < length; ++i) { codePoint = string.charCodeAt(i) // is surrogate component if (codePoint > 0xD7FF && codePoint < 0xE000) { // last char was a lead if (!leadSurrogate) { // no lead yet if (codePoint > 0xDBFF) { // unexpected trail if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) continue } else if (i + 1 === length) { // unpaired lead if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) continue } // valid lead leadSurrogate = codePoint continue } // 2 leads in a row if (codePoint < 0xDC00) { if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) leadSurrogate = codePoint continue } // valid surrogate pair codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000 } else if (leadSurrogate) { // valid bmp char, but last char was a lead if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) } leadSurrogate = null // encode utf8 if (codePoint < 0x80) { if ((units -= 1) < 0) break bytes.push(codePoint) } else if (codePoint < 0x800) { if ((units -= 2) < 0) break bytes.push( codePoint >> 0x6 | 0xC0, codePoint & 0x3F | 0x80 ) } else if (codePoint < 0x10000) { if ((units -= 3) < 0) break bytes.push( codePoint >> 0xC | 0xE0, codePoint >> 0x6 & 0x3F | 0x80, codePoint & 0x3F | 0x80 ) } else if (codePoint < 0x110000) { if ((units -= 4) < 0) break bytes.push( codePoint >> 0x12 | 0xF0, codePoint >> 0xC & 0x3F | 0x80, codePoint >> 0x6 & 0x3F | 0x80, codePoint & 0x3F | 0x80 ) } else { throw new Error('Invalid code point') } } return bytes } function asciiToBytes (str) { var byteArray = [] for (var i = 0; i < str.length; ++i) { // Node's code seems to be doing this and not & 0x7F.. byteArray.push(str.charCodeAt(i) & 0xFF) } return byteArray } function utf16leToBytes (str, units) { var c, hi, lo var byteArray = [] for (var i = 0; i < str.length; ++i) { if ((units -= 2) < 0) break c = str.charCodeAt(i) hi = c >> 8 lo = c % 256 byteArray.push(lo) byteArray.push(hi) } return byteArray } function base64ToBytes (str) { return base64.toByteArray(base64clean(str)) } function blitBuffer (src, dst, offset, length) { for (var i = 0; i < length; ++i) { if ((i + offset >= dst.length) || (i >= src.length)) break dst[i + offset] = src[i] } return i } // ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass // the `instanceof` check but they should be treated as of that type. // See: https://github.com/feross/buffer/issues/166 function isInstance (obj, type) { return obj instanceof type || (obj != null && obj.constructor != null && obj.constructor.name != null && obj.constructor.name === type.name) } function numberIsNaN (obj) { // For IE11 support return obj !== obj // eslint-disable-line no-self-compare } }).call(this)}).call(this,require("buffer").Buffer) },{"base64-js":407,"buffer":414,"ieee754":446}],415:[function(require,module,exports){ 'use strict'; var GetIntrinsic = require('get-intrinsic'); var callBind = require('./'); var $indexOf = callBind(GetIntrinsic('String.prototype.indexOf')); module.exports = function callBoundIntrinsic(name, allowMissing) { var intrinsic = GetIntrinsic(name, !!allowMissing); if (typeof intrinsic === 'function' && $indexOf(name, '.prototype.') > -1) { return callBind(intrinsic); } return intrinsic; }; },{"./":416,"get-intrinsic":440}],416:[function(require,module,exports){ 'use strict'; var bind = require('function-bind'); var GetIntrinsic = require('get-intrinsic'); var $apply = GetIntrinsic('%Function.prototype.apply%'); var $call = GetIntrinsic('%Function.prototype.call%'); var $reflectApply = GetIntrinsic('%Reflect.apply%', true) || bind.call($call, $apply); var $gOPD = GetIntrinsic('%Object.getOwnPropertyDescriptor%', true); var $defineProperty = GetIntrinsic('%Object.defineProperty%', true); var $max = GetIntrinsic('%Math.max%'); if ($defineProperty) { try { $defineProperty({}, 'a', { value: 1 }); } catch (e) { // IE 8 has a broken defineProperty $defineProperty = null; } } module.exports = function callBind(originalFunction) { var func = $reflectApply(bind, $call, arguments); if ($gOPD && $defineProperty) { var desc = $gOPD(func, 'length'); if (desc.configurable) { // original length, plus the receiver, minus any additional arguments (after the receiver) $defineProperty( func, 'length', { value: 1 + $max(0, originalFunction.length - (arguments.length - 1)) } ); } } return func; }; var applyBind = function applyBind() { return $reflectApply(bind, $apply, arguments); }; if ($defineProperty) { $defineProperty(module.exports, 'apply', { value: applyBind }); } else { module.exports.apply = applyBind; } },{"function-bind":438,"get-intrinsic":440}],417:[function(require,module,exports){ module.exports={A:{A:{J:0.0131217,D:0.00621152,E:0.0360158,F:0.086438,A:0.00720317,B:0.475409,"4B":0.009298},B:"ms",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","4B","J","D","E","F","A","B","","",""],E:"IE",F:{"4B":962323200,J:998870400,D:1161129600,E:1237420800,F:1300060800,A:1346716800,B:1381968000}},B:{A:{C:0.007858,K:0.004267,L:0.004268,G:0.003929,M:0.003702,N:0.007858,O:0.023574,P:0,Q:0.004298,R:0.00944,S:0.004043,T:0.007858,U:0.007858,V:0.003929,W:0.003929,X:0.004318,Y:0.003929,Z:0.004118,a:0.003939,d:0.007858,e:0.004118,f:0.003939,g:0.003801,h:0.003929,i:0.003855,j:0.003929,k:0.003929,l:0.007858,m:0.019645,n:0.015716,o:0.055006,p:0.652214,b:3.4143,H:0},B:"webkit",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","C","K","L","G","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z","a","d","e","f","g","h","i","j","k","l","m","n","o","p","b","H","","",""],E:"Edge",F:{C:1438128000,K:1447286400,L:1470096000,G:1491868800,M:1508198400,N:1525046400,O:1542067200,P:1579046400,Q:1581033600,R:1586736000,S:1590019200,T:1594857600,U:1598486400,V:1602201600,W:1605830400,X:1611360000,Y:1614816000,Z:1618358400,a:1622073600,d:1626912000,e:1630627200,f:1632441600,g:1634774400,h:1637539200,i:1641427200,j:1643932800,k:1646265600,l:1649635200,m:1651190400,n:1653955200,o:1655942400,p:1659657600,b:1661990400,H:1664755200},D:{C:"ms",K:"ms",L:"ms",G:"ms",M:"ms",N:"ms",O:"ms"}},C:{A:{"0":0.004418,"1":0.008834,"2":0.008322,"3":0.008928,"4":0.004471,"5":0.009284,"6":0.004707,"7":0.009076,"8":0.007858,"9":0.004783,"5B":0.004118,pB:0.004271,I:0.019645,q:0.004879,J:0.020136,D:0.005725,E:0.004525,F:0.00533,A:0.004283,B:0.007858,C:0.004471,K:0.004486,L:0.00453,G:0.008322,M:0.004417,N:0.004425,O:0.004161,r:0.004443,s:0.004283,t:0.008322,u:0.013698,v:0.004161,w:0.008786,x:0.004118,y:0.004317,z:0.004393,AB:0.003929,BB:0.004783,CB:0.00487,DB:0.005029,EB:0.0047,FB:0.011787,GB:0.007858,HB:0.003867,IB:0.004525,JB:0.004293,KB:0.003702,LB:0.004538,MB:0.008282,NB:0.011601,OB:0.055006,PB:0.011601,QB:0.003929,RB:0.007858,SB:0.003929,TB:0.011601,UB:0.003939,qB:0.003855,VB:0.003929,rB:0.004356,WB:0.004425,XB:0.008322,c:0.00415,YB:0.004267,ZB:0.003801,aB:0.004267,bB:0.007858,cB:0.00415,dB:0.004293,eB:0.004425,fB:0.003929,gB:0.00415,hB:0.00415,iB:0.004318,jB:0.004356,kB:0.003929,lB:0.03929,P:0.007858,Q:0.007858,R:0.007858,sB:0.007858,S:0.007858,T:0.003929,U:0.004268,V:0.003801,W:0.011787,X:0.007858,Y:0.003929,Z:0.003929,a:0.070722,d:0.003801,e:0.003855,f:0.019645,g:0.007858,h:0.003929,i:0.007858,j:0.007858,k:0.011787,l:0.011787,m:0.011787,n:0.051077,o:0.141444,p:1.60303,b:0.542202,H:0.007858,tB:0,"6B":0.008786,"7B":0.00487},B:"moz",C:["5B","pB","6B","7B","I","q","J","D","E","F","A","B","C","K","L","G","M","N","O","r","s","t","u","v","w","x","y","z","0","1","2","3","4","5","6","7","8","9","AB","BB","CB","DB","EB","FB","GB","HB","IB","JB","KB","LB","MB","NB","OB","PB","QB","RB","SB","TB","UB","qB","VB","rB","WB","XB","c","YB","ZB","aB","bB","cB","dB","eB","fB","gB","hB","iB","jB","kB","lB","P","Q","R","sB","S","T","U","V","W","X","Y","Z","a","d","e","f","g","h","i","j","k","l","m","n","o","p","b","H","tB",""],E:"Firefox",F:{"0":1395100800,"1":1398729600,"2":1402358400,"3":1405987200,"4":1409616000,"5":1413244800,"6":1417392000,"7":1421107200,"8":1424736000,"9":1428278400,"5B":1161648000,pB:1213660800,"6B":1246320000,"7B":1264032000,I:1300752000,q:1308614400,J:1313452800,D:1317081600,E:1317081600,F:1320710400,A:1324339200,B:1327968000,C:1331596800,K:1335225600,L:1338854400,G:1342483200,M:1346112000,N:1349740800,O:1353628800,r:1357603200,s:1361232000,t:1364860800,u:1368489600,v:1372118400,w:1375747200,x:1379376000,y:1386633600,z:1391472000,AB:1431475200,BB:1435881600,CB:1439251200,DB:1442880000,EB:1446508800,FB:1450137600,GB:1453852800,HB:1457395200,IB:1461628800,JB:1465257600,KB:1470096000,LB:1474329600,MB:1479168000,NB:1485216000,OB:1488844800,PB:1492560000,QB:1497312000,RB:1502150400,SB:1506556800,TB:1510617600,UB:1516665600,qB:1520985600,VB:1525824000,rB:1529971200,WB:1536105600,XB:1540252800,c:1544486400,YB:1548720000,ZB:1552953600,aB:1558396800,bB:1562630400,cB:1567468800,dB:1571788800,eB:1575331200,fB:1578355200,gB:1581379200,hB:1583798400,iB:1586304000,jB:1588636800,kB:1591056000,lB:1593475200,P:1595894400,Q:1598313600,R:1600732800,sB:1603152000,S:1605571200,T:1607990400,U:1611619200,V:1614038400,W:1616457600,X:1618790400,Y:1622505600,Z:1626134400,a:1628553600,d:1630972800,e:1633392000,f:1635811200,g:1638835200,h:1641859200,i:1644364800,j:1646697600,k:1649116800,l:1651536000,m:1653955200,n:1656374400,o:1658793600,p:1661212800,b:1663632000,H:null,tB:null}},D:{A:{"0":0.0047,"1":0.004538,"2":0.008322,"3":0.008596,"4":0.004566,"5":0.004118,"6":0.007858,"7":0.003702,"8":0.004335,"9":0.004464,I:0.004706,q:0.004879,J:0.004879,D:0.005591,E:0.005591,F:0.005591,A:0.004534,B:0.004464,C:0.010424,K:0.0083,L:0.004706,G:0.015087,M:0.004393,N:0.004393,O:0.008652,r:0.008322,s:0.004393,t:0.004317,u:0.003929,v:0.008786,w:0.003939,x:0.004461,y:0.004141,z:0.004326,AB:0.015716,BB:0.003867,CB:0.015716,DB:0.007858,EB:0.003929,FB:0.007858,GB:0.007858,HB:0.007858,IB:0.003867,JB:0.007858,KB:0.019645,LB:0.047148,MB:0.003867,NB:0.003929,OB:0.003929,PB:0.007858,QB:0.003867,RB:0.003929,SB:0.03929,TB:0.003929,UB:0.003702,qB:0.003702,VB:0.011787,rB:0.007858,WB:0.003929,XB:0.011787,c:0.003929,YB:0.011787,ZB:0.027503,aB:0.011787,bB:0.007858,cB:0.047148,dB:0.023574,eB:0.015716,fB:0.023574,gB:0.007858,hB:0.031432,iB:0.047148,jB:0.03929,kB:0.015716,lB:0.035361,P:0.113941,Q:0.043219,R:0.03929,S:0.082509,T:0.086438,U:0.121799,V:0.11787,W:0.121799,X:0.023574,Y:0.043219,Z:0.023574,a:0.062864,d:0.051077,e:0.047148,f:0.03929,g:0.023574,h:0.082509,i:0.066793,j:0.062864,k:0.066793,l:0.113941,m:0.110012,n:0.208237,o:0.664001,p:4.8091,b:16.604,H:0.294675,tB:0.019645,"8B":0.011787,"9B":0},B:"webkit",C:["","","","","I","q","J","D","E","F","A","B","C","K","L","G","M","N","O","r","s","t","u","v","w","x","y","z","0","1","2","3","4","5","6","7","8","9","AB","BB","CB","DB","EB","FB","GB","HB","IB","JB","KB","LB","MB","NB","OB","PB","QB","RB","SB","TB","UB","qB","VB","rB","WB","XB","c","YB","ZB","aB","bB","cB","dB","eB","fB","gB","hB","iB","jB","kB","lB","P","Q","R","S","T","U","V","W","X","Y","Z","a","d","e","f","g","h","i","j","k","l","m","n","o","p","b","H","tB","8B","9B"],E:"Chrome",F:{"0":1369094400,"1":1374105600,"2":1376956800,"3":1384214400,"4":1389657600,"5":1392940800,"6":1397001600,"7":1400544000,"8":1405468800,"9":1409011200,I:1264377600,q:1274745600,J:1283385600,D:1287619200,E:1291248000,F:1296777600,A:1299542400,B:1303862400,C:1307404800,K:1312243200,L:1316131200,G:1316131200,M:1319500800,N:1323734400,O:1328659200,r:1332892800,s:1337040000,t:1340668800,u:1343692800,v:1348531200,w:1352246400,x:1357862400,y:1361404800,z:1364428800,AB:1412640000,BB:1416268800,CB:1421798400,DB:1425513600,EB:1429401600,FB:1432080000,GB:1437523200,HB:1441152000,IB:1444780800,JB:1449014400,KB:1453248000,LB:1456963200,MB:1460592000,NB:1464134400,OB:1469059200,PB:1472601600,QB:1476230400,RB:1480550400,SB:1485302400,TB:1489017600,UB:1492560000,qB:1496707200,VB:1500940800,rB:1504569600,WB:1508198400,XB:1512518400,c:1516752000,YB:1520294400,ZB:1523923200,aB:1527552000,bB:1532390400,cB:1536019200,dB:1539648000,eB:1543968000,fB:1548720000,gB:1552348800,hB:1555977600,iB:1559606400,jB:1564444800,kB:1568073600,lB:1571702400,P:1575936000,Q:1580860800,R:1586304000,S:1589846400,T:1594684800,U:1598313600,V:1601942400,W:1605571200,X:1611014400,Y:1614556800,Z:1618272000,a:1621987200,d:1626739200,e:1630368000,f:1632268800,g:1634601600,h:1637020800,i:1641340800,j:1643673600,k:1646092800,l:1648512000,m:1650931200,n:1653350400,o:1655769600,p:1659398400,b:1661817600,H:1664236800,tB:null,"8B":null,"9B":null}},E:{A:{I:0,q:0.008322,J:0.004656,D:0.004465,E:0.003929,F:0.003929,A:0.004425,B:0.004318,C:0.003801,K:0.027503,L:0.11787,G:0.027503,AC:0,uB:0.008692,BC:0.011787,CC:0.00456,DC:0.004283,EC:0.015716,vB:0.007858,mB:0.019645,nB:0.03929,wB:0.259314,FC:0.306462,GC:0.051077,xB:0.051077,yB:0.141444,zB:0.31432,"0B":1.77984,oB:0.184663,"1B":0.011787,HC:0},B:"webkit",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","AC","uB","I","q","BC","J","CC","D","DC","E","F","EC","A","vB","B","mB","C","nB","K","wB","L","FC","G","GC","xB","yB","zB","0B","oB","1B","HC",""],E:"Safari",F:{AC:1205798400,uB:1226534400,I:1244419200,q:1275868800,BC:1311120000,J:1343174400,CC:1382400000,D:1382400000,DC:1410998400,E:1413417600,F:1443657600,EC:1458518400,A:1474329600,vB:1490572800,B:1505779200,mB:1522281600,C:1537142400,nB:1553472000,K:1568851200,wB:1585008000,L:1600214400,FC:1619395200,G:1632096000,GC:1635292800,xB:1639353600,yB:1647216000,zB:1652745600,"0B":1658275200,oB:1662940800,"1B":null,HC:null}},F:{A:{"0":0.007858,"1":0.004879,"2":0.004879,"3":0.003929,"4":0.005152,"5":0.005014,"6":0.009758,"7":0.004879,"8":0.003929,"9":0.004283,F:0.0082,B:0.016581,C:0.004317,G:0.00685,M:0.00685,N:0.00685,O:0.005014,r:0.006015,s:0.004879,t:0.006597,u:0.006597,v:0.013434,w:0.006702,x:0.006015,y:0.005595,z:0.004393,AB:0.004367,BB:0.004534,CB:0.007858,DB:0.004227,EB:0.004418,FB:0.004161,GB:0.004227,HB:0.004725,IB:0.011787,JB:0.008942,KB:0.004707,LB:0.004827,MB:0.004707,NB:0.004707,OB:0.004326,PB:0.008922,QB:0.014349,RB:0.004425,SB:0.00472,TB:0.004425,UB:0.004425,VB:0.00472,WB:0.004532,XB:0.004566,c:0.02283,YB:0.00867,ZB:0.004656,aB:0.004642,bB:0.003929,cB:0.00944,dB:0.004293,eB:0.003929,fB:0.004298,gB:0.096692,hB:0.004201,iB:0.004141,jB:0.004257,kB:0.003939,lB:0.008236,P:0.003855,Q:0.003939,R:0.008514,sB:0.003939,S:0.003939,T:0.003702,U:0.011787,V:0.003855,W:0.003855,X:0.003929,Y:0.07858,Z:0.887954,a:0.035361,IC:0.00685,JC:0,KC:0.008392,LC:0.004706,mB:0.006229,"2B":0.004879,MC:0.008786,nB:0.00472},B:"webkit",C:["","","","","","","","","","","","","","","","","","","","","F","IC","JC","KC","LC","B","mB","2B","MC","C","nB","G","M","N","O","r","s","t","u","v","w","x","y","z","0","1","2","3","4","5","6","7","8","9","AB","BB","CB","DB","EB","FB","GB","HB","IB","JB","KB","LB","MB","NB","OB","PB","QB","RB","SB","TB","UB","VB","WB","XB","c","YB","ZB","aB","bB","cB","dB","eB","fB","gB","hB","iB","jB","kB","lB","P","Q","R","sB","S","T","U","V","W","X","Y","Z","a","","",""],E:"Opera",F:{"0":1425945600,"1":1430179200,"2":1433808000,"3":1438646400,"4":1442448000,"5":1445904000,"6":1449100800,"7":1454371200,"8":1457308800,"9":1462320000,F:1150761600,IC:1223424000,JC:1251763200,KC:1267488000,LC:1277942400,B:1292457600,mB:1302566400,"2B":1309219200,MC:1323129600,C:1323129600,nB:1352073600,G:1372723200,M:1377561600,N:1381104000,O:1386288000,r:1390867200,s:1393891200,t:1399334400,u:1401753600,v:1405987200,w:1409616000,x:1413331200,y:1417132800,z:1422316800,AB:1465344000,BB:1470096000,CB:1474329600,DB:1477267200,EB:1481587200,FB:1486425600,GB:1490054400,HB:1494374400,IB:1498003200,JB:1502236800,KB:1506470400,LB:1510099200,MB:1515024000,NB:1517961600,OB:1521676800,PB:1525910400,QB:1530144000,RB:1534982400,SB:1537833600,TB:1543363200,UB:1548201600,VB:1554768000,WB:1561593600,XB:1566259200,c:1570406400,YB:1573689600,ZB:1578441600,aB:1583971200,bB:1587513600,cB:1592956800,dB:1595894400,eB:1600128000,fB:1603238400,gB:1613520000,hB:1612224000,iB:1616544000,jB:1619568000,kB:1623715200,lB:1627948800,P:1631577600,Q:1633392000,R:1635984000,sB:1638403200,S:1642550400,T:1644969600,U:1647993600,V:1650412800,W:1652745600,X:1654646400,Y:1657152000,Z:1660780800,a:1663113600},D:{F:"o",B:"o",C:"o",IC:"o",JC:"o",KC:"o",LC:"o",mB:"o","2B":"o",MC:"o",nB:"o"}},G:{A:{E:0,uB:0,NC:0,"3B":0.0030538,OC:0.00458069,PC:0.00458069,QC:0.015269,RC:0.00916139,SC:0.0198497,TC:0.0641297,UC:0.00458069,VC:0.074818,WC:0.030538,XC:0.0244304,YC:0.0290111,ZC:0.427531,aC:0.0198497,bC:0.0106883,cC:0.04428,dC:0.140475,eC:0.432112,fC:0.916139,gC:0.230562,xB:0.322175,yB:0.426004,zB:1.04134,"0B":8.71401,oB:1.9132,"1B":0.0244304},B:"webkit",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","uB","NC","3B","OC","PC","QC","E","RC","SC","TC","UC","VC","WC","XC","YC","ZC","aC","bC","cC","dC","eC","fC","gC","xB","yB","zB","0B","oB","1B","",""],E:"Safari on iOS",F:{uB:1270252800,NC:1283904000,"3B":1299628800,OC:1331078400,PC:1359331200,QC:1394409600,E:1410912000,RC:1413763200,SC:1442361600,TC:1458518400,UC:1473724800,VC:1490572800,WC:1505779200,XC:1522281600,YC:1537142400,ZC:1553472000,aC:1568851200,bC:1572220800,cC:1580169600,dC:1585008000,eC:1600214400,fC:1619395200,gC:1632096000,xB:1639353600,yB:1647216000,zB:1652659200,"0B":1658275200,oB:1662940800,"1B":null}},H:{A:{hC:1.06906},B:"o",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","hC","","",""],E:"Opera Mini",F:{hC:1426464000}},I:{A:{pB:0,I:0.024284,H:0,iC:0,jC:0.006071,kC:0,lC:0.024284,"3B":0.078923,mC:0,nC:0.309621},B:"webkit",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","iC","jC","kC","pB","I","lC","3B","mC","nC","H","","",""],E:"Android Browser",F:{iC:1256515200,jC:1274313600,kC:1291593600,pB:1298332800,I:1318896000,lC:1341792000,"3B":1374624000,mC:1386547200,nC:1401667200,H:1664323200}},J:{A:{D:0,A:0},B:"webkit",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","D","A","","",""],E:"Blackberry Browser",F:{D:1325376000,A:1359504000}},K:{A:{A:0,B:0,C:0,c:0.0111391,mB:0,"2B":0,nB:0},B:"o",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","A","B","mB","2B","C","nB","c","","",""],E:"Opera Mobile",F:{A:1287100800,B:1300752000,mB:1314835200,"2B":1318291200,C:1330300800,nB:1349740800,c:1613433600},D:{c:"webkit"}},L:{A:{H:41.2317},B:"webkit",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","H","","",""],E:"Chrome for Android",F:{H:1664323200}},M:{A:{b:0.297479},B:"moz",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","b","","",""],E:"Firefox for Android",F:{b:1663632000}},N:{A:{A:0.0115934,B:0.022664},B:"ms",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","A","B","","",""],E:"IE Mobile",F:{A:1340150400,B:1353456000}},O:{A:{oC:0.710307},B:"webkit",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","oC","","",""],E:"UC Browser for Android",F:{oC:1634688000},D:{oC:"webkit"}},P:{A:{I:0.166875,pC:0.0103543,qC:0.010304,rC:0.062578,sC:0.0103584,tC:0.0104443,vB:0.0105043,uC:0.031289,vC:0.0208593,wC:0.062578,xC:0.062578,yC:0.062578,oB:0.114726,zC:0.239882,"0C":2.02336},B:"webkit",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","I","pC","qC","rC","sC","tC","vB","uC","vC","wC","xC","yC","oB","zC","0C","","",""],E:"Samsung Internet",F:{I:1461024000,pC:1481846400,qC:1509408000,rC:1528329600,sC:1546128000,tC:1554163200,vB:1567900800,uC:1582588800,vC:1593475200,wC:1605657600,xC:1618531200,yC:1629072000,oB:1640736000,zC:1651708800,"0C":1659657600}},Q:{A:{wB:0.139633},B:"webkit",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","wB","","",""],E:"QQ Browser",F:{wB:1663718400}},R:{A:{"1C":0},B:"webkit",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","1C","","",""],E:"Baidu Browser",F:{"1C":1663027200}},S:{A:{"2C":0.024284},B:"moz",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","2C","","",""],E:"KaiOS Browser",F:{"2C":1527811200}}}; },{}],418:[function(require,module,exports){ module.exports={"0":"28","1":"29","2":"30","3":"31","4":"32","5":"33","6":"34","7":"35","8":"36","9":"37",A:"10",B:"11",C:"12",D:"7",E:"8",F:"9",G:"15",H:"106",I:"4",J:"6",K:"13",L:"14",M:"16",N:"17",O:"18",P:"79",Q:"80",R:"81",S:"83",T:"84",U:"85",V:"86",W:"87",X:"88",Y:"89",Z:"90",a:"91",b:"105",c:"64",d:"92",e:"93",f:"94",g:"95",h:"96",i:"97",j:"98",k:"99",l:"100",m:"101",n:"102",o:"103",p:"104",q:"5",r:"19",s:"20",t:"21",u:"22",v:"23",w:"24",x:"25",y:"26",z:"27",AB:"38",BB:"39",CB:"40",DB:"41",EB:"42",FB:"43",GB:"44",HB:"45",IB:"46",JB:"47",KB:"48",LB:"49",MB:"50",NB:"51",OB:"52",PB:"53",QB:"54",RB:"55",SB:"56",TB:"57",UB:"58",VB:"60",WB:"62",XB:"63",YB:"65",ZB:"66",aB:"67",bB:"68",cB:"69",dB:"70",eB:"71",fB:"72",gB:"73",hB:"74",iB:"75",jB:"76",kB:"77",lB:"78",mB:"11.1",nB:"12.1",oB:"16.0",pB:"3",qB:"59",rB:"61",sB:"82",tB:"107",uB:"3.2",vB:"10.1",wB:"13.1",xB:"15.2-15.3",yB:"15.4",zB:"15.5","0B":"15.6","1B":"16.1","2B":"11.5","3B":"4.2-4.3","4B":"5.5","5B":"2","6B":"3.5","7B":"3.6","8B":"108","9B":"109",AC:"3.1",BC:"5.1",CC:"6.1",DC:"7.1",EC:"9.1",FC:"14.1",GC:"15.1",HC:"TP",IC:"9.5-9.6",JC:"10.0-10.1",KC:"10.5",LC:"10.6",MC:"11.6",NC:"4.0-4.1",OC:"5.0-5.1",PC:"6.0-6.1",QC:"7.0-7.1",RC:"8.1-8.4",SC:"9.0-9.2",TC:"9.3",UC:"10.0-10.2",VC:"10.3",WC:"11.0-11.2",XC:"11.3-11.4",YC:"12.0-12.1",ZC:"12.2-12.5",aC:"13.0-13.1",bC:"13.2",cC:"13.3",dC:"13.4-13.7",eC:"14.0-14.4",fC:"14.5-14.8",gC:"15.0-15.1",hC:"all",iC:"2.1",jC:"2.2",kC:"2.3",lC:"4.1",mC:"4.4",nC:"4.4.3-4.4.4",oC:"13.4",pC:"5.0-5.4",qC:"6.2-6.4",rC:"7.2-7.4",sC:"8.2",tC:"9.2",uC:"11.1-11.2",vC:"12.0",wC:"13.0",xC:"14.0",yC:"15.0",zC:"17.0","0C":"18.0","1C":"13.18","2C":"2.5"}; },{}],419:[function(require,module,exports){ module.exports={A:"ie",B:"edge",C:"firefox",D:"chrome",E:"safari",F:"opera",G:"ios_saf",H:"op_mini",I:"android",J:"bb",K:"op_mob",L:"and_chr",M:"and_ff",N:"ie_mob",O:"and_uc",P:"samsung",Q:"and_qq",R:"baidu",S:"kaios"}; },{}],420:[function(require,module,exports){ 'use strict' const browsers = require('./browsers').browsers const versions = require('./browserVersions').browserVersions const agentsData = require('../../data/agents') function unpackBrowserVersions(versionsData) { return Object.keys(versionsData).reduce((usage, version) => { usage[versions[version]] = versionsData[version] return usage }, {}) } module.exports.agents = Object.keys(agentsData).reduce((map, key) => { let versionsData = agentsData[key] map[browsers[key]] = Object.keys(versionsData).reduce((data, entry) => { if (entry === 'A') { data.usage_global = unpackBrowserVersions(versionsData[entry]) } else if (entry === 'C') { data.versions = versionsData[entry].reduce((list, version) => { if (version === '') { list.push(null) } else { list.push(versions[version]) } return list }, []) } else if (entry === 'D') { data.prefix_exceptions = unpackBrowserVersions(versionsData[entry]) } else if (entry === 'E') { data.browser = versionsData[entry] } else if (entry === 'F') { data.release_date = Object.keys(versionsData[entry]).reduce( (map2, key2) => { map2[versions[key2]] = versionsData[entry][key2] return map2 }, {} ) } else { // entry is B data.prefix = versionsData[entry] } return data }, {}) return map }, {}) },{"../../data/agents":417,"./browserVersions":421,"./browsers":422}],421:[function(require,module,exports){ module.exports.browserVersions = require('../../data/browserVersions') },{"../../data/browserVersions":418}],422:[function(require,module,exports){ module.exports.browsers = require('../../data/browsers') },{"../../data/browsers":419}],423:[function(require,module,exports){ (function (process){(function (){ 'use strict'; const escapeStringRegexp = require('escape-string-regexp'); const ansiStyles = require('ansi-styles'); const stdoutColor = require('supports-color').stdout; const template = require('./templates.js'); const isSimpleWindowsTerm = process.platform === 'win32' && !(process.env.TERM || '').toLowerCase().startsWith('xterm'); // `supportsColor.level` ā†’ `ansiStyles.color[name]` mapping const levelMapping = ['ansi', 'ansi', 'ansi256', 'ansi16m']; // `color-convert` models to exclude from the Chalk API due to conflicts and such const skipModels = new Set(['gray']); const styles = Object.create(null); function applyOptions(obj, options) { options = options || {}; // Detect level if not set manually const scLevel = stdoutColor ? stdoutColor.level : 0; obj.level = options.level === undefined ? scLevel : options.level; obj.enabled = 'enabled' in options ? options.enabled : obj.level > 0; } function Chalk(options) { // We check for this.template here since calling `chalk.constructor()` // by itself will have a `this` of a previously constructed chalk object if (!this || !(this instanceof Chalk) || this.template) { const chalk = {}; applyOptions(chalk, options); chalk.template = function () { const args = [].slice.call(arguments); return chalkTag.apply(null, [chalk.template].concat(args)); }; Object.setPrototypeOf(chalk, Chalk.prototype); Object.setPrototypeOf(chalk.template, chalk); chalk.template.constructor = Chalk; return chalk.template; } applyOptions(this, options); } // Use bright blue on Windows as the normal blue color is illegible if (isSimpleWindowsTerm) { ansiStyles.blue.open = '\u001B[94m'; } for (const key of Object.keys(ansiStyles)) { ansiStyles[key].closeRe = new RegExp(escapeStringRegexp(ansiStyles[key].close), 'g'); styles[key] = { get() { const codes = ansiStyles[key]; return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, key); } }; } styles.visible = { get() { return build.call(this, this._styles || [], true, 'visible'); } }; ansiStyles.color.closeRe = new RegExp(escapeStringRegexp(ansiStyles.color.close), 'g'); for (const model of Object.keys(ansiStyles.color.ansi)) { if (skipModels.has(model)) { continue; } styles[model] = { get() { const level = this.level; return function () { const open = ansiStyles.color[levelMapping[level]][model].apply(null, arguments); const codes = { open, close: ansiStyles.color.close, closeRe: ansiStyles.color.closeRe }; return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model); }; } }; } ansiStyles.bgColor.closeRe = new RegExp(escapeStringRegexp(ansiStyles.bgColor.close), 'g'); for (const model of Object.keys(ansiStyles.bgColor.ansi)) { if (skipModels.has(model)) { continue; } const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1); styles[bgModel] = { get() { const level = this.level; return function () { const open = ansiStyles.bgColor[levelMapping[level]][model].apply(null, arguments); const codes = { open, close: ansiStyles.bgColor.close, closeRe: ansiStyles.bgColor.closeRe }; return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model); }; } }; } const proto = Object.defineProperties(() => {}, styles); function build(_styles, _empty, key) { const builder = function () { return applyStyle.apply(builder, arguments); }; builder._styles = _styles; builder._empty = _empty; const self = this; Object.defineProperty(builder, 'level', { enumerable: true, get() { return self.level; }, set(level) { self.level = level; } }); Object.defineProperty(builder, 'enabled', { enumerable: true, get() { return self.enabled; }, set(enabled) { self.enabled = enabled; } }); // See below for fix regarding invisible grey/dim combination on Windows builder.hasGrey = this.hasGrey || key === 'gray' || key === 'grey'; // `__proto__` is used because we must return a function, but there is // no way to create a function with a different prototype builder.__proto__ = proto; // eslint-disable-line no-proto return builder; } function applyStyle() { // Support varags, but simply cast to string in case there's only one arg const args = arguments; const argsLen = args.length; let str = String(arguments[0]); if (argsLen === 0) { return ''; } if (argsLen > 1) { // Don't slice `arguments`, it prevents V8 optimizations for (let a = 1; a < argsLen; a++) { str += ' ' + args[a]; } } if (!this.enabled || this.level <= 0 || !str) { return this._empty ? '' : str; } // Turns out that on Windows dimmed gray text becomes invisible in cmd.exe, // see https://github.com/chalk/chalk/issues/58 // If we're on Windows and we're dealing with a gray color, temporarily make 'dim' a noop. const originalDim = ansiStyles.dim.open; if (isSimpleWindowsTerm && this.hasGrey) { ansiStyles.dim.open = ''; } for (const code of this._styles.slice().reverse()) { // Replace any instances already present with a re-opening code // otherwise only the part of the string until said closing code // will be colored, and the rest will simply be 'plain'. str = code.open + str.replace(code.closeRe, code.open) + code.close; // Close the styling before a linebreak and reopen // after next line to fix a bleed issue on macOS // https://github.com/chalk/chalk/pull/92 str = str.replace(/\r?\n/g, `${code.close}$&${code.open}`); } // Reset the original `dim` if we changed it to work around the Windows dimmed gray issue ansiStyles.dim.open = originalDim; return str; } function chalkTag(chalk, strings) { if (!Array.isArray(strings)) { // If chalk() was called by itself or with a string, // return the string itself as a string. return [].slice.call(arguments, 1).join(' '); } const args = [].slice.call(arguments, 2); const parts = [strings.raw[0]]; for (let i = 1; i < strings.length; i++) { parts.push(String(args[i - 1]).replace(/[{}\\]/g, '\\$&')); parts.push(String(strings.raw[i])); } return template(chalk, parts.join('')); } Object.defineProperties(Chalk.prototype, styles); module.exports = Chalk(); // eslint-disable-line new-cap module.exports.supportsColor = stdoutColor; module.exports.default = module.exports; // For TypeScript }).call(this)}).call(this,require('_process')) },{"./templates.js":424,"_process":460,"ansi-styles":400,"escape-string-regexp":434,"supports-color":538}],424:[function(require,module,exports){ 'use strict'; const TEMPLATE_REGEX = /(?:\\(u[a-f\d]{4}|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi; const STYLE_REGEX = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g; const STRING_REGEX = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/; const ESCAPE_REGEX = /\\(u[a-f\d]{4}|x[a-f\d]{2}|.)|([^\\])/gi; const ESCAPES = new Map([ ['n', '\n'], ['r', '\r'], ['t', '\t'], ['b', '\b'], ['f', '\f'], ['v', '\v'], ['0', '\0'], ['\\', '\\'], ['e', '\u001B'], ['a', '\u0007'] ]); function unescape(c) { if ((c[0] === 'u' && c.length === 5) || (c[0] === 'x' && c.length === 3)) { return String.fromCharCode(parseInt(c.slice(1), 16)); } return ESCAPES.get(c) || c; } function parseArguments(name, args) { const results = []; const chunks = args.trim().split(/\s*,\s*/g); let matches; for (const chunk of chunks) { if (!isNaN(chunk)) { results.push(Number(chunk)); } else if ((matches = chunk.match(STRING_REGEX))) { results.push(matches[2].replace(ESCAPE_REGEX, (m, escape, chr) => escape ? unescape(escape) : chr)); } else { throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`); } } return results; } function parseStyle(style) { STYLE_REGEX.lastIndex = 0; const results = []; let matches; while ((matches = STYLE_REGEX.exec(style)) !== null) { const name = matches[1]; if (matches[2]) { const args = parseArguments(name, matches[2]); results.push([name].concat(args)); } else { results.push([name]); } } return results; } function buildStyle(chalk, styles) { const enabled = {}; for (const layer of styles) { for (const style of layer.styles) { enabled[style[0]] = layer.inverse ? null : style.slice(1); } } let current = chalk; for (const styleName of Object.keys(enabled)) { if (Array.isArray(enabled[styleName])) { if (!(styleName in current)) { throw new Error(`Unknown Chalk style: ${styleName}`); } if (enabled[styleName].length > 0) { current = current[styleName].apply(current, enabled[styleName]); } else { current = current[styleName]; } } } return current; } module.exports = (chalk, tmp) => { const styles = []; const chunks = []; let chunk = []; // eslint-disable-next-line max-params tmp.replace(TEMPLATE_REGEX, (m, escapeChar, inverse, style, close, chr) => { if (escapeChar) { chunk.push(unescape(escapeChar)); } else if (style) { const str = chunk.join(''); chunk = []; chunks.push(styles.length === 0 ? str : buildStyle(chalk, styles)(str)); styles.push({inverse, styles: parseStyle(style)}); } else if (close) { if (styles.length === 0) { throw new Error('Found extraneous } in Chalk template literal'); } chunks.push(buildStyle(chalk, styles)(chunk.join(''))); chunk = []; styles.pop(); } else { chunk.push(chr); } }); chunks.push(chunk.join('')); if (styles.length > 0) { const errMsg = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? '' : 's'} (\`}\`)`; throw new Error(errMsg); } return chunks.join(''); }; },{}],425:[function(require,module,exports){ /* MIT license */ var cssKeywords = require('color-name'); // NOTE: conversions should only return primitive values (i.e. arrays, or // values that give correct `typeof` results). // do not use box values types (i.e. Number(), String(), etc.) var reverseKeywords = {}; for (var key in cssKeywords) { if (cssKeywords.hasOwnProperty(key)) { reverseKeywords[cssKeywords[key]] = key; } } var convert = module.exports = { rgb: {channels: 3, labels: 'rgb'}, hsl: {channels: 3, labels: 'hsl'}, hsv: {channels: 3, labels: 'hsv'}, hwb: {channels: 3, labels: 'hwb'}, cmyk: {channels: 4, labels: 'cmyk'}, xyz: {channels: 3, labels: 'xyz'}, lab: {channels: 3, labels: 'lab'}, lch: {channels: 3, labels: 'lch'}, hex: {channels: 1, labels: ['hex']}, keyword: {channels: 1, labels: ['keyword']}, ansi16: {channels: 1, labels: ['ansi16']}, ansi256: {channels: 1, labels: ['ansi256']}, hcg: {channels: 3, labels: ['h', 'c', 'g']}, apple: {channels: 3, labels: ['r16', 'g16', 'b16']}, gray: {channels: 1, labels: ['gray']} }; // hide .channels and .labels properties for (var model in convert) { if (convert.hasOwnProperty(model)) { if (!('channels' in convert[model])) { throw new Error('missing channels property: ' + model); } if (!('labels' in convert[model])) { throw new Error('missing channel labels property: ' + model); } if (convert[model].labels.length !== convert[model].channels) { throw new Error('channel and label counts mismatch: ' + model); } var channels = convert[model].channels; var labels = convert[model].labels; delete convert[model].channels; delete convert[model].labels; Object.defineProperty(convert[model], 'channels', {value: channels}); Object.defineProperty(convert[model], 'labels', {value: labels}); } } convert.rgb.hsl = function (rgb) { var r = rgb[0] / 255; var g = rgb[1] / 255; var b = rgb[2] / 255; var min = Math.min(r, g, b); var max = Math.max(r, g, b); var delta = max - min; var h; var s; var l; if (max === min) { h = 0; } else if (r === max) { h = (g - b) / delta; } else if (g === max) { h = 2 + (b - r) / delta; } else if (b === max) { h = 4 + (r - g) / delta; } h = Math.min(h * 60, 360); if (h < 0) { h += 360; } l = (min + max) / 2; if (max === min) { s = 0; } else if (l <= 0.5) { s = delta / (max + min); } else { s = delta / (2 - max - min); } return [h, s * 100, l * 100]; }; convert.rgb.hsv = function (rgb) { var rdif; var gdif; var bdif; var h; var s; var r = rgb[0] / 255; var g = rgb[1] / 255; var b = rgb[2] / 255; var v = Math.max(r, g, b); var diff = v - Math.min(r, g, b); var diffc = function (c) { return (v - c) / 6 / diff + 1 / 2; }; if (diff === 0) { h = s = 0; } else { s = diff / v; rdif = diffc(r); gdif = diffc(g); bdif = diffc(b); if (r === v) { h = bdif - gdif; } else if (g === v) { h = (1 / 3) + rdif - bdif; } else if (b === v) { h = (2 / 3) + gdif - rdif; } if (h < 0) { h += 1; } else if (h > 1) { h -= 1; } } return [ h * 360, s * 100, v * 100 ]; }; convert.rgb.hwb = function (rgb) { var r = rgb[0]; var g = rgb[1]; var b = rgb[2]; var h = convert.rgb.hsl(rgb)[0]; var w = 1 / 255 * Math.min(r, Math.min(g, b)); b = 1 - 1 / 255 * Math.max(r, Math.max(g, b)); return [h, w * 100, b * 100]; }; convert.rgb.cmyk = function (rgb) { var r = rgb[0] / 255; var g = rgb[1] / 255; var b = rgb[2] / 255; var c; var m; var y; var k; k = Math.min(1 - r, 1 - g, 1 - b); c = (1 - r - k) / (1 - k) || 0; m = (1 - g - k) / (1 - k) || 0; y = (1 - b - k) / (1 - k) || 0; return [c * 100, m * 100, y * 100, k * 100]; }; /** * See https://en.m.wikipedia.org/wiki/Euclidean_distance#Squared_Euclidean_distance * */ function comparativeDistance(x, y) { return ( Math.pow(x[0] - y[0], 2) + Math.pow(x[1] - y[1], 2) + Math.pow(x[2] - y[2], 2) ); } convert.rgb.keyword = function (rgb) { var reversed = reverseKeywords[rgb]; if (reversed) { return reversed; } var currentClosestDistance = Infinity; var currentClosestKeyword; for (var keyword in cssKeywords) { if (cssKeywords.hasOwnProperty(keyword)) { var value = cssKeywords[keyword]; // Compute comparative distance var distance = comparativeDistance(rgb, value); // Check if its less, if so set as closest if (distance < currentClosestDistance) { currentClosestDistance = distance; currentClosestKeyword = keyword; } } } return currentClosestKeyword; }; convert.keyword.rgb = function (keyword) { return cssKeywords[keyword]; }; convert.rgb.xyz = function (rgb) { var r = rgb[0] / 255; var g = rgb[1] / 255; var b = rgb[2] / 255; // assume sRGB r = r > 0.04045 ? Math.pow(((r + 0.055) / 1.055), 2.4) : (r / 12.92); g = g > 0.04045 ? Math.pow(((g + 0.055) / 1.055), 2.4) : (g / 12.92); b = b > 0.04045 ? Math.pow(((b + 0.055) / 1.055), 2.4) : (b / 12.92); var x = (r * 0.4124) + (g * 0.3576) + (b * 0.1805); var y = (r * 0.2126) + (g * 0.7152) + (b * 0.0722); var z = (r * 0.0193) + (g * 0.1192) + (b * 0.9505); return [x * 100, y * 100, z * 100]; }; convert.rgb.lab = function (rgb) { var xyz = convert.rgb.xyz(rgb); var x = xyz[0]; var y = xyz[1]; var z = xyz[2]; var l; var a; var b; x /= 95.047; y /= 100; z /= 108.883; x = x > 0.008856 ? Math.pow(x, 1 / 3) : (7.787 * x) + (16 / 116); y = y > 0.008856 ? Math.pow(y, 1 / 3) : (7.787 * y) + (16 / 116); z = z > 0.008856 ? Math.pow(z, 1 / 3) : (7.787 * z) + (16 / 116); l = (116 * y) - 16; a = 500 * (x - y); b = 200 * (y - z); return [l, a, b]; }; convert.hsl.rgb = function (hsl) { var h = hsl[0] / 360; var s = hsl[1] / 100; var l = hsl[2] / 100; var t1; var t2; var t3; var rgb; var val; if (s === 0) { val = l * 255; return [val, val, val]; } if (l < 0.5) { t2 = l * (1 + s); } else { t2 = l + s - l * s; } t1 = 2 * l - t2; rgb = [0, 0, 0]; for (var i = 0; i < 3; i++) { t3 = h + 1 / 3 * -(i - 1); if (t3 < 0) { t3++; } if (t3 > 1) { t3--; } if (6 * t3 < 1) { val = t1 + (t2 - t1) * 6 * t3; } else if (2 * t3 < 1) { val = t2; } else if (3 * t3 < 2) { val = t1 + (t2 - t1) * (2 / 3 - t3) * 6; } else { val = t1; } rgb[i] = val * 255; } return rgb; }; convert.hsl.hsv = function (hsl) { var h = hsl[0]; var s = hsl[1] / 100; var l = hsl[2] / 100; var smin = s; var lmin = Math.max(l, 0.01); var sv; var v; l *= 2; s *= (l <= 1) ? l : 2 - l; smin *= lmin <= 1 ? lmin : 2 - lmin; v = (l + s) / 2; sv = l === 0 ? (2 * smin) / (lmin + smin) : (2 * s) / (l + s); return [h, sv * 100, v * 100]; }; convert.hsv.rgb = function (hsv) { var h = hsv[0] / 60; var s = hsv[1] / 100; var v = hsv[2] / 100; var hi = Math.floor(h) % 6; var f = h - Math.floor(h); var p = 255 * v * (1 - s); var q = 255 * v * (1 - (s * f)); var t = 255 * v * (1 - (s * (1 - f))); v *= 255; switch (hi) { case 0: return [v, t, p]; case 1: return [q, v, p]; case 2: return [p, v, t]; case 3: return [p, q, v]; case 4: return [t, p, v]; case 5: return [v, p, q]; } }; convert.hsv.hsl = function (hsv) { var h = hsv[0]; var s = hsv[1] / 100; var v = hsv[2] / 100; var vmin = Math.max(v, 0.01); var lmin; var sl; var l; l = (2 - s) * v; lmin = (2 - s) * vmin; sl = s * vmin; sl /= (lmin <= 1) ? lmin : 2 - lmin; sl = sl || 0; l /= 2; return [h, sl * 100, l * 100]; }; // http://dev.w3.org/csswg/css-color/#hwb-to-rgb convert.hwb.rgb = function (hwb) { var h = hwb[0] / 360; var wh = hwb[1] / 100; var bl = hwb[2] / 100; var ratio = wh + bl; var i; var v; var f; var n; // wh + bl cant be > 1 if (ratio > 1) { wh /= ratio; bl /= ratio; } i = Math.floor(6 * h); v = 1 - bl; f = 6 * h - i; if ((i & 0x01) !== 0) { f = 1 - f; } n = wh + f * (v - wh); // linear interpolation var r; var g; var b; switch (i) { default: case 6: case 0: r = v; g = n; b = wh; break; case 1: r = n; g = v; b = wh; break; case 2: r = wh; g = v; b = n; break; case 3: r = wh; g = n; b = v; break; case 4: r = n; g = wh; b = v; break; case 5: r = v; g = wh; b = n; break; } return [r * 255, g * 255, b * 255]; }; convert.cmyk.rgb = function (cmyk) { var c = cmyk[0] / 100; var m = cmyk[1] / 100; var y = cmyk[2] / 100; var k = cmyk[3] / 100; var r; var g; var b; r = 1 - Math.min(1, c * (1 - k) + k); g = 1 - Math.min(1, m * (1 - k) + k); b = 1 - Math.min(1, y * (1 - k) + k); return [r * 255, g * 255, b * 255]; }; convert.xyz.rgb = function (xyz) { var x = xyz[0] / 100; var y = xyz[1] / 100; var z = xyz[2] / 100; var r; var g; var b; r = (x * 3.2406) + (y * -1.5372) + (z * -0.4986); g = (x * -0.9689) + (y * 1.8758) + (z * 0.0415); b = (x * 0.0557) + (y * -0.2040) + (z * 1.0570); // assume sRGB r = r > 0.0031308 ? ((1.055 * Math.pow(r, 1.0 / 2.4)) - 0.055) : r * 12.92; g = g > 0.0031308 ? ((1.055 * Math.pow(g, 1.0 / 2.4)) - 0.055) : g * 12.92; b = b > 0.0031308 ? ((1.055 * Math.pow(b, 1.0 / 2.4)) - 0.055) : b * 12.92; r = Math.min(Math.max(0, r), 1); g = Math.min(Math.max(0, g), 1); b = Math.min(Math.max(0, b), 1); return [r * 255, g * 255, b * 255]; }; convert.xyz.lab = function (xyz) { var x = xyz[0]; var y = xyz[1]; var z = xyz[2]; var l; var a; var b; x /= 95.047; y /= 100; z /= 108.883; x = x > 0.008856 ? Math.pow(x, 1 / 3) : (7.787 * x) + (16 / 116); y = y > 0.008856 ? Math.pow(y, 1 / 3) : (7.787 * y) + (16 / 116); z = z > 0.008856 ? Math.pow(z, 1 / 3) : (7.787 * z) + (16 / 116); l = (116 * y) - 16; a = 500 * (x - y); b = 200 * (y - z); return [l, a, b]; }; convert.lab.xyz = function (lab) { var l = lab[0]; var a = lab[1]; var b = lab[2]; var x; var y; var z; y = (l + 16) / 116; x = a / 500 + y; z = y - b / 200; var y2 = Math.pow(y, 3); var x2 = Math.pow(x, 3); var z2 = Math.pow(z, 3); y = y2 > 0.008856 ? y2 : (y - 16 / 116) / 7.787; x = x2 > 0.008856 ? x2 : (x - 16 / 116) / 7.787; z = z2 > 0.008856 ? z2 : (z - 16 / 116) / 7.787; x *= 95.047; y *= 100; z *= 108.883; return [x, y, z]; }; convert.lab.lch = function (lab) { var l = lab[0]; var a = lab[1]; var b = lab[2]; var hr; var h; var c; hr = Math.atan2(b, a); h = hr * 360 / 2 / Math.PI; if (h < 0) { h += 360; } c = Math.sqrt(a * a + b * b); return [l, c, h]; }; convert.lch.lab = function (lch) { var l = lch[0]; var c = lch[1]; var h = lch[2]; var a; var b; var hr; hr = h / 360 * 2 * Math.PI; a = c * Math.cos(hr); b = c * Math.sin(hr); return [l, a, b]; }; convert.rgb.ansi16 = function (args) { var r = args[0]; var g = args[1]; var b = args[2]; var value = 1 in arguments ? arguments[1] : convert.rgb.hsv(args)[2]; // hsv -> ansi16 optimization value = Math.round(value / 50); if (value === 0) { return 30; } var ansi = 30 + ((Math.round(b / 255) << 2) | (Math.round(g / 255) << 1) | Math.round(r / 255)); if (value === 2) { ansi += 60; } return ansi; }; convert.hsv.ansi16 = function (args) { // optimization here; we already know the value and don't need to get // it converted for us. return convert.rgb.ansi16(convert.hsv.rgb(args), args[2]); }; convert.rgb.ansi256 = function (args) { var r = args[0]; var g = args[1]; var b = args[2]; // we use the extended greyscale palette here, with the exception of // black and white. normal palette only has 4 greyscale shades. if (r === g && g === b) { if (r < 8) { return 16; } if (r > 248) { return 231; } return Math.round(((r - 8) / 247) * 24) + 232; } var ansi = 16 + (36 * Math.round(r / 255 * 5)) + (6 * Math.round(g / 255 * 5)) + Math.round(b / 255 * 5); return ansi; }; convert.ansi16.rgb = function (args) { var color = args % 10; // handle greyscale if (color === 0 || color === 7) { if (args > 50) { color += 3.5; } color = color / 10.5 * 255; return [color, color, color]; } var mult = (~~(args > 50) + 1) * 0.5; var r = ((color & 1) * mult) * 255; var g = (((color >> 1) & 1) * mult) * 255; var b = (((color >> 2) & 1) * mult) * 255; return [r, g, b]; }; convert.ansi256.rgb = function (args) { // handle greyscale if (args >= 232) { var c = (args - 232) * 10 + 8; return [c, c, c]; } args -= 16; var rem; var r = Math.floor(args / 36) / 5 * 255; var g = Math.floor((rem = args % 36) / 6) / 5 * 255; var b = (rem % 6) / 5 * 255; return [r, g, b]; }; convert.rgb.hex = function (args) { var integer = ((Math.round(args[0]) & 0xFF) << 16) + ((Math.round(args[1]) & 0xFF) << 8) + (Math.round(args[2]) & 0xFF); var string = integer.toString(16).toUpperCase(); return '000000'.substring(string.length) + string; }; convert.hex.rgb = function (args) { var match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i); if (!match) { return [0, 0, 0]; } var colorString = match[0]; if (match[0].length === 3) { colorString = colorString.split('').map(function (char) { return char + char; }).join(''); } var integer = parseInt(colorString, 16); var r = (integer >> 16) & 0xFF; var g = (integer >> 8) & 0xFF; var b = integer & 0xFF; return [r, g, b]; }; convert.rgb.hcg = function (rgb) { var r = rgb[0] / 255; var g = rgb[1] / 255; var b = rgb[2] / 255; var max = Math.max(Math.max(r, g), b); var min = Math.min(Math.min(r, g), b); var chroma = (max - min); var grayscale; var hue; if (chroma < 1) { grayscale = min / (1 - chroma); } else { grayscale = 0; } if (chroma <= 0) { hue = 0; } else if (max === r) { hue = ((g - b) / chroma) % 6; } else if (max === g) { hue = 2 + (b - r) / chroma; } else { hue = 4 + (r - g) / chroma + 4; } hue /= 6; hue %= 1; return [hue * 360, chroma * 100, grayscale * 100]; }; convert.hsl.hcg = function (hsl) { var s = hsl[1] / 100; var l = hsl[2] / 100; var c = 1; var f = 0; if (l < 0.5) { c = 2.0 * s * l; } else { c = 2.0 * s * (1.0 - l); } if (c < 1.0) { f = (l - 0.5 * c) / (1.0 - c); } return [hsl[0], c * 100, f * 100]; }; convert.hsv.hcg = function (hsv) { var s = hsv[1] / 100; var v = hsv[2] / 100; var c = s * v; var f = 0; if (c < 1.0) { f = (v - c) / (1 - c); } return [hsv[0], c * 100, f * 100]; }; convert.hcg.rgb = function (hcg) { var h = hcg[0] / 360; var c = hcg[1] / 100; var g = hcg[2] / 100; if (c === 0.0) { return [g * 255, g * 255, g * 255]; } var pure = [0, 0, 0]; var hi = (h % 1) * 6; var v = hi % 1; var w = 1 - v; var mg = 0; switch (Math.floor(hi)) { case 0: pure[0] = 1; pure[1] = v; pure[2] = 0; break; case 1: pure[0] = w; pure[1] = 1; pure[2] = 0; break; case 2: pure[0] = 0; pure[1] = 1; pure[2] = v; break; case 3: pure[0] = 0; pure[1] = w; pure[2] = 1; break; case 4: pure[0] = v; pure[1] = 0; pure[2] = 1; break; default: pure[0] = 1; pure[1] = 0; pure[2] = w; } mg = (1.0 - c) * g; return [ (c * pure[0] + mg) * 255, (c * pure[1] + mg) * 255, (c * pure[2] + mg) * 255 ]; }; convert.hcg.hsv = function (hcg) { var c = hcg[1] / 100; var g = hcg[2] / 100; var v = c + g * (1.0 - c); var f = 0; if (v > 0.0) { f = c / v; } return [hcg[0], f * 100, v * 100]; }; convert.hcg.hsl = function (hcg) { var c = hcg[1] / 100; var g = hcg[2] / 100; var l = g * (1.0 - c) + 0.5 * c; var s = 0; if (l > 0.0 && l < 0.5) { s = c / (2 * l); } else if (l >= 0.5 && l < 1.0) { s = c / (2 * (1 - l)); } return [hcg[0], s * 100, l * 100]; }; convert.hcg.hwb = function (hcg) { var c = hcg[1] / 100; var g = hcg[2] / 100; var v = c + g * (1.0 - c); return [hcg[0], (v - c) * 100, (1 - v) * 100]; }; convert.hwb.hcg = function (hwb) { var w = hwb[1] / 100; var b = hwb[2] / 100; var v = 1 - b; var c = v - w; var g = 0; if (c < 1) { g = (v - c) / (1 - c); } return [hwb[0], c * 100, g * 100]; }; convert.apple.rgb = function (apple) { return [(apple[0] / 65535) * 255, (apple[1] / 65535) * 255, (apple[2] / 65535) * 255]; }; convert.rgb.apple = function (rgb) { return [(rgb[0] / 255) * 65535, (rgb[1] / 255) * 65535, (rgb[2] / 255) * 65535]; }; convert.gray.rgb = function (args) { return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255]; }; convert.gray.hsl = convert.gray.hsv = function (args) { return [0, 0, args[0]]; }; convert.gray.hwb = function (gray) { return [0, 100, gray[0]]; }; convert.gray.cmyk = function (gray) { return [0, 0, 0, gray[0]]; }; convert.gray.lab = function (gray) { return [gray[0], 0, 0]; }; convert.gray.hex = function (gray) { var val = Math.round(gray[0] / 100 * 255) & 0xFF; var integer = (val << 16) + (val << 8) + val; var string = integer.toString(16).toUpperCase(); return '000000'.substring(string.length) + string; }; convert.rgb.gray = function (rgb) { var val = (rgb[0] + rgb[1] + rgb[2]) / 3; return [val / 255 * 100]; }; },{"color-name":428}],426:[function(require,module,exports){ var conversions = require('./conversions'); var route = require('./route'); var convert = {}; var models = Object.keys(conversions); function wrapRaw(fn) { var wrappedFn = function (args) { if (args === undefined || args === null) { return args; } if (arguments.length > 1) { args = Array.prototype.slice.call(arguments); } return fn(args); }; // preserve .conversion property if there is one if ('conversion' in fn) { wrappedFn.conversion = fn.conversion; } return wrappedFn; } function wrapRounded(fn) { var wrappedFn = function (args) { if (args === undefined || args === null) { return args; } if (arguments.length > 1) { args = Array.prototype.slice.call(arguments); } var result = fn(args); // we're assuming the result is an array here. // see notice in conversions.js; don't use box types // in conversion functions. if (typeof result === 'object') { for (var len = result.length, i = 0; i < len; i++) { result[i] = Math.round(result[i]); } } return result; }; // preserve .conversion property if there is one if ('conversion' in fn) { wrappedFn.conversion = fn.conversion; } return wrappedFn; } models.forEach(function (fromModel) { convert[fromModel] = {}; Object.defineProperty(convert[fromModel], 'channels', {value: conversions[fromModel].channels}); Object.defineProperty(convert[fromModel], 'labels', {value: conversions[fromModel].labels}); var routes = route(fromModel); var routeModels = Object.keys(routes); routeModels.forEach(function (toModel) { var fn = routes[toModel]; convert[fromModel][toModel] = wrapRounded(fn); convert[fromModel][toModel].raw = wrapRaw(fn); }); }); module.exports = convert; },{"./conversions":425,"./route":427}],427:[function(require,module,exports){ var conversions = require('./conversions'); /* this function routes a model to all other models. all functions that are routed have a property `.conversion` attached to the returned synthetic function. This property is an array of strings, each with the steps in between the 'from' and 'to' color models (inclusive). conversions that are not possible simply are not included. */ function buildGraph() { var graph = {}; // https://jsperf.com/object-keys-vs-for-in-with-closure/3 var models = Object.keys(conversions); for (var len = models.length, i = 0; i < len; i++) { graph[models[i]] = { // http://jsperf.com/1-vs-infinity // micro-opt, but this is simple. distance: -1, parent: null }; } return graph; } // https://en.wikipedia.org/wiki/Breadth-first_search function deriveBFS(fromModel) { var graph = buildGraph(); var queue = [fromModel]; // unshift -> queue -> pop graph[fromModel].distance = 0; while (queue.length) { var current = queue.pop(); var adjacents = Object.keys(conversions[current]); for (var len = adjacents.length, i = 0; i < len; i++) { var adjacent = adjacents[i]; var node = graph[adjacent]; if (node.distance === -1) { node.distance = graph[current].distance + 1; node.parent = current; queue.unshift(adjacent); } } } return graph; } function link(from, to) { return function (args) { return to(from(args)); }; } function wrapConversion(toModel, graph) { var path = [graph[toModel].parent, toModel]; var fn = conversions[graph[toModel].parent][toModel]; var cur = graph[toModel].parent; while (graph[cur].parent) { path.unshift(graph[cur].parent); fn = link(conversions[graph[cur].parent][cur], fn); cur = graph[cur].parent; } fn.conversion = path; return fn; } module.exports = function (fromModel) { var graph = deriveBFS(fromModel); var conversion = {}; var models = Object.keys(graph); for (var len = models.length, i = 0; i < len; i++) { var toModel = models[i]; var node = graph[toModel]; if (node.parent === null) { // no possible conversion, or this node is the source model. continue; } conversion[toModel] = wrapConversion(toModel, graph); } return conversion; }; },{"./conversions":425}],428:[function(require,module,exports){ 'use strict' module.exports = { "aliceblue": [240, 248, 255], "antiquewhite": [250, 235, 215], "aqua": [0, 255, 255], "aquamarine": [127, 255, 212], "azure": [240, 255, 255], "beige": [245, 245, 220], "bisque": [255, 228, 196], "black": [0, 0, 0], "blanchedalmond": [255, 235, 205], "blue": [0, 0, 255], "blueviolet": [138, 43, 226], "brown": [165, 42, 42], "burlywood": [222, 184, 135], "cadetblue": [95, 158, 160], "chartreuse": [127, 255, 0], "chocolate": [210, 105, 30], "coral": [255, 127, 80], "cornflowerblue": [100, 149, 237], "cornsilk": [255, 248, 220], "crimson": [220, 20, 60], "cyan": [0, 255, 255], "darkblue": [0, 0, 139], "darkcyan": [0, 139, 139], "darkgoldenrod": [184, 134, 11], "darkgray": [169, 169, 169], "darkgreen": [0, 100, 0], "darkgrey": [169, 169, 169], "darkkhaki": [189, 183, 107], "darkmagenta": [139, 0, 139], "darkolivegreen": [85, 107, 47], "darkorange": [255, 140, 0], "darkorchid": [153, 50, 204], "darkred": [139, 0, 0], "darksalmon": [233, 150, 122], "darkseagreen": [143, 188, 143], "darkslateblue": [72, 61, 139], "darkslategray": [47, 79, 79], "darkslategrey": [47, 79, 79], "darkturquoise": [0, 206, 209], "darkviolet": [148, 0, 211], "deeppink": [255, 20, 147], "deepskyblue": [0, 191, 255], "dimgray": [105, 105, 105], "dimgrey": [105, 105, 105], "dodgerblue": [30, 144, 255], "firebrick": [178, 34, 34], "floralwhite": [255, 250, 240], "forestgreen": [34, 139, 34], "fuchsia": [255, 0, 255], "gainsboro": [220, 220, 220], "ghostwhite": [248, 248, 255], "gold": [255, 215, 0], "goldenrod": [218, 165, 32], "gray": [128, 128, 128], "green": [0, 128, 0], "greenyellow": [173, 255, 47], "grey": [128, 128, 128], "honeydew": [240, 255, 240], "hotpink": [255, 105, 180], "indianred": [205, 92, 92], "indigo": [75, 0, 130], "ivory": [255, 255, 240], "khaki": [240, 230, 140], "lavender": [230, 230, 250], "lavenderblush": [255, 240, 245], "lawngreen": [124, 252, 0], "lemonchiffon": [255, 250, 205], "lightblue": [173, 216, 230], "lightcoral": [240, 128, 128], "lightcyan": [224, 255, 255], "lightgoldenrodyellow": [250, 250, 210], "lightgray": [211, 211, 211], "lightgreen": [144, 238, 144], "lightgrey": [211, 211, 211], "lightpink": [255, 182, 193], "lightsalmon": [255, 160, 122], "lightseagreen": [32, 178, 170], "lightskyblue": [135, 206, 250], "lightslategray": [119, 136, 153], "lightslategrey": [119, 136, 153], "lightsteelblue": [176, 196, 222], "lightyellow": [255, 255, 224], "lime": [0, 255, 0], "limegreen": [50, 205, 50], "linen": [250, 240, 230], "magenta": [255, 0, 255], "maroon": [128, 0, 0], "mediumaquamarine": [102, 205, 170], "mediumblue": [0, 0, 205], "mediumorchid": [186, 85, 211], "mediumpurple": [147, 112, 219], "mediumseagreen": [60, 179, 113], "mediumslateblue": [123, 104, 238], "mediumspringgreen": [0, 250, 154], "mediumturquoise": [72, 209, 204], "mediumvioletred": [199, 21, 133], "midnightblue": [25, 25, 112], "mintcream": [245, 255, 250], "mistyrose": [255, 228, 225], "moccasin": [255, 228, 181], "navajowhite": [255, 222, 173], "navy": [0, 0, 128], "oldlace": [253, 245, 230], "olive": [128, 128, 0], "olivedrab": [107, 142, 35], "orange": [255, 165, 0], "orangered": [255, 69, 0], "orchid": [218, 112, 214], "palegoldenrod": [238, 232, 170], "palegreen": [152, 251, 152], "paleturquoise": [175, 238, 238], "palevioletred": [219, 112, 147], "papayawhip": [255, 239, 213], "peachpuff": [255, 218, 185], "peru": [205, 133, 63], "pink": [255, 192, 203], "plum": [221, 160, 221], "powderblue": [176, 224, 230], "purple": [128, 0, 128], "rebeccapurple": [102, 51, 153], "red": [255, 0, 0], "rosybrown": [188, 143, 143], "royalblue": [65, 105, 225], "saddlebrown": [139, 69, 19], "salmon": [250, 128, 114], "sandybrown": [244, 164, 96], "seagreen": [46, 139, 87], "seashell": [255, 245, 238], "sienna": [160, 82, 45], "silver": [192, 192, 192], "skyblue": [135, 206, 235], "slateblue": [106, 90, 205], "slategray": [112, 128, 144], "slategrey": [112, 128, 144], "snow": [255, 250, 250], "springgreen": [0, 255, 127], "steelblue": [70, 130, 180], "tan": [210, 180, 140], "teal": [0, 128, 128], "thistle": [216, 191, 216], "tomato": [255, 99, 71], "turquoise": [64, 224, 208], "violet": [238, 130, 238], "wheat": [245, 222, 179], "white": [255, 255, 255], "whitesmoke": [245, 245, 245], "yellow": [255, 255, 0], "yellowgreen": [154, 205, 50] }; },{}],429:[function(require,module,exports){ 'use strict'; var fs = require('fs'); var path = require('path'); var SafeBuffer = require('safe-buffer'); Object.defineProperty(exports, 'commentRegex', { get: function getCommentRegex () { return /^\s*\/(?:\/|\*)[@#]\s+sourceMappingURL=data:(?:application|text)\/json;(?:charset[:=]\S+?;)?base64,(?:.*)$/mg; } }); Object.defineProperty(exports, 'mapFileCommentRegex', { get: function getMapFileCommentRegex () { // Matches sourceMappingURL in either // or /* comment styles. return /(?:\/\/[@#][ \t]+sourceMappingURL=([^\s'"`]+?)[ \t]*$)|(?:\/\*[@#][ \t]+sourceMappingURL=([^\*]+?)[ \t]*(?:\*\/){1}[ \t]*$)/mg; } }); function decodeBase64(base64) { return SafeBuffer.Buffer.from(base64, 'base64').toString(); } function stripComment(sm) { return sm.split(',').pop(); } function readFromFileMap(sm, dir) { // NOTE: this will only work on the server since it attempts to read the map file var r = exports.mapFileCommentRegex.exec(sm); // for some odd reason //# .. captures in 1 and /* .. */ in 2 var filename = r[1] || r[2]; var filepath = path.resolve(dir, filename); try { return fs.readFileSync(filepath, 'utf8'); } catch (e) { throw new Error('An error occurred while trying to read the map file at ' + filepath + '\n' + e); } } function Converter (sm, opts) { opts = opts || {}; if (opts.isFileComment) sm = readFromFileMap(sm, opts.commentFileDir); if (opts.hasComment) sm = stripComment(sm); if (opts.isEncoded) sm = decodeBase64(sm); if (opts.isJSON || opts.isEncoded) sm = JSON.parse(sm); this.sourcemap = sm; } Converter.prototype.toJSON = function (space) { return JSON.stringify(this.sourcemap, null, space); }; Converter.prototype.toBase64 = function () { var json = this.toJSON(); return SafeBuffer.Buffer.from(json, 'utf8').toString('base64'); }; Converter.prototype.toComment = function (options) { var base64 = this.toBase64(); var data = 'sourceMappingURL=data:application/json;charset=utf-8;base64,' + base64; return options && options.multiline ? '/*# ' + data + ' */' : '//# ' + data; }; // returns copy instead of original Converter.prototype.toObject = function () { return JSON.parse(this.toJSON()); }; Converter.prototype.addProperty = function (key, value) { if (this.sourcemap.hasOwnProperty(key)) throw new Error('property "' + key + '" already exists on the sourcemap, use set property instead'); return this.setProperty(key, value); }; Converter.prototype.setProperty = function (key, value) { this.sourcemap[key] = value; return this; }; Converter.prototype.getProperty = function (key) { return this.sourcemap[key]; }; exports.fromObject = function (obj) { return new Converter(obj); }; exports.fromJSON = function (json) { return new Converter(json, { isJSON: true }); }; exports.fromBase64 = function (base64) { return new Converter(base64, { isEncoded: true }); }; exports.fromComment = function (comment) { comment = comment .replace(/^\/\*/g, '//') .replace(/\*\/$/g, ''); return new Converter(comment, { isEncoded: true, hasComment: true }); }; exports.fromMapFileComment = function (comment, dir) { return new Converter(comment, { commentFileDir: dir, isFileComment: true, isJSON: true }); }; // Finds last sourcemap comment in file or returns null if none was found exports.fromSource = function (content) { var m = content.match(exports.commentRegex); return m ? exports.fromComment(m.pop()) : null; }; // Finds last sourcemap comment in file or returns null if none was found exports.fromMapFileSource = function (content, dir) { var m = content.match(exports.mapFileCommentRegex); return m ? exports.fromMapFileComment(m.pop(), dir) : null; }; exports.removeComments = function (src) { return src.replace(exports.commentRegex, ''); }; exports.removeMapFileComments = function (src) { return src.replace(exports.mapFileCommentRegex, ''); }; exports.generateMapFileComment = function (file, options) { var data = 'sourceMappingURL=' + file; return options && options.multiline ? '/*# ' + data + ' */' : '//# ' + data; }; },{"fs":408,"path":459,"safe-buffer":510}],430:[function(require,module,exports){ (function (process){(function (){ /* eslint-env browser */ /** * This is the web browser implementation of `debug()`. */ exports.log = log; exports.formatArgs = formatArgs; exports.save = save; exports.load = load; exports.useColors = useColors; exports.storage = localstorage(); /** * Colors. */ exports.colors = [ '#0000CC', '#0000FF', '#0033CC', '#0033FF', '#0066CC', '#0066FF', '#0099CC', '#0099FF', '#00CC00', '#00CC33', '#00CC66', '#00CC99', '#00CCCC', '#00CCFF', '#3300CC', '#3300FF', '#3333CC', '#3333FF', '#3366CC', '#3366FF', '#3399CC', '#3399FF', '#33CC00', '#33CC33', '#33CC66', '#33CC99', '#33CCCC', '#33CCFF', '#6600CC', '#6600FF', '#6633CC', '#6633FF', '#66CC00', '#66CC33', '#9900CC', '#9900FF', '#9933CC', '#9933FF', '#99CC00', '#99CC33', '#CC0000', '#CC0033', '#CC0066', '#CC0099', '#CC00CC', '#CC00FF', '#CC3300', '#CC3333', '#CC3366', '#CC3399', '#CC33CC', '#CC33FF', '#CC6600', '#CC6633', '#CC9900', '#CC9933', '#CCCC00', '#CCCC33', '#FF0000', '#FF0033', '#FF0066', '#FF0099', '#FF00CC', '#FF00FF', '#FF3300', '#FF3333', '#FF3366', '#FF3399', '#FF33CC', '#FF33FF', '#FF6600', '#FF6633', '#FF9900', '#FF9933', '#FFCC00', '#FFCC33' ]; /** * Currently only WebKit-based Web Inspectors, Firefox >= v31, * and the Firebug extension (any Firefox version) are known * to support "%c" CSS customizations. * * TODO: add a `localStorage` variable to explicitly enable/disable colors */ // eslint-disable-next-line complexity function useColors() { // NB: In an Electron preload script, document will be defined but not fully // initialized. Since we know we're in Chrome, we'll just detect this case // explicitly if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) { return true; } // Internet Explorer and Edge do not support colors. if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) { return false; } // Is webkit? http://stackoverflow.com/a/16459606/376773 // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632 return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) || // Is firebug? http://stackoverflow.com/a/398120/376773 (typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) || // Is firefox >= v31? // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) || // Double check webkit in userAgent just in case we are in a worker (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/)); } /** * Colorize log arguments if enabled. * * @api public */ function formatArgs(args) { args[0] = (this.useColors ? '%c' : '') + this.namespace + (this.useColors ? ' %c' : ' ') + args[0] + (this.useColors ? '%c ' : ' ') + '+' + module.exports.humanize(this.diff); if (!this.useColors) { return; } const c = 'color: ' + this.color; args.splice(1, 0, c, 'color: inherit'); // The final "%c" is somewhat tricky, because there could be other // arguments passed either before or after the %c, so we need to // figure out the correct index to insert the CSS into let index = 0; let lastC = 0; args[0].replace(/%[a-zA-Z%]/g, match => { if (match === '%%') { return; } index++; if (match === '%c') { // We only are interested in the *last* %c // (the user may have provided their own) lastC = index; } }); args.splice(lastC, 0, c); } /** * Invokes `console.log()` when available. * No-op when `console.log` is not a "function". * * @api public */ function log(...args) { // This hackery is required for IE8/9, where // the `console.log` function doesn't have 'apply' return typeof console === 'object' && console.log && console.log(...args); } /** * Save `namespaces`. * * @param {String} namespaces * @api private */ function save(namespaces) { try { if (namespaces) { exports.storage.setItem('debug', namespaces); } else { exports.storage.removeItem('debug'); } } catch (error) { // Swallow // XXX (@Qix-) should we be logging these? } } /** * Load `namespaces`. * * @return {String} returns the previously persisted debug modes * @api private */ function load() { let r; try { r = exports.storage.getItem('debug'); } catch (error) { // Swallow // XXX (@Qix-) should we be logging these? } // If debug isn't set in LS, and we're in Electron, try to load $DEBUG if (!r && typeof process !== 'undefined' && 'env' in process) { r = process.env.DEBUG; } return r; } /** * Localstorage attempts to return the localstorage. * * This is necessary because safari throws * when a user disables cookies/localstorage * and you attempt to access it. * * @return {LocalStorage} * @api private */ function localstorage() { try { // TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context // The Browser also has localStorage in the global context. return localStorage; } catch (error) { // Swallow // XXX (@Qix-) should we be logging these? } } module.exports = require('./common')(exports); const {formatters} = module.exports; /** * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default. */ formatters.j = function (v) { try { return JSON.stringify(v); } catch (error) { return '[UnexpectedJSONParseError]: ' + error.message; } }; }).call(this)}).call(this,require('_process')) },{"./common":431,"_process":460}],431:[function(require,module,exports){ /** * This is the common logic for both the Node.js and web browser * implementations of `debug()`. */ function setup(env) { createDebug.debug = createDebug; createDebug.default = createDebug; createDebug.coerce = coerce; createDebug.disable = disable; createDebug.enable = enable; createDebug.enabled = enabled; createDebug.humanize = require('ms'); Object.keys(env).forEach(key => { createDebug[key] = env[key]; }); /** * Active `debug` instances. */ createDebug.instances = []; /** * The currently active debug mode names, and names to skip. */ createDebug.names = []; createDebug.skips = []; /** * Map of special "%n" handling functions, for the debug "format" argument. * * Valid key names are a single, lower or upper-case letter, i.e. "n" and "N". */ createDebug.formatters = {}; /** * Selects a color for a debug namespace * @param {String} namespace The namespace string for the for the debug instance to be colored * @return {Number|String} An ANSI color code for the given namespace * @api private */ function selectColor(namespace) { let hash = 0; for (let i = 0; i < namespace.length; i++) { hash = ((hash << 5) - hash) + namespace.charCodeAt(i); hash |= 0; // Convert to 32bit integer } return createDebug.colors[Math.abs(hash) % createDebug.colors.length]; } createDebug.selectColor = selectColor; /** * Create a debugger with the given `namespace`. * * @param {String} namespace * @return {Function} * @api public */ function createDebug(namespace) { let prevTime; function debug(...args) { // Disabled? if (!debug.enabled) { return; } const self = debug; // Set `diff` timestamp const curr = Number(new Date()); const ms = curr - (prevTime || curr); self.diff = ms; self.prev = prevTime; self.curr = curr; prevTime = curr; args[0] = createDebug.coerce(args[0]); if (typeof args[0] !== 'string') { // Anything else let's inspect with %O args.unshift('%O'); } // Apply any `formatters` transformations let index = 0; args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => { // If we encounter an escaped % then don't increase the array index if (match === '%%') { return match; } index++; const formatter = createDebug.formatters[format]; if (typeof formatter === 'function') { const val = args[index]; match = formatter.call(self, val); // Now we need to remove `args[index]` since it's inlined in the `format` args.splice(index, 1); index--; } return match; }); // Apply env-specific formatting (colors, etc.) createDebug.formatArgs.call(self, args); const logFn = self.log || createDebug.log; logFn.apply(self, args); } debug.namespace = namespace; debug.enabled = createDebug.enabled(namespace); debug.useColors = createDebug.useColors(); debug.color = selectColor(namespace); debug.destroy = destroy; debug.extend = extend; // Debug.formatArgs = formatArgs; // debug.rawLog = rawLog; // env-specific initialization logic for debug instances if (typeof createDebug.init === 'function') { createDebug.init(debug); } createDebug.instances.push(debug); return debug; } function destroy() { const index = createDebug.instances.indexOf(this); if (index !== -1) { createDebug.instances.splice(index, 1); return true; } return false; } function extend(namespace, delimiter) { const newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace); newDebug.log = this.log; return newDebug; } /** * Enables a debug mode by namespaces. This can include modes * separated by a colon and wildcards. * * @param {String} namespaces * @api public */ function enable(namespaces) { createDebug.save(namespaces); createDebug.names = []; createDebug.skips = []; let i; const split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/); const len = split.length; for (i = 0; i < len; i++) { if (!split[i]) { // ignore empty strings continue; } namespaces = split[i].replace(/\*/g, '.*?'); if (namespaces[0] === '-') { createDebug.skips.push(new RegExp('^' + namespaces.substr(1) + '$')); } else { createDebug.names.push(new RegExp('^' + namespaces + '$')); } } for (i = 0; i < createDebug.instances.length; i++) { const instance = createDebug.instances[i]; instance.enabled = createDebug.enabled(instance.namespace); } } /** * Disable debug output. * * @return {String} namespaces * @api public */ function disable() { const namespaces = [ ...createDebug.names.map(toNamespace), ...createDebug.skips.map(toNamespace).map(namespace => '-' + namespace) ].join(','); createDebug.enable(''); return namespaces; } /** * Returns true if the given mode name is enabled, false otherwise. * * @param {String} name * @return {Boolean} * @api public */ function enabled(name) { if (name[name.length - 1] === '*') { return true; } let i; let len; for (i = 0, len = createDebug.skips.length; i < len; i++) { if (createDebug.skips[i].test(name)) { return false; } } for (i = 0, len = createDebug.names.length; i < len; i++) { if (createDebug.names[i].test(name)) { return true; } } return false; } /** * Convert regexp to namespace * * @param {RegExp} regxep * @return {String} namespace * @api private */ function toNamespace(regexp) { return regexp.toString() .substring(2, regexp.toString().length - 2) .replace(/\.\*\?$/, '*'); } /** * Coerce `val`. * * @param {Mixed} val * @return {Mixed} * @api private */ function coerce(val) { if (val instanceof Error) { return val.stack || val.message; } return val; } createDebug.enable(createDebug.load()); return createDebug; } module.exports = setup; },{"ms":454}],432:[function(require,module,exports){ module.exports = { "0.20": "39", "0.21": "41", "0.22": "41", "0.23": "41", "0.24": "41", "0.25": "42", "0.26": "42", "0.27": "43", "0.28": "43", "0.29": "43", "0.30": "44", "0.31": "45", "0.32": "45", "0.33": "45", "0.34": "45", "0.35": "45", "0.36": "47", "0.37": "49", "1.0": "49", "1.1": "50", "1.2": "51", "1.3": "52", "1.4": "53", "1.5": "54", "1.6": "56", "1.7": "58", "1.8": "59", "2.0": "61", "2.1": "61", "3.0": "66", "3.1": "66", "4.0": "69", "4.1": "69", "4.2": "69", "5.0": "73", "6.0": "76", "6.1": "76", "7.0": "78", "7.1": "78", "7.2": "78", "7.3": "78", "8.0": "80", "8.1": "80", "8.2": "80", "8.3": "80", "8.4": "80", "8.5": "80", "9.0": "83", "9.1": "83", "9.2": "83", "9.3": "83", "9.4": "83", "10.0": "85", "10.1": "85", "10.2": "85", "10.3": "85", "10.4": "85", "11.0": "87", "11.1": "87", "11.2": "87", "11.3": "87", "11.4": "87", "11.5": "87", "12.0": "89", "12.1": "89", "12.2": "89", "13.0": "91", "13.1": "91", "13.2": "91", "13.3": "91", "13.4": "91", "13.5": "91", "13.6": "91", "14.0": "93", "14.1": "93", "14.2": "93", "15.0": "94", "15.1": "94", "15.2": "94", "15.3": "94", "15.4": "94", "15.5": "94", "16.0": "96", "16.1": "96", "16.2": "96", "17.0": "98", "17.1": "98", "17.2": "98", "17.3": "98", "17.4": "98", "18.0": "100", "18.1": "100", "18.2": "100", "18.3": "100", "19.0": "102", "19.1": "102", "20.0": "104", "20.1": "104", "20.2": "104", "20.3": "104", "21.0": "106", "21.1": "106", "22.0": "108" }; },{}],433:[function(require,module,exports){ 'use strict'; var GetIntrinsic = require('get-intrinsic'); var $gOPD = GetIntrinsic('%Object.getOwnPropertyDescriptor%'); if ($gOPD) { try { $gOPD([], 'length'); } catch (e) { // IE 8 has a broken gOPD $gOPD = null; } } module.exports = $gOPD; },{"get-intrinsic":440}],434:[function(require,module,exports){ 'use strict'; var matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g; module.exports = function (str) { if (typeof str !== 'string') { throw new TypeError('Expected a string'); } return str.replace(matchOperatorsRe, '\\$&'); }; },{}],435:[function(require,module,exports){ // Copyright Joyent, Inc. and other Node contributors. // // 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. 'use strict'; var R = typeof Reflect === 'object' ? Reflect : null var ReflectApply = R && typeof R.apply === 'function' ? R.apply : function ReflectApply(target, receiver, args) { return Function.prototype.apply.call(target, receiver, args); } var ReflectOwnKeys if (R && typeof R.ownKeys === 'function') { ReflectOwnKeys = R.ownKeys } else if (Object.getOwnPropertySymbols) { ReflectOwnKeys = function ReflectOwnKeys(target) { return Object.getOwnPropertyNames(target) .concat(Object.getOwnPropertySymbols(target)); }; } else { ReflectOwnKeys = function ReflectOwnKeys(target) { return Object.getOwnPropertyNames(target); }; } function ProcessEmitWarning(warning) { if (console && console.warn) console.warn(warning); } var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) { return value !== value; } function EventEmitter() { EventEmitter.init.call(this); } module.exports = EventEmitter; module.exports.once = once; // Backwards-compat with node 0.10.x EventEmitter.EventEmitter = EventEmitter; EventEmitter.prototype._events = undefined; EventEmitter.prototype._eventsCount = 0; EventEmitter.prototype._maxListeners = undefined; // By default EventEmitters will print a warning if more than 10 listeners are // added to it. This is a useful default which helps finding memory leaks. var defaultMaxListeners = 10; function checkListener(listener) { if (typeof listener !== 'function') { throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener); } } Object.defineProperty(EventEmitter, 'defaultMaxListeners', { enumerable: true, get: function() { return defaultMaxListeners; }, set: function(arg) { if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) { throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.'); } defaultMaxListeners = arg; } }); EventEmitter.init = function() { if (this._events === undefined || this._events === Object.getPrototypeOf(this)._events) { this._events = Object.create(null); this._eventsCount = 0; } this._maxListeners = this._maxListeners || undefined; }; // Obviously not all Emitters should be limited to 10. This function allows // that to be increased. Set to zero for unlimited. EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) { if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) { throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.'); } this._maxListeners = n; return this; }; function _getMaxListeners(that) { if (that._maxListeners === undefined) return EventEmitter.defaultMaxListeners; return that._maxListeners; } EventEmitter.prototype.getMaxListeners = function getMaxListeners() { return _getMaxListeners(this); }; EventEmitter.prototype.emit = function emit(type) { var args = []; for (var i = 1; i < arguments.length; i++) args.push(arguments[i]); var doError = (type === 'error'); var events = this._events; if (events !== undefined) doError = (doError && events.error === undefined); else if (!doError) return false; // If there is no 'error' event listener then throw. if (doError) { var er; if (args.length > 0) er = args[0]; if (er instanceof Error) { // Note: The comments on the `throw` lines are intentional, they show // up in Node's output if this results in an unhandled exception. throw er; // Unhandled 'error' event } // At least give some kind of context to the user var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : '')); err.context = er; throw err; // Unhandled 'error' event } var handler = events[type]; if (handler === undefined) return false; if (typeof handler === 'function') { ReflectApply(handler, this, args); } else { var len = handler.length; var listeners = arrayClone(handler, len); for (var i = 0; i < len; ++i) ReflectApply(listeners[i], this, args); } return true; }; function _addListener(target, type, listener, prepend) { var m; var events; var existing; checkListener(listener); events = target._events; if (events === undefined) { events = target._events = Object.create(null); target._eventsCount = 0; } else { // To avoid recursion in the case that type === "newListener"! Before // adding it to the listeners, first emit "newListener". if (events.newListener !== undefined) { target.emit('newListener', type, listener.listener ? listener.listener : listener); // Re-assign `events` because a newListener handler could have caused the // this._events to be assigned to a new object events = target._events; } existing = events[type]; } if (existing === undefined) { // Optimize the case of one listener. Don't need the extra array object. existing = events[type] = listener; ++target._eventsCount; } else { if (typeof existing === 'function') { // Adding the second element, need to change to array. existing = events[type] = prepend ? [listener, existing] : [existing, listener]; // If we've already got an array, just append. } else if (prepend) { existing.unshift(listener); } else { existing.push(listener); } // Check for listener leak m = _getMaxListeners(target); if (m > 0 && existing.length > m && !existing.warned) { existing.warned = true; // No error code for this since it is a Warning // eslint-disable-next-line no-restricted-syntax var w = new Error('Possible EventEmitter memory leak detected. ' + existing.length + ' ' + String(type) + ' listeners ' + 'added. Use emitter.setMaxListeners() to ' + 'increase limit'); w.name = 'MaxListenersExceededWarning'; w.emitter = target; w.type = type; w.count = existing.length; ProcessEmitWarning(w); } } return target; } EventEmitter.prototype.addListener = function addListener(type, listener) { return _addListener(this, type, listener, false); }; EventEmitter.prototype.on = EventEmitter.prototype.addListener; EventEmitter.prototype.prependListener = function prependListener(type, listener) { return _addListener(this, type, listener, true); }; function onceWrapper() { if (!this.fired) { this.target.removeListener(this.type, this.wrapFn); this.fired = true; if (arguments.length === 0) return this.listener.call(this.target); return this.listener.apply(this.target, arguments); } } function _onceWrap(target, type, listener) { var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener }; var wrapped = onceWrapper.bind(state); wrapped.listener = listener; state.wrapFn = wrapped; return wrapped; } EventEmitter.prototype.once = function once(type, listener) { checkListener(listener); this.on(type, _onceWrap(this, type, listener)); return this; }; EventEmitter.prototype.prependOnceListener = function prependOnceListener(type, listener) { checkListener(listener); this.prependListener(type, _onceWrap(this, type, listener)); return this; }; // Emits a 'removeListener' event if and only if the listener was removed. EventEmitter.prototype.removeListener = function removeListener(type, listener) { var list, events, position, i, originalListener; checkListener(listener); events = this._events; if (events === undefined) return this; list = events[type]; if (list === undefined) return this; if (list === listener || list.listener === listener) { if (--this._eventsCount === 0) this._events = Object.create(null); else { delete events[type]; if (events.removeListener) this.emit('removeListener', type, list.listener || listener); } } else if (typeof list !== 'function') { position = -1; for (i = list.length - 1; i >= 0; i--) { if (list[i] === listener || list[i].listener === listener) { originalListener = list[i].listener; position = i; break; } } if (position < 0) return this; if (position === 0) list.shift(); else { spliceOne(list, position); } if (list.length === 1) events[type] = list[0]; if (events.removeListener !== undefined) this.emit('removeListener', type, originalListener || listener); } return this; }; EventEmitter.prototype.off = EventEmitter.prototype.removeListener; EventEmitter.prototype.removeAllListeners = function removeAllListeners(type) { var listeners, events, i; events = this._events; if (events === undefined) return this; // not listening for removeListener, no need to emit if (events.removeListener === undefined) { if (arguments.length === 0) { this._events = Object.create(null); this._eventsCount = 0; } else if (events[type] !== undefined) { if (--this._eventsCount === 0) this._events = Object.create(null); else delete events[type]; } return this; } // emit removeListener for all listeners on all events if (arguments.length === 0) { var keys = Object.keys(events); var key; for (i = 0; i < keys.length; ++i) { key = keys[i]; if (key === 'removeListener') continue; this.removeAllListeners(key); } this.removeAllListeners('removeListener'); this._events = Object.create(null); this._eventsCount = 0; return this; } listeners = events[type]; if (typeof listeners === 'function') { this.removeListener(type, listeners); } else if (listeners !== undefined) { // LIFO order for (i = listeners.length - 1; i >= 0; i--) { this.removeListener(type, listeners[i]); } } return this; }; function _listeners(target, type, unwrap) { var events = target._events; if (events === undefined) return []; var evlistener = events[type]; if (evlistener === undefined) return []; if (typeof evlistener === 'function') return unwrap ? [evlistener.listener || evlistener] : [evlistener]; return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length); } EventEmitter.prototype.listeners = function listeners(type) { return _listeners(this, type, true); }; EventEmitter.prototype.rawListeners = function rawListeners(type) { return _listeners(this, type, false); }; EventEmitter.listenerCount = function(emitter, type) { if (typeof emitter.listenerCount === 'function') { return emitter.listenerCount(type); } else { return listenerCount.call(emitter, type); } }; EventEmitter.prototype.listenerCount = listenerCount; function listenerCount(type) { var events = this._events; if (events !== undefined) { var evlistener = events[type]; if (typeof evlistener === 'function') { return 1; } else if (evlistener !== undefined) { return evlistener.length; } } return 0; } EventEmitter.prototype.eventNames = function eventNames() { return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : []; }; function arrayClone(arr, n) { var copy = new Array(n); for (var i = 0; i < n; ++i) copy[i] = arr[i]; return copy; } function spliceOne(list, index) { for (; index + 1 < list.length; index++) list[index] = list[index + 1]; list.pop(); } function unwrapListeners(arr) { var ret = new Array(arr.length); for (var i = 0; i < ret.length; ++i) { ret[i] = arr[i].listener || arr[i]; } return ret; } function once(emitter, name) { return new Promise(function (resolve, reject) { function errorListener(err) { emitter.removeListener(name, resolver); reject(err); } function resolver() { if (typeof emitter.removeListener === 'function') { emitter.removeListener('error', errorListener); } resolve([].slice.call(arguments)); }; eventTargetAgnosticAddListener(emitter, name, resolver, { once: true }); if (name !== 'error') { addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true }); } }); } function addErrorHandlerIfEventEmitter(emitter, handler, flags) { if (typeof emitter.on === 'function') { eventTargetAgnosticAddListener(emitter, 'error', handler, flags); } } function eventTargetAgnosticAddListener(emitter, name, listener, flags) { if (typeof emitter.on === 'function') { if (flags.once) { emitter.once(name, listener); } else { emitter.on(name, listener); } } else if (typeof emitter.addEventListener === 'function') { // EventTarget does not have `error` event semantics like Node // EventEmitters, we do not listen for `error` events here. emitter.addEventListener(name, function wrapListener(arg) { // IE does not have builtin `{ once: true }` support so we // have to do it manually. if (flags.once) { emitter.removeEventListener(name, wrapListener); } listener(arg); }); } else { throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter); } } },{}],436:[function(require,module,exports){ var hasOwn = Object.prototype.hasOwnProperty; var toString = Object.prototype.toString; module.exports = function forEach (obj, fn, ctx) { if (toString.call(fn) !== '[object Function]') { throw new TypeError('iterator must be a function'); } var l = obj.length; if (l === +l) { for (var i = 0; i < l; i++) { fn.call(ctx, obj[i], i, obj); } } else { for (var k in obj) { if (hasOwn.call(obj, k)) { fn.call(ctx, obj[k], k, obj); } } } }; },{}],437:[function(require,module,exports){ 'use strict'; /* eslint no-invalid-this: 1 */ var ERROR_MESSAGE = 'Function.prototype.bind called on incompatible '; var slice = Array.prototype.slice; var toStr = Object.prototype.toString; var funcType = '[object Function]'; module.exports = function bind(that) { var target = this; if (typeof target !== 'function' || toStr.call(target) !== funcType) { throw new TypeError(ERROR_MESSAGE + target); } var args = slice.call(arguments, 1); var bound; var binder = function () { if (this instanceof bound) { var result = target.apply( this, args.concat(slice.call(arguments)) ); if (Object(result) === result) { return result; } return this; } else { return target.apply( that, args.concat(slice.call(arguments)) ); } }; var boundLength = Math.max(0, target.length - args.length); var boundArgs = []; for (var i = 0; i < boundLength; i++) { boundArgs.push('$' + i); } bound = Function('binder', 'return function (' + boundArgs.join(',') + '){ return binder.apply(this,arguments); }')(binder); if (target.prototype) { var Empty = function Empty() {}; Empty.prototype = target.prototype; bound.prototype = new Empty(); Empty.prototype = null; } return bound; }; },{}],438:[function(require,module,exports){ 'use strict'; var implementation = require('./implementation'); module.exports = Function.prototype.bind || implementation; },{"./implementation":437}],439:[function(require,module,exports){ "use strict"; // These use the global symbol registry so that multiple copies of this // library can work together in case they are not deduped. const GENSYNC_START = Symbol.for("gensync:v1:start"); const GENSYNC_SUSPEND = Symbol.for("gensync:v1:suspend"); const GENSYNC_EXPECTED_START = "GENSYNC_EXPECTED_START"; const GENSYNC_EXPECTED_SUSPEND = "GENSYNC_EXPECTED_SUSPEND"; const GENSYNC_OPTIONS_ERROR = "GENSYNC_OPTIONS_ERROR"; const GENSYNC_RACE_NONEMPTY = "GENSYNC_RACE_NONEMPTY"; const GENSYNC_ERRBACK_NO_CALLBACK = "GENSYNC_ERRBACK_NO_CALLBACK"; module.exports = Object.assign( function gensync(optsOrFn) { let genFn = optsOrFn; if (typeof optsOrFn !== "function") { genFn = newGenerator(optsOrFn); } else { genFn = wrapGenerator(optsOrFn); } return Object.assign(genFn, makeFunctionAPI(genFn)); }, { all: buildOperation({ name: "all", arity: 1, sync: function(args) { const items = Array.from(args[0]); return items.map(item => evaluateSync(item)); }, async: function(args, resolve, reject) { const items = Array.from(args[0]); if (items.length === 0) { Promise.resolve().then(() => resolve([])); return; } let count = 0; const results = items.map(() => undefined); items.forEach((item, i) => { evaluateAsync( item, val => { results[i] = val; count += 1; if (count === results.length) resolve(results); }, reject ); }); }, }), race: buildOperation({ name: "race", arity: 1, sync: function(args) { const items = Array.from(args[0]); if (items.length === 0) { throw makeError("Must race at least 1 item", GENSYNC_RACE_NONEMPTY); } return evaluateSync(items[0]); }, async: function(args, resolve, reject) { const items = Array.from(args[0]); if (items.length === 0) { throw makeError("Must race at least 1 item", GENSYNC_RACE_NONEMPTY); } for (const item of items) { evaluateAsync(item, resolve, reject); } }, }), } ); /** * Given a generator function, return the standard API object that executes * the generator and calls the callbacks. */ function makeFunctionAPI(genFn) { const fns = { sync: function(...args) { return evaluateSync(genFn.apply(this, args)); }, async: function(...args) { return new Promise((resolve, reject) => { evaluateAsync(genFn.apply(this, args), resolve, reject); }); }, errback: function(...args) { const cb = args.pop(); if (typeof cb !== "function") { throw makeError( "Asynchronous function called without callback", GENSYNC_ERRBACK_NO_CALLBACK ); } let gen; try { gen = genFn.apply(this, args); } catch (err) { cb(err); return; } evaluateAsync(gen, val => cb(undefined, val), err => cb(err)); }, }; return fns; } function assertTypeof(type, name, value, allowUndefined) { if ( typeof value === type || (allowUndefined && typeof value === "undefined") ) { return; } let msg; if (allowUndefined) { msg = `Expected opts.${name} to be either a ${type}, or undefined.`; } else { msg = `Expected opts.${name} to be a ${type}.`; } throw makeError(msg, GENSYNC_OPTIONS_ERROR); } function makeError(msg, code) { return Object.assign(new Error(msg), { code }); } /** * Given an options object, return a new generator that dispatches the * correct handler based on sync or async execution. */ function newGenerator({ name, arity, sync, async, errback }) { assertTypeof("string", "name", name, true /* allowUndefined */); assertTypeof("number", "arity", arity, true /* allowUndefined */); assertTypeof("function", "sync", sync); assertTypeof("function", "async", async, true /* allowUndefined */); assertTypeof("function", "errback", errback, true /* allowUndefined */); if (async && errback) { throw makeError( "Expected one of either opts.async or opts.errback, but got _both_.", GENSYNC_OPTIONS_ERROR ); } if (typeof name !== "string") { let fnName; if (errback && errback.name && errback.name !== "errback") { fnName = errback.name; } if (async && async.name && async.name !== "async") { fnName = async.name.replace(/Async$/, ""); } if (sync && sync.name && sync.name !== "sync") { fnName = sync.name.replace(/Sync$/, ""); } if (typeof fnName === "string") { name = fnName; } } if (typeof arity !== "number") { arity = sync.length; } return buildOperation({ name, arity, sync: function(args) { return sync.apply(this, args); }, async: function(args, resolve, reject) { if (async) { async.apply(this, args).then(resolve, reject); } else if (errback) { errback.call(this, ...args, (err, value) => { if (err == null) resolve(value); else reject(err); }); } else { resolve(sync.apply(this, args)); } }, }); } function wrapGenerator(genFn) { return setFunctionMetadata(genFn.name, genFn.length, function(...args) { return genFn.apply(this, args); }); } function buildOperation({ name, arity, sync, async }) { return setFunctionMetadata(name, arity, function*(...args) { const resume = yield GENSYNC_START; if (!resume) { // Break the tail call to avoid a bug in V8 v6.X with --harmony enabled. const res = sync.call(this, args); return res; } let result; try { async.call( this, args, value => { if (result) return; result = { value }; resume(); }, err => { if (result) return; result = { err }; resume(); } ); } catch (err) { result = { err }; resume(); } // Suspend until the callbacks run. Will resume synchronously if the // callback was already called. yield GENSYNC_SUSPEND; if (result.hasOwnProperty("err")) { throw result.err; } return result.value; }); } function evaluateSync(gen) { let value; while (!({ value } = gen.next()).done) { assertStart(value, gen); } return value; } function evaluateAsync(gen, resolve, reject) { (function step() { try { let value; while (!({ value } = gen.next()).done) { assertStart(value, gen); // If this throws, it is considered to have broken the contract // established for async handlers. If these handlers are called // synchronously, it is also considered bad behavior. let sync = true; let didSyncResume = false; const out = gen.next(() => { if (sync) { didSyncResume = true; } else { step(); } }); sync = false; assertSuspend(out, gen); if (!didSyncResume) { // Callback wasn't called synchronously, so break out of the loop // and let it call 'step' later. return; } } return resolve(value); } catch (err) { return reject(err); } })(); } function assertStart(value, gen) { if (value === GENSYNC_START) return; throwError( gen, makeError( `Got unexpected yielded value in gensync generator: ${JSON.stringify( value )}. Did you perhaps mean to use 'yield*' instead of 'yield'?`, GENSYNC_EXPECTED_START ) ); } function assertSuspend({ value, done }, gen) { if (!done && value === GENSYNC_SUSPEND) return; throwError( gen, makeError( done ? "Unexpected generator completion. If you get this, it is probably a gensync bug." : `Expected GENSYNC_SUSPEND, got ${JSON.stringify( value )}. If you get this, it is probably a gensync bug.`, GENSYNC_EXPECTED_SUSPEND ) ); } function throwError(gen, err) { // Call `.throw` so that users can step in a debugger to easily see which // 'yield' passed an unexpected value. If the `.throw` call didn't throw // back to the generator, we explicitly do it to stop the error // from being swallowed by user code try/catches. if (gen.throw) gen.throw(err); throw err; } function isIterable(value) { return ( !!value && (typeof value === "object" || typeof value === "function") && !value[Symbol.iterator] ); } function setFunctionMetadata(name, arity, fn) { if (typeof name === "string") { // This should always work on the supported Node versions, but for the // sake of users that are compiling to older versions, we check for // configurability so we don't throw. const nameDesc = Object.getOwnPropertyDescriptor(fn, "name"); if (!nameDesc || nameDesc.configurable) { Object.defineProperty( fn, "name", Object.assign(nameDesc || {}, { configurable: true, value: name, }) ); } } if (typeof arity === "number") { const lengthDesc = Object.getOwnPropertyDescriptor(fn, "length"); if (!lengthDesc || lengthDesc.configurable) { Object.defineProperty( fn, "length", Object.assign(lengthDesc || {}, { configurable: true, value: arity, }) ); } } return fn; } },{}],440:[function(require,module,exports){ 'use strict'; var undefined; var $SyntaxError = SyntaxError; var $Function = Function; var $TypeError = TypeError; // eslint-disable-next-line consistent-return var getEvalledConstructor = function (expressionSyntax) { try { return $Function('"use strict"; return (' + expressionSyntax + ').constructor;')(); } catch (e) {} }; var $gOPD = Object.getOwnPropertyDescriptor; if ($gOPD) { try { $gOPD({}, ''); } catch (e) { $gOPD = null; // this is IE 8, which has a broken gOPD } } var throwTypeError = function () { throw new $TypeError(); }; var ThrowTypeError = $gOPD ? (function () { try { // eslint-disable-next-line no-unused-expressions, no-caller, no-restricted-properties arguments.callee; // IE 8 does not throw here return throwTypeError; } catch (calleeThrows) { try { // IE 8 throws on Object.getOwnPropertyDescriptor(arguments, '') return $gOPD(arguments, 'callee').get; } catch (gOPDthrows) { return throwTypeError; } } }()) : throwTypeError; var hasSymbols = require('has-symbols')(); var getProto = Object.getPrototypeOf || function (x) { return x.__proto__; }; // eslint-disable-line no-proto var needsEval = {}; var TypedArray = typeof Uint8Array === 'undefined' ? undefined : getProto(Uint8Array); var INTRINSICS = { '%AggregateError%': typeof AggregateError === 'undefined' ? undefined : AggregateError, '%Array%': Array, '%ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined : ArrayBuffer, '%ArrayIteratorPrototype%': hasSymbols ? getProto([][Symbol.iterator]()) : undefined, '%AsyncFromSyncIteratorPrototype%': undefined, '%AsyncFunction%': needsEval, '%AsyncGenerator%': needsEval, '%AsyncGeneratorFunction%': needsEval, '%AsyncIteratorPrototype%': needsEval, '%Atomics%': typeof Atomics === 'undefined' ? undefined : Atomics, '%BigInt%': typeof BigInt === 'undefined' ? undefined : BigInt, '%Boolean%': Boolean, '%DataView%': typeof DataView === 'undefined' ? undefined : DataView, '%Date%': Date, '%decodeURI%': decodeURI, '%decodeURIComponent%': decodeURIComponent, '%encodeURI%': encodeURI, '%encodeURIComponent%': encodeURIComponent, '%Error%': Error, '%eval%': eval, // eslint-disable-line no-eval '%EvalError%': EvalError, '%Float32Array%': typeof Float32Array === 'undefined' ? undefined : Float32Array, '%Float64Array%': typeof Float64Array === 'undefined' ? undefined : Float64Array, '%FinalizationRegistry%': typeof FinalizationRegistry === 'undefined' ? undefined : FinalizationRegistry, '%Function%': $Function, '%GeneratorFunction%': needsEval, '%Int8Array%': typeof Int8Array === 'undefined' ? undefined : Int8Array, '%Int16Array%': typeof Int16Array === 'undefined' ? undefined : Int16Array, '%Int32Array%': typeof Int32Array === 'undefined' ? undefined : Int32Array, '%isFinite%': isFinite, '%isNaN%': isNaN, '%IteratorPrototype%': hasSymbols ? getProto(getProto([][Symbol.iterator]())) : undefined, '%JSON%': typeof JSON === 'object' ? JSON : undefined, '%Map%': typeof Map === 'undefined' ? undefined : Map, '%MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols ? undefined : getProto(new Map()[Symbol.iterator]()), '%Math%': Math, '%Number%': Number, '%Object%': Object, '%parseFloat%': parseFloat, '%parseInt%': parseInt, '%Promise%': typeof Promise === 'undefined' ? undefined : Promise, '%Proxy%': typeof Proxy === 'undefined' ? undefined : Proxy, '%RangeError%': RangeError, '%ReferenceError%': ReferenceError, '%Reflect%': typeof Reflect === 'undefined' ? undefined : Reflect, '%RegExp%': RegExp, '%Set%': typeof Set === 'undefined' ? undefined : Set, '%SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols ? undefined : getProto(new Set()[Symbol.iterator]()), '%SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined : SharedArrayBuffer, '%String%': String, '%StringIteratorPrototype%': hasSymbols ? getProto(''[Symbol.iterator]()) : undefined, '%Symbol%': hasSymbols ? Symbol : undefined, '%SyntaxError%': $SyntaxError, '%ThrowTypeError%': ThrowTypeError, '%TypedArray%': TypedArray, '%TypeError%': $TypeError, '%Uint8Array%': typeof Uint8Array === 'undefined' ? undefined : Uint8Array, '%Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined : Uint8ClampedArray, '%Uint16Array%': typeof Uint16Array === 'undefined' ? undefined : Uint16Array, '%Uint32Array%': typeof Uint32Array === 'undefined' ? undefined : Uint32Array, '%URIError%': URIError, '%WeakMap%': typeof WeakMap === 'undefined' ? undefined : WeakMap, '%WeakRef%': typeof WeakRef === 'undefined' ? undefined : WeakRef, '%WeakSet%': typeof WeakSet === 'undefined' ? undefined : WeakSet }; var doEval = function doEval(name) { var value; if (name === '%AsyncFunction%') { value = getEvalledConstructor('async function () {}'); } else if (name === '%GeneratorFunction%') { value = getEvalledConstructor('function* () {}'); } else if (name === '%AsyncGeneratorFunction%') { value = getEvalledConstructor('async function* () {}'); } else if (name === '%AsyncGenerator%') { var fn = doEval('%AsyncGeneratorFunction%'); if (fn) { value = fn.prototype; } } else if (name === '%AsyncIteratorPrototype%') { var gen = doEval('%AsyncGenerator%'); if (gen) { value = getProto(gen.prototype); } } INTRINSICS[name] = value; return value; }; var LEGACY_ALIASES = { '%ArrayBufferPrototype%': ['ArrayBuffer', 'prototype'], '%ArrayPrototype%': ['Array', 'prototype'], '%ArrayProto_entries%': ['Array', 'prototype', 'entries'], '%ArrayProto_forEach%': ['Array', 'prototype', 'forEach'], '%ArrayProto_keys%': ['Array', 'prototype', 'keys'], '%ArrayProto_values%': ['Array', 'prototype', 'values'], '%AsyncFunctionPrototype%': ['AsyncFunction', 'prototype'], '%AsyncGenerator%': ['AsyncGeneratorFunction', 'prototype'], '%AsyncGeneratorPrototype%': ['AsyncGeneratorFunction', 'prototype', 'prototype'], '%BooleanPrototype%': ['Boolean', 'prototype'], '%DataViewPrototype%': ['DataView', 'prototype'], '%DatePrototype%': ['Date', 'prototype'], '%ErrorPrototype%': ['Error', 'prototype'], '%EvalErrorPrototype%': ['EvalError', 'prototype'], '%Float32ArrayPrototype%': ['Float32Array', 'prototype'], '%Float64ArrayPrototype%': ['Float64Array', 'prototype'], '%FunctionPrototype%': ['Function', 'prototype'], '%Generator%': ['GeneratorFunction', 'prototype'], '%GeneratorPrototype%': ['GeneratorFunction', 'prototype', 'prototype'], '%Int8ArrayPrototype%': ['Int8Array', 'prototype'], '%Int16ArrayPrototype%': ['Int16Array', 'prototype'], '%Int32ArrayPrototype%': ['Int32Array', 'prototype'], '%JSONParse%': ['JSON', 'parse'], '%JSONStringify%': ['JSON', 'stringify'], '%MapPrototype%': ['Map', 'prototype'], '%NumberPrototype%': ['Number', 'prototype'], '%ObjectPrototype%': ['Object', 'prototype'], '%ObjProto_toString%': ['Object', 'prototype', 'toString'], '%ObjProto_valueOf%': ['Object', 'prototype', 'valueOf'], '%PromisePrototype%': ['Promise', 'prototype'], '%PromiseProto_then%': ['Promise', 'prototype', 'then'], '%Promise_all%': ['Promise', 'all'], '%Promise_reject%': ['Promise', 'reject'], '%Promise_resolve%': ['Promise', 'resolve'], '%RangeErrorPrototype%': ['RangeError', 'prototype'], '%ReferenceErrorPrototype%': ['ReferenceError', 'prototype'], '%RegExpPrototype%': ['RegExp', 'prototype'], '%SetPrototype%': ['Set', 'prototype'], '%SharedArrayBufferPrototype%': ['SharedArrayBuffer', 'prototype'], '%StringPrototype%': ['String', 'prototype'], '%SymbolPrototype%': ['Symbol', 'prototype'], '%SyntaxErrorPrototype%': ['SyntaxError', 'prototype'], '%TypedArrayPrototype%': ['TypedArray', 'prototype'], '%TypeErrorPrototype%': ['TypeError', 'prototype'], '%Uint8ArrayPrototype%': ['Uint8Array', 'prototype'], '%Uint8ClampedArrayPrototype%': ['Uint8ClampedArray', 'prototype'], '%Uint16ArrayPrototype%': ['Uint16Array', 'prototype'], '%Uint32ArrayPrototype%': ['Uint32Array', 'prototype'], '%URIErrorPrototype%': ['URIError', 'prototype'], '%WeakMapPrototype%': ['WeakMap', 'prototype'], '%WeakSetPrototype%': ['WeakSet', 'prototype'] }; var bind = require('function-bind'); var hasOwn = require('has'); var $concat = bind.call(Function.call, Array.prototype.concat); var $spliceApply = bind.call(Function.apply, Array.prototype.splice); var $replace = bind.call(Function.call, String.prototype.replace); var $strSlice = bind.call(Function.call, String.prototype.slice); /* adapted from https://github.com/lodash/lodash/blob/4.17.15/dist/lodash.js#L6735-L6744 */ var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g; var reEscapeChar = /\\(\\)?/g; /** Used to match backslashes in property paths. */ var stringToPath = function stringToPath(string) { var first = $strSlice(string, 0, 1); var last = $strSlice(string, -1); if (first === '%' && last !== '%') { throw new $SyntaxError('invalid intrinsic syntax, expected closing `%`'); } else if (last === '%' && first !== '%') { throw new $SyntaxError('invalid intrinsic syntax, expected opening `%`'); } var result = []; $replace(string, rePropName, function (match, number, quote, subString) { result[result.length] = quote ? $replace(subString, reEscapeChar, '$1') : number || match; }); return result; }; /* end adaptation */ var getBaseIntrinsic = function getBaseIntrinsic(name, allowMissing) { var intrinsicName = name; var alias; if (hasOwn(LEGACY_ALIASES, intrinsicName)) { alias = LEGACY_ALIASES[intrinsicName]; intrinsicName = '%' + alias[0] + '%'; } if (hasOwn(INTRINSICS, intrinsicName)) { var value = INTRINSICS[intrinsicName]; if (value === needsEval) { value = doEval(intrinsicName); } if (typeof value === 'undefined' && !allowMissing) { throw new $TypeError('intrinsic ' + name + ' exists, but is not available. Please file an issue!'); } return { alias: alias, name: intrinsicName, value: value }; } throw new $SyntaxError('intrinsic ' + name + ' does not exist!'); }; module.exports = function GetIntrinsic(name, allowMissing) { if (typeof name !== 'string' || name.length === 0) { throw new $TypeError('intrinsic name must be a non-empty string'); } if (arguments.length > 1 && typeof allowMissing !== 'boolean') { throw new $TypeError('"allowMissing" argument must be a boolean'); } var parts = stringToPath(name); var intrinsicBaseName = parts.length > 0 ? parts[0] : ''; var intrinsic = getBaseIntrinsic('%' + intrinsicBaseName + '%', allowMissing); var intrinsicRealName = intrinsic.name; var value = intrinsic.value; var skipFurtherCaching = false; var alias = intrinsic.alias; if (alias) { intrinsicBaseName = alias[0]; $spliceApply(parts, $concat([0, 1], alias)); } for (var i = 1, isOwn = true; i < parts.length; i += 1) { var part = parts[i]; var first = $strSlice(part, 0, 1); var last = $strSlice(part, -1); if ( ( (first === '"' || first === "'" || first === '`') || (last === '"' || last === "'" || last === '`') ) && first !== last ) { throw new $SyntaxError('property names with quotes must have matching quotes'); } if (part === 'constructor' || !isOwn) { skipFurtherCaching = true; } intrinsicBaseName += '.' + part; intrinsicRealName = '%' + intrinsicBaseName + '%'; if (hasOwn(INTRINSICS, intrinsicRealName)) { value = INTRINSICS[intrinsicRealName]; } else if (value != null) { if (!(part in value)) { if (!allowMissing) { throw new $TypeError('base intrinsic for ' + name + ' exists, but the property is not available.'); } return void undefined; } if ($gOPD && (i + 1) >= parts.length) { var desc = $gOPD(value, part); isOwn = !!desc; // By convention, when a data property is converted to an accessor // property to emulate a data property that does not suffer from // the override mistake, that accessor's getter is marked with // an `originalValue` property. Here, when we detect this, we // uphold the illusion by pretending to see that original data // property, i.e., returning the value rather than the getter // itself. if (isOwn && 'get' in desc && !('originalValue' in desc.get)) { value = desc.get; } else { value = value[part]; } } else { isOwn = hasOwn(value, part); value = value[part]; } if (isOwn && !skipFurtherCaching) { INTRINSICS[intrinsicRealName] = value; } } } return value; }; },{"function-bind":438,"has":445,"has-symbols":443}],441:[function(require,module,exports){ module.exports={ "builtin": { "Array": false, "ArrayBuffer": false, "Atomics": false, "BigInt": false, "BigInt64Array": false, "BigUint64Array": false, "Boolean": false, "constructor": false, "DataView": false, "Date": false, "decodeURI": false, "decodeURIComponent": false, "encodeURI": false, "encodeURIComponent": false, "Error": false, "escape": false, "eval": false, "EvalError": false, "Float32Array": false, "Float64Array": false, "Function": false, "globalThis": false, "hasOwnProperty": false, "Infinity": false, "Int16Array": false, "Int32Array": false, "Int8Array": false, "isFinite": false, "isNaN": false, "isPrototypeOf": false, "JSON": false, "Map": false, "Math": false, "NaN": false, "Number": false, "Object": false, "parseFloat": false, "parseInt": false, "Promise": false, "propertyIsEnumerable": false, "Proxy": false, "RangeError": false, "ReferenceError": false, "Reflect": false, "RegExp": false, "Set": false, "SharedArrayBuffer": false, "String": false, "Symbol": false, "SyntaxError": false, "toLocaleString": false, "toString": false, "TypeError": false, "Uint16Array": false, "Uint32Array": false, "Uint8Array": false, "Uint8ClampedArray": false, "undefined": false, "unescape": false, "URIError": false, "valueOf": false, "WeakMap": false, "WeakSet": false }, "es5": { "Array": false, "Boolean": false, "constructor": false, "Date": false, "decodeURI": false, "decodeURIComponent": false, "encodeURI": false, "encodeURIComponent": false, "Error": false, "escape": false, "eval": false, "EvalError": false, "Function": false, "hasOwnProperty": false, "Infinity": false, "isFinite": false, "isNaN": false, "isPrototypeOf": false, "JSON": false, "Math": false, "NaN": false, "Number": false, "Object": false, "parseFloat": false, "parseInt": false, "propertyIsEnumerable": false, "RangeError": false, "ReferenceError": false, "RegExp": false, "String": false, "SyntaxError": false, "toLocaleString": false, "toString": false, "TypeError": false, "undefined": false, "unescape": false, "URIError": false, "valueOf": false }, "es2015": { "Array": false, "ArrayBuffer": false, "Boolean": false, "constructor": false, "DataView": false, "Date": false, "decodeURI": false, "decodeURIComponent": false, "encodeURI": false, "encodeURIComponent": false, "Error": false, "escape": false, "eval": false, "EvalError": false, "Float32Array": false, "Float64Array": false, "Function": false, "hasOwnProperty": false, "Infinity": false, "Int16Array": false, "Int32Array": false, "Int8Array": false, "isFinite": false, "isNaN": false, "isPrototypeOf": false, "JSON": false, "Map": false, "Math": false, "NaN": false, "Number": false, "Object": false, "parseFloat": false, "parseInt": false, "Promise": false, "propertyIsEnumerable": false, "Proxy": false, "RangeError": false, "ReferenceError": false, "Reflect": false, "RegExp": false, "Set": false, "String": false, "Symbol": false, "SyntaxError": false, "toLocaleString": false, "toString": false, "TypeError": false, "Uint16Array": false, "Uint32Array": false, "Uint8Array": false, "Uint8ClampedArray": false, "undefined": false, "unescape": false, "URIError": false, "valueOf": false, "WeakMap": false, "WeakSet": false }, "es2017": { "Array": false, "ArrayBuffer": false, "Atomics": false, "Boolean": false, "constructor": false, "DataView": false, "Date": false, "decodeURI": false, "decodeURIComponent": false, "encodeURI": false, "encodeURIComponent": false, "Error": false, "escape": false, "eval": false, "EvalError": false, "Float32Array": false, "Float64Array": false, "Function": false, "hasOwnProperty": false, "Infinity": false, "Int16Array": false, "Int32Array": false, "Int8Array": false, "isFinite": false, "isNaN": false, "isPrototypeOf": false, "JSON": false, "Map": false, "Math": false, "NaN": false, "Number": false, "Object": false, "parseFloat": false, "parseInt": false, "Promise": false, "propertyIsEnumerable": false, "Proxy": false, "RangeError": false, "ReferenceError": false, "Reflect": false, "RegExp": false, "Set": false, "SharedArrayBuffer": false, "String": false, "Symbol": false, "SyntaxError": false, "toLocaleString": false, "toString": false, "TypeError": false, "Uint16Array": false, "Uint32Array": false, "Uint8Array": false, "Uint8ClampedArray": false, "undefined": false, "unescape": false, "URIError": false, "valueOf": false, "WeakMap": false, "WeakSet": false }, "browser": { "AbortController": false, "AbortSignal": false, "addEventListener": false, "alert": false, "AnalyserNode": false, "Animation": false, "AnimationEffectReadOnly": false, "AnimationEffectTiming": false, "AnimationEffectTimingReadOnly": false, "AnimationEvent": false, "AnimationPlaybackEvent": false, "AnimationTimeline": false, "applicationCache": false, "ApplicationCache": false, "ApplicationCacheErrorEvent": false, "atob": false, "Attr": false, "Audio": false, "AudioBuffer": false, "AudioBufferSourceNode": false, "AudioContext": false, "AudioDestinationNode": false, "AudioListener": false, "AudioNode": false, "AudioParam": false, "AudioProcessingEvent": false, "AudioScheduledSourceNode": false, "AudioWorkletGlobalScope ": false, "AudioWorkletNode": false, "AudioWorkletProcessor": false, "BarProp": false, "BaseAudioContext": false, "BatteryManager": false, "BeforeUnloadEvent": false, "BiquadFilterNode": false, "Blob": false, "BlobEvent": false, "blur": false, "BroadcastChannel": false, "btoa": false, "BudgetService": false, "ByteLengthQueuingStrategy": false, "Cache": false, "caches": false, "CacheStorage": false, "cancelAnimationFrame": false, "cancelIdleCallback": false, "CanvasCaptureMediaStreamTrack": false, "CanvasGradient": false, "CanvasPattern": false, "CanvasRenderingContext2D": false, "ChannelMergerNode": false, "ChannelSplitterNode": false, "CharacterData": false, "clearInterval": false, "clearTimeout": false, "clientInformation": false, "ClipboardEvent": false, "close": false, "closed": false, "CloseEvent": false, "Comment": false, "CompositionEvent": false, "confirm": false, "console": false, "ConstantSourceNode": false, "ConvolverNode": false, "CountQueuingStrategy": false, "createImageBitmap": false, "Credential": false, "CredentialsContainer": false, "crypto": false, "Crypto": false, "CryptoKey": false, "CSS": false, "CSSConditionRule": false, "CSSFontFaceRule": false, "CSSGroupingRule": false, "CSSImportRule": false, "CSSKeyframeRule": false, "CSSKeyframesRule": false, "CSSMediaRule": false, "CSSNamespaceRule": false, "CSSPageRule": false, "CSSRule": false, "CSSRuleList": false, "CSSStyleDeclaration": false, "CSSStyleRule": false, "CSSStyleSheet": false, "CSSSupportsRule": false, "CustomElementRegistry": false, "customElements": false, "CustomEvent": false, "DataTransfer": false, "DataTransferItem": false, "DataTransferItemList": false, "defaultstatus": false, "defaultStatus": false, "DelayNode": false, "DeviceMotionEvent": false, "DeviceOrientationEvent": false, "devicePixelRatio": false, "dispatchEvent": false, "document": false, "Document": false, "DocumentFragment": false, "DocumentType": false, "DOMError": false, "DOMException": false, "DOMImplementation": false, "DOMMatrix": false, "DOMMatrixReadOnly": false, "DOMParser": false, "DOMPoint": false, "DOMPointReadOnly": false, "DOMQuad": false, "DOMRect": false, "DOMRectReadOnly": false, "DOMStringList": false, "DOMStringMap": false, "DOMTokenList": false, "DragEvent": false, "DynamicsCompressorNode": false, "Element": false, "ErrorEvent": false, "event": false, "Event": false, "EventSource": false, "EventTarget": false, "external": false, "fetch": false, "File": false, "FileList": false, "FileReader": false, "find": false, "focus": false, "FocusEvent": false, "FontFace": false, "FontFaceSetLoadEvent": false, "FormData": false, "frameElement": false, "frames": false, "GainNode": false, "Gamepad": false, "GamepadButton": false, "GamepadEvent": false, "getComputedStyle": false, "getSelection": false, "HashChangeEvent": false, "Headers": false, "history": false, "History": false, "HTMLAllCollection": false, "HTMLAnchorElement": false, "HTMLAreaElement": false, "HTMLAudioElement": false, "HTMLBaseElement": false, "HTMLBodyElement": false, "HTMLBRElement": false, "HTMLButtonElement": false, "HTMLCanvasElement": false, "HTMLCollection": false, "HTMLContentElement": false, "HTMLDataElement": false, "HTMLDataListElement": false, "HTMLDetailsElement": false, "HTMLDialogElement": false, "HTMLDirectoryElement": false, "HTMLDivElement": false, "HTMLDListElement": false, "HTMLDocument": false, "HTMLElement": false, "HTMLEmbedElement": false, "HTMLFieldSetElement": false, "HTMLFontElement": false, "HTMLFormControlsCollection": false, "HTMLFormElement": false, "HTMLFrameElement": false, "HTMLFrameSetElement": false, "HTMLHeadElement": false, "HTMLHeadingElement": false, "HTMLHRElement": false, "HTMLHtmlElement": false, "HTMLIFrameElement": false, "HTMLImageElement": false, "HTMLInputElement": false, "HTMLLabelElement": false, "HTMLLegendElement": false, "HTMLLIElement": false, "HTMLLinkElement": false, "HTMLMapElement": false, "HTMLMarqueeElement": false, "HTMLMediaElement": false, "HTMLMenuElement": false, "HTMLMetaElement": false, "HTMLMeterElement": false, "HTMLModElement": false, "HTMLObjectElement": false, "HTMLOListElement": false, "HTMLOptGroupElement": false, "HTMLOptionElement": false, "HTMLOptionsCollection": false, "HTMLOutputElement": false, "HTMLParagraphElement": false, "HTMLParamElement": false, "HTMLPictureElement": false, "HTMLPreElement": false, "HTMLProgressElement": false, "HTMLQuoteElement": false, "HTMLScriptElement": false, "HTMLSelectElement": false, "HTMLShadowElement": false, "HTMLSlotElement": false, "HTMLSourceElement": false, "HTMLSpanElement": false, "HTMLStyleElement": false, "HTMLTableCaptionElement": false, "HTMLTableCellElement": false, "HTMLTableColElement": false, "HTMLTableElement": false, "HTMLTableRowElement": false, "HTMLTableSectionElement": false, "HTMLTemplateElement": false, "HTMLTextAreaElement": false, "HTMLTimeElement": false, "HTMLTitleElement": false, "HTMLTrackElement": false, "HTMLUListElement": false, "HTMLUnknownElement": false, "HTMLVideoElement": false, "IDBCursor": false, "IDBCursorWithValue": false, "IDBDatabase": false, "IDBFactory": false, "IDBIndex": false, "IDBKeyRange": false, "IDBObjectStore": false, "IDBOpenDBRequest": false, "IDBRequest": false, "IDBTransaction": false, "IDBVersionChangeEvent": false, "IdleDeadline": false, "IIRFilterNode": false, "Image": false, "ImageBitmap": false, "ImageBitmapRenderingContext": false, "ImageCapture": false, "ImageData": false, "indexedDB": false, "innerHeight": false, "innerWidth": false, "InputEvent": false, "IntersectionObserver": false, "IntersectionObserverEntry": false, "Intl": false, "isSecureContext": false, "KeyboardEvent": false, "KeyframeEffect": false, "KeyframeEffectReadOnly": false, "length": false, "localStorage": false, "location": true, "Location": false, "locationbar": false, "matchMedia": false, "MediaDeviceInfo": false, "MediaDevices": false, "MediaElementAudioSourceNode": false, "MediaEncryptedEvent": false, "MediaError": false, "MediaKeyMessageEvent": false, "MediaKeySession": false, "MediaKeyStatusMap": false, "MediaKeySystemAccess": false, "MediaList": false, "MediaQueryList": false, "MediaQueryListEvent": false, "MediaRecorder": false, "MediaSettingsRange": false, "MediaSource": false, "MediaStream": false, "MediaStreamAudioDestinationNode": false, "MediaStreamAudioSourceNode": false, "MediaStreamEvent": false, "MediaStreamTrack": false, "MediaStreamTrackEvent": false, "menubar": false, "MessageChannel": false, "MessageEvent": false, "MessagePort": false, "MIDIAccess": false, "MIDIConnectionEvent": false, "MIDIInput": false, "MIDIInputMap": false, "MIDIMessageEvent": false, "MIDIOutput": false, "MIDIOutputMap": false, "MIDIPort": false, "MimeType": false, "MimeTypeArray": false, "MouseEvent": false, "moveBy": false, "moveTo": false, "MutationEvent": false, "MutationObserver": false, "MutationRecord": false, "name": false, "NamedNodeMap": false, "NavigationPreloadManager": false, "navigator": false, "Navigator": false, "NetworkInformation": false, "Node": false, "NodeFilter": false, "NodeIterator": false, "NodeList": false, "Notification": false, "OfflineAudioCompletionEvent": false, "OfflineAudioContext": false, "offscreenBuffering": false, "OffscreenCanvas": true, "onabort": true, "onafterprint": true, "onanimationend": true, "onanimationiteration": true, "onanimationstart": true, "onappinstalled": true, "onauxclick": true, "onbeforeinstallprompt": true, "onbeforeprint": true, "onbeforeunload": true, "onblur": true, "oncancel": true, "oncanplay": true, "oncanplaythrough": true, "onchange": true, "onclick": true, "onclose": true, "oncontextmenu": true, "oncuechange": true, "ondblclick": true, "ondevicemotion": true, "ondeviceorientation": true, "ondeviceorientationabsolute": true, "ondrag": true, "ondragend": true, "ondragenter": true, "ondragleave": true, "ondragover": true, "ondragstart": true, "ondrop": true, "ondurationchange": true, "onemptied": true, "onended": true, "onerror": true, "onfocus": true, "ongotpointercapture": true, "onhashchange": true, "oninput": true, "oninvalid": true, "onkeydown": true, "onkeypress": true, "onkeyup": true, "onlanguagechange": true, "onload": true, "onloadeddata": true, "onloadedmetadata": true, "onloadstart": true, "onlostpointercapture": true, "onmessage": true, "onmessageerror": true, "onmousedown": true, "onmouseenter": true, "onmouseleave": true, "onmousemove": true, "onmouseout": true, "onmouseover": true, "onmouseup": true, "onmousewheel": true, "onoffline": true, "ononline": true, "onpagehide": true, "onpageshow": true, "onpause": true, "onplay": true, "onplaying": true, "onpointercancel": true, "onpointerdown": true, "onpointerenter": true, "onpointerleave": true, "onpointermove": true, "onpointerout": true, "onpointerover": true, "onpointerup": true, "onpopstate": true, "onprogress": true, "onratechange": true, "onrejectionhandled": true, "onreset": true, "onresize": true, "onscroll": true, "onsearch": true, "onseeked": true, "onseeking": true, "onselect": true, "onstalled": true, "onstorage": true, "onsubmit": true, "onsuspend": true, "ontimeupdate": true, "ontoggle": true, "ontransitionend": true, "onunhandledrejection": true, "onunload": true, "onvolumechange": true, "onwaiting": true, "onwheel": true, "open": false, "openDatabase": false, "opener": false, "Option": false, "origin": false, "OscillatorNode": false, "outerHeight": false, "outerWidth": false, "PageTransitionEvent": false, "pageXOffset": false, "pageYOffset": false, "PannerNode": false, "parent": false, "Path2D": false, "PaymentAddress": false, "PaymentRequest": false, "PaymentRequestUpdateEvent": false, "PaymentResponse": false, "performance": false, "Performance": false, "PerformanceEntry": false, "PerformanceLongTaskTiming": false, "PerformanceMark": false, "PerformanceMeasure": false, "PerformanceNavigation": false, "PerformanceNavigationTiming": false, "PerformanceObserver": false, "PerformanceObserverEntryList": false, "PerformancePaintTiming": false, "PerformanceResourceTiming": false, "PerformanceTiming": false, "PeriodicWave": false, "Permissions": false, "PermissionStatus": false, "personalbar": false, "PhotoCapabilities": false, "Plugin": false, "PluginArray": false, "PointerEvent": false, "PopStateEvent": false, "postMessage": false, "Presentation": false, "PresentationAvailability": false, "PresentationConnection": false, "PresentationConnectionAvailableEvent": false, "PresentationConnectionCloseEvent": false, "PresentationConnectionList": false, "PresentationReceiver": false, "PresentationRequest": false, "print": false, "ProcessingInstruction": false, "ProgressEvent": false, "PromiseRejectionEvent": false, "prompt": false, "PushManager": false, "PushSubscription": false, "PushSubscriptionOptions": false, "queueMicrotask": false, "RadioNodeList": false, "Range": false, "ReadableStream": false, "registerProcessor": false, "RemotePlayback": false, "removeEventListener": false, "Request": false, "requestAnimationFrame": false, "requestIdleCallback": false, "resizeBy": false, "ResizeObserver": false, "ResizeObserverEntry": false, "resizeTo": false, "Response": false, "RTCCertificate": false, "RTCDataChannel": false, "RTCDataChannelEvent": false, "RTCDtlsTransport": false, "RTCIceCandidate": false, "RTCIceGatherer": false, "RTCIceTransport": false, "RTCPeerConnection": false, "RTCPeerConnectionIceEvent": false, "RTCRtpContributingSource": false, "RTCRtpReceiver": false, "RTCRtpSender": false, "RTCSctpTransport": false, "RTCSessionDescription": false, "RTCStatsReport": false, "RTCTrackEvent": false, "screen": false, "Screen": false, "screenLeft": false, "ScreenOrientation": false, "screenTop": false, "screenX": false, "screenY": false, "ScriptProcessorNode": false, "scroll": false, "scrollbars": false, "scrollBy": false, "scrollTo": false, "scrollX": false, "scrollY": false, "SecurityPolicyViolationEvent": false, "Selection": false, "self": false, "ServiceWorker": false, "ServiceWorkerContainer": false, "ServiceWorkerRegistration": false, "sessionStorage": false, "setInterval": false, "setTimeout": false, "ShadowRoot": false, "SharedWorker": false, "SourceBuffer": false, "SourceBufferList": false, "speechSynthesis": false, "SpeechSynthesisEvent": false, "SpeechSynthesisUtterance": false, "StaticRange": false, "status": false, "statusbar": false, "StereoPannerNode": false, "stop": false, "Storage": false, "StorageEvent": false, "StorageManager": false, "styleMedia": false, "StyleSheet": false, "StyleSheetList": false, "SubtleCrypto": false, "SVGAElement": false, "SVGAngle": false, "SVGAnimatedAngle": false, "SVGAnimatedBoolean": false, "SVGAnimatedEnumeration": false, "SVGAnimatedInteger": false, "SVGAnimatedLength": false, "SVGAnimatedLengthList": false, "SVGAnimatedNumber": false, "SVGAnimatedNumberList": false, "SVGAnimatedPreserveAspectRatio": false, "SVGAnimatedRect": false, "SVGAnimatedString": false, "SVGAnimatedTransformList": false, "SVGAnimateElement": false, "SVGAnimateMotionElement": false, "SVGAnimateTransformElement": false, "SVGAnimationElement": false, "SVGCircleElement": false, "SVGClipPathElement": false, "SVGComponentTransferFunctionElement": false, "SVGDefsElement": false, "SVGDescElement": false, "SVGDiscardElement": false, "SVGElement": false, "SVGEllipseElement": false, "SVGFEBlendElement": false, "SVGFEColorMatrixElement": false, "SVGFEComponentTransferElement": false, "SVGFECompositeElement": false, "SVGFEConvolveMatrixElement": false, "SVGFEDiffuseLightingElement": false, "SVGFEDisplacementMapElement": false, "SVGFEDistantLightElement": false, "SVGFEDropShadowElement": false, "SVGFEFloodElement": false, "SVGFEFuncAElement": false, "SVGFEFuncBElement": false, "SVGFEFuncGElement": false, "SVGFEFuncRElement": false, "SVGFEGaussianBlurElement": false, "SVGFEImageElement": false, "SVGFEMergeElement": false, "SVGFEMergeNodeElement": false, "SVGFEMorphologyElement": false, "SVGFEOffsetElement": false, "SVGFEPointLightElement": false, "SVGFESpecularLightingElement": false, "SVGFESpotLightElement": false, "SVGFETileElement": false, "SVGFETurbulenceElement": false, "SVGFilterElement": false, "SVGForeignObjectElement": false, "SVGGElement": false, "SVGGeometryElement": false, "SVGGradientElement": false, "SVGGraphicsElement": false, "SVGImageElement": false, "SVGLength": false, "SVGLengthList": false, "SVGLinearGradientElement": false, "SVGLineElement": false, "SVGMarkerElement": false, "SVGMaskElement": false, "SVGMatrix": false, "SVGMetadataElement": false, "SVGMPathElement": false, "SVGNumber": false, "SVGNumberList": false, "SVGPathElement": false, "SVGPatternElement": false, "SVGPoint": false, "SVGPointList": false, "SVGPolygonElement": false, "SVGPolylineElement": false, "SVGPreserveAspectRatio": false, "SVGRadialGradientElement": false, "SVGRect": false, "SVGRectElement": false, "SVGScriptElement": false, "SVGSetElement": false, "SVGStopElement": false, "SVGStringList": false, "SVGStyleElement": false, "SVGSVGElement": false, "SVGSwitchElement": false, "SVGSymbolElement": false, "SVGTextContentElement": false, "SVGTextElement": false, "SVGTextPathElement": false, "SVGTextPositioningElement": false, "SVGTitleElement": false, "SVGTransform": false, "SVGTransformList": false, "SVGTSpanElement": false, "SVGUnitTypes": false, "SVGUseElement": false, "SVGViewElement": false, "TaskAttributionTiming": false, "Text": false, "TextDecoder": false, "TextEncoder": false, "TextEvent": false, "TextMetrics": false, "TextTrack": false, "TextTrackCue": false, "TextTrackCueList": false, "TextTrackList": false, "TimeRanges": false, "toolbar": false, "top": false, "Touch": false, "TouchEvent": false, "TouchList": false, "TrackEvent": false, "TransitionEvent": false, "TreeWalker": false, "UIEvent": false, "URL": false, "URLSearchParams": false, "ValidityState": false, "visualViewport": false, "VisualViewport": false, "VTTCue": false, "WaveShaperNode": false, "WebAssembly": false, "WebGL2RenderingContext": false, "WebGLActiveInfo": false, "WebGLBuffer": false, "WebGLContextEvent": false, "WebGLFramebuffer": false, "WebGLProgram": false, "WebGLQuery": false, "WebGLRenderbuffer": false, "WebGLRenderingContext": false, "WebGLSampler": false, "WebGLShader": false, "WebGLShaderPrecisionFormat": false, "WebGLSync": false, "WebGLTexture": false, "WebGLTransformFeedback": false, "WebGLUniformLocation": false, "WebGLVertexArrayObject": false, "WebSocket": false, "WheelEvent": false, "window": false, "Window": false, "Worker": false, "WritableStream": false, "XMLDocument": false, "XMLHttpRequest": false, "XMLHttpRequestEventTarget": false, "XMLHttpRequestUpload": false, "XMLSerializer": false, "XPathEvaluator": false, "XPathExpression": false, "XPathResult": false, "XSLTProcessor": false }, "worker": { "addEventListener": false, "applicationCache": false, "atob": false, "Blob": false, "BroadcastChannel": false, "btoa": false, "Cache": false, "caches": false, "clearInterval": false, "clearTimeout": false, "close": true, "console": false, "fetch": false, "FileReaderSync": false, "FormData": false, "Headers": false, "IDBCursor": false, "IDBCursorWithValue": false, "IDBDatabase": false, "IDBFactory": false, "IDBIndex": false, "IDBKeyRange": false, "IDBObjectStore": false, "IDBOpenDBRequest": false, "IDBRequest": false, "IDBTransaction": false, "IDBVersionChangeEvent": false, "ImageData": false, "importScripts": true, "indexedDB": false, "location": false, "MessageChannel": false, "MessagePort": false, "name": false, "navigator": false, "Notification": false, "onclose": true, "onconnect": true, "onerror": true, "onlanguagechange": true, "onmessage": true, "onoffline": true, "ononline": true, "onrejectionhandled": true, "onunhandledrejection": true, "performance": false, "Performance": false, "PerformanceEntry": false, "PerformanceMark": false, "PerformanceMeasure": false, "PerformanceNavigation": false, "PerformanceResourceTiming": false, "PerformanceTiming": false, "postMessage": true, "Promise": false, "queueMicrotask": false, "removeEventListener": false, "Request": false, "Response": false, "self": true, "ServiceWorkerRegistration": false, "setInterval": false, "setTimeout": false, "TextDecoder": false, "TextEncoder": false, "URL": false, "URLSearchParams": false, "WebSocket": false, "Worker": false, "WorkerGlobalScope": false, "XMLHttpRequest": false }, "node": { "__dirname": false, "__filename": false, "Buffer": false, "clearImmediate": false, "clearInterval": false, "clearTimeout": false, "console": false, "exports": true, "global": false, "Intl": false, "module": false, "process": false, "queueMicrotask": false, "require": false, "setImmediate": false, "setInterval": false, "setTimeout": false, "TextDecoder": false, "TextEncoder": false, "URL": false, "URLSearchParams": false }, "commonjs": { "exports": true, "global": false, "module": false, "require": false }, "amd": { "define": false, "require": false }, "mocha": { "after": false, "afterEach": false, "before": false, "beforeEach": false, "context": false, "describe": false, "it": false, "mocha": false, "run": false, "setup": false, "specify": false, "suite": false, "suiteSetup": false, "suiteTeardown": false, "teardown": false, "test": false, "xcontext": false, "xdescribe": false, "xit": false, "xspecify": false }, "jasmine": { "afterAll": false, "afterEach": false, "beforeAll": false, "beforeEach": false, "describe": false, "expect": false, "fail": false, "fdescribe": false, "fit": false, "it": false, "jasmine": false, "pending": false, "runs": false, "spyOn": false, "spyOnProperty": false, "waits": false, "waitsFor": false, "xdescribe": false, "xit": false }, "jest": { "afterAll": false, "afterEach": false, "beforeAll": false, "beforeEach": false, "describe": false, "expect": false, "fdescribe": false, "fit": false, "it": false, "jest": false, "pit": false, "require": false, "test": false, "xdescribe": false, "xit": false, "xtest": false }, "qunit": { "asyncTest": false, "deepEqual": false, "equal": false, "expect": false, "module": false, "notDeepEqual": false, "notEqual": false, "notOk": false, "notPropEqual": false, "notStrictEqual": false, "ok": false, "propEqual": false, "QUnit": false, "raises": false, "start": false, "stop": false, "strictEqual": false, "test": false, "throws": false }, "phantomjs": { "console": true, "exports": true, "phantom": true, "require": true, "WebPage": true }, "couch": { "emit": false, "exports": false, "getRow": false, "log": false, "module": false, "provides": false, "require": false, "respond": false, "send": false, "start": false, "sum": false }, "rhino": { "defineClass": false, "deserialize": false, "gc": false, "help": false, "importClass": false, "importPackage": false, "java": false, "load": false, "loadClass": false, "Packages": false, "print": false, "quit": false, "readFile": false, "readUrl": false, "runCommand": false, "seal": false, "serialize": false, "spawn": false, "sync": false, "toint32": false, "version": false }, "nashorn": { "__DIR__": false, "__FILE__": false, "__LINE__": false, "com": false, "edu": false, "exit": false, "java": false, "Java": false, "javafx": false, "JavaImporter": false, "javax": false, "JSAdapter": false, "load": false, "loadWithNewGlobal": false, "org": false, "Packages": false, "print": false, "quit": false }, "wsh": { "ActiveXObject": true, "Enumerator": true, "GetObject": true, "ScriptEngine": true, "ScriptEngineBuildVersion": true, "ScriptEngineMajorVersion": true, "ScriptEngineMinorVersion": true, "VBArray": true, "WScript": true, "WSH": true, "XDomainRequest": true }, "jquery": { "$": false, "jQuery": false }, "yui": { "YAHOO": false, "YAHOO_config": false, "YUI": false, "YUI_config": false }, "shelljs": { "cat": false, "cd": false, "chmod": false, "config": false, "cp": false, "dirs": false, "echo": false, "env": false, "error": false, "exec": false, "exit": false, "find": false, "grep": false, "ln": false, "ls": false, "mkdir": false, "mv": false, "popd": false, "pushd": false, "pwd": false, "rm": false, "sed": false, "set": false, "target": false, "tempdir": false, "test": false, "touch": false, "which": false }, "prototypejs": { "$": false, "$$": false, "$A": false, "$break": false, "$continue": false, "$F": false, "$H": false, "$R": false, "$w": false, "Abstract": false, "Ajax": false, "Autocompleter": false, "Builder": false, "Class": false, "Control": false, "Draggable": false, "Draggables": false, "Droppables": false, "Effect": false, "Element": false, "Enumerable": false, "Event": false, "Field": false, "Form": false, "Hash": false, "Insertion": false, "ObjectRange": false, "PeriodicalExecuter": false, "Position": false, "Prototype": false, "Scriptaculous": false, "Selector": false, "Sortable": false, "SortableObserver": false, "Sound": false, "Template": false, "Toggle": false, "Try": false }, "meteor": { "_": false, "$": false, "Accounts": false, "AccountsClient": false, "AccountsCommon": false, "AccountsServer": false, "App": false, "Assets": false, "Blaze": false, "check": false, "Cordova": false, "DDP": false, "DDPRateLimiter": false, "DDPServer": false, "Deps": false, "EJSON": false, "Email": false, "HTTP": false, "Log": false, "Match": false, "Meteor": false, "Mongo": false, "MongoInternals": false, "Npm": false, "Package": false, "Plugin": false, "process": false, "Random": false, "ReactiveDict": false, "ReactiveVar": false, "Router": false, "ServiceConfiguration": false, "Session": false, "share": false, "Spacebars": false, "Template": false, "Tinytest": false, "Tracker": false, "UI": false, "Utils": false, "WebApp": false, "WebAppInternals": false }, "mongo": { "_isWindows": false, "_rand": false, "BulkWriteResult": false, "cat": false, "cd": false, "connect": false, "db": false, "getHostName": false, "getMemInfo": false, "hostname": false, "ISODate": false, "listFiles": false, "load": false, "ls": false, "md5sumFile": false, "mkdir": false, "Mongo": false, "NumberInt": false, "NumberLong": false, "ObjectId": false, "PlanCache": false, "print": false, "printjson": false, "pwd": false, "quit": false, "removeFile": false, "rs": false, "sh": false, "UUID": false, "version": false, "WriteResult": false }, "applescript": { "$": false, "Application": false, "Automation": false, "console": false, "delay": false, "Library": false, "ObjC": false, "ObjectSpecifier": false, "Path": false, "Progress": false, "Ref": false }, "serviceworker": { "addEventListener": false, "applicationCache": false, "atob": false, "Blob": false, "BroadcastChannel": false, "btoa": false, "Cache": false, "caches": false, "CacheStorage": false, "clearInterval": false, "clearTimeout": false, "Client": false, "clients": false, "Clients": false, "close": true, "console": false, "ExtendableEvent": false, "ExtendableMessageEvent": false, "fetch": false, "FetchEvent": false, "FileReaderSync": false, "FormData": false, "Headers": false, "IDBCursor": false, "IDBCursorWithValue": false, "IDBDatabase": false, "IDBFactory": false, "IDBIndex": false, "IDBKeyRange": false, "IDBObjectStore": false, "IDBOpenDBRequest": false, "IDBRequest": false, "IDBTransaction": false, "IDBVersionChangeEvent": false, "ImageData": false, "importScripts": false, "indexedDB": false, "location": false, "MessageChannel": false, "MessagePort": false, "name": false, "navigator": false, "Notification": false, "onclose": true, "onconnect": true, "onerror": true, "onfetch": true, "oninstall": true, "onlanguagechange": true, "onmessage": true, "onmessageerror": true, "onnotificationclick": true, "onnotificationclose": true, "onoffline": true, "ononline": true, "onpush": true, "onpushsubscriptionchange": true, "onrejectionhandled": true, "onsync": true, "onunhandledrejection": true, "performance": false, "Performance": false, "PerformanceEntry": false, "PerformanceMark": false, "PerformanceMeasure": false, "PerformanceNavigation": false, "PerformanceResourceTiming": false, "PerformanceTiming": false, "postMessage": true, "Promise": false, "queueMicrotask": false, "registration": false, "removeEventListener": false, "Request": false, "Response": false, "self": false, "ServiceWorker": false, "ServiceWorkerContainer": false, "ServiceWorkerGlobalScope": false, "ServiceWorkerMessageEvent": false, "ServiceWorkerRegistration": false, "setInterval": false, "setTimeout": false, "skipWaiting": false, "TextDecoder": false, "TextEncoder": false, "URL": false, "URLSearchParams": false, "WebSocket": false, "WindowClient": false, "Worker": false, "WorkerGlobalScope": false, "XMLHttpRequest": false }, "atomtest": { "advanceClock": false, "fakeClearInterval": false, "fakeClearTimeout": false, "fakeSetInterval": false, "fakeSetTimeout": false, "resetTimeouts": false, "waitsForPromise": false }, "embertest": { "andThen": false, "click": false, "currentPath": false, "currentRouteName": false, "currentURL": false, "fillIn": false, "find": false, "findAll": false, "findWithAssert": false, "keyEvent": false, "pauseTest": false, "resumeTest": false, "triggerEvent": false, "visit": false, "wait": false }, "protractor": { "$": false, "$$": false, "browser": false, "by": false, "By": false, "DartObject": false, "element": false, "protractor": false }, "shared-node-browser": { "clearInterval": false, "clearTimeout": false, "console": false, "setInterval": false, "setTimeout": false, "URL": false, "URLSearchParams": false }, "webextensions": { "browser": false, "chrome": false, "opr": false }, "greasemonkey": { "cloneInto": false, "createObjectIn": false, "exportFunction": false, "GM": false, "GM_addStyle": false, "GM_deleteValue": false, "GM_getResourceText": false, "GM_getResourceURL": false, "GM_getValue": false, "GM_info": false, "GM_listValues": false, "GM_log": false, "GM_openInTab": false, "GM_registerMenuCommand": false, "GM_setClipboard": false, "GM_setValue": false, "GM_xmlhttpRequest": false, "unsafeWindow": false }, "devtools": { "$": false, "$_": false, "$$": false, "$0": false, "$1": false, "$2": false, "$3": false, "$4": false, "$x": false, "chrome": false, "clear": false, "copy": false, "debug": false, "dir": false, "dirxml": false, "getEventListeners": false, "inspect": false, "keys": false, "monitor": false, "monitorEvents": false, "profile": false, "profileEnd": false, "queryObjects": false, "table": false, "undebug": false, "unmonitor": false, "unmonitorEvents": false, "values": false } } },{}],442:[function(require,module,exports){ 'use strict'; module.exports = require('./globals.json'); },{"./globals.json":441}],443:[function(require,module,exports){ (function (global){(function (){ 'use strict'; var origSymbol = global.Symbol; var hasSymbolSham = require('./shams'); module.exports = function hasNativeSymbols() { if (typeof origSymbol !== 'function') { return false; } if (typeof Symbol !== 'function') { return false; } if (typeof origSymbol('foo') !== 'symbol') { return false; } if (typeof Symbol('bar') !== 'symbol') { return false; } return hasSymbolSham(); }; }).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) },{"./shams":444}],444:[function(require,module,exports){ 'use strict'; /* eslint complexity: [2, 18], max-statements: [2, 33] */ module.exports = function hasSymbols() { if (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false; } if (typeof Symbol.iterator === 'symbol') { return true; } var obj = {}; var sym = Symbol('test'); var symObj = Object(sym); if (typeof sym === 'string') { return false; } if (Object.prototype.toString.call(sym) !== '[object Symbol]') { return false; } if (Object.prototype.toString.call(symObj) !== '[object Symbol]') { return false; } // temp disabled per https://github.com/ljharb/object.assign/issues/17 // if (sym instanceof Symbol) { return false; } // temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4 // if (!(symObj instanceof Symbol)) { return false; } // if (typeof Symbol.prototype.toString !== 'function') { return false; } // if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; } var symVal = 42; obj[sym] = symVal; for (sym in obj) { return false; } // eslint-disable-line no-restricted-syntax if (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false; } if (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false; } var syms = Object.getOwnPropertySymbols(obj); if (syms.length !== 1 || syms[0] !== sym) { return false; } if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; } if (typeof Object.getOwnPropertyDescriptor === 'function') { var descriptor = Object.getOwnPropertyDescriptor(obj, sym); if (descriptor.value !== symVal || descriptor.enumerable !== true) { return false; } } return true; }; },{}],445:[function(require,module,exports){ 'use strict'; var bind = require('function-bind'); module.exports = bind.call(Function.call, Object.prototype.hasOwnProperty); },{"function-bind":438}],446:[function(require,module,exports){ /*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh */ exports.read = function (buffer, offset, isLE, mLen, nBytes) { var e, m var eLen = (nBytes * 8) - mLen - 1 var eMax = (1 << eLen) - 1 var eBias = eMax >> 1 var nBits = -7 var i = isLE ? (nBytes - 1) : 0 var d = isLE ? -1 : 1 var s = buffer[offset + i] i += d e = s & ((1 << (-nBits)) - 1) s >>= (-nBits) nBits += eLen for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {} m = e & ((1 << (-nBits)) - 1) e >>= (-nBits) nBits += mLen for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {} if (e === 0) { e = 1 - eBias } else if (e === eMax) { return m ? NaN : ((s ? -1 : 1) * Infinity) } else { m = m + Math.pow(2, mLen) e = e - eBias } return (s ? -1 : 1) * m * Math.pow(2, e - mLen) } exports.write = function (buffer, value, offset, isLE, mLen, nBytes) { var e, m, c var eLen = (nBytes * 8) - mLen - 1 var eMax = (1 << eLen) - 1 var eBias = eMax >> 1 var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0) var i = isLE ? 0 : (nBytes - 1) var d = isLE ? 1 : -1 var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0 value = Math.abs(value) if (isNaN(value) || value === Infinity) { m = isNaN(value) ? 1 : 0 e = eMax } else { e = Math.floor(Math.log(value) / Math.LN2) if (value * (c = Math.pow(2, -e)) < 1) { e-- c *= 2 } if (e + eBias >= 1) { value += rt / c } else { value += rt * Math.pow(2, 1 - eBias) } if (value * c >= 2) { e++ c /= 2 } if (e + eBias >= eMax) { m = 0 e = eMax } else if (e + eBias >= 1) { m = ((value * c) - 1) * Math.pow(2, mLen) e = e + eBias } else { m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen) e = 0 } } for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {} e = (e << mLen) | m eLen += mLen for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {} buffer[offset + i - d] |= s * 128 } },{}],447:[function(require,module,exports){ if (typeof Object.create === 'function') { // implementation from standard node.js 'util' module module.exports = function inherits(ctor, superCtor) { if (superCtor) { ctor.super_ = superCtor ctor.prototype = Object.create(superCtor.prototype, { constructor: { value: ctor, enumerable: false, writable: true, configurable: true } }) } }; } else { // old school shim for old browsers module.exports = function inherits(ctor, superCtor) { if (superCtor) { ctor.super_ = superCtor var TempCtor = function () {} TempCtor.prototype = superCtor.prototype ctor.prototype = new TempCtor() ctor.prototype.constructor = ctor } } } },{}],448:[function(require,module,exports){ 'use strict'; var hasToStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol'; var callBound = require('call-bind/callBound'); var $toString = callBound('Object.prototype.toString'); var isStandardArguments = function isArguments(value) { if (hasToStringTag && value && typeof value === 'object' && Symbol.toStringTag in value) { return false; } return $toString(value) === '[object Arguments]'; }; var isLegacyArguments = function isArguments(value) { if (isStandardArguments(value)) { return true; } return value !== null && typeof value === 'object' && typeof value.length === 'number' && value.length >= 0 && $toString(value) !== '[object Array]' && $toString(value.callee) === '[object Function]'; }; var supportsStandardArguments = (function () { return isStandardArguments(arguments); }()); isStandardArguments.isLegacyArguments = isLegacyArguments; // for tests module.exports = supportsStandardArguments ? isStandardArguments : isLegacyArguments; },{"call-bind/callBound":415}],449:[function(require,module,exports){ /*! * Determine if an object is a Buffer * * @author Feross Aboukhadijeh * @license MIT */ // The _isBuffer check is for Safari 5-7 support, because it's missing // Object.prototype.constructor. Remove this eventually module.exports = function (obj) { return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer) } function isBuffer (obj) { return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj) } // For Node v0.10 support. Remove this eventually. function isSlowBuffer (obj) { return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isBuffer(obj.slice(0, 0)) } },{}],450:[function(require,module,exports){ 'use strict'; var toStr = Object.prototype.toString; var fnToStr = Function.prototype.toString; var isFnRegex = /^\s*(?:function)?\*/; var hasToStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol'; var getProto = Object.getPrototypeOf; var getGeneratorFunc = function () { // eslint-disable-line consistent-return if (!hasToStringTag) { return false; } try { return Function('return function*() {}')(); } catch (e) { } }; var generatorFunc = getGeneratorFunc(); var GeneratorFunction = getProto && generatorFunc ? getProto(generatorFunc) : false; module.exports = function isGeneratorFunction(fn) { if (typeof fn !== 'function') { return false; } if (isFnRegex.test(fnToStr.call(fn))) { return true; } if (!hasToStringTag) { var str = toStr.call(fn); return str === '[object GeneratorFunction]'; } return getProto && getProto(fn) === GeneratorFunction; }; },{}],451:[function(require,module,exports){ (function (global){(function (){ 'use strict'; var forEach = require('foreach'); var availableTypedArrays = require('available-typed-arrays'); var callBound = require('call-bind/callBound'); var $toString = callBound('Object.prototype.toString'); var hasSymbols = require('has-symbols')(); var hasToStringTag = hasSymbols && typeof Symbol.toStringTag === 'symbol'; var typedArrays = availableTypedArrays(); var $indexOf = callBound('Array.prototype.indexOf', true) || function indexOf(array, value) { for (var i = 0; i < array.length; i += 1) { if (array[i] === value) { return i; } } return -1; }; var $slice = callBound('String.prototype.slice'); var toStrTags = {}; var gOPD = require('es-abstract/helpers/getOwnPropertyDescriptor'); var getPrototypeOf = Object.getPrototypeOf; // require('getprototypeof'); if (hasToStringTag && gOPD && getPrototypeOf) { forEach(typedArrays, function (typedArray) { var arr = new global[typedArray](); if (!(Symbol.toStringTag in arr)) { throw new EvalError('this engine has support for Symbol.toStringTag, but ' + typedArray + ' does not have the property! Please report this.'); } var proto = getPrototypeOf(arr); var descriptor = gOPD(proto, Symbol.toStringTag); if (!descriptor) { var superProto = getPrototypeOf(proto); descriptor = gOPD(superProto, Symbol.toStringTag); } toStrTags[typedArray] = descriptor.get; }); } var tryTypedArrays = function tryAllTypedArrays(value) { var anyTrue = false; forEach(toStrTags, function (getter, typedArray) { if (!anyTrue) { try { anyTrue = getter.call(value) === typedArray; } catch (e) { /**/ } } }); return anyTrue; }; module.exports = function isTypedArray(value) { if (!value || typeof value !== 'object') { return false; } if (!hasToStringTag) { var tag = $slice($toString(value), 8, -1); return $indexOf(typedArrays, tag) > -1; } if (!gOPD) { return false; } return tryTypedArrays(value); }; }).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) },{"available-typed-arrays":406,"call-bind/callBound":415,"es-abstract/helpers/getOwnPropertyDescriptor":433,"foreach":436,"has-symbols":443}],452:[function(require,module,exports){ // Copyright 2014, 2015, 2016, 2017, 2018 Simon Lydell // License: MIT. (See LICENSE.) Object.defineProperty(exports, "__esModule", { value: true }) // This regex comes from regex.coffee, and is inserted here by generate-index.js // (run `npm run build`). exports.default = /((['"])(?:(?!\2|\\).|\\(?:\r\n|[\s\S]))*(\2)?|`(?:[^`\\$]|\\[\s\S]|\$(?!\{)|\$\{(?:[^{}]|\{[^}]*\}?)*\}?)*(`)?)|(\/\/.*)|(\/\*(?:[^*]|\*(?!\/))*(\*\/)?)|(\/(?!\*)(?:\[(?:(?![\]\\]).|\\.)*\]|(?![\/\]\\]).|\\.)+\/(?:(?!\s*(?:\b|[\u0080-\uFFFF$\\'"~({]|[+\-!](?!=)|\.?\d))|[gmiyus]{1,6}\b(?![\u0080-\uFFFF$\\]|\s*(?:[+\-*%&|^<>!=?({]|\/(?![\/*])))))|(0[xX][\da-fA-F]+|0[oO][0-7]+|0[bB][01]+|(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?)|((?!\d)(?:(?!\s)[$\w\u0080-\uFFFF]|\\u[\da-fA-F]{4}|\\u\{[\da-fA-F]+\})+)|(--|\+\+|&&|\|\||=>|\.{3}|(?:[+\-\/%&|^]|\*{1,2}|<{1,2}|>{1,3}|!=?|={1,2})=?|[?~.,:;[\](){}])|(\s+)|(^$|[\s\S])/g exports.matchToToken = function(match) { var token = {type: "invalid", value: match[0], closed: undefined} if (match[ 1]) token.type = "string" , token.closed = !!(match[3] || match[4]) else if (match[ 5]) token.type = "comment" else if (match[ 6]) token.type = "comment", token.closed = !!match[7] else if (match[ 8]) token.type = "regex" else if (match[ 9]) token.type = "number" else if (match[10]) token.type = "name" else if (match[11]) token.type = "punctuator" else if (match[12]) token.type = "whitespace" return token } },{}],453:[function(require,module,exports){ (function (Buffer){(function (){ 'use strict'; const object = {}; const hasOwnProperty = object.hasOwnProperty; const forOwn = (object, callback) => { for (const key in object) { if (hasOwnProperty.call(object, key)) { callback(key, object[key]); } } }; const extend = (destination, source) => { if (!source) { return destination; } forOwn(source, (key, value) => { destination[key] = value; }); return destination; }; const forEach = (array, callback) => { const length = array.length; let index = -1; while (++index < length) { callback(array[index]); } }; const toString = object.toString; const isArray = Array.isArray; const isBuffer = Buffer.isBuffer; const isObject = (value) => { // This is a very simple check, but itā€™s good enough for what we need. return toString.call(value) == '[object Object]'; }; const isString = (value) => { return typeof value == 'string' || toString.call(value) == '[object String]'; }; const isNumber = (value) => { return typeof value == 'number' || toString.call(value) == '[object Number]'; }; const isFunction = (value) => { return typeof value == 'function'; }; const isMap = (value) => { return toString.call(value) == '[object Map]'; }; const isSet = (value) => { return toString.call(value) == '[object Set]'; }; /*--------------------------------------------------------------------------*/ // https://mathiasbynens.be/notes/javascript-escapes#single const singleEscapes = { '"': '\\"', '\'': '\\\'', '\\': '\\\\', '\b': '\\b', '\f': '\\f', '\n': '\\n', '\r': '\\r', '\t': '\\t' // `\v` is omitted intentionally, because in IE < 9, '\v' == 'v'. // '\v': '\\x0B' }; const regexSingleEscape = /["'\\\b\f\n\r\t]/; const regexDigit = /[0-9]/; const regexWhitelist = /[ !#-&\(-\[\]-_a-~]/; const jsesc = (argument, options) => { const increaseIndentation = () => { oldIndent = indent; ++options.indentLevel; indent = options.indent.repeat(options.indentLevel) }; // Handle options const defaults = { 'escapeEverything': false, 'minimal': false, 'isScriptContext': false, 'quotes': 'single', 'wrap': false, 'es6': false, 'json': false, 'compact': true, 'lowercaseHex': false, 'numbers': 'decimal', 'indent': '\t', 'indentLevel': 0, '__inline1__': false, '__inline2__': false }; const json = options && options.json; if (json) { defaults.quotes = 'double'; defaults.wrap = true; } options = extend(defaults, options); if ( options.quotes != 'single' && options.quotes != 'double' && options.quotes != 'backtick' ) { options.quotes = 'single'; } const quote = options.quotes == 'double' ? '"' : (options.quotes == 'backtick' ? '`' : '\'' ); const compact = options.compact; const lowercaseHex = options.lowercaseHex; let indent = options.indent.repeat(options.indentLevel); let oldIndent = ''; const inline1 = options.__inline1__; const inline2 = options.__inline2__; const newLine = compact ? '' : '\n'; let result; let isEmpty = true; const useBinNumbers = options.numbers == 'binary'; const useOctNumbers = options.numbers == 'octal'; const useDecNumbers = options.numbers == 'decimal'; const useHexNumbers = options.numbers == 'hexadecimal'; if (json && argument && isFunction(argument.toJSON)) { argument = argument.toJSON(); } if (!isString(argument)) { if (isMap(argument)) { if (argument.size == 0) { return 'new Map()'; } if (!compact) { options.__inline1__ = true; options.__inline2__ = false; } return 'new Map(' + jsesc(Array.from(argument), options) + ')'; } if (isSet(argument)) { if (argument.size == 0) { return 'new Set()'; } return 'new Set(' + jsesc(Array.from(argument), options) + ')'; } if (isBuffer(argument)) { if (argument.length == 0) { return 'Buffer.from([])'; } return 'Buffer.from(' + jsesc(Array.from(argument), options) + ')'; } if (isArray(argument)) { result = []; options.wrap = true; if (inline1) { options.__inline1__ = false; options.__inline2__ = true; } if (!inline2) { increaseIndentation(); } forEach(argument, (value) => { isEmpty = false; if (inline2) { options.__inline2__ = false; } result.push( (compact || inline2 ? '' : indent) + jsesc(value, options) ); }); if (isEmpty) { return '[]'; } if (inline2) { return '[' + result.join(', ') + ']'; } return '[' + newLine + result.join(',' + newLine) + newLine + (compact ? '' : oldIndent) + ']'; } else if (isNumber(argument)) { if (json) { // Some number values (e.g. `Infinity`) cannot be represented in JSON. return JSON.stringify(argument); } if (useDecNumbers) { return String(argument); } if (useHexNumbers) { let hexadecimal = argument.toString(16); if (!lowercaseHex) { hexadecimal = hexadecimal.toUpperCase(); } return '0x' + hexadecimal; } if (useBinNumbers) { return '0b' + argument.toString(2); } if (useOctNumbers) { return '0o' + argument.toString(8); } } else if (!isObject(argument)) { if (json) { // For some values (e.g. `undefined`, `function` objects), // `JSON.stringify(value)` returns `undefined` (which isnā€™t valid // JSON) instead of `'null'`. return JSON.stringify(argument) || 'null'; } return String(argument); } else { // itā€™s an object result = []; options.wrap = true; increaseIndentation(); forOwn(argument, (key, value) => { isEmpty = false; result.push( (compact ? '' : indent) + jsesc(key, options) + ':' + (compact ? '' : ' ') + jsesc(value, options) ); }); if (isEmpty) { return '{}'; } return '{' + newLine + result.join(',' + newLine) + newLine + (compact ? '' : oldIndent) + '}'; } } const string = argument; // Loop over each code unit in the string and escape it let index = -1; const length = string.length; result = ''; while (++index < length) { const character = string.charAt(index); if (options.es6) { const first = string.charCodeAt(index); if ( // check if itā€™s the start of a surrogate pair first >= 0xD800 && first <= 0xDBFF && // high surrogate length > index + 1 // there is a next code unit ) { const second = string.charCodeAt(index + 1); if (second >= 0xDC00 && second <= 0xDFFF) { // low surrogate // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae const codePoint = (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000; let hexadecimal = codePoint.toString(16); if (!lowercaseHex) { hexadecimal = hexadecimal.toUpperCase(); } result += '\\u{' + hexadecimal + '}'; ++index; continue; } } } if (!options.escapeEverything) { if (regexWhitelist.test(character)) { // Itā€™s a printable ASCII character that is not `"`, `'` or `\`, // so donā€™t escape it. result += character; continue; } if (character == '"') { result += quote == character ? '\\"' : character; continue; } if (character == '`') { result += quote == character ? '\\`' : character; continue; } if (character == '\'') { result += quote == character ? '\\\'' : character; continue; } } if ( character == '\0' && !json && !regexDigit.test(string.charAt(index + 1)) ) { result += '\\0'; continue; } if (regexSingleEscape.test(character)) { // no need for a `hasOwnProperty` check here result += singleEscapes[character]; continue; } const charCode = character.charCodeAt(0); if (options.minimal && charCode != 0x2028 && charCode != 0x2029) { result += character; continue; } let hexadecimal = charCode.toString(16); if (!lowercaseHex) { hexadecimal = hexadecimal.toUpperCase(); } const longhand = hexadecimal.length > 2 || json; const escaped = '\\' + (longhand ? 'u' : 'x') + ('0000' + hexadecimal).slice(longhand ? -4 : -2); result += escaped; continue; } if (options.wrap) { result = quote + result + quote; } if (quote == '`') { result = result.replace(/\$\{/g, '\\\$\{'); } if (options.isScriptContext) { // https://mathiasbynens.be/notes/etago return result .replace(/<\/(script|style)/gi, '<\\/$1') .replace(/' is a single-line comment this.index += 3; var comment = this.skipSingleLineComment(3); if (this.trackComment) { comments = comments.concat(comment); } } else { break; } } else if (ch === 0x3C && !this.isModule) { if (this.source.slice(this.index + 1, this.index + 4) === '!--') { this.index += 4; // ` image/svg+xml regenerator-regenerator-transform-0.15.2/lib/000077500000000000000000000000001446323212200212055ustar00rootroot00000000000000regenerator-regenerator-transform-0.15.2/lib/util.js000066400000000000000000000041531446323212200225230ustar00rootroot00000000000000/** * Copyright (c) 2014-present, Facebook, Inc. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ var assert = require("assert"); var types = require("recast").types; var n = types.namedTypes; var b = types.builders; var hasOwn = Object.prototype.hasOwnProperty; exports.defaults = function(obj) { var len = arguments.length; var extension; for (var i = 1; i < len; ++i) { if ((extension = arguments[i])) { for (var key in extension) { if (hasOwn.call(extension, key) && !hasOwn.call(obj, key)) { obj[key] = extension[key]; } } } } return obj; }; exports.runtimeProperty = function(name) { return b.memberExpression( b.identifier("regeneratorRuntime"), b.identifier(name), false ); }; // Inspired by the isReference function from ast-util: // https://github.com/eventualbuddha/ast-util/blob/9bf91c5ce8/lib/index.js#L466-L506 exports.isReference = function(path, name) { var node = path.value; if (!n.Identifier.check(node)) { return false; } if (name && node.name !== name) { return false; } var parent = path.parent.value; switch (parent.type) { case "VariableDeclarator": return path.name === "init"; case "MemberExpression": return path.name === "object" || ( parent.computed && path.name === "property" ); case "FunctionExpression": case "FunctionDeclaration": case "ArrowFunctionExpression": if (path.name === "id") { return false; } if (path.parentPath.name === "params" && parent.params === path.parentPath.value && parent.params[path.name] === node) { return false; } return true; case "ClassDeclaration": case "ClassExpression": return path.name !== "id"; case "CatchClause": return path.name !== "param"; case "Property": case "MethodDefinition": return path.name !== "key"; case "ImportSpecifier": case "ImportDefaultSpecifier": case "ImportNamespaceSpecifier": case "LabeledStatement": return false; default: return true; } }; regenerator-regenerator-transform-0.15.2/lib/visit.js000066400000000000000000000031771446323212200227110ustar00rootroot00000000000000/** * Copyright (c) 2014-present, Facebook, Inc. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ var recast = require("recast"); var types = recast.types; var n = types.namedTypes; var util = require("./util.js"); exports.transform = function transform(node, options) { options = util.defaults(options || {}, { includeRuntime: false }); var result = require("@babel/core").transformFromAstSync(node, null, { presets: [require("regenerator-preset")], code: false, ast: true, // The deep-clone utility that Babel uses (based on V8's Serialization API // https://nodejs.org/api/v8.html#v8_serialization_api in Node.js) removes // the prototypes from the cloned node.loc.lines objects that Recast uses // internally, leading to _blockHoist test failures in tests.transform.js. // Also, unless cloning is somehow truly necessary, it should be faster to // skip this step. cloneInputAst: false }); node = result.ast; if (options.includeRuntime === true) { injectRuntime(n.File.check(node) ? node.program : node); } return node; }; function injectRuntime(program) { n.Program.assert(program); // Include the runtime by modifying the AST rather than by concatenating // strings. This technique will allow for more accurate source mapping. var runtimePath = require("..").runtime.path; var runtime = fs.readFileSync(runtimePath, "utf8"); var runtimeBody = recast.parse(runtime, { sourceFileName: runtimePath }).program.body; var body = program.body; body.unshift.apply(body, runtimeBody); } regenerator-regenerator-transform-0.15.2/main.js000066400000000000000000000041761446323212200217310ustar00rootroot00000000000000/** * Copyright (c) 2014-present, Facebook, Inc. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ var fs = require("fs"); var through = require("through"); var transform = require("./lib/visit").transform; var utils = require("./lib/util"); function exports(file, options) { var data = []; return through(write, end); function write(buf) { data.push(buf); } function end() { try { this.queue(compile(data.join(""), options).code); this.queue(null); } catch (e) { this.emit('error', e); } } } // To get a writable stream for use as a browserify transform, call // require("regenerator")(). module.exports = exports; // To include the runtime globally in the current node process, call // require("regenerator").runtime(). function runtime() { regeneratorRuntime = require("regenerator-runtime"); } exports.runtime = runtime; runtime.path = require("regenerator-runtime/path.js").path; var cachedRuntimeCode; function getRuntimeCode() { return cachedRuntimeCode || (cachedRuntimeCode = fs.readFileSync(runtime.path, "utf8")); } var transformOptions = { presets: [require("regenerator-preset")], parserOpts: { sourceType: "module", allowImportExportEverywhere: true, allowReturnOutsideFunction: true, allowSuperOutsideMethod: true, strictMode: false, plugins: ["*", "jsx", "flow"] } }; function compile(source, options) { var result; options = utils.defaults(options || {}, { includeRuntime: false }); var result = require("@babel/core").transformSync( source, transformOptions ); if (options.includeRuntime === true) { result.code = getRuntimeCode() + "\n" + result.code; } return result; } // Allow packages that depend on Regenerator to use the same copy of // ast-types, in case multiple versions are installed by NPM. exports.types = require("recast").types; // Transforms a string of source code, returning a { code, map? } result. exports.compile = compile; // To modify an AST directly, call require("regenerator").transform(ast). exports.transform = transform; regenerator-regenerator-transform-0.15.2/package-lock.json000066400000000000000000010355341446323212200236660ustar00rootroot00000000000000{ "name": "regenerator", "version": "0.14.10", "lockfileVersion": 2, "requires": true, "packages": { "": { "name": "regenerator", "version": "0.14.10", "license": "MIT", "dependencies": { "@babel/core": "^7.8.4", "@babel/runtime": "^7.8.4", "@babel/types": "^7.8.3", "commoner": "^0.10.8", "private": "^0.1.8", "recast": "^0.21.5", "regenerator-preset": "^0.14.1", "regenerator-runtime": "^0.13.11", "regenerator-transform": "^0.15.1", "through": "^2.3.8" }, "bin": { "regenerator": "bin/regenerator" }, "devDependencies": { "@babel/cli": "^7.8.4", "@babel/parser": "^7.8.4", "@babel/plugin-transform-modules-commonjs": "^7.8.3", "@babel/plugin-transform-parameters": "^7.8.4", "babel-check-duplicated-nodes": "^1.0.0", "browserify": "^17.0.0", "mocha": "^10.0.0", "promise": "^8.0.3", "semver": "^7.1.3", "uglify-js": "^3.14.0" }, "engines": { "node": ">= 0.6" } }, "node_modules/@ampproject/remapping": { "version": "2.2.0", "resolved": "https://registry.npmjs.org/@ampproject/remapping/-/remapping-2.2.0.tgz", "integrity": "sha512-qRmjj8nj9qmLTQXXmaR1cck3UXSRMPrbsLJAasZpF+t3riI71BXed5ebIOYwQntykeZuhjsdweEc9BxH5Jc26w==", "dependencies": { "@jridgewell/gen-mapping": "^0.1.0", "@jridgewell/trace-mapping": "^0.3.9" }, "engines": { "node": ">=6.0.0" } }, "node_modules/@ampproject/remapping/node_modules/@jridgewell/gen-mapping": { "version": "0.1.1", "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.1.1.tgz", "integrity": "sha512-sQXCasFk+U8lWYEe66WxRDOE9PjVz4vSM51fTu3Hw+ClTpUSQb718772vH3pyS5pShp6lvQM7SxgIDXXXmOX7w==", "dependencies": { "@jridgewell/set-array": "^1.0.0", "@jridgewell/sourcemap-codec": "^1.4.10" }, "engines": { "node": ">=6.0.0" } }, "node_modules/@babel/cli": { "version": "7.19.3", "resolved": "https://registry.npmjs.org/@babel/cli/-/cli-7.19.3.tgz", "integrity": "sha512-643/TybmaCAe101m2tSVHi9UKpETXP9c/Ff4mD2tAwkdP6esKIfaauZFc67vGEM6r9fekbEGid+sZhbEnSe3dg==", "dev": true, "dependencies": { "@jridgewell/trace-mapping": "^0.3.8", "commander": "^4.0.1", "convert-source-map": "^1.1.0", "fs-readdir-recursive": "^1.1.0", "glob": "^7.2.0", "make-dir": "^2.1.0", "slash": "^2.0.0" }, "bin": { "babel": "bin/babel.js", "babel-external-helpers": "bin/babel-external-helpers.js" }, "engines": { "node": ">=6.9.0" }, "optionalDependencies": { "@nicolo-ribaudo/chokidar-2": "2.1.8-no-fsevents.3", "chokidar": "^3.4.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/cli/node_modules/commander": { "version": "4.1.1", "resolved": "https://registry.npmjs.org/commander/-/commander-4.1.1.tgz", "integrity": "sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA==", "dev": true, "engines": { "node": ">= 6" } }, "node_modules/@babel/cli/node_modules/glob": { "version": "7.2.3", "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz", "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==", "dev": true, "dependencies": { "fs.realpath": "^1.0.0", "inflight": "^1.0.4", "inherits": "2", "minimatch": "^3.1.1", "once": "^1.3.0", "path-is-absolute": "^1.0.0" }, "engines": { "node": "*" }, "funding": { "url": "https://github.com/sponsors/isaacs" } }, "node_modules/@babel/code-frame": { "version": "7.18.6", "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.18.6.tgz", "integrity": "sha512-TDCmlK5eOvH+eH7cdAFlNXeVJqWIQ7gW9tY1GJIpUtFb6CmjVyq2VM3u71bOyR8CRihcCgMUYoDNyLXao3+70Q==", "dependencies": { "@babel/highlight": "^7.18.6" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/compat-data": { "version": "7.20.1", "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.20.1.tgz", "integrity": "sha512-EWZ4mE2diW3QALKvDMiXnbZpRvlj+nayZ112nK93SnhqOtpdsbVD4W+2tEoT3YNBAG9RBR0ISY758ZkOgsn6pQ==", "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/core": { "version": "7.20.2", "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.20.2.tgz", "integrity": "sha512-w7DbG8DtMrJcFOi4VrLm+8QM4az8Mo+PuLBKLp2zrYRCow8W/f9xiXm5sN53C8HksCyDQwCKha9JiDoIyPjT2g==", "dependencies": { "@ampproject/remapping": "^2.1.0", "@babel/code-frame": "^7.18.6", "@babel/generator": "^7.20.2", "@babel/helper-compilation-targets": "^7.20.0", "@babel/helper-module-transforms": "^7.20.2", "@babel/helpers": "^7.20.1", "@babel/parser": "^7.20.2", "@babel/template": "^7.18.10", "@babel/traverse": "^7.20.1", "@babel/types": "^7.20.2", "convert-source-map": "^1.7.0", "debug": "^4.1.0", "gensync": "^1.0.0-beta.2", "json5": "^2.2.1", "semver": "^6.3.0" }, "engines": { "node": ">=6.9.0" }, "funding": { "type": "opencollective", "url": "https://opencollective.com/babel" } }, "node_modules/@babel/core/node_modules/semver": { "version": "6.3.0", "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==", "bin": { "semver": "bin/semver.js" } }, "node_modules/@babel/generator": { "version": "7.20.3", "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.20.3.tgz", "integrity": "sha512-Wl5ilw2UD1+ZYprHVprxHZJCFeBWlzZYOovE4SDYLZnqCOD11j+0QzNeEWKLLTWM7nixrZEh7vNIyb76MyJg3A==", "dependencies": { "@babel/types": "^7.20.2", "@jridgewell/gen-mapping": "^0.3.2", "jsesc": "^2.5.1" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helper-annotate-as-pure": { "version": "7.18.6", "resolved": "https://registry.npmjs.org/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.18.6.tgz", "integrity": "sha512-duORpUiYrEpzKIop6iNbjnwKLAKnJ47csTyRACyEmWj0QdUrm5aqNJGHSSEQSUAvNW0ojX0dOmK9dZduvkfeXA==", "dependencies": { "@babel/types": "^7.18.6" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helper-compilation-targets": { "version": "7.20.0", "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.20.0.tgz", "integrity": "sha512-0jp//vDGp9e8hZzBc6N/KwA5ZK3Wsm/pfm4CrY7vzegkVxc65SgSn6wYOnwHe9Js9HRQ1YTCKLGPzDtaS3RoLQ==", "dependencies": { "@babel/compat-data": "^7.20.0", "@babel/helper-validator-option": "^7.18.6", "browserslist": "^4.21.3", "semver": "^6.3.0" }, "engines": { "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0" } }, "node_modules/@babel/helper-compilation-targets/node_modules/semver": { "version": "6.3.0", "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==", "bin": { "semver": "bin/semver.js" } }, "node_modules/@babel/helper-environment-visitor": { "version": "7.18.9", "resolved": "https://registry.npmjs.org/@babel/helper-environment-visitor/-/helper-environment-visitor-7.18.9.tgz", "integrity": "sha512-3r/aACDJ3fhQ/EVgFy0hpj8oHyHpQc+LPtJoY9SzTThAsStm4Ptegq92vqKoE3vD706ZVFWITnMnxucw+S9Ipg==", "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helper-function-name": { "version": "7.19.0", "resolved": "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.19.0.tgz", "integrity": "sha512-WAwHBINyrpqywkUH0nTnNgI5ina5TFn85HKS0pbPDfxFfhyR/aNQEn4hGi1P1JyT//I0t4OgXUlofzWILRvS5w==", "dependencies": { "@babel/template": "^7.18.10", "@babel/types": "^7.19.0" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helper-hoist-variables": { "version": "7.18.6", "resolved": "https://registry.npmjs.org/@babel/helper-hoist-variables/-/helper-hoist-variables-7.18.6.tgz", "integrity": "sha512-UlJQPkFqFULIcyW5sbzgbkxn2FKRgwWiRexcuaR8RNJRy8+LLveqPjwZV/bwrLZCN0eUHD/x8D0heK1ozuoo6Q==", "dependencies": { "@babel/types": "^7.18.6" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helper-member-expression-to-functions": { "version": "7.18.9", "resolved": "https://registry.npmjs.org/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.18.9.tgz", "integrity": "sha512-RxifAh2ZoVU67PyKIO4AMi1wTenGfMR/O/ae0CCRqwgBAt5v7xjdtRw7UoSbsreKrQn5t7r89eruK/9JjYHuDg==", "dependencies": { "@babel/types": "^7.18.9" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helper-module-imports": { "version": "7.18.6", "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.18.6.tgz", "integrity": "sha512-0NFvs3VkuSYbFi1x2Vd6tKrywq+z/cLeYC/RJNFrIX/30Bf5aiGYbtvGXolEktzJH8o5E5KJ3tT+nkxuuZFVlA==", "dependencies": { "@babel/types": "^7.18.6" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helper-module-transforms": { "version": "7.20.2", "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.20.2.tgz", "integrity": "sha512-zvBKyJXRbmK07XhMuujYoJ48B5yvvmM6+wcpv6Ivj4Yg6qO7NOZOSnvZN9CRl1zz1Z4cKf8YejmCMh8clOoOeA==", "dependencies": { "@babel/helper-environment-visitor": "^7.18.9", "@babel/helper-module-imports": "^7.18.6", "@babel/helper-simple-access": "^7.20.2", "@babel/helper-split-export-declaration": "^7.18.6", "@babel/helper-validator-identifier": "^7.19.1", "@babel/template": "^7.18.10", "@babel/traverse": "^7.20.1", "@babel/types": "^7.20.2" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helper-optimise-call-expression": { "version": "7.18.6", "resolved": "https://registry.npmjs.org/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.18.6.tgz", "integrity": "sha512-HP59oD9/fEHQkdcbgFCnbmgH5vIQTJbxh2yf+CdM89/glUNnuzr87Q8GIjGEnOktTROemO0Pe0iPAYbqZuOUiA==", "dependencies": { "@babel/types": "^7.18.6" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helper-plugin-utils": { "version": "7.22.5", "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.22.5.tgz", "integrity": "sha512-uLls06UVKgFG9QD4OeFYLEGteMIAa5kpTPcFL28yuCIIzsf6ZyKZMllKVOCZFhiZ5ptnwX4mtKdWCBE/uT4amg==", "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helper-replace-supers": { "version": "7.19.1", "resolved": "https://registry.npmjs.org/@babel/helper-replace-supers/-/helper-replace-supers-7.19.1.tgz", "integrity": "sha512-T7ahH7wV0Hfs46SFh5Jz3s0B6+o8g3c+7TMxu7xKfmHikg7EAZ3I2Qk9LFhjxXq8sL7UkP5JflezNwoZa8WvWw==", "dependencies": { "@babel/helper-environment-visitor": "^7.18.9", "@babel/helper-member-expression-to-functions": "^7.18.9", "@babel/helper-optimise-call-expression": "^7.18.6", "@babel/traverse": "^7.19.1", "@babel/types": "^7.19.0" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helper-simple-access": { "version": "7.20.2", "resolved": "https://registry.npmjs.org/@babel/helper-simple-access/-/helper-simple-access-7.20.2.tgz", "integrity": "sha512-+0woI/WPq59IrqDYbVGfshjT5Dmk/nnbdpcF8SnMhhXObpTq2KNBdLFRFrkVdbDOyUmHBCxzm5FHV1rACIkIbA==", "dependencies": { "@babel/types": "^7.20.2" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helper-split-export-declaration": { "version": "7.18.6", "resolved": "https://registry.npmjs.org/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.18.6.tgz", "integrity": "sha512-bde1etTx6ZyTmobl9LLMMQsaizFVZrquTEHOqKeQESMKo4PlObf+8+JA25ZsIpZhT/WEd39+vOdLXAFG/nELpA==", "dependencies": { "@babel/types": "^7.18.6" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helper-string-parser": { "version": "7.22.5", "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.22.5.tgz", "integrity": "sha512-mM4COjgZox8U+JcXQwPijIZLElkgEpO5rsERVDJTc2qfCDfERyob6k5WegS14SX18IIjv+XD+GrqNumY5JRCDw==", "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helper-validator-identifier": { "version": "7.22.5", "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.22.5.tgz", "integrity": "sha512-aJXu+6lErq8ltp+JhkJUfk1MTGyuA4v7f3pA+BJ5HLfNC6nAQ0Cpi9uOquUj8Hehg0aUiHzWQbOVJGao6ztBAQ==", "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helper-validator-option": { "version": "7.18.6", "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.18.6.tgz", "integrity": "sha512-XO7gESt5ouv/LRJdrVjkShckw6STTaB7l9BrpBaAHDeF5YZT+01PCwmR0SJHnkW6i8OwW/EVWRShfi4j2x+KQw==", "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helper-wrap-function": { "version": "7.19.0", "resolved": "https://registry.npmjs.org/@babel/helper-wrap-function/-/helper-wrap-function-7.19.0.tgz", "integrity": "sha512-txX8aN8CZyYGTwcLhlk87KRqncAzhh5TpQamZUa0/u3an36NtDpUP6bQgBCBcLeBs09R/OwQu3OjK0k/HwfNDg==", "dependencies": { "@babel/helper-function-name": "^7.19.0", "@babel/template": "^7.18.10", "@babel/traverse": "^7.19.0", "@babel/types": "^7.19.0" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helpers": { "version": "7.20.1", "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.20.1.tgz", "integrity": "sha512-J77mUVaDTUJFZ5BpP6mMn6OIl3rEWymk2ZxDBQJUG3P+PbmyMcF3bYWvz0ma69Af1oobDqT/iAsvzhB58xhQUg==", "dependencies": { "@babel/template": "^7.18.10", "@babel/traverse": "^7.20.1", "@babel/types": "^7.20.0" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/highlight": { "version": "7.18.6", "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.18.6.tgz", "integrity": "sha512-u7stbOuYjaPezCuLj29hNW1v64M2Md2qupEKP1fHc7WdOA3DgLh37suiSrZYY7haUB7iBeQZ9P1uiRF359do3g==", "dependencies": { "@babel/helper-validator-identifier": "^7.18.6", "chalk": "^2.0.0", "js-tokens": "^4.0.0" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/parser": { "version": "7.22.5", "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.22.5.tgz", "integrity": "sha512-DFZMC9LJUG9PLOclRC32G63UXwzqS2koQC8dkx+PLdmt1xSePYpbT/NbsrJy8Q/muXz7o/h/d4A7Fuyixm559Q==", "bin": { "parser": "bin/babel-parser.js" }, "engines": { "node": ">=6.0.0" } }, "node_modules/@babel/plugin-proposal-function-sent": { "version": "7.12.13", "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-function-sent/-/plugin-proposal-function-sent-7.12.13.tgz", "integrity": "sha512-nw5dSsy0+o+WBE372ooERkkZmFv2KJcujzTB5SdhQPKIElVA1pa7hclD23Vzl4VlcoJsC7KCCXpww2qAkbrrKA==", "dependencies": { "@babel/helper-plugin-utils": "^7.12.13", "@babel/helper-wrap-function": "^7.12.13", "@babel/plugin-syntax-function-sent": "^7.12.13" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-syntax-async-generators": { "version": "7.8.4", "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-async-generators/-/plugin-syntax-async-generators-7.8.4.tgz", "integrity": "sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw==", "dependencies": { "@babel/helper-plugin-utils": "^7.8.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-syntax-function-sent": { "version": "7.12.13", "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-function-sent/-/plugin-syntax-function-sent-7.12.13.tgz", "integrity": "sha512-Uv9lAv+/vX8hmvC2rTUvywJacR517eRqTKfLZrtLAoMGUjfQSZ0nPEFJWmfJs1H54zBaIj15ATfUnkheZnSK9w==", "dependencies": { "@babel/helper-plugin-utils": "^7.12.13" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-transform-arrow-functions": { "version": "7.18.6", "resolved": "https://registry.npmjs.org/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.18.6.tgz", "integrity": "sha512-9S9X9RUefzrsHZmKMbDXxweEH+YlE8JJEuat9FdvW9Qh1cw7W64jELCtWNkPBPX5En45uy28KGvA/AySqUh8CQ==", "dependencies": { "@babel/helper-plugin-utils": "^7.18.6" }, "engines": { "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-transform-block-scoping": { "version": "7.19.4", "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.19.4.tgz", "integrity": "sha512-934S2VLLlt2hRJwPf4MczaOr4hYF0z+VKPwqTNxyKX7NthTiPfhuKFWQZHXRM0vh/wo/VyXB3s4bZUNA08l+tQ==", "dependencies": { "@babel/helper-plugin-utils": "^7.19.0" }, "engines": { "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-transform-classes": { "version": "7.19.0", "resolved": "https://registry.npmjs.org/@babel/plugin-transform-classes/-/plugin-transform-classes-7.19.0.tgz", "integrity": "sha512-YfeEE9kCjqTS9IitkgfJuxjcEtLUHMqa8yUJ6zdz8vR7hKuo6mOy2C05P0F1tdMmDCeuyidKnlrw/iTppHcr2A==", "dependencies": { "@babel/helper-annotate-as-pure": "^7.18.6", "@babel/helper-compilation-targets": "^7.19.0", "@babel/helper-environment-visitor": "^7.18.9", "@babel/helper-function-name": "^7.19.0", "@babel/helper-optimise-call-expression": "^7.18.6", "@babel/helper-plugin-utils": "^7.19.0", "@babel/helper-replace-supers": "^7.18.9", "@babel/helper-split-export-declaration": "^7.18.6", "globals": "^11.1.0" }, "engines": { "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-transform-for-of": { "version": "7.18.8", "resolved": "https://registry.npmjs.org/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.18.8.tgz", "integrity": "sha512-yEfTRnjuskWYo0k1mHUqrVWaZwrdq8AYbfrpqULOJOaucGSp4mNMVps+YtA8byoevxS/urwU75vyhQIxcCgiBQ==", "dependencies": { "@babel/helper-plugin-utils": "^7.18.6" }, "engines": { "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-transform-modules-commonjs": { "version": "7.19.6", "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.19.6.tgz", "integrity": "sha512-8PIa1ym4XRTKuSsOUXqDG0YaOlEuTVvHMe5JCfgBMOtHvJKw/4NGovEGN33viISshG/rZNVrACiBmPQLvWN8xQ==", "dev": true, "dependencies": { "@babel/helper-module-transforms": "^7.19.6", "@babel/helper-plugin-utils": "^7.19.0", "@babel/helper-simple-access": "^7.19.4" }, "engines": { "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-transform-parameters": { "version": "7.22.5", "resolved": "https://registry.npmjs.org/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.22.5.tgz", "integrity": "sha512-AVkFUBurORBREOmHRKo06FjHYgjrabpdqRSwq6+C7R5iTCZOsM4QbcB27St0a4U6fffyAOqh3s/qEfybAhfivg==", "dev": true, "dependencies": { "@babel/helper-plugin-utils": "^7.22.5" }, "engines": { "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/runtime": { "version": "7.22.5", "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.22.5.tgz", "integrity": "sha512-ecjvYlnAaZ/KVneE/OdKYBYfgXV3Ptu6zQWmgEF7vwKhQnvVS6bjMD2XYgj+SNvQ1GfK/pjgokfPkC/2CO8CuA==", "dependencies": { "regenerator-runtime": "^0.13.11" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/template": { "version": "7.18.10", "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.18.10.tgz", "integrity": "sha512-TI+rCtooWHr3QJ27kJxfjutghu44DLnasDMwpDqCXVTal9RLp3RSYNh4NdBrRP2cQAoG9A8juOQl6P6oZG4JxA==", "dependencies": { "@babel/code-frame": "^7.18.6", "@babel/parser": "^7.18.10", "@babel/types": "^7.18.10" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/traverse": { "version": "7.20.1", "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.20.1.tgz", "integrity": "sha512-d3tN8fkVJwFLkHkBN479SOsw4DMZnz8cdbL/gvuDuzy3TS6Nfw80HuQqhw1pITbIruHyh7d1fMA47kWzmcUEGA==", "dependencies": { "@babel/code-frame": "^7.18.6", "@babel/generator": "^7.20.1", "@babel/helper-environment-visitor": "^7.18.9", "@babel/helper-function-name": "^7.19.0", "@babel/helper-hoist-variables": "^7.18.6", "@babel/helper-split-export-declaration": "^7.18.6", "@babel/parser": "^7.20.1", "@babel/types": "^7.20.0", "debug": "^4.1.0", "globals": "^11.1.0" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/types": { "version": "7.22.5", "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.22.5.tgz", "integrity": "sha512-zo3MIHGOkPOfoRXitsgHLjEXmlDaD/5KU1Uzuc9GNiZPhSqVxVRtxuPaSBZDsYZ9qV88AjtMtWW7ww98loJ9KA==", "dependencies": { "@babel/helper-string-parser": "^7.22.5", "@babel/helper-validator-identifier": "^7.22.5", "to-fast-properties": "^2.0.0" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@jridgewell/gen-mapping": { "version": "0.3.2", "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.2.tgz", "integrity": "sha512-mh65xKQAzI6iBcFzwv28KVWSmCkdRBWoOh+bYQGW3+6OZvbbN3TqMGo5hqYxQniRcH9F2VZIoJCm4pa3BPDK/A==", "dependencies": { "@jridgewell/set-array": "^1.0.1", "@jridgewell/sourcemap-codec": "^1.4.10", "@jridgewell/trace-mapping": "^0.3.9" }, "engines": { "node": ">=6.0.0" } }, "node_modules/@jridgewell/resolve-uri": { "version": "3.1.0", "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.0.tgz", "integrity": "sha512-F2msla3tad+Mfht5cJq7LSXcdudKTWCVYUgw6pLFOOHSTtZlj6SWNYAp+AhuqLmWdBO2X5hPrLcu8cVP8fy28w==", "engines": { "node": ">=6.0.0" } }, "node_modules/@jridgewell/set-array": { "version": "1.1.2", "resolved": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.1.2.tgz", "integrity": "sha512-xnkseuNADM0gt2bs+BvhO0p78Mk762YnZdsuzFV018NoG1Sj1SCQvpSqa7XUaTam5vAGasABV9qXASMKnFMwMw==", "engines": { "node": ">=6.0.0" } }, "node_modules/@jridgewell/sourcemap-codec": { "version": "1.4.14", "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.14.tgz", "integrity": "sha512-XPSJHWmi394fuUuzDnGz1wiKqWfo1yXecHQMRf2l6hztTO+nPru658AyDngaBe7isIxEkRsPR3FZh+s7iVa4Uw==" }, "node_modules/@jridgewell/trace-mapping": { "version": "0.3.16", "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.16.tgz", "integrity": "sha512-LCQ+NeThyJ4k1W2d+vIKdxuSt9R3pQSZ4P92m7EakaYuXcVWbHuT5bjNcqLd4Rdgi6xYWYDvBJZJLZSLanjDcA==", "dependencies": { "@jridgewell/resolve-uri": "3.1.0", "@jridgewell/sourcemap-codec": "1.4.14" } }, "node_modules/@nicolo-ribaudo/chokidar-2": { "version": "2.1.8-no-fsevents.3", "resolved": "https://registry.npmjs.org/@nicolo-ribaudo/chokidar-2/-/chokidar-2-2.1.8-no-fsevents.3.tgz", "integrity": "sha512-s88O1aVtXftvp5bCPB7WnmXc5IwOZZ7YPuwNPt+GtOOXpPvad1LfbmjYv+qII7zP6RU2QGnqve27dnLycEnyEQ==", "dev": true, "optional": true }, "node_modules/acorn": { "version": "5.7.4", "resolved": "https://registry.npmjs.org/acorn/-/acorn-5.7.4.tgz", "integrity": "sha512-1D++VG7BhrtvQpNbBzovKNc1FLGGEE/oGe7b9xJm/RFHMBeUaUGpluV9RLjZa47YFdPcDAenEYuq9pQPcMdLJg==", "bin": { "acorn": "bin/acorn" }, "engines": { "node": ">=0.4.0" } }, "node_modules/acorn-node": { "version": "1.8.2", "resolved": "https://registry.npmjs.org/acorn-node/-/acorn-node-1.8.2.tgz", "integrity": "sha512-8mt+fslDufLYntIoPAaIMUe/lrbrehIiwmR3t2k9LljIzoigEPF27eLk2hy8zSGzmR/ogr7zbRKINMo1u0yh5A==", "dev": true, "dependencies": { "acorn": "^7.0.0", "acorn-walk": "^7.0.0", "xtend": "^4.0.2" } }, "node_modules/acorn-node/node_modules/acorn": { "version": "7.4.1", "resolved": "https://registry.npmjs.org/acorn/-/acorn-7.4.1.tgz", "integrity": "sha512-nQyp0o1/mNdbTO1PO6kHkwSrmgZ0MT/jCCpNiwbUjGoRN4dlBhqJtoQuCnEOKzgTVwg0ZWiCoQy6SxMebQVh8A==", "dev": true, "bin": { "acorn": "bin/acorn" }, "engines": { "node": ">=0.4.0" } }, "node_modules/acorn-walk": { "version": "7.2.0", "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-7.2.0.tgz", "integrity": "sha512-OPdCF6GsMIP+Az+aWfAAOEt2/+iVDKE7oy6lJ098aoe59oAmK76qV6Gw60SbZ8jHuG2wH058GF4pLFbYamYrVA==", "dev": true, "engines": { "node": ">=0.4.0" } }, "node_modules/ansi-colors": { "version": "4.1.1", "resolved": "https://registry.npmjs.org/ansi-colors/-/ansi-colors-4.1.1.tgz", "integrity": "sha512-JoX0apGbHaUJBNl6yF+p6JAFYZ666/hhCGKN5t9QFjbJQKUU/g8MNbFDbvfrgKXvI1QpZplPOnwIo99lX/AAmA==", "dev": true, "engines": { "node": ">=6" } }, "node_modules/ansi-regex": { "version": "5.0.1", "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", "dev": true, "engines": { "node": ">=8" } }, "node_modules/ansi-styles": { "version": "3.2.1", "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", "dependencies": { "color-convert": "^1.9.0" }, "engines": { "node": ">=4" } }, "node_modules/argparse": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==", "dev": true }, "node_modules/array-filter": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/array-filter/-/array-filter-1.0.0.tgz", "integrity": "sha1-uveeYubvTCpMC4MSMtr/7CUfnYM=", "dev": true }, "node_modules/asap": { "version": "2.0.6", "resolved": "https://registry.npmjs.org/asap/-/asap-2.0.6.tgz", "integrity": "sha1-5QNHYR1+aQlDIIu9r+vLwvuGbUY=", "dev": true }, "node_modules/asn1.js": { "version": "5.4.1", "resolved": "https://registry.npmjs.org/asn1.js/-/asn1.js-5.4.1.tgz", "integrity": "sha512-+I//4cYPccV8LdmBLiX8CYvf9Sp3vQsrqu2QNXRcrbiWvcx/UdlFiqUJJzxRQxgsZmvhXhn4cSKeSmoFjVdupA==", "dev": true, "dependencies": { "bn.js": "^4.0.0", "inherits": "^2.0.1", "minimalistic-assert": "^1.0.0", "safer-buffer": "^2.1.0" } }, "node_modules/asn1.js/node_modules/bn.js": { "version": "4.12.0", "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz", "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==", "dev": true }, "node_modules/assert": { "version": "1.5.0", "resolved": "https://registry.npmjs.org/assert/-/assert-1.5.0.tgz", "integrity": "sha512-EDsgawzwoun2CZkCgtxJbv392v4nbk9XDD06zI+kQYoBM/3RBWLlEyJARDOmhAAosBjWACEkKL6S+lIZtcAubA==", "dev": true, "dependencies": { "object-assign": "^4.1.1", "util": "0.10.3" } }, "node_modules/assert/node_modules/inherits": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.1.tgz", "integrity": "sha1-sX0I0ya0Qj5Wjv9xn5GwscvfafE=", "dev": true }, "node_modules/assert/node_modules/util": { "version": "0.10.3", "resolved": "https://registry.npmjs.org/util/-/util-0.10.3.tgz", "integrity": "sha1-evsa/lCAUkZInj23/g7TeTNqwPk=", "dev": true, "dependencies": { "inherits": "2.0.1" } }, "node_modules/ast-types": { "version": "0.9.6", "resolved": "https://registry.npmjs.org/ast-types/-/ast-types-0.9.6.tgz", "integrity": "sha1-ECyenpAF0+fjgpvwxPok7oYu6bk=", "engines": { "node": ">= 0.8" } }, "node_modules/available-typed-arrays": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.2.tgz", "integrity": "sha512-XWX3OX8Onv97LMk/ftVyBibpGwY5a8SmuxZPzeOxqmuEqUCOM9ZE+uIaD1VNJ5QnvU2UQusvmKbuM1FR8QWGfQ==", "dev": true, "dependencies": { "array-filter": "^1.0.0" }, "engines": { "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/babel-check-duplicated-nodes": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/babel-check-duplicated-nodes/-/babel-check-duplicated-nodes-1.0.0.tgz", "integrity": "sha512-luUr6B28RzichAHdhCaGY6z53sm4+PAxzSedNlhZ9LtdW9txpR3G2Y5983iOnBosky88V08LeaUiDB/NR7vWvQ==", "dev": true }, "node_modules/balanced-match": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz", "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c=" }, "node_modules/base64-js": { "version": "1.5.1", "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz", "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==", "dev": true, "funding": [ { "type": "github", "url": "https://github.com/sponsors/feross" }, { "type": "patreon", "url": "https://www.patreon.com/feross" }, { "type": "consulting", "url": "https://feross.org/support" } ] }, "node_modules/bn.js": { "version": "5.2.0", "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-5.2.0.tgz", "integrity": "sha512-D7iWRBvnZE8ecXiLj/9wbxH7Tk79fAh8IHaTNq1RWRixsS02W+5qS+iE9yq6RYl0asXx5tw0bLhmT5pIfbSquw==", "dev": true }, "node_modules/brace-expansion": { "version": "1.1.11", "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", "dependencies": { "balanced-match": "^1.0.0", "concat-map": "0.0.1" } }, "node_modules/brorand": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/brorand/-/brorand-1.1.0.tgz", "integrity": "sha1-EsJe/kCkXjwyPrhnWgoM5XsiNx8=", "dev": true }, "node_modules/browser-pack": { "version": "6.1.0", "resolved": "https://registry.npmjs.org/browser-pack/-/browser-pack-6.1.0.tgz", "integrity": "sha512-erYug8XoqzU3IfcU8fUgyHqyOXqIE4tUTTQ+7mqUjQlvnXkOO6OlT9c/ZoJVHYoAaqGxr09CN53G7XIsO4KtWA==", "dev": true, "dependencies": { "combine-source-map": "~0.8.0", "defined": "^1.0.0", "JSONStream": "^1.0.3", "safe-buffer": "^5.1.1", "through2": "^2.0.0", "umd": "^3.0.0" }, "bin": { "browser-pack": "bin/cmd.js" } }, "node_modules/browser-resolve": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/browser-resolve/-/browser-resolve-2.0.0.tgz", "integrity": "sha512-7sWsQlYL2rGLy2IWm8WL8DCTJvYLc/qlOnsakDac87SOoCd16WLsaAMdCiAqsTNHIe+SXfaqyxyo6THoWqs8WQ==", "dev": true, "dependencies": { "resolve": "^1.17.0" } }, "node_modules/browser-stdout": { "version": "1.3.1", "resolved": "https://registry.npmjs.org/browser-stdout/-/browser-stdout-1.3.1.tgz", "integrity": "sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw==", "dev": true }, "node_modules/browserify": { "version": "17.0.0", "resolved": "https://registry.npmjs.org/browserify/-/browserify-17.0.0.tgz", "integrity": "sha512-SaHqzhku9v/j6XsQMRxPyBrSP3gnwmE27gLJYZgMT2GeK3J0+0toN+MnuNYDfHwVGQfLiMZ7KSNSIXHemy905w==", "dev": true, "dependencies": { "assert": "^1.4.0", "browser-pack": "^6.0.1", "browser-resolve": "^2.0.0", "browserify-zlib": "~0.2.0", "buffer": "~5.2.1", "cached-path-relative": "^1.0.0", "concat-stream": "^1.6.0", "console-browserify": "^1.1.0", "constants-browserify": "~1.0.0", "crypto-browserify": "^3.0.0", "defined": "^1.0.0", "deps-sort": "^2.0.1", "domain-browser": "^1.2.0", "duplexer2": "~0.1.2", "events": "^3.0.0", "glob": "^7.1.0", "has": "^1.0.0", "htmlescape": "^1.1.0", "https-browserify": "^1.0.0", "inherits": "~2.0.1", "insert-module-globals": "^7.2.1", "JSONStream": "^1.0.3", "labeled-stream-splicer": "^2.0.0", "mkdirp-classic": "^0.5.2", "module-deps": "^6.2.3", "os-browserify": "~0.3.0", "parents": "^1.0.1", "path-browserify": "^1.0.0", "process": "~0.11.0", "punycode": "^1.3.2", "querystring-es3": "~0.2.0", "read-only-stream": "^2.0.0", "readable-stream": "^2.0.2", "resolve": "^1.1.4", "shasum-object": "^1.0.0", "shell-quote": "^1.6.1", "stream-browserify": "^3.0.0", "stream-http": "^3.0.0", "string_decoder": "^1.1.1", "subarg": "^1.0.0", "syntax-error": "^1.1.1", "through2": "^2.0.0", "timers-browserify": "^1.0.1", "tty-browserify": "0.0.1", "url": "~0.11.0", "util": "~0.12.0", "vm-browserify": "^1.0.0", "xtend": "^4.0.0" }, "bin": { "browserify": "bin/cmd.js" }, "engines": { "node": ">= 0.8" } }, "node_modules/browserify-aes": { "version": "1.2.0", "resolved": "https://registry.npmjs.org/browserify-aes/-/browserify-aes-1.2.0.tgz", "integrity": "sha512-+7CHXqGuspUn/Sl5aO7Ea0xWGAtETPXNSAjHo48JfLdPWcMng33Xe4znFvQweqc/uzk5zSOI3H52CYnjCfb5hA==", "dev": true, "dependencies": { "buffer-xor": "^1.0.3", "cipher-base": "^1.0.0", "create-hash": "^1.1.0", "evp_bytestokey": "^1.0.3", "inherits": "^2.0.1", "safe-buffer": "^5.0.1" } }, "node_modules/browserify-cipher": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/browserify-cipher/-/browserify-cipher-1.0.1.tgz", "integrity": "sha512-sPhkz0ARKbf4rRQt2hTpAHqn47X3llLkUGn+xEJzLjwY8LRs2p0v7ljvI5EyoRO/mexrNunNECisZs+gw2zz1w==", "dev": true, "dependencies": { "browserify-aes": "^1.0.4", "browserify-des": "^1.0.0", "evp_bytestokey": "^1.0.0" } }, "node_modules/browserify-des": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/browserify-des/-/browserify-des-1.0.2.tgz", "integrity": "sha512-BioO1xf3hFwz4kc6iBhI3ieDFompMhrMlnDFC4/0/vd5MokpuAc3R+LYbwTA9A5Yc9pq9UYPqffKpW2ObuwX5A==", "dev": true, "dependencies": { "cipher-base": "^1.0.1", "des.js": "^1.0.0", "inherits": "^2.0.1", "safe-buffer": "^5.1.2" } }, "node_modules/browserify-rsa": { "version": "4.1.0", "resolved": "https://registry.npmjs.org/browserify-rsa/-/browserify-rsa-4.1.0.tgz", "integrity": "sha512-AdEER0Hkspgno2aR97SAf6vi0y0k8NuOpGnVH3O99rcA5Q6sh8QxcngtHuJ6uXwnfAXNM4Gn1Gb7/MV1+Ymbog==", "dev": true, "dependencies": { "bn.js": "^5.0.0", "randombytes": "^2.0.1" } }, "node_modules/browserify-sign": { "version": "4.2.1", "resolved": "https://registry.npmjs.org/browserify-sign/-/browserify-sign-4.2.1.tgz", "integrity": "sha512-/vrA5fguVAKKAVTNJjgSm1tRQDHUU6DbwO9IROu/0WAzC8PKhucDSh18J0RMvVeHAn5puMd+QHC2erPRNf8lmg==", "dev": true, "dependencies": { "bn.js": "^5.1.1", "browserify-rsa": "^4.0.1", "create-hash": "^1.2.0", "create-hmac": "^1.1.7", "elliptic": "^6.5.3", "inherits": "^2.0.4", "parse-asn1": "^5.1.5", "readable-stream": "^3.6.0", "safe-buffer": "^5.2.0" } }, "node_modules/browserify-sign/node_modules/readable-stream": { "version": "3.6.0", "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.0.tgz", "integrity": "sha512-BViHy7LKeTz4oNnkcLJ+lVSL6vpiFeX6/d3oSH8zCW7UxP2onchk+vTGB143xuFjHS3deTgkKoXXymXqymiIdA==", "dev": true, "dependencies": { "inherits": "^2.0.3", "string_decoder": "^1.1.1", "util-deprecate": "^1.0.1" }, "engines": { "node": ">= 6" } }, "node_modules/browserify-sign/node_modules/safe-buffer": { "version": "5.2.1", "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz", "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==", "dev": true, "funding": [ { "type": "github", "url": "https://github.com/sponsors/feross" }, { "type": "patreon", "url": "https://www.patreon.com/feross" }, { "type": "consulting", "url": "https://feross.org/support" } ] }, "node_modules/browserify-zlib": { "version": "0.2.0", "resolved": "https://registry.npmjs.org/browserify-zlib/-/browserify-zlib-0.2.0.tgz", "integrity": "sha512-Z942RysHXmJrhqk88FmKBVq/v5tqmSkDz7p54G/MGyjMnCFFnC79XWNbg+Vta8W6Wb2qtSZTSxIGkJrRpCFEiA==", "dev": true, "dependencies": { "pako": "~1.0.5" } }, "node_modules/browserify/node_modules/glob": { "version": "7.1.6", "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.6.tgz", "integrity": "sha512-LwaxwyZ72Lk7vZINtNNrywX0ZuLyStrdDtabefZKAY5ZGJhVtgdznluResxNmPitE0SAO+O26sWTHeKSI2wMBA==", "dev": true, "dependencies": { "fs.realpath": "^1.0.0", "inflight": "^1.0.4", "inherits": "2", "minimatch": "^3.0.4", "once": "^1.3.0", "path-is-absolute": "^1.0.0" }, "engines": { "node": "*" }, "funding": { "url": "https://github.com/sponsors/isaacs" } }, "node_modules/browserslist": { "version": "4.21.4", "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.21.4.tgz", "integrity": "sha512-CBHJJdDmgjl3daYjN5Cp5kbTf1mUhZoS+beLklHIvkOWscs83YAhLlF3Wsh/lciQYAcbBJgTOD44VtG31ZM4Hw==", "funding": [ { "type": "opencollective", "url": "https://opencollective.com/browserslist" }, { "type": "tidelift", "url": "https://tidelift.com/funding/github/npm/browserslist" } ], "dependencies": { "caniuse-lite": "^1.0.30001400", "electron-to-chromium": "^1.4.251", "node-releases": "^2.0.6", "update-browserslist-db": "^1.0.9" }, "bin": { "browserslist": "cli.js" }, "engines": { "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7" } }, "node_modules/buffer": { "version": "5.2.1", "resolved": "https://registry.npmjs.org/buffer/-/buffer-5.2.1.tgz", "integrity": "sha512-c+Ko0loDaFfuPWiL02ls9Xd3GO3cPVmUobQ6t3rXNUk304u6hGq+8N/kFi+QEIKhzK3uwolVhLzszmfLmMLnqg==", "dev": true, "dependencies": { "base64-js": "^1.0.2", "ieee754": "^1.1.4" } }, "node_modules/buffer-from": { "version": "1.1.1", "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.1.tgz", "integrity": "sha512-MQcXEUbCKtEo7bhqEs6560Hyd4XaovZlO/k9V3hjVUF/zwW7KBVdSK4gIt/bzwS9MbR5qob+F5jusZsb0YQK2A==", "dev": true }, "node_modules/buffer-xor": { "version": "1.0.3", "resolved": "https://registry.npmjs.org/buffer-xor/-/buffer-xor-1.0.3.tgz", "integrity": "sha1-JuYe0UIvtw3ULm42cp7VHYVf6Nk=", "dev": true }, "node_modules/builtin-status-codes": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/builtin-status-codes/-/builtin-status-codes-3.0.0.tgz", "integrity": "sha1-hZgoeOIbmOHGZCXgPQF0eI9Wnug=", "dev": true }, "node_modules/cached-path-relative": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/cached-path-relative/-/cached-path-relative-1.1.0.tgz", "integrity": "sha512-WF0LihfemtesFcJgO7xfOoOcnWzY/QHR4qeDqV44jPU3HTI54+LnfXK3SA27AVVGCdZFgjjFFaqUA9Jx7dMJZA==", "dev": true }, "node_modules/call-bind": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.2.tgz", "integrity": "sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==", "dev": true, "dependencies": { "function-bind": "^1.1.1", "get-intrinsic": "^1.0.2" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/camelcase": { "version": "6.3.0", "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz", "integrity": "sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==", "dev": true, "engines": { "node": ">=10" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/caniuse-lite": { "version": "1.0.30001419", "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001419.tgz", "integrity": "sha512-aFO1r+g6R7TW+PNQxKzjITwLOyDhVRLjW0LcwS/HCZGUUKTGNp9+IwLC4xyDSZBygVL/mxaFR3HIV6wEKQuSzw==", "funding": [ { "type": "opencollective", "url": "https://opencollective.com/browserslist" }, { "type": "tidelift", "url": "https://tidelift.com/funding/github/npm/caniuse-lite" } ] }, "node_modules/chalk": { "version": "2.4.2", "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", "dependencies": { "ansi-styles": "^3.2.1", "escape-string-regexp": "^1.0.5", "supports-color": "^5.3.0" }, "engines": { "node": ">=4" } }, "node_modules/chokidar": { "version": "3.5.1", "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.1.tgz", "integrity": "sha512-9+s+Od+W0VJJzawDma/gvBNQqkTiqYTWLuZoyAsivsI4AaWTCzHG06/TMjsf1cYe9Cb97UCEhjz7HvnPk2p/tw==", "dev": true, "optional": true, "dependencies": { "anymatch": "~3.1.1", "braces": "~3.0.2", "glob-parent": "~5.1.0", "is-binary-path": "~2.1.0", "is-glob": "~4.0.1", "normalize-path": "~3.0.0", "readdirp": "~3.5.0" }, "engines": { "node": ">= 8.10.0" }, "optionalDependencies": { "fsevents": "~2.3.1" } }, "node_modules/chokidar/node_modules/anymatch": { "version": "3.1.1", "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.1.tgz", "integrity": "sha512-mM8522psRCqzV+6LhomX5wgp25YVibjh8Wj23I5RPkPppSVSjyKD2A2mBJmWGa+KN7f2D6LNh9jkBCeyLktzjg==", "dev": true, "optional": true, "dependencies": { "normalize-path": "^3.0.0", "picomatch": "^2.0.4" }, "engines": { "node": ">= 8" } }, "node_modules/chokidar/node_modules/binary-extensions": { "version": "2.2.0", "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz", "integrity": "sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==", "dev": true, "optional": true, "engines": { "node": ">=8" } }, "node_modules/chokidar/node_modules/braces": { "version": "3.0.2", "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz", "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==", "dev": true, "optional": true, "dependencies": { "fill-range": "^7.0.1" }, "engines": { "node": ">=8" } }, "node_modules/chokidar/node_modules/fill-range": { "version": "7.0.1", "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz", "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==", "dev": true, "optional": true, "dependencies": { "to-regex-range": "^5.0.1" }, "engines": { "node": ">=8" } }, "node_modules/chokidar/node_modules/glob-parent": { "version": "5.1.2", "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", "dev": true, "optional": true, "dependencies": { "is-glob": "^4.0.1" }, "engines": { "node": ">= 6" } }, "node_modules/chokidar/node_modules/is-binary-path": { "version": "2.1.0", "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz", "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==", "dev": true, "optional": true, "dependencies": { "binary-extensions": "^2.0.0" }, "engines": { "node": ">=8" } }, "node_modules/chokidar/node_modules/is-number": { "version": "7.0.0", "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", "dev": true, "optional": true, "engines": { "node": ">=0.12.0" } }, "node_modules/chokidar/node_modules/readdirp": { "version": "3.5.0", "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.5.0.tgz", "integrity": "sha512-cMhu7c/8rdhkHXWsY+osBhfSy0JikwpHK/5+imo+LpeasTF8ouErHrlYkwT0++njiyuDvc7OFY5T3ukvZ8qmFQ==", "dev": true, "optional": true, "dependencies": { "picomatch": "^2.2.1" }, "engines": { "node": ">=8.10.0" } }, "node_modules/chokidar/node_modules/to-regex-range": { "version": "5.0.1", "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", "dev": true, "optional": true, "dependencies": { "is-number": "^7.0.0" }, "engines": { "node": ">=8.0" } }, "node_modules/cipher-base": { "version": "1.0.4", "resolved": "https://registry.npmjs.org/cipher-base/-/cipher-base-1.0.4.tgz", "integrity": "sha512-Kkht5ye6ZGmwv40uUDZztayT2ThLQGfnj/T71N/XzeZeo3nf8foyW7zGTsPYkEya3m5f3cAypH+qe7YOrM1U2Q==", "dev": true, "dependencies": { "inherits": "^2.0.1", "safe-buffer": "^5.0.1" } }, "node_modules/cliui": { "version": "7.0.4", "resolved": "https://registry.npmjs.org/cliui/-/cliui-7.0.4.tgz", "integrity": "sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==", "dev": true, "dependencies": { "string-width": "^4.2.0", "strip-ansi": "^6.0.0", "wrap-ansi": "^7.0.0" } }, "node_modules/color-convert": { "version": "1.9.3", "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz", "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==", "dependencies": { "color-name": "1.1.3" } }, "node_modules/color-name": { "version": "1.1.3", "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz", "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==" }, "node_modules/combine-source-map": { "version": "0.8.0", "resolved": "https://registry.npmjs.org/combine-source-map/-/combine-source-map-0.8.0.tgz", "integrity": "sha1-pY0N8ELBhvz4IqjoAV9UUNLXmos=", "dev": true, "dependencies": { "convert-source-map": "~1.1.0", "inline-source-map": "~0.6.0", "lodash.memoize": "~3.0.3", "source-map": "~0.5.3" } }, "node_modules/combine-source-map/node_modules/convert-source-map": { "version": "1.1.3", "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.1.3.tgz", "integrity": "sha1-SCnId+n+SbMWHzvzZziI4gRpmGA=", "dev": true }, "node_modules/commander": { "version": "2.20.3", "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz", "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==" }, "node_modules/commoner": { "version": "0.10.8", "resolved": "https://registry.npmjs.org/commoner/-/commoner-0.10.8.tgz", "integrity": "sha1-NPw2cs0kOT6LtH5wyqApOBH08sU=", "dependencies": { "commander": "^2.5.0", "detective": "^4.3.1", "glob": "^5.0.15", "graceful-fs": "^4.1.2", "iconv-lite": "^0.4.5", "mkdirp": "^0.5.0", "private": "^0.1.6", "q": "^1.1.2", "recast": "^0.11.17" }, "bin": { "commonize": "bin/commonize" }, "engines": { "node": ">= 0.8" } }, "node_modules/commoner/node_modules/recast": { "version": "0.11.23", "resolved": "https://registry.npmjs.org/recast/-/recast-0.11.23.tgz", "integrity": "sha1-RR/TAEqx5N+bTktmN2sqIZEkYtM=", "dependencies": { "ast-types": "0.9.6", "esprima": "~3.1.0", "private": "~0.1.5", "source-map": "~0.5.0" }, "engines": { "node": ">= 0.8" } }, "node_modules/concat-map": { "version": "0.0.1", "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=" }, "node_modules/concat-stream": { "version": "1.6.2", "resolved": "https://registry.npmjs.org/concat-stream/-/concat-stream-1.6.2.tgz", "integrity": "sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==", "dev": true, "engines": [ "node >= 0.8" ], "dependencies": { "buffer-from": "^1.0.0", "inherits": "^2.0.3", "readable-stream": "^2.2.2", "typedarray": "^0.0.6" } }, "node_modules/console-browserify": { "version": "1.2.0", "resolved": "https://registry.npmjs.org/console-browserify/-/console-browserify-1.2.0.tgz", "integrity": "sha512-ZMkYO/LkF17QvCPqM0gxw8yUzigAOZOSWSHg91FH6orS7vcEj5dVZTidN2fQ14yBSdg97RqhSNwLUXInd52OTA==", "dev": true }, "node_modules/constants-browserify": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/constants-browserify/-/constants-browserify-1.0.0.tgz", "integrity": "sha1-wguW2MYXdIqvHBYCF2DNJ/y4y3U=", "dev": true }, "node_modules/convert-source-map": { "version": "1.7.0", "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.7.0.tgz", "integrity": "sha512-4FJkXzKXEDB1snCFZlLP4gpC3JILicCpGbzG9f9G7tGqGCzETQ2hWPrcinA9oU4wtf2biUaEH5065UnMeR33oA==", "dependencies": { "safe-buffer": "~5.1.1" } }, "node_modules/core-util-is": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz", "integrity": "sha1-tf1UIgqivFq1eqtxQMlAdUUDwac=", "dev": true }, "node_modules/create-ecdh": { "version": "4.0.4", "resolved": "https://registry.npmjs.org/create-ecdh/-/create-ecdh-4.0.4.tgz", "integrity": "sha512-mf+TCx8wWc9VpuxfP2ht0iSISLZnt0JgWlrOKZiNqyUZWnjIaCIVNQArMHnCZKfEYRg6IM7A+NeJoN8gf/Ws0A==", "dev": true, "dependencies": { "bn.js": "^4.1.0", "elliptic": "^6.5.3" } }, "node_modules/create-ecdh/node_modules/bn.js": { "version": "4.12.0", "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz", "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==", "dev": true }, "node_modules/create-hash": { "version": "1.2.0", "resolved": "https://registry.npmjs.org/create-hash/-/create-hash-1.2.0.tgz", "integrity": "sha512-z00bCGNHDG8mHAkP7CtT1qVu+bFQUPjYq/4Iv3C3kWjTFV10zIjfSoeqXo9Asws8gwSHDGj/hl2u4OGIjapeCg==", "dev": true, "dependencies": { "cipher-base": "^1.0.1", "inherits": "^2.0.1", "md5.js": "^1.3.4", "ripemd160": "^2.0.1", "sha.js": "^2.4.0" } }, "node_modules/create-hmac": { "version": "1.1.7", "resolved": "https://registry.npmjs.org/create-hmac/-/create-hmac-1.1.7.tgz", "integrity": "sha512-MJG9liiZ+ogc4TzUwuvbER1JRdgvUFSB5+VR/g5h82fGaIRWMWddtKBHi7/sVhfjQZ6SehlyhvQYrcYkaUIpLg==", "dev": true, "dependencies": { "cipher-base": "^1.0.3", "create-hash": "^1.1.0", "inherits": "^2.0.1", "ripemd160": "^2.0.0", "safe-buffer": "^5.0.1", "sha.js": "^2.4.8" } }, "node_modules/crypto-browserify": { "version": "3.12.0", "resolved": "https://registry.npmjs.org/crypto-browserify/-/crypto-browserify-3.12.0.tgz", "integrity": "sha512-fz4spIh+znjO2VjL+IdhEpRJ3YN6sMzITSBijk6FK2UvTqruSQW+/cCZTSNsMiZNvUeq0CqurF+dAbyiGOY6Wg==", "dev": true, "dependencies": { "browserify-cipher": "^1.0.0", "browserify-sign": "^4.0.0", "create-ecdh": "^4.0.0", "create-hash": "^1.1.0", "create-hmac": "^1.1.0", "diffie-hellman": "^5.0.0", "inherits": "^2.0.1", "pbkdf2": "^3.0.3", "public-encrypt": "^4.0.0", "randombytes": "^2.0.0", "randomfill": "^1.0.3" }, "engines": { "node": "*" } }, "node_modules/dash-ast": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/dash-ast/-/dash-ast-1.0.0.tgz", "integrity": "sha512-Vy4dx7gquTeMcQR/hDkYLGUnwVil6vk4FOOct+djUnHOUWt+zJPJAaRIXaAFkPXtJjvlY7o3rfRu0/3hpnwoUA==", "dev": true }, "node_modules/debug": { "version": "4.1.1", "resolved": "https://registry.npmjs.org/debug/-/debug-4.1.1.tgz", "integrity": "sha512-pYAIzeRo8J6KPEaJ0VWOh5Pzkbw/RetuzehGM7QRRX5he4fPHx2rdKMB256ehJCkX+XRQm16eZLqLNS8RSZXZw==", "deprecated": "Debug versions >=3.2.0 <3.2.7 || >=4 <4.3.1 have a low-severity ReDos regression when used in a Node.js environment. It is recommended you upgrade to 3.2.7 or 4.3.1. (https://github.com/visionmedia/debug/issues/797)", "dependencies": { "ms": "^2.1.1" } }, "node_modules/decamelize": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-4.0.0.tgz", "integrity": "sha512-9iE1PgSik9HeIIw2JO94IidnE3eBoQrFJ3w7sFuzSX4DpmZ3v5sZpUiV5Swcf6mQEF+Y0ru8Neo+p+nyh2J+hQ==", "dev": true, "engines": { "node": ">=10" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/define-properties": { "version": "1.1.3", "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.1.3.tgz", "integrity": "sha512-3MqfYKj2lLzdMSf8ZIZE/V+Zuy+BgD6f164e8K2w7dgnpKArBDerGYpM46IYYcjnkdPNMjPk9A6VFB8+3SKlXQ==", "dev": true, "dependencies": { "object-keys": "^1.0.12" }, "engines": { "node": ">= 0.4" } }, "node_modules/defined": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/defined/-/defined-1.0.0.tgz", "integrity": "sha1-yY2bzvdWdBiOEQlpFRGZ45sfppM=" }, "node_modules/deps-sort": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/deps-sort/-/deps-sort-2.0.1.tgz", "integrity": "sha512-1orqXQr5po+3KI6kQb9A4jnXT1PBwggGl2d7Sq2xsnOeI9GPcE/tGcF9UiSZtZBM7MukY4cAh7MemS6tZYipfw==", "dev": true, "dependencies": { "JSONStream": "^1.0.3", "shasum-object": "^1.0.0", "subarg": "^1.0.0", "through2": "^2.0.0" }, "bin": { "deps-sort": "bin/cmd.js" } }, "node_modules/des.js": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/des.js/-/des.js-1.0.1.tgz", "integrity": "sha512-Q0I4pfFrv2VPd34/vfLrFOoRmlYj3OV50i7fskps1jZWK1kApMWWT9G6RRUeYedLcBDIhnSDaUvJMb3AhUlaEA==", "dev": true, "dependencies": { "inherits": "^2.0.1", "minimalistic-assert": "^1.0.0" } }, "node_modules/detective": { "version": "4.7.1", "resolved": "https://registry.npmjs.org/detective/-/detective-4.7.1.tgz", "integrity": "sha512-H6PmeeUcZloWtdt4DAkFyzFL94arpHr3NOwwmVILFiy+9Qd4JTxxXrzfyGk/lmct2qVGBwTSwSXagqu2BxmWig==", "dependencies": { "acorn": "^5.2.1", "defined": "^1.0.0" } }, "node_modules/diff": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/diff/-/diff-5.0.0.tgz", "integrity": "sha512-/VTCrvm5Z0JGty/BWHljh+BAiw3IK+2j87NGMu8Nwc/f48WoDAC395uomO9ZD117ZOBaHmkX1oyLvkVM/aIT3w==", "dev": true, "engines": { "node": ">=0.3.1" } }, "node_modules/diffie-hellman": { "version": "5.0.3", "resolved": "https://registry.npmjs.org/diffie-hellman/-/diffie-hellman-5.0.3.tgz", "integrity": "sha512-kqag/Nl+f3GwyK25fhUMYj81BUOrZ9IuJsjIcDE5icNM9FJHAVm3VcUDxdLPoQtTuUylWm6ZIknYJwwaPxsUzg==", "dev": true, "dependencies": { "bn.js": "^4.1.0", "miller-rabin": "^4.0.0", "randombytes": "^2.0.0" } }, "node_modules/diffie-hellman/node_modules/bn.js": { "version": "4.12.0", "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz", "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==", "dev": true }, "node_modules/domain-browser": { "version": "1.2.0", "resolved": "https://registry.npmjs.org/domain-browser/-/domain-browser-1.2.0.tgz", "integrity": "sha512-jnjyiM6eRyZl2H+W8Q/zLMA481hzi0eszAaBUzIVnmYVDBbnLxVNnfu1HgEBvCbL+71FrxMl3E6lpKH7Ge3OXA==", "dev": true, "engines": { "node": ">=0.4", "npm": ">=1.2" } }, "node_modules/duplexer2": { "version": "0.1.4", "resolved": "https://registry.npmjs.org/duplexer2/-/duplexer2-0.1.4.tgz", "integrity": "sha1-ixLauHjA1p4+eJEFFmKjL8a93ME=", "dev": true, "dependencies": { "readable-stream": "^2.0.2" } }, "node_modules/electron-to-chromium": { "version": "1.4.281", "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.4.281.tgz", "integrity": "sha512-yer0w5wCYdFoZytfmbNhwiGI/3cW06+RV7E23ln4490DVMxs7PvYpbsrSmAiBn/V6gode8wvJlST2YfWgvzWIg==" }, "node_modules/elliptic": { "version": "6.5.4", "resolved": "https://registry.npmjs.org/elliptic/-/elliptic-6.5.4.tgz", "integrity": "sha512-iLhC6ULemrljPZb+QutR5TQGB+pdW6KGD5RSegS+8sorOZT+rdQFbsQFJgvN3eRqNALqJer4oQ16YvJHlU8hzQ==", "dev": true, "dependencies": { "bn.js": "^4.11.9", "brorand": "^1.1.0", "hash.js": "^1.0.0", "hmac-drbg": "^1.0.1", "inherits": "^2.0.4", "minimalistic-assert": "^1.0.1", "minimalistic-crypto-utils": "^1.0.1" } }, "node_modules/elliptic/node_modules/bn.js": { "version": "4.12.0", "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz", "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==", "dev": true }, "node_modules/emoji-regex": { "version": "8.0.0", "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", "dev": true }, "node_modules/es-abstract": { "version": "1.18.0", "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.18.0.tgz", "integrity": "sha512-LJzK7MrQa8TS0ja2w3YNLzUgJCGPdPOV1yVvezjNnS89D+VR08+Szt2mz3YB2Dck/+w5tfIq/RoUAFqJJGM2yw==", "dev": true, "dependencies": { "call-bind": "^1.0.2", "es-to-primitive": "^1.2.1", "function-bind": "^1.1.1", "get-intrinsic": "^1.1.1", "has": "^1.0.3", "has-symbols": "^1.0.2", "is-callable": "^1.2.3", "is-negative-zero": "^2.0.1", "is-regex": "^1.1.2", "is-string": "^1.0.5", "object-inspect": "^1.9.0", "object-keys": "^1.1.1", "object.assign": "^4.1.2", "string.prototype.trimend": "^1.0.4", "string.prototype.trimstart": "^1.0.4", "unbox-primitive": "^1.0.0" }, "engines": { "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/es-abstract/node_modules/has-symbols": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.2.tgz", "integrity": "sha512-chXa79rL/UC2KlX17jo3vRGz0azaWEx5tGqZg5pO3NUyEJVB17dMruQlzCCOfUvElghKcm5194+BCRvi2Rv/Gw==", "dev": true, "engines": { "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/es-abstract/node_modules/object.assign": { "version": "4.1.2", "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.2.tgz", "integrity": "sha512-ixT2L5THXsApyiUPYKmW+2EHpXXe5Ii3M+f4e+aJFAHao5amFRW6J0OO6c/LU8Be47utCx2GL89hxGB6XSmKuQ==", "dev": true, "dependencies": { "call-bind": "^1.0.0", "define-properties": "^1.1.3", "has-symbols": "^1.0.1", "object-keys": "^1.1.1" }, "engines": { "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/es-to-primitive": { "version": "1.2.1", "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.2.1.tgz", "integrity": "sha512-QCOllgZJtaUo9miYBcLChTUaHNjJF3PYs1VidD7AwiEj1kYxKeQTctLAezAOH5ZKRH0g2IgPn6KwB4IT8iRpvA==", "dev": true, "dependencies": { "is-callable": "^1.1.4", "is-date-object": "^1.0.1", "is-symbol": "^1.0.2" }, "engines": { "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/escalade": { "version": "3.1.1", "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz", "integrity": "sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==", "engines": { "node": ">=6" } }, "node_modules/escape-string-regexp": { "version": "1.0.5", "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==", "engines": { "node": ">=0.8.0" } }, "node_modules/esprima": { "version": "3.1.3", "resolved": "https://registry.npmjs.org/esprima/-/esprima-3.1.3.tgz", "integrity": "sha1-/cpRzuYTOJXjyI1TXOSdv/YqRjM=", "bin": { "esparse": "bin/esparse.js", "esvalidate": "bin/esvalidate.js" }, "engines": { "node": ">=4" } }, "node_modules/events": { "version": "3.3.0", "resolved": "https://registry.npmjs.org/events/-/events-3.3.0.tgz", "integrity": "sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==", "dev": true, "engines": { "node": ">=0.8.x" } }, "node_modules/evp_bytestokey": { "version": "1.0.3", "resolved": "https://registry.npmjs.org/evp_bytestokey/-/evp_bytestokey-1.0.3.tgz", "integrity": "sha512-/f2Go4TognH/KvCISP7OUsHn85hT9nUkxxA9BEWxFn+Oj9o8ZNLm/40hdlgSLyuOimsrTKLUMEorQexp/aPQeA==", "dev": true, "dependencies": { "md5.js": "^1.3.4", "safe-buffer": "^5.1.1" } }, "node_modules/fast-safe-stringify": { "version": "2.0.7", "resolved": "https://registry.npmjs.org/fast-safe-stringify/-/fast-safe-stringify-2.0.7.tgz", "integrity": "sha512-Utm6CdzT+6xsDk2m8S6uL8VHxNwI6Jub+e9NYTcAms28T84pTa25GJQV9j0CY0N1rM8hK4x6grpF2BQf+2qwVA==", "dev": true }, "node_modules/find-up": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", "dev": true, "dependencies": { "locate-path": "^6.0.0", "path-exists": "^4.0.0" }, "engines": { "node": ">=10" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/flat": { "version": "5.0.2", "resolved": "https://registry.npmjs.org/flat/-/flat-5.0.2.tgz", "integrity": "sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==", "dev": true, "bin": { "flat": "cli.js" } }, "node_modules/foreach": { "version": "2.0.5", "resolved": "https://registry.npmjs.org/foreach/-/foreach-2.0.5.tgz", "integrity": "sha1-C+4AUBiusmDQo6865ljdATbsG5k=", "dev": true }, "node_modules/fs-readdir-recursive": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/fs-readdir-recursive/-/fs-readdir-recursive-1.1.0.tgz", "integrity": "sha512-GNanXlVr2pf02+sPN40XN8HG+ePaNcvM0q5mZBd668Obwb0yD5GiUbZOFgwn8kGMY6I3mdyDJzieUy3PTYyTRA==", "dev": true }, "node_modules/fs.realpath": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=", "dev": true }, "node_modules/fsevents": { "version": "2.3.2", "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz", "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==", "dev": true, "hasInstallScript": true, "optional": true, "os": [ "darwin" ], "engines": { "node": "^8.16.0 || ^10.6.0 || >=11.0.0" } }, "node_modules/function-bind": { "version": "1.1.1", "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz", "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==", "dev": true }, "node_modules/gensync": { "version": "1.0.0-beta.2", "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz", "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==", "engines": { "node": ">=6.9.0" } }, "node_modules/get-assigned-identifiers": { "version": "1.2.0", "resolved": "https://registry.npmjs.org/get-assigned-identifiers/-/get-assigned-identifiers-1.2.0.tgz", "integrity": "sha512-mBBwmeGTrxEMO4pMaaf/uUEFHnYtwr8FTe8Y/mer4rcV/bye0qGm6pw1bGZFGStxC5O76c5ZAVBGnqHmOaJpdQ==", "dev": true }, "node_modules/get-caller-file": { "version": "2.0.5", "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz", "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==", "dev": true, "engines": { "node": "6.* || 8.* || >= 10.*" } }, "node_modules/get-intrinsic": { "version": "1.1.1", "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.1.1.tgz", "integrity": "sha512-kWZrnVM42QCiEA2Ig1bG8zjoIMOgxWwYCEeNdwY6Tv/cOSeGpcoX4pXHfKUxNKVoArnrEr2e9srnAxxGIraS9Q==", "dev": true, "dependencies": { "function-bind": "^1.1.1", "has": "^1.0.3", "has-symbols": "^1.0.1" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/glob": { "version": "5.0.15", "resolved": "https://registry.npmjs.org/glob/-/glob-5.0.15.tgz", "integrity": "sha1-G8k2ueAvSmA/zCIuz3Yz0wuLk7E=", "dependencies": { "inflight": "^1.0.4", "inherits": "2", "minimatch": "2 || 3", "once": "^1.3.0", "path-is-absolute": "^1.0.0" }, "engines": { "node": "*" } }, "node_modules/glob-parent": { "version": "5.1.2", "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", "dev": true, "dependencies": { "is-glob": "^4.0.1" }, "engines": { "node": ">= 6" } }, "node_modules/globals": { "version": "11.12.0", "resolved": "https://registry.npmjs.org/globals/-/globals-11.12.0.tgz", "integrity": "sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==", "engines": { "node": ">=4" } }, "node_modules/graceful-fs": { "version": "4.2.3", "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.3.tgz", "integrity": "sha512-a30VEBm4PEdx1dRB7MFK7BejejvCvBronbLjht+sHuGYj8PHs7M/5Z+rt5lw551vZ7yfTCj4Vuyy3mSJytDWRQ==" }, "node_modules/has": { "version": "1.0.3", "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz", "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==", "dev": true, "dependencies": { "function-bind": "^1.1.1" }, "engines": { "node": ">= 0.4.0" } }, "node_modules/has-bigints": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/has-bigints/-/has-bigints-1.0.1.tgz", "integrity": "sha512-LSBS2LjbNBTf6287JEbEzvJgftkF5qFkmCo9hDRpAzKhUOlJ+hx8dd4USs00SgsUNwc4617J9ki5YtEClM2ffA==", "dev": true, "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/has-flag": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==", "engines": { "node": ">=4" } }, "node_modules/has-symbols": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.1.tgz", "integrity": "sha512-PLcsoqu++dmEIZB+6totNFKq/7Do+Z0u4oT0zKOJNl3lYK6vGwwu2hjHs+68OEZbTjiUE9bgOABXbP/GvrS0Kg==", "dev": true, "engines": { "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/hash-base": { "version": "3.1.0", "resolved": "https://registry.npmjs.org/hash-base/-/hash-base-3.1.0.tgz", "integrity": "sha512-1nmYp/rhMDiE7AYkDw+lLwlAzz0AntGIe51F3RfFfEqyQ3feY2eI/NcwC6umIQVOASPMsWJLJScWKSSvzL9IVA==", "dev": true, "dependencies": { "inherits": "^2.0.4", "readable-stream": "^3.6.0", "safe-buffer": "^5.2.0" }, "engines": { "node": ">=4" } }, "node_modules/hash-base/node_modules/readable-stream": { "version": "3.6.0", "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.0.tgz", "integrity": "sha512-BViHy7LKeTz4oNnkcLJ+lVSL6vpiFeX6/d3oSH8zCW7UxP2onchk+vTGB143xuFjHS3deTgkKoXXymXqymiIdA==", "dev": true, "dependencies": { "inherits": "^2.0.3", "string_decoder": "^1.1.1", "util-deprecate": "^1.0.1" }, "engines": { "node": ">= 6" } }, "node_modules/hash-base/node_modules/safe-buffer": { "version": "5.2.1", "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz", "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==", "dev": true, "funding": [ { "type": "github", "url": "https://github.com/sponsors/feross" }, { "type": "patreon", "url": "https://www.patreon.com/feross" }, { "type": "consulting", "url": "https://feross.org/support" } ] }, "node_modules/hash.js": { "version": "1.1.7", "resolved": "https://registry.npmjs.org/hash.js/-/hash.js-1.1.7.tgz", "integrity": "sha512-taOaskGt4z4SOANNseOviYDvjEJinIkRgmp7LbKP2YTTmVxWBl87s/uzK9r+44BclBSp2X7K1hqeNfz9JbBeXA==", "dev": true, "dependencies": { "inherits": "^2.0.3", "minimalistic-assert": "^1.0.1" } }, "node_modules/he": { "version": "1.2.0", "resolved": "https://registry.npmjs.org/he/-/he-1.2.0.tgz", "integrity": "sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==", "dev": true, "bin": { "he": "bin/he" } }, "node_modules/hmac-drbg": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/hmac-drbg/-/hmac-drbg-1.0.1.tgz", "integrity": "sha1-0nRXAQJabHdabFRXk+1QL8DGSaE=", "dev": true, "dependencies": { "hash.js": "^1.0.3", "minimalistic-assert": "^1.0.0", "minimalistic-crypto-utils": "^1.0.1" } }, "node_modules/htmlescape": { "version": "1.1.1", "resolved": "https://registry.npmjs.org/htmlescape/-/htmlescape-1.1.1.tgz", "integrity": "sha1-OgPtwiFLyjtmQko+eVk0lQnLA1E=", "dev": true, "engines": { "node": ">=0.10" } }, "node_modules/https-browserify": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/https-browserify/-/https-browserify-1.0.0.tgz", "integrity": "sha1-7AbBDgo0wPL68Zn3/X/Hj//QPHM=", "dev": true }, "node_modules/iconv-lite": { "version": "0.4.24", "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz", "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==", "dependencies": { "safer-buffer": ">= 2.1.2 < 3" }, "engines": { "node": ">=0.10.0" } }, "node_modules/ieee754": { "version": "1.2.1", "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz", "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==", "dev": true, "funding": [ { "type": "github", "url": "https://github.com/sponsors/feross" }, { "type": "patreon", "url": "https://www.patreon.com/feross" }, { "type": "consulting", "url": "https://feross.org/support" } ] }, "node_modules/inflight": { "version": "1.0.6", "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=", "dependencies": { "once": "^1.3.0", "wrappy": "1" } }, "node_modules/inherits": { "version": "2.0.4", "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==" }, "node_modules/inline-source-map": { "version": "0.6.2", "resolved": "https://registry.npmjs.org/inline-source-map/-/inline-source-map-0.6.2.tgz", "integrity": "sha1-+Tk0ccGKedFyT4Y/o4tYY3Ct4qU=", "dev": true, "dependencies": { "source-map": "~0.5.3" } }, "node_modules/insert-module-globals": { "version": "7.2.1", "resolved": "https://registry.npmjs.org/insert-module-globals/-/insert-module-globals-7.2.1.tgz", "integrity": "sha512-ufS5Qq9RZN+Bu899eA9QCAYThY+gGW7oRkmb0vC93Vlyu/CFGcH0OYPEjVkDXA5FEbTt1+VWzdoOD3Ny9N+8tg==", "dev": true, "dependencies": { "acorn-node": "^1.5.2", "combine-source-map": "^0.8.0", "concat-stream": "^1.6.1", "is-buffer": "^1.1.0", "JSONStream": "^1.0.3", "path-is-absolute": "^1.0.1", "process": "~0.11.0", "through2": "^2.0.0", "undeclared-identifiers": "^1.1.2", "xtend": "^4.0.0" }, "bin": { "insert-module-globals": "bin/cmd.js" } }, "node_modules/is-arguments": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/is-arguments/-/is-arguments-1.1.0.tgz", "integrity": "sha512-1Ij4lOMPl/xB5kBDn7I+b2ttPMKa8szhEIrXDuXQD/oe3HJLTLhqhgGspwgyGd6MOywBUqVvYicF72lkgDnIHg==", "dev": true, "dependencies": { "call-bind": "^1.0.0" }, "engines": { "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/is-bigint": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/is-bigint/-/is-bigint-1.0.1.tgz", "integrity": "sha512-J0ELF4yHFxHy0cmSxZuheDOz2luOdVvqjwmEcj8H/L1JHeuEDSDbeRP+Dk9kFVk5RTFzbucJ2Kb9F7ixY2QaCg==", "dev": true, "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/is-boolean-object": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/is-boolean-object/-/is-boolean-object-1.1.0.tgz", "integrity": "sha512-a7Uprx8UtD+HWdyYwnD1+ExtTgqQtD2k/1yJgtXP6wnMm8byhkoTZRl+95LLThpzNZJ5aEvi46cdH+ayMFRwmA==", "dev": true, "dependencies": { "call-bind": "^1.0.0" }, "engines": { "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/is-buffer": { "version": "1.1.6", "resolved": "https://registry.npmjs.org/is-buffer/-/is-buffer-1.1.6.tgz", "integrity": "sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==", "dev": true }, "node_modules/is-callable": { "version": "1.2.3", "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.2.3.tgz", "integrity": "sha512-J1DcMe8UYTBSrKezuIUTUwjXsho29693unXM2YhJUTR2txK/eG47bvNa/wipPFmZFgr/N6f1GA66dv0mEyTIyQ==", "dev": true, "engines": { "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/is-core-module": { "version": "2.2.0", "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.2.0.tgz", "integrity": "sha512-XRAfAdyyY5F5cOXn7hYQDqh2Xmii+DEfIcQGxK/uNwMHhIkPWO0g8msXcbzLe+MpGoR951MlqM/2iIlU4vKDdQ==", "dev": true, "dependencies": { "has": "^1.0.3" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/is-date-object": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.2.tgz", "integrity": "sha512-USlDT524woQ08aoZFzh3/Z6ch9Y/EWXEHQ/AaRN0SkKq4t2Jw2R2339tSXmwuVoY7LLlBCbOIlx2myP/L5zk0g==", "dev": true, "engines": { "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/is-extglob": { "version": "2.1.1", "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", "integrity": "sha1-qIwCU1eR8C7TfHahueqXc8gz+MI=", "dev": true, "engines": { "node": ">=0.10.0" } }, "node_modules/is-fullwidth-code-point": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", "dev": true, "engines": { "node": ">=8" } }, "node_modules/is-generator-function": { "version": "1.0.8", "resolved": "https://registry.npmjs.org/is-generator-function/-/is-generator-function-1.0.8.tgz", "integrity": "sha512-2Omr/twNtufVZFr1GhxjOMFPAj2sjc/dKaIqBhvo4qciXfJmITGH6ZGd8eZYNHza8t1y0e01AuqRhJwfWp26WQ==", "dev": true, "engines": { "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/is-glob": { "version": "4.0.1", "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.1.tgz", "integrity": "sha512-5G0tKtBTFImOqDnLB2hG6Bp2qcKEFduo4tZu9MT/H6NQv/ghhy30o55ufafxJ/LdH79LLs2Kfrn85TLKyA7BUg==", "dev": true, "dependencies": { "is-extglob": "^2.1.1" }, "engines": { "node": ">=0.10.0" } }, "node_modules/is-negative-zero": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/is-negative-zero/-/is-negative-zero-2.0.1.tgz", "integrity": "sha512-2z6JzQvZRa9A2Y7xC6dQQm4FSTSTNWjKIYYTt4246eMTJmIo0Q+ZyOsU66X8lxK1AbB92dFeglPLrhwpeRKO6w==", "dev": true, "engines": { "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/is-number-object": { "version": "1.0.4", "resolved": "https://registry.npmjs.org/is-number-object/-/is-number-object-1.0.4.tgz", "integrity": "sha512-zohwelOAur+5uXtk8O3GPQ1eAcu4ZX3UwxQhUlfFFMNpUd83gXgjbhJh6HmB6LUNV/ieOLQuDwJO3dWJosUeMw==", "dev": true, "engines": { "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/is-plain-obj": { "version": "2.1.0", "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-2.1.0.tgz", "integrity": "sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==", "dev": true, "engines": { "node": ">=8" } }, "node_modules/is-regex": { "version": "1.1.2", "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.1.2.tgz", "integrity": "sha512-axvdhb5pdhEVThqJzYXwMlVuZwC+FF2DpcOhTS+y/8jVq4trxyPgfcwIxIKiyeuLlSQYKkmUaPQJ8ZE4yNKXDg==", "dev": true, "dependencies": { "call-bind": "^1.0.2", "has-symbols": "^1.0.1" }, "engines": { "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/is-string": { "version": "1.0.5", "resolved": "https://registry.npmjs.org/is-string/-/is-string-1.0.5.tgz", "integrity": "sha512-buY6VNRjhQMiF1qWDouloZlQbRhDPCebwxSjxMjxgemYT46YMd2NR0/H+fBhEfWX4A/w9TBJ+ol+okqJKFE6vQ==", "dev": true, "engines": { "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/is-symbol": { "version": "1.0.3", "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.3.tgz", "integrity": "sha512-OwijhaRSgqvhm/0ZdAcXNZt9lYdKFpcRDT5ULUuYXPoT794UNOdU+gpT6Rzo7b4V2HUl/op6GqY894AZwv9faQ==", "dev": true, "dependencies": { "has-symbols": "^1.0.1" }, "engines": { "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/is-typed-array": { "version": "1.1.5", "resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.5.tgz", "integrity": "sha512-S+GRDgJlR3PyEbsX/Fobd9cqpZBuvUS+8asRqYDMLCb2qMzt1oz5m5oxQCxOgUDxiWsOVNi4yaF+/uvdlHlYug==", "dev": true, "dependencies": { "available-typed-arrays": "^1.0.2", "call-bind": "^1.0.2", "es-abstract": "^1.18.0-next.2", "foreach": "^2.0.5", "has-symbols": "^1.0.1" }, "engines": { "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/is-unicode-supported": { "version": "0.1.0", "resolved": "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-0.1.0.tgz", "integrity": "sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw==", "dev": true, "engines": { "node": ">=10" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/isarray": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=", "dev": true }, "node_modules/js-tokens": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz", "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==" }, "node_modules/js-yaml": { "version": "4.1.0", "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz", "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==", "dev": true, "dependencies": { "argparse": "^2.0.1" }, "bin": { "js-yaml": "bin/js-yaml.js" } }, "node_modules/jsesc": { "version": "2.5.2", "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-2.5.2.tgz", "integrity": "sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA==", "bin": { "jsesc": "bin/jsesc" }, "engines": { "node": ">=4" } }, "node_modules/json5": { "version": "2.2.3", "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz", "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==", "bin": { "json5": "lib/cli.js" }, "engines": { "node": ">=6" } }, "node_modules/jsonparse": { "version": "1.3.1", "resolved": "https://registry.npmjs.org/jsonparse/-/jsonparse-1.3.1.tgz", "integrity": "sha1-P02uSpH6wxX3EGL4UhzCOfE2YoA=", "dev": true, "engines": [ "node >= 0.2.0" ] }, "node_modules/JSONStream": { "version": "1.3.5", "resolved": "https://registry.npmjs.org/JSONStream/-/JSONStream-1.3.5.tgz", "integrity": "sha512-E+iruNOY8VV9s4JEbe1aNEm6MiszPRr/UfcHMz0TQh1BXSxHK+ASV1R6W4HpjBhSeS+54PIsAMCBmwD06LLsqQ==", "dev": true, "dependencies": { "jsonparse": "^1.2.0", "through": ">=2.2.7 <3" }, "bin": { "JSONStream": "bin.js" }, "engines": { "node": "*" } }, "node_modules/labeled-stream-splicer": { "version": "2.0.2", "resolved": "https://registry.npmjs.org/labeled-stream-splicer/-/labeled-stream-splicer-2.0.2.tgz", "integrity": "sha512-Ca4LSXFFZUjPScRaqOcFxneA0VpKZr4MMYCljyQr4LIewTLb3Y0IUTIsnBBsVubIeEfxeSZpSjSsRM8APEQaAw==", "dev": true, "dependencies": { "inherits": "^2.0.1", "stream-splicer": "^2.0.0" } }, "node_modules/locate-path": { "version": "6.0.0", "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", "dev": true, "dependencies": { "p-locate": "^5.0.0" }, "engines": { "node": ">=10" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/lodash.memoize": { "version": "3.0.4", "resolved": "https://registry.npmjs.org/lodash.memoize/-/lodash.memoize-3.0.4.tgz", "integrity": "sha1-LcvSwofLwKVcxCMovQxzYVDVPj8=", "dev": true }, "node_modules/log-symbols": { "version": "4.1.0", "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-4.1.0.tgz", "integrity": "sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg==", "dev": true, "dependencies": { "chalk": "^4.1.0", "is-unicode-supported": "^0.1.0" }, "engines": { "node": ">=10" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/log-symbols/node_modules/ansi-styles": { "version": "4.3.0", "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", "dev": true, "dependencies": { "color-convert": "^2.0.1" }, "engines": { "node": ">=8" }, "funding": { "url": "https://github.com/chalk/ansi-styles?sponsor=1" } }, "node_modules/log-symbols/node_modules/chalk": { "version": "4.1.2", "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", "dev": true, "dependencies": { "ansi-styles": "^4.1.0", "supports-color": "^7.1.0" }, "engines": { "node": ">=10" }, "funding": { "url": "https://github.com/chalk/chalk?sponsor=1" } }, "node_modules/log-symbols/node_modules/color-convert": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", "dev": true, "dependencies": { "color-name": "~1.1.4" }, "engines": { "node": ">=7.0.0" } }, "node_modules/log-symbols/node_modules/color-name": { "version": "1.1.4", "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", "dev": true }, "node_modules/log-symbols/node_modules/has-flag": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", "dev": true, "engines": { "node": ">=8" } }, "node_modules/log-symbols/node_modules/supports-color": { "version": "7.2.0", "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", "dev": true, "dependencies": { "has-flag": "^4.0.0" }, "engines": { "node": ">=8" } }, "node_modules/lru-cache": { "version": "6.0.0", "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz", "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==", "dev": true, "dependencies": { "yallist": "^4.0.0" }, "engines": { "node": ">=10" } }, "node_modules/make-dir": { "version": "2.1.0", "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-2.1.0.tgz", "integrity": "sha512-LS9X+dc8KLxXCb8dni79fLIIUA5VyZoyjSMCwTluaXA0o27cCK0bhXkpgw+sTXVpPy/lSO57ilRixqk0vDmtRA==", "dev": true, "dependencies": { "pify": "^4.0.1", "semver": "^5.6.0" }, "engines": { "node": ">=6" } }, "node_modules/make-dir/node_modules/semver": { "version": "5.7.1", "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz", "integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==", "dev": true, "bin": { "semver": "bin/semver" } }, "node_modules/md5.js": { "version": "1.3.5", "resolved": "https://registry.npmjs.org/md5.js/-/md5.js-1.3.5.tgz", "integrity": "sha512-xitP+WxNPcTTOgnTJcrhM0xvdPepipPSf3I8EIpGKeFLjt3PlJLIDG3u8EX53ZIubkb+5U2+3rELYpEhHhzdkg==", "dev": true, "dependencies": { "hash-base": "^3.0.0", "inherits": "^2.0.1", "safe-buffer": "^5.1.2" } }, "node_modules/miller-rabin": { "version": "4.0.1", "resolved": "https://registry.npmjs.org/miller-rabin/-/miller-rabin-4.0.1.tgz", "integrity": "sha512-115fLhvZVqWwHPbClyntxEVfVDfl9DLLTuJvq3g2O/Oxi8AiNouAHvDSzHS0viUJc+V5vm3eq91Xwqn9dp4jRA==", "dev": true, "dependencies": { "bn.js": "^4.0.0", "brorand": "^1.0.1" }, "bin": { "miller-rabin": "bin/miller-rabin" } }, "node_modules/miller-rabin/node_modules/bn.js": { "version": "4.12.0", "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz", "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==", "dev": true }, "node_modules/minimalistic-assert": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz", "integrity": "sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==", "dev": true }, "node_modules/minimalistic-crypto-utils": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/minimalistic-crypto-utils/-/minimalistic-crypto-utils-1.0.1.tgz", "integrity": "sha1-9sAMHAsIIkblxNmd+4x8CDsrWCo=", "dev": true }, "node_modules/minimatch": { "version": "3.1.2", "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", "dependencies": { "brace-expansion": "^1.1.7" }, "engines": { "node": "*" } }, "node_modules/minimist": { "version": "1.2.6", "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.6.tgz", "integrity": "sha512-Jsjnk4bw3YJqYzbdyBiNsPWHPfO++UGG749Cxs6peCu5Xg4nrena6OVxOYxrQTqww0Jmwt+Ref8rggumkTLz9Q==" }, "node_modules/mkdirp": { "version": "0.5.3", "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.3.tgz", "integrity": "sha512-P+2gwrFqx8lhew375MQHHeTlY8AuOJSrGf0R5ddkEndUkmwpgUob/vQuBD1V22/Cw1/lJr4x+EjllSezBThzBg==", "deprecated": "Legacy versions of mkdirp are no longer supported. Please update to mkdirp 1.x. (Note that the API surface has changed to use Promises in 1.x.)", "dependencies": { "minimist": "^1.2.5" }, "bin": { "mkdirp": "bin/cmd.js" } }, "node_modules/mkdirp-classic": { "version": "0.5.3", "resolved": "https://registry.npmjs.org/mkdirp-classic/-/mkdirp-classic-0.5.3.tgz", "integrity": "sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A==", "dev": true }, "node_modules/mocha": { "version": "10.1.0", "resolved": "https://registry.npmjs.org/mocha/-/mocha-10.1.0.tgz", "integrity": "sha512-vUF7IYxEoN7XhQpFLxQAEMtE4W91acW4B6En9l97MwE9stL1A9gusXfoHZCLVHDUJ/7V5+lbCM6yMqzo5vNymg==", "dev": true, "dependencies": { "ansi-colors": "4.1.1", "browser-stdout": "1.3.1", "chokidar": "3.5.3", "debug": "4.3.4", "diff": "5.0.0", "escape-string-regexp": "4.0.0", "find-up": "5.0.0", "glob": "7.2.0", "he": "1.2.0", "js-yaml": "4.1.0", "log-symbols": "4.1.0", "minimatch": "5.0.1", "ms": "2.1.3", "nanoid": "3.3.3", "serialize-javascript": "6.0.0", "strip-json-comments": "3.1.1", "supports-color": "8.1.1", "workerpool": "6.2.1", "yargs": "16.2.0", "yargs-parser": "20.2.4", "yargs-unparser": "2.0.0" }, "bin": { "_mocha": "bin/_mocha", "mocha": "bin/mocha.js" }, "engines": { "node": ">= 14.0.0" }, "funding": { "type": "opencollective", "url": "https://opencollective.com/mochajs" } }, "node_modules/mocha/node_modules/anymatch": { "version": "3.1.2", "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.2.tgz", "integrity": "sha512-P43ePfOAIupkguHUycrc4qJ9kz8ZiuOUijaETwX7THt0Y/GNK7v0aa8rY816xWjZ7rJdA5XdMcpVFTKMq+RvWg==", "dev": true, "dependencies": { "normalize-path": "^3.0.0", "picomatch": "^2.0.4" }, "engines": { "node": ">= 8" } }, "node_modules/mocha/node_modules/binary-extensions": { "version": "2.2.0", "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz", "integrity": "sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==", "dev": true, "engines": { "node": ">=8" } }, "node_modules/mocha/node_modules/braces": { "version": "3.0.2", "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz", "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==", "dev": true, "dependencies": { "fill-range": "^7.0.1" }, "engines": { "node": ">=8" } }, "node_modules/mocha/node_modules/chokidar": { "version": "3.5.3", "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.3.tgz", "integrity": "sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==", "dev": true, "funding": [ { "type": "individual", "url": "https://paulmillr.com/funding/" } ], "dependencies": { "anymatch": "~3.1.2", "braces": "~3.0.2", "glob-parent": "~5.1.2", "is-binary-path": "~2.1.0", "is-glob": "~4.0.1", "normalize-path": "~3.0.0", "readdirp": "~3.6.0" }, "engines": { "node": ">= 8.10.0" }, "optionalDependencies": { "fsevents": "~2.3.2" } }, "node_modules/mocha/node_modules/debug": { "version": "4.3.4", "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz", "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==", "dev": true, "dependencies": { "ms": "2.1.2" }, "engines": { "node": ">=6.0" }, "peerDependenciesMeta": { "supports-color": { "optional": true } } }, "node_modules/mocha/node_modules/debug/node_modules/ms": { "version": "2.1.2", "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==", "dev": true }, "node_modules/mocha/node_modules/escape-string-regexp": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==", "dev": true, "engines": { "node": ">=10" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/mocha/node_modules/fill-range": { "version": "7.0.1", "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz", "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==", "dev": true, "dependencies": { "to-regex-range": "^5.0.1" }, "engines": { "node": ">=8" } }, "node_modules/mocha/node_modules/glob": { "version": "7.2.0", "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.0.tgz", "integrity": "sha512-lmLf6gtyrPq8tTjSmrO94wBeQbFR3HbLHbuyD69wuyQkImp2hWqMGB47OX65FBkPffO641IP9jWa1z4ivqG26Q==", "dev": true, "dependencies": { "fs.realpath": "^1.0.0", "inflight": "^1.0.4", "inherits": "2", "minimatch": "^3.0.4", "once": "^1.3.0", "path-is-absolute": "^1.0.0" }, "engines": { "node": "*" }, "funding": { "url": "https://github.com/sponsors/isaacs" } }, "node_modules/mocha/node_modules/glob/node_modules/minimatch": { "version": "3.1.2", "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", "dev": true, "dependencies": { "brace-expansion": "^1.1.7" }, "engines": { "node": "*" } }, "node_modules/mocha/node_modules/has-flag": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", "dev": true, "engines": { "node": ">=8" } }, "node_modules/mocha/node_modules/is-binary-path": { "version": "2.1.0", "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz", "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==", "dev": true, "dependencies": { "binary-extensions": "^2.0.0" }, "engines": { "node": ">=8" } }, "node_modules/mocha/node_modules/is-number": { "version": "7.0.0", "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", "dev": true, "engines": { "node": ">=0.12.0" } }, "node_modules/mocha/node_modules/minimatch": { "version": "5.0.1", "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.0.1.tgz", "integrity": "sha512-nLDxIFRyhDblz3qMuq+SoRZED4+miJ/G+tdDrjkkkRnjAsBexeGpgjLEQ0blJy7rHhR2b93rhQY4SvyWu9v03g==", "dev": true, "dependencies": { "brace-expansion": "^2.0.1" }, "engines": { "node": ">=10" } }, "node_modules/mocha/node_modules/minimatch/node_modules/brace-expansion": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz", "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==", "dev": true, "dependencies": { "balanced-match": "^1.0.0" } }, "node_modules/mocha/node_modules/ms": { "version": "2.1.3", "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", "dev": true }, "node_modules/mocha/node_modules/readdirp": { "version": "3.6.0", "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz", "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==", "dev": true, "dependencies": { "picomatch": "^2.2.1" }, "engines": { "node": ">=8.10.0" } }, "node_modules/mocha/node_modules/supports-color": { "version": "8.1.1", "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz", "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==", "dev": true, "dependencies": { "has-flag": "^4.0.0" }, "engines": { "node": ">=10" }, "funding": { "url": "https://github.com/chalk/supports-color?sponsor=1" } }, "node_modules/mocha/node_modules/to-regex-range": { "version": "5.0.1", "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", "dev": true, "dependencies": { "is-number": "^7.0.0" }, "engines": { "node": ">=8.0" } }, "node_modules/module-deps": { "version": "6.2.3", "resolved": "https://registry.npmjs.org/module-deps/-/module-deps-6.2.3.tgz", "integrity": "sha512-fg7OZaQBcL4/L+AK5f4iVqf9OMbCclXfy/znXRxTVhJSeW5AIlS9AwheYwDaXM3lVW7OBeaeUEY3gbaC6cLlSA==", "dev": true, "dependencies": { "browser-resolve": "^2.0.0", "cached-path-relative": "^1.0.2", "concat-stream": "~1.6.0", "defined": "^1.0.0", "detective": "^5.2.0", "duplexer2": "^0.1.2", "inherits": "^2.0.1", "JSONStream": "^1.0.3", "parents": "^1.0.0", "readable-stream": "^2.0.2", "resolve": "^1.4.0", "stream-combiner2": "^1.1.1", "subarg": "^1.0.0", "through2": "^2.0.0", "xtend": "^4.0.0" }, "bin": { "module-deps": "bin/cmd.js" }, "engines": { "node": ">= 0.8.0" } }, "node_modules/module-deps/node_modules/detective": { "version": "5.2.0", "resolved": "https://registry.npmjs.org/detective/-/detective-5.2.0.tgz", "integrity": "sha512-6SsIx+nUUbuK0EthKjv0zrdnajCCXVYGmbYYiYjFVpzcjwEs/JMDZ8tPRG29J/HhN56t3GJp2cGSWDRjjot8Pg==", "dev": true, "dependencies": { "acorn-node": "^1.6.1", "defined": "^1.0.0", "minimist": "^1.1.1" }, "bin": { "detective": "bin/detective.js" }, "engines": { "node": ">=0.8.0" } }, "node_modules/ms": { "version": "2.1.2", "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==" }, "node_modules/nanoid": { "version": "3.3.3", "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.3.tgz", "integrity": "sha512-p1sjXuopFs0xg+fPASzQ28agW1oHD7xDsd9Xkf3T15H3c/cifrFHVwrh74PdoklAPi+i7MdRsE47vm2r6JoB+w==", "dev": true, "bin": { "nanoid": "bin/nanoid.cjs" }, "engines": { "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" } }, "node_modules/node-releases": { "version": "2.0.6", "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.6.tgz", "integrity": "sha512-PiVXnNuFm5+iYkLBNeq5211hvO38y63T0i2KKh2KnUs3RpzJ+JtODFjkD8yjLwnDkTYF1eKXheUwdssR+NRZdg==" }, "node_modules/normalize-path": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz", "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==", "dev": true, "engines": { "node": ">=0.10.0" } }, "node_modules/object-assign": { "version": "4.1.1", "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", "integrity": "sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM=", "dev": true, "engines": { "node": ">=0.10.0" } }, "node_modules/object-inspect": { "version": "1.9.0", "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.9.0.tgz", "integrity": "sha512-i3Bp9iTqwhaLZBxGkRfo5ZbE07BQRT7MGu8+nNgwW9ItGp1TzCTw2DLEoWwjClxBjOFI/hWljTAmYGCEwmtnOw==", "dev": true, "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/object-keys": { "version": "1.1.1", "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz", "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==", "dev": true, "engines": { "node": ">= 0.4" } }, "node_modules/once": { "version": "1.4.0", "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=", "dependencies": { "wrappy": "1" } }, "node_modules/os-browserify": { "version": "0.3.0", "resolved": "https://registry.npmjs.org/os-browserify/-/os-browserify-0.3.0.tgz", "integrity": "sha1-hUNzx/XCMVkU/Jv8a9gjj92h7Cc=", "dev": true }, "node_modules/p-limit": { "version": "3.1.0", "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", "dev": true, "dependencies": { "yocto-queue": "^0.1.0" }, "engines": { "node": ">=10" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/p-locate": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", "dev": true, "dependencies": { "p-limit": "^3.0.2" }, "engines": { "node": ">=10" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/pako": { "version": "1.0.11", "resolved": "https://registry.npmjs.org/pako/-/pako-1.0.11.tgz", "integrity": "sha512-4hLB8Py4zZce5s4yd9XzopqwVv/yGNhV1Bl8NTmCq1763HeK2+EwVTv+leGeL13Dnh2wfbqowVPXCIO0z4taYw==", "dev": true }, "node_modules/parents": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/parents/-/parents-1.0.1.tgz", "integrity": "sha1-/t1NK/GTp3dF/nHjcdc8MwfZx1E=", "dev": true, "dependencies": { "path-platform": "~0.11.15" } }, "node_modules/parse-asn1": { "version": "5.1.6", "resolved": "https://registry.npmjs.org/parse-asn1/-/parse-asn1-5.1.6.tgz", "integrity": "sha512-RnZRo1EPU6JBnra2vGHj0yhp6ebyjBZpmUCLHWiFhxlzvBCCpAuZ7elsBp1PVAbQN0/04VD/19rfzlBSwLstMw==", "dev": true, "dependencies": { "asn1.js": "^5.2.0", "browserify-aes": "^1.0.0", "evp_bytestokey": "^1.0.0", "pbkdf2": "^3.0.3", "safe-buffer": "^5.1.1" } }, "node_modules/path-browserify": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/path-browserify/-/path-browserify-1.0.1.tgz", "integrity": "sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g==", "dev": true }, "node_modules/path-exists": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", "dev": true, "engines": { "node": ">=8" } }, "node_modules/path-is-absolute": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=", "engines": { "node": ">=0.10.0" } }, "node_modules/path-parse": { "version": "1.0.7", "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz", "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==", "dev": true }, "node_modules/path-platform": { "version": "0.11.15", "resolved": "https://registry.npmjs.org/path-platform/-/path-platform-0.11.15.tgz", "integrity": "sha1-6GQhf3TDaFDwhSt43Hv31KVyG/I=", "dev": true, "engines": { "node": ">= 0.8.0" } }, "node_modules/pbkdf2": { "version": "3.1.1", "resolved": "https://registry.npmjs.org/pbkdf2/-/pbkdf2-3.1.1.tgz", "integrity": "sha512-4Ejy1OPxi9f2tt1rRV7Go7zmfDQ+ZectEQz3VGUQhgq62HtIRPDyG/JtnwIxs6x3uNMwo2V7q1fMvKjb+Tnpqg==", "dev": true, "dependencies": { "create-hash": "^1.1.2", "create-hmac": "^1.1.4", "ripemd160": "^2.0.1", "safe-buffer": "^5.0.1", "sha.js": "^2.4.8" }, "engines": { "node": ">=0.12" } }, "node_modules/picocolors": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.0.0.tgz", "integrity": "sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==" }, "node_modules/picomatch": { "version": "2.2.1", "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.2.1.tgz", "integrity": "sha512-ISBaA8xQNmwELC7eOjqFKMESB2VIqt4PPDD0nsS95b/9dZXvVKOlz9keMSnoGGKcOHXfTvDD6WMaRoSc9UuhRA==", "dev": true, "engines": { "node": ">=8.6" }, "funding": { "url": "https://github.com/sponsors/jonschlinkert" } }, "node_modules/pify": { "version": "4.0.1", "resolved": "https://registry.npmjs.org/pify/-/pify-4.0.1.tgz", "integrity": "sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g==", "dev": true, "engines": { "node": ">=6" } }, "node_modules/private": { "version": "0.1.8", "resolved": "https://registry.npmjs.org/private/-/private-0.1.8.tgz", "integrity": "sha512-VvivMrbvd2nKkiG38qjULzlc+4Vx4wm/whI9pQD35YrARNnhxeiRktSOhSukRLFNlzg6Br/cJPet5J/u19r/mg==", "engines": { "node": ">= 0.6" } }, "node_modules/process": { "version": "0.11.10", "resolved": "https://registry.npmjs.org/process/-/process-0.11.10.tgz", "integrity": "sha1-czIwDoQBYb2j5podHZGn1LwW8YI=", "dev": true, "engines": { "node": ">= 0.6.0" } }, "node_modules/process-nextick-args": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz", "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==", "dev": true }, "node_modules/promise": { "version": "8.2.0", "resolved": "https://registry.npmjs.org/promise/-/promise-8.2.0.tgz", "integrity": "sha512-+CMAlLHqwRYwBMXKCP+o8ns7DN+xHDUiI+0nArsiJ9y+kJVPLFxEaSw6Ha9s9H0tftxg2Yzl25wqj9G7m5wLZg==", "dev": true, "dependencies": { "asap": "~2.0.6" } }, "node_modules/public-encrypt": { "version": "4.0.3", "resolved": "https://registry.npmjs.org/public-encrypt/-/public-encrypt-4.0.3.tgz", "integrity": "sha512-zVpa8oKZSz5bTMTFClc1fQOnyyEzpl5ozpi1B5YcvBrdohMjH2rfsBtyXcuNuwjsDIXmBYlF2N5FlJYhR29t8Q==", "dev": true, "dependencies": { "bn.js": "^4.1.0", "browserify-rsa": "^4.0.0", "create-hash": "^1.1.0", "parse-asn1": "^5.0.0", "randombytes": "^2.0.1", "safe-buffer": "^5.1.2" } }, "node_modules/public-encrypt/node_modules/bn.js": { "version": "4.12.0", "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz", "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==", "dev": true }, "node_modules/punycode": { "version": "1.4.1", "resolved": "https://registry.npmjs.org/punycode/-/punycode-1.4.1.tgz", "integrity": "sha1-wNWmOycYgArY4esPpSachN1BhF4=", "dev": true }, "node_modules/q": { "version": "1.5.1", "resolved": "https://registry.npmjs.org/q/-/q-1.5.1.tgz", "integrity": "sha1-fjL3W0E4EpHQRhHxvxQQmsAGUdc=", "engines": { "node": ">=0.6.0", "teleport": ">=0.2.0" } }, "node_modules/querystring": { "version": "0.2.0", "resolved": "https://registry.npmjs.org/querystring/-/querystring-0.2.0.tgz", "integrity": "sha1-sgmEkgO7Jd+CDadW50cAWHhSFiA=", "deprecated": "The querystring API is considered Legacy. new code should use the URLSearchParams API instead.", "dev": true, "engines": { "node": ">=0.4.x" } }, "node_modules/querystring-es3": { "version": "0.2.1", "resolved": "https://registry.npmjs.org/querystring-es3/-/querystring-es3-0.2.1.tgz", "integrity": "sha1-nsYfeQSYdXB9aUFFlv2Qek1xHnM=", "dev": true, "engines": { "node": ">=0.4.x" } }, "node_modules/randombytes": { "version": "2.1.0", "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz", "integrity": "sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==", "dev": true, "dependencies": { "safe-buffer": "^5.1.0" } }, "node_modules/randomfill": { "version": "1.0.4", "resolved": "https://registry.npmjs.org/randomfill/-/randomfill-1.0.4.tgz", "integrity": "sha512-87lcbR8+MhcWcUiQ+9e+Rwx8MyR2P7qnt15ynUlbm3TU/fjbgz4GsvfSUDTemtCCtVCqb4ZcEFlyPNTh9bBTLw==", "dev": true, "dependencies": { "randombytes": "^2.0.5", "safe-buffer": "^5.1.0" } }, "node_modules/read-only-stream": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/read-only-stream/-/read-only-stream-2.0.0.tgz", "integrity": "sha1-JyT9aoET1zdkrCiNQ4YnDB2/F/A=", "dev": true, "dependencies": { "readable-stream": "^2.0.2" } }, "node_modules/readable-stream": { "version": "2.3.7", "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.7.tgz", "integrity": "sha512-Ebho8K4jIbHAxnuxi7o42OrZgF/ZTNcsZj6nRKyUmkhLFq8CHItp/fy6hQZuZmP/n3yZ9VBUbp4zz/mX8hmYPw==", "dev": true, "dependencies": { "core-util-is": "~1.0.0", "inherits": "~2.0.3", "isarray": "~1.0.0", "process-nextick-args": "~2.0.0", "safe-buffer": "~5.1.1", "string_decoder": "~1.1.1", "util-deprecate": "~1.0.1" } }, "node_modules/recast": { "version": "0.21.5", "resolved": "https://registry.npmjs.org/recast/-/recast-0.21.5.tgz", "integrity": "sha512-hjMmLaUXAm1hIuTqOdeYObMslq/q+Xff6QE3Y2P+uoHAg2nmVlLBps2hzh1UJDdMtDTMXOFewK6ky51JQIeECg==", "dependencies": { "ast-types": "0.15.2", "esprima": "~4.0.0", "source-map": "~0.6.1", "tslib": "^2.0.1" }, "engines": { "node": ">= 4" } }, "node_modules/recast/node_modules/ast-types": { "version": "0.15.2", "resolved": "https://registry.npmjs.org/ast-types/-/ast-types-0.15.2.tgz", "integrity": "sha512-c27loCv9QkZinsa5ProX751khO9DJl/AcB5c2KNtA6NRvHKS0PgLfcftz72KVq504vB0Gku5s2kUZzDBvQWvHg==", "dependencies": { "tslib": "^2.0.1" }, "engines": { "node": ">=4" } }, "node_modules/recast/node_modules/esprima": { "version": "4.0.1", "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz", "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==", "bin": { "esparse": "bin/esparse.js", "esvalidate": "bin/esvalidate.js" }, "engines": { "node": ">=4" } }, "node_modules/recast/node_modules/source-map": { "version": "0.6.1", "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", "engines": { "node": ">=0.10.0" } }, "node_modules/regenerator-preset": { "version": "0.14.1", "resolved": "https://registry.npmjs.org/regenerator-preset/-/regenerator-preset-0.14.1.tgz", "integrity": "sha512-7zEo8AK6N87TvOtFXEGec+LAGvCjgZyP/pbxm5NYAoWsmQCCd/IUKBwBqoOffiIhr1UOlgCGsRtwlR71Hl3Ewg==", "dependencies": { "@babel/plugin-proposal-function-sent": "^7.8.3", "@babel/plugin-syntax-async-generators": "^7.8.4", "@babel/plugin-transform-arrow-functions": "^7.8.3", "@babel/plugin-transform-block-scoping": "^7.8.3", "@babel/plugin-transform-classes": "^7.8.3", "@babel/plugin-transform-for-of": "^7.8.4", "regenerator-transform": "^0.15.0" } }, "node_modules/regenerator-runtime": { "version": "0.13.11", "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.13.11.tgz", "integrity": "sha512-kY1AZVr2Ra+t+piVaJ4gxaFaReZVH40AKNo7UCX6W+dEwBo/2oZJzqfuN1qLq1oL45o56cPaTXELwrTh8Fpggg==" }, "node_modules/regenerator-transform": { "version": "0.15.1", "resolved": "https://registry.npmjs.org/regenerator-transform/-/regenerator-transform-0.15.1.tgz", "integrity": "sha512-knzmNAcuyxV+gQCufkYcvOqX/qIIfHLv0u5x79kRxuGojfYVky1f15TzZEu2Avte8QGepvUNTnLskf8E6X6Vyg==", "dependencies": { "@babel/runtime": "^7.8.4" } }, "node_modules/require-directory": { "version": "2.1.1", "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz", "integrity": "sha1-jGStX9MNqxyXbiNE/+f3kqam30I=", "dev": true, "engines": { "node": ">=0.10.0" } }, "node_modules/resolve": { "version": "1.20.0", "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.20.0.tgz", "integrity": "sha512-wENBPt4ySzg4ybFQW2TT1zMQucPK95HSh/nq2CFTZVOGut2+pQvSsgtda4d26YrYcr067wjbmzOG8byDPBX63A==", "dev": true, "dependencies": { "is-core-module": "^2.2.0", "path-parse": "^1.0.6" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/ripemd160": { "version": "2.0.2", "resolved": "https://registry.npmjs.org/ripemd160/-/ripemd160-2.0.2.tgz", "integrity": "sha512-ii4iagi25WusVoiC4B4lq7pbXfAp3D9v5CwfkY33vffw2+pkDjY1D8GaN7spsxvCSx8dkPqOZCEZyfxcmJG2IA==", "dev": true, "dependencies": { "hash-base": "^3.0.0", "inherits": "^2.0.1" } }, "node_modules/safe-buffer": { "version": "5.1.2", "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz", "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==" }, "node_modules/safer-buffer": { "version": "2.1.2", "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz", "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==" }, "node_modules/semver": { "version": "7.5.2", "resolved": "https://registry.npmjs.org/semver/-/semver-7.5.2.tgz", "integrity": "sha512-SoftuTROv/cRjCze/scjGyiDtcUyxw1rgYQSZY7XTmtR5hX+dm76iDbTH8TkLPHCQmlbQVSSbNZCPM2hb0knnQ==", "dev": true, "dependencies": { "lru-cache": "^6.0.0" }, "bin": { "semver": "bin/semver.js" }, "engines": { "node": ">=10" } }, "node_modules/serialize-javascript": { "version": "6.0.0", "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.0.tgz", "integrity": "sha512-Qr3TosvguFt8ePWqsvRfrKyQXIiW+nGbYpy8XK24NQHE83caxWt+mIymTT19DGFbNWNLfEwsrkSmN64lVWB9ag==", "dev": true, "dependencies": { "randombytes": "^2.1.0" } }, "node_modules/sha.js": { "version": "2.4.11", "resolved": "https://registry.npmjs.org/sha.js/-/sha.js-2.4.11.tgz", "integrity": "sha512-QMEp5B7cftE7APOjk5Y6xgrbWu+WkLVQwk8JNjZ8nKRciZaByEW6MubieAiToS7+dwvrjGhH8jRXz3MVd0AYqQ==", "dev": true, "dependencies": { "inherits": "^2.0.1", "safe-buffer": "^5.0.1" }, "bin": { "sha.js": "bin.js" } }, "node_modules/shasum-object": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/shasum-object/-/shasum-object-1.0.0.tgz", "integrity": "sha512-Iqo5rp/3xVi6M4YheapzZhhGPVs0yZwHj7wvwQ1B9z8H6zk+FEnI7y3Teq7qwnekfEhu8WmG2z0z4iWZaxLWVg==", "dev": true, "dependencies": { "fast-safe-stringify": "^2.0.7" } }, "node_modules/shell-quote": { "version": "1.7.3", "resolved": "https://registry.npmjs.org/shell-quote/-/shell-quote-1.7.3.tgz", "integrity": "sha512-Vpfqwm4EnqGdlsBFNmHhxhElJYrdfcxPThu+ryKS5J8L/fhAwLazFZtq+S+TWZ9ANj2piSQLGj6NQg+lKPmxrw==", "dev": true }, "node_modules/simple-concat": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/simple-concat/-/simple-concat-1.0.1.tgz", "integrity": "sha512-cSFtAPtRhljv69IK0hTVZQ+OfE9nePi/rtJmw5UjHeVyVroEqJXP1sFztKUy1qU+xvz3u/sfYJLa947b7nAN2Q==", "dev": true, "funding": [ { "type": "github", "url": "https://github.com/sponsors/feross" }, { "type": "patreon", "url": "https://www.patreon.com/feross" }, { "type": "consulting", "url": "https://feross.org/support" } ] }, "node_modules/slash": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/slash/-/slash-2.0.0.tgz", "integrity": "sha512-ZYKh3Wh2z1PpEXWr0MpSBZ0V6mZHAQfYevttO11c51CaWjGTaadiKZ+wVt1PbMlDV5qhMFslpZCemhwOK7C89A==", "dev": true, "engines": { "node": ">=6" } }, "node_modules/source-map": { "version": "0.5.7", "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz", "integrity": "sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=", "engines": { "node": ">=0.10.0" } }, "node_modules/stream-browserify": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/stream-browserify/-/stream-browserify-3.0.0.tgz", "integrity": "sha512-H73RAHsVBapbim0tU2JwwOiXUj+fikfiaoYAKHF3VJfA0pe2BCzkhAHBlLG6REzE+2WNZcxOXjK7lkso+9euLA==", "dev": true, "dependencies": { "inherits": "~2.0.4", "readable-stream": "^3.5.0" } }, "node_modules/stream-browserify/node_modules/readable-stream": { "version": "3.6.0", "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.0.tgz", "integrity": "sha512-BViHy7LKeTz4oNnkcLJ+lVSL6vpiFeX6/d3oSH8zCW7UxP2onchk+vTGB143xuFjHS3deTgkKoXXymXqymiIdA==", "dev": true, "dependencies": { "inherits": "^2.0.3", "string_decoder": "^1.1.1", "util-deprecate": "^1.0.1" }, "engines": { "node": ">= 6" } }, "node_modules/stream-combiner2": { "version": "1.1.1", "resolved": "https://registry.npmjs.org/stream-combiner2/-/stream-combiner2-1.1.1.tgz", "integrity": "sha1-+02KFCDqNidk4hrUeAOXvry0HL4=", "dev": true, "dependencies": { "duplexer2": "~0.1.0", "readable-stream": "^2.0.2" } }, "node_modules/stream-http": { "version": "3.1.1", "resolved": "https://registry.npmjs.org/stream-http/-/stream-http-3.1.1.tgz", "integrity": "sha512-S7OqaYu0EkFpgeGFb/NPOoPLxFko7TPqtEeFg5DXPB4v/KETHG0Ln6fRFrNezoelpaDKmycEmmZ81cC9DAwgYg==", "dev": true, "dependencies": { "builtin-status-codes": "^3.0.0", "inherits": "^2.0.4", "readable-stream": "^3.6.0", "xtend": "^4.0.2" } }, "node_modules/stream-http/node_modules/readable-stream": { "version": "3.6.0", "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.0.tgz", "integrity": "sha512-BViHy7LKeTz4oNnkcLJ+lVSL6vpiFeX6/d3oSH8zCW7UxP2onchk+vTGB143xuFjHS3deTgkKoXXymXqymiIdA==", "dev": true, "dependencies": { "inherits": "^2.0.3", "string_decoder": "^1.1.1", "util-deprecate": "^1.0.1" }, "engines": { "node": ">= 6" } }, "node_modules/stream-splicer": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/stream-splicer/-/stream-splicer-2.0.1.tgz", "integrity": "sha512-Xizh4/NPuYSyAXyT7g8IvdJ9HJpxIGL9PjyhtywCZvvP0OPIdqyrr4dMikeuvY8xahpdKEBlBTySe583totajg==", "dev": true, "dependencies": { "inherits": "^2.0.1", "readable-stream": "^2.0.2" } }, "node_modules/string_decoder": { "version": "1.1.1", "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz", "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==", "dev": true, "dependencies": { "safe-buffer": "~5.1.0" } }, "node_modules/string-width": { "version": "4.2.3", "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", "dev": true, "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", "strip-ansi": "^6.0.1" }, "engines": { "node": ">=8" } }, "node_modules/string.prototype.trimend": { "version": "1.0.4", "resolved": "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.4.tgz", "integrity": "sha512-y9xCjw1P23Awk8EvTpcyL2NIr1j7wJ39f+k6lvRnSMz+mz9CGz9NYPelDk42kOz6+ql8xjfK8oYzy3jAP5QU5A==", "dev": true, "dependencies": { "call-bind": "^1.0.2", "define-properties": "^1.1.3" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/string.prototype.trimstart": { "version": "1.0.4", "resolved": "https://registry.npmjs.org/string.prototype.trimstart/-/string.prototype.trimstart-1.0.4.tgz", "integrity": "sha512-jh6e984OBfvxS50tdY2nRZnoC5/mLFKOREQfw8t5yytkoUsJRNxvI/E39qu1sD0OtWI3OC0XgKSmcWwziwYuZw==", "dev": true, "dependencies": { "call-bind": "^1.0.2", "define-properties": "^1.1.3" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/strip-ansi": { "version": "6.0.1", "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", "dev": true, "dependencies": { "ansi-regex": "^5.0.1" }, "engines": { "node": ">=8" } }, "node_modules/strip-json-comments": { "version": "3.1.1", "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz", "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==", "dev": true, "engines": { "node": ">=8" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/subarg": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/subarg/-/subarg-1.0.0.tgz", "integrity": "sha1-9izxdYHplrSPyWVpn1TAauJouNI=", "dev": true, "dependencies": { "minimist": "^1.1.0" } }, "node_modules/supports-color": { "version": "5.5.0", "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", "dependencies": { "has-flag": "^3.0.0" }, "engines": { "node": ">=4" } }, "node_modules/syntax-error": { "version": "1.4.0", "resolved": "https://registry.npmjs.org/syntax-error/-/syntax-error-1.4.0.tgz", "integrity": "sha512-YPPlu67mdnHGTup2A8ff7BC2Pjq0e0Yp/IyTFN03zWO0RcK07uLcbi7C2KpGR2FvWbaB0+bfE27a+sBKebSo7w==", "dev": true, "dependencies": { "acorn-node": "^1.2.0" } }, "node_modules/through": { "version": "2.3.8", "resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz", "integrity": "sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU=" }, "node_modules/through2": { "version": "2.0.5", "resolved": "https://registry.npmjs.org/through2/-/through2-2.0.5.tgz", "integrity": "sha512-/mrRod8xqpA+IHSLyGCQ2s8SPHiCDEeQJSep1jqLYeEUClOFG2Qsh+4FU6G9VeqpZnGW/Su8LQGc4YKni5rYSQ==", "dev": true, "dependencies": { "readable-stream": "~2.3.6", "xtend": "~4.0.1" } }, "node_modules/timers-browserify": { "version": "1.4.2", "resolved": "https://registry.npmjs.org/timers-browserify/-/timers-browserify-1.4.2.tgz", "integrity": "sha1-ycWLV1voQHN1y14kYtrO50NZ9B0=", "dev": true, "dependencies": { "process": "~0.11.0" }, "engines": { "node": ">=0.6.0" } }, "node_modules/to-fast-properties": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-2.0.0.tgz", "integrity": "sha1-3F5pjL0HkmW8c+A3doGk5Og/YW4=", "engines": { "node": ">=4" } }, "node_modules/tslib": { "version": "2.4.0", "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.4.0.tgz", "integrity": "sha512-d6xOpEDfsi2CZVlPQzGeux8XMwLT9hssAsaPYExaQMuYskwb+x1x7J371tWlbBdWHroy99KnVB6qIkUbs5X3UQ==" }, "node_modules/tty-browserify": { "version": "0.0.1", "resolved": "https://registry.npmjs.org/tty-browserify/-/tty-browserify-0.0.1.tgz", "integrity": "sha512-C3TaO7K81YvjCgQH9Q1S3R3P3BtN3RIM8n+OvX4il1K1zgE8ZhI0op7kClgkxtutIE8hQrcrHBXvIheqKUUCxw==", "dev": true }, "node_modules/typedarray": { "version": "0.0.6", "resolved": "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz", "integrity": "sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c=", "dev": true }, "node_modules/uglify-js": { "version": "3.17.4", "resolved": "https://registry.npmjs.org/uglify-js/-/uglify-js-3.17.4.tgz", "integrity": "sha512-T9q82TJI9e/C1TAxYvfb16xO120tMVFZrGA3f9/P4424DNu6ypK103y0GPFVa17yotwSyZW5iYXgjYHkGrJW/g==", "dev": true, "bin": { "uglifyjs": "bin/uglifyjs" }, "engines": { "node": ">=0.8.0" } }, "node_modules/umd": { "version": "3.0.3", "resolved": "https://registry.npmjs.org/umd/-/umd-3.0.3.tgz", "integrity": "sha512-4IcGSufhFshvLNcMCV80UnQVlZ5pMOC8mvNPForqwA4+lzYQuetTESLDQkeLmihq8bRcnpbQa48Wb8Lh16/xow==", "dev": true, "bin": { "umd": "bin/cli.js" } }, "node_modules/unbox-primitive": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.0.1.tgz", "integrity": "sha512-tZU/3NqK3dA5gpE1KtyiJUrEB0lxnGkMFHptJ7q6ewdZ8s12QrODwNbhIJStmJkd1QDXa1NRA8aF2A1zk/Ypyw==", "dev": true, "dependencies": { "function-bind": "^1.1.1", "has-bigints": "^1.0.1", "has-symbols": "^1.0.2", "which-boxed-primitive": "^1.0.2" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/unbox-primitive/node_modules/has-symbols": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.2.tgz", "integrity": "sha512-chXa79rL/UC2KlX17jo3vRGz0azaWEx5tGqZg5pO3NUyEJVB17dMruQlzCCOfUvElghKcm5194+BCRvi2Rv/Gw==", "dev": true, "engines": { "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/undeclared-identifiers": { "version": "1.1.3", "resolved": "https://registry.npmjs.org/undeclared-identifiers/-/undeclared-identifiers-1.1.3.tgz", "integrity": "sha512-pJOW4nxjlmfwKApE4zvxLScM/njmwj/DiUBv7EabwE4O8kRUy+HIwxQtZLBPll/jx1LJyBcqNfB3/cpv9EZwOw==", "dev": true, "dependencies": { "acorn-node": "^1.3.0", "dash-ast": "^1.0.0", "get-assigned-identifiers": "^1.2.0", "simple-concat": "^1.0.0", "xtend": "^4.0.1" }, "bin": { "undeclared-identifiers": "bin.js" } }, "node_modules/update-browserslist-db": { "version": "1.0.10", "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.0.10.tgz", "integrity": "sha512-OztqDenkfFkbSG+tRxBeAnCVPckDBcvibKd35yDONx6OU8N7sqgwc7rCbkJ/WcYtVRZ4ba68d6byhC21GFh7sQ==", "funding": [ { "type": "opencollective", "url": "https://opencollective.com/browserslist" }, { "type": "tidelift", "url": "https://tidelift.com/funding/github/npm/browserslist" } ], "dependencies": { "escalade": "^3.1.1", "picocolors": "^1.0.0" }, "bin": { "browserslist-lint": "cli.js" }, "peerDependencies": { "browserslist": ">= 4.21.0" } }, "node_modules/url": { "version": "0.11.0", "resolved": "https://registry.npmjs.org/url/-/url-0.11.0.tgz", "integrity": "sha1-ODjpfPxgUh63PFJajlW/3Z4uKPE=", "dev": true, "dependencies": { "punycode": "1.3.2", "querystring": "0.2.0" } }, "node_modules/url/node_modules/punycode": { "version": "1.3.2", "resolved": "https://registry.npmjs.org/punycode/-/punycode-1.3.2.tgz", "integrity": "sha1-llOgNvt8HuQjQvIyXM7v6jkmxI0=", "dev": true }, "node_modules/util": { "version": "0.12.3", "resolved": "https://registry.npmjs.org/util/-/util-0.12.3.tgz", "integrity": "sha512-I8XkoQwE+fPQEhy9v012V+TSdH2kp9ts29i20TaaDUXsg7x/onePbhFJUExBfv/2ay1ZOp/Vsm3nDlmnFGSAog==", "dev": true, "dependencies": { "inherits": "^2.0.3", "is-arguments": "^1.0.4", "is-generator-function": "^1.0.7", "is-typed-array": "^1.1.3", "safe-buffer": "^5.1.2", "which-typed-array": "^1.1.2" } }, "node_modules/util-deprecate": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", "integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=", "dev": true }, "node_modules/vm-browserify": { "version": "1.1.2", "resolved": "https://registry.npmjs.org/vm-browserify/-/vm-browserify-1.1.2.tgz", "integrity": "sha512-2ham8XPWTONajOR0ohOKOHXkm3+gaBmGut3SRuu75xLd/RRaY6vqgh8NBYYk7+RW3u5AtzPQZG8F10LHkl0lAQ==", "dev": true }, "node_modules/which-boxed-primitive": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/which-boxed-primitive/-/which-boxed-primitive-1.0.2.tgz", "integrity": "sha512-bwZdv0AKLpplFY2KZRX6TvyuN7ojjr7lwkg6ml0roIy9YeuSr7JS372qlNW18UQYzgYK9ziGcerWqZOmEn9VNg==", "dev": true, "dependencies": { "is-bigint": "^1.0.1", "is-boolean-object": "^1.1.0", "is-number-object": "^1.0.4", "is-string": "^1.0.5", "is-symbol": "^1.0.3" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/which-typed-array": { "version": "1.1.4", "resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.4.tgz", "integrity": "sha512-49E0SpUe90cjpoc7BOJwyPHRqSAd12c10Qm2amdEZrJPCY2NDxaW01zHITrem+rnETY3dwrbH3UUrUwagfCYDA==", "dev": true, "dependencies": { "available-typed-arrays": "^1.0.2", "call-bind": "^1.0.0", "es-abstract": "^1.18.0-next.1", "foreach": "^2.0.5", "function-bind": "^1.1.1", "has-symbols": "^1.0.1", "is-typed-array": "^1.1.3" }, "engines": { "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/workerpool": { "version": "6.2.1", "resolved": "https://registry.npmjs.org/workerpool/-/workerpool-6.2.1.tgz", "integrity": "sha512-ILEIE97kDZvF9Wb9f6h5aXK4swSlKGUcOEGiIYb2OOu/IrDU9iwj0fD//SsA6E5ibwJxpEvhullJY4Sl4GcpAw==", "dev": true }, "node_modules/wrap-ansi": { "version": "7.0.0", "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", "dev": true, "dependencies": { "ansi-styles": "^4.0.0", "string-width": "^4.1.0", "strip-ansi": "^6.0.0" }, "engines": { "node": ">=10" }, "funding": { "url": "https://github.com/chalk/wrap-ansi?sponsor=1" } }, "node_modules/wrap-ansi/node_modules/ansi-styles": { "version": "4.3.0", "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", "dev": true, "dependencies": { "color-convert": "^2.0.1" }, "engines": { "node": ">=8" }, "funding": { "url": "https://github.com/chalk/ansi-styles?sponsor=1" } }, "node_modules/wrap-ansi/node_modules/color-convert": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", "dev": true, "dependencies": { "color-name": "~1.1.4" }, "engines": { "node": ">=7.0.0" } }, "node_modules/wrap-ansi/node_modules/color-name": { "version": "1.1.4", "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", "dev": true }, "node_modules/wrappy": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=" }, "node_modules/xtend": { "version": "4.0.2", "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz", "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==", "dev": true, "engines": { "node": ">=0.4" } }, "node_modules/y18n": { "version": "5.0.8", "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz", "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==", "dev": true, "engines": { "node": ">=10" } }, "node_modules/yallist": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==", "dev": true }, "node_modules/yargs": { "version": "16.2.0", "resolved": "https://registry.npmjs.org/yargs/-/yargs-16.2.0.tgz", "integrity": "sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==", "dev": true, "dependencies": { "cliui": "^7.0.2", "escalade": "^3.1.1", "get-caller-file": "^2.0.5", "require-directory": "^2.1.1", "string-width": "^4.2.0", "y18n": "^5.0.5", "yargs-parser": "^20.2.2" }, "engines": { "node": ">=10" } }, "node_modules/yargs-parser": { "version": "20.2.4", "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-20.2.4.tgz", "integrity": "sha512-WOkpgNhPTlE73h4VFAFsOnomJVaovO8VqLDzy5saChRBFQFBoMYirowyW+Q9HB4HFF4Z7VZTiG3iSzJJA29yRA==", "dev": true, "engines": { "node": ">=10" } }, "node_modules/yargs-unparser": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/yargs-unparser/-/yargs-unparser-2.0.0.tgz", "integrity": "sha512-7pRTIA9Qc1caZ0bZ6RYRGbHJthJWuakf+WmHK0rVeLkNrrGhfoabBNdue6kdINI6r4if7ocq9aD/n7xwKOdzOA==", "dev": true, "dependencies": { "camelcase": "^6.0.0", "decamelize": "^4.0.0", "flat": "^5.0.2", "is-plain-obj": "^2.1.0" }, "engines": { "node": ">=10" } }, "node_modules/yocto-queue": { "version": "0.1.0", "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", "dev": true, "engines": { "node": ">=10" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } } }, "dependencies": { "@ampproject/remapping": { "version": "2.2.0", "resolved": "https://registry.npmjs.org/@ampproject/remapping/-/remapping-2.2.0.tgz", "integrity": "sha512-qRmjj8nj9qmLTQXXmaR1cck3UXSRMPrbsLJAasZpF+t3riI71BXed5ebIOYwQntykeZuhjsdweEc9BxH5Jc26w==", "requires": { "@jridgewell/gen-mapping": "^0.1.0", "@jridgewell/trace-mapping": "^0.3.9" }, "dependencies": { "@jridgewell/gen-mapping": { "version": "0.1.1", "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.1.1.tgz", "integrity": "sha512-sQXCasFk+U8lWYEe66WxRDOE9PjVz4vSM51fTu3Hw+ClTpUSQb718772vH3pyS5pShp6lvQM7SxgIDXXXmOX7w==", "requires": { "@jridgewell/set-array": "^1.0.0", "@jridgewell/sourcemap-codec": "^1.4.10" } } } }, "@babel/cli": { "version": "7.19.3", "resolved": "https://registry.npmjs.org/@babel/cli/-/cli-7.19.3.tgz", "integrity": "sha512-643/TybmaCAe101m2tSVHi9UKpETXP9c/Ff4mD2tAwkdP6esKIfaauZFc67vGEM6r9fekbEGid+sZhbEnSe3dg==", "dev": true, "requires": { "@jridgewell/trace-mapping": "^0.3.8", "@nicolo-ribaudo/chokidar-2": "2.1.8-no-fsevents.3", "chokidar": "^3.4.0", "commander": "^4.0.1", "convert-source-map": "^1.1.0", "fs-readdir-recursive": "^1.1.0", "glob": "^7.2.0", "make-dir": "^2.1.0", "slash": "^2.0.0" }, "dependencies": { "commander": { "version": "4.1.1", "resolved": "https://registry.npmjs.org/commander/-/commander-4.1.1.tgz", "integrity": "sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA==", "dev": true }, "glob": { "version": "7.2.3", "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz", "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==", "dev": true, "requires": { "fs.realpath": "^1.0.0", "inflight": "^1.0.4", "inherits": "2", "minimatch": "^3.1.1", "once": "^1.3.0", "path-is-absolute": "^1.0.0" } } } }, "@babel/code-frame": { "version": "7.18.6", "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.18.6.tgz", "integrity": "sha512-TDCmlK5eOvH+eH7cdAFlNXeVJqWIQ7gW9tY1GJIpUtFb6CmjVyq2VM3u71bOyR8CRihcCgMUYoDNyLXao3+70Q==", "requires": { "@babel/highlight": "^7.18.6" } }, "@babel/compat-data": { "version": "7.20.1", "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.20.1.tgz", "integrity": "sha512-EWZ4mE2diW3QALKvDMiXnbZpRvlj+nayZ112nK93SnhqOtpdsbVD4W+2tEoT3YNBAG9RBR0ISY758ZkOgsn6pQ==" }, "@babel/core": { "version": "7.20.2", "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.20.2.tgz", "integrity": "sha512-w7DbG8DtMrJcFOi4VrLm+8QM4az8Mo+PuLBKLp2zrYRCow8W/f9xiXm5sN53C8HksCyDQwCKha9JiDoIyPjT2g==", "requires": { "@ampproject/remapping": "^2.1.0", "@babel/code-frame": "^7.18.6", "@babel/generator": "^7.20.2", "@babel/helper-compilation-targets": "^7.20.0", "@babel/helper-module-transforms": "^7.20.2", "@babel/helpers": "^7.20.1", "@babel/parser": "^7.20.2", "@babel/template": "^7.18.10", "@babel/traverse": "^7.20.1", "@babel/types": "^7.20.2", "convert-source-map": "^1.7.0", "debug": "^4.1.0", "gensync": "^1.0.0-beta.2", "json5": "^2.2.1", "semver": "^6.3.0" }, "dependencies": { "semver": { "version": "6.3.0", "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==" } } }, "@babel/generator": { "version": "7.20.3", "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.20.3.tgz", "integrity": "sha512-Wl5ilw2UD1+ZYprHVprxHZJCFeBWlzZYOovE4SDYLZnqCOD11j+0QzNeEWKLLTWM7nixrZEh7vNIyb76MyJg3A==", "requires": { "@babel/types": "^7.20.2", "@jridgewell/gen-mapping": "^0.3.2", "jsesc": "^2.5.1" } }, "@babel/helper-annotate-as-pure": { "version": "7.18.6", "resolved": "https://registry.npmjs.org/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.18.6.tgz", "integrity": "sha512-duORpUiYrEpzKIop6iNbjnwKLAKnJ47csTyRACyEmWj0QdUrm5aqNJGHSSEQSUAvNW0ojX0dOmK9dZduvkfeXA==", "requires": { "@babel/types": "^7.18.6" } }, "@babel/helper-compilation-targets": { "version": "7.20.0", "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.20.0.tgz", "integrity": "sha512-0jp//vDGp9e8hZzBc6N/KwA5ZK3Wsm/pfm4CrY7vzegkVxc65SgSn6wYOnwHe9Js9HRQ1YTCKLGPzDtaS3RoLQ==", "requires": { "@babel/compat-data": "^7.20.0", "@babel/helper-validator-option": "^7.18.6", "browserslist": "^4.21.3", "semver": "^6.3.0" }, "dependencies": { "semver": { "version": "6.3.0", "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==" } } }, "@babel/helper-environment-visitor": { "version": "7.18.9", "resolved": "https://registry.npmjs.org/@babel/helper-environment-visitor/-/helper-environment-visitor-7.18.9.tgz", "integrity": "sha512-3r/aACDJ3fhQ/EVgFy0hpj8oHyHpQc+LPtJoY9SzTThAsStm4Ptegq92vqKoE3vD706ZVFWITnMnxucw+S9Ipg==" }, "@babel/helper-function-name": { "version": "7.19.0", "resolved": "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.19.0.tgz", "integrity": "sha512-WAwHBINyrpqywkUH0nTnNgI5ina5TFn85HKS0pbPDfxFfhyR/aNQEn4hGi1P1JyT//I0t4OgXUlofzWILRvS5w==", "requires": { "@babel/template": "^7.18.10", "@babel/types": "^7.19.0" } }, "@babel/helper-hoist-variables": { "version": "7.18.6", "resolved": "https://registry.npmjs.org/@babel/helper-hoist-variables/-/helper-hoist-variables-7.18.6.tgz", "integrity": "sha512-UlJQPkFqFULIcyW5sbzgbkxn2FKRgwWiRexcuaR8RNJRy8+LLveqPjwZV/bwrLZCN0eUHD/x8D0heK1ozuoo6Q==", "requires": { "@babel/types": "^7.18.6" } }, "@babel/helper-member-expression-to-functions": { "version": "7.18.9", "resolved": "https://registry.npmjs.org/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.18.9.tgz", "integrity": "sha512-RxifAh2ZoVU67PyKIO4AMi1wTenGfMR/O/ae0CCRqwgBAt5v7xjdtRw7UoSbsreKrQn5t7r89eruK/9JjYHuDg==", "requires": { "@babel/types": "^7.18.9" } }, "@babel/helper-module-imports": { "version": "7.18.6", "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.18.6.tgz", "integrity": "sha512-0NFvs3VkuSYbFi1x2Vd6tKrywq+z/cLeYC/RJNFrIX/30Bf5aiGYbtvGXolEktzJH8o5E5KJ3tT+nkxuuZFVlA==", "requires": { "@babel/types": "^7.18.6" } }, "@babel/helper-module-transforms": { "version": "7.20.2", "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.20.2.tgz", "integrity": "sha512-zvBKyJXRbmK07XhMuujYoJ48B5yvvmM6+wcpv6Ivj4Yg6qO7NOZOSnvZN9CRl1zz1Z4cKf8YejmCMh8clOoOeA==", "requires": { "@babel/helper-environment-visitor": "^7.18.9", "@babel/helper-module-imports": "^7.18.6", "@babel/helper-simple-access": "^7.20.2", "@babel/helper-split-export-declaration": "^7.18.6", "@babel/helper-validator-identifier": "^7.19.1", "@babel/template": "^7.18.10", "@babel/traverse": "^7.20.1", "@babel/types": "^7.20.2" } }, "@babel/helper-optimise-call-expression": { "version": "7.18.6", "resolved": "https://registry.npmjs.org/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.18.6.tgz", "integrity": "sha512-HP59oD9/fEHQkdcbgFCnbmgH5vIQTJbxh2yf+CdM89/glUNnuzr87Q8GIjGEnOktTROemO0Pe0iPAYbqZuOUiA==", "requires": { "@babel/types": "^7.18.6" } }, "@babel/helper-plugin-utils": { "version": "7.22.5", "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.22.5.tgz", "integrity": "sha512-uLls06UVKgFG9QD4OeFYLEGteMIAa5kpTPcFL28yuCIIzsf6ZyKZMllKVOCZFhiZ5ptnwX4mtKdWCBE/uT4amg==" }, "@babel/helper-replace-supers": { "version": "7.19.1", "resolved": "https://registry.npmjs.org/@babel/helper-replace-supers/-/helper-replace-supers-7.19.1.tgz", "integrity": "sha512-T7ahH7wV0Hfs46SFh5Jz3s0B6+o8g3c+7TMxu7xKfmHikg7EAZ3I2Qk9LFhjxXq8sL7UkP5JflezNwoZa8WvWw==", "requires": { "@babel/helper-environment-visitor": "^7.18.9", "@babel/helper-member-expression-to-functions": "^7.18.9", "@babel/helper-optimise-call-expression": "^7.18.6", "@babel/traverse": "^7.19.1", "@babel/types": "^7.19.0" } }, "@babel/helper-simple-access": { "version": "7.20.2", "resolved": "https://registry.npmjs.org/@babel/helper-simple-access/-/helper-simple-access-7.20.2.tgz", "integrity": "sha512-+0woI/WPq59IrqDYbVGfshjT5Dmk/nnbdpcF8SnMhhXObpTq2KNBdLFRFrkVdbDOyUmHBCxzm5FHV1rACIkIbA==", "requires": { "@babel/types": "^7.20.2" } }, "@babel/helper-split-export-declaration": { "version": "7.18.6", "resolved": "https://registry.npmjs.org/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.18.6.tgz", "integrity": "sha512-bde1etTx6ZyTmobl9LLMMQsaizFVZrquTEHOqKeQESMKo4PlObf+8+JA25ZsIpZhT/WEd39+vOdLXAFG/nELpA==", "requires": { "@babel/types": "^7.18.6" } }, "@babel/helper-string-parser": { "version": "7.22.5", "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.22.5.tgz", "integrity": "sha512-mM4COjgZox8U+JcXQwPijIZLElkgEpO5rsERVDJTc2qfCDfERyob6k5WegS14SX18IIjv+XD+GrqNumY5JRCDw==" }, "@babel/helper-validator-identifier": { "version": "7.22.5", "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.22.5.tgz", "integrity": "sha512-aJXu+6lErq8ltp+JhkJUfk1MTGyuA4v7f3pA+BJ5HLfNC6nAQ0Cpi9uOquUj8Hehg0aUiHzWQbOVJGao6ztBAQ==" }, "@babel/helper-validator-option": { "version": "7.18.6", "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.18.6.tgz", "integrity": "sha512-XO7gESt5ouv/LRJdrVjkShckw6STTaB7l9BrpBaAHDeF5YZT+01PCwmR0SJHnkW6i8OwW/EVWRShfi4j2x+KQw==" }, "@babel/helper-wrap-function": { "version": "7.19.0", "resolved": "https://registry.npmjs.org/@babel/helper-wrap-function/-/helper-wrap-function-7.19.0.tgz", "integrity": "sha512-txX8aN8CZyYGTwcLhlk87KRqncAzhh5TpQamZUa0/u3an36NtDpUP6bQgBCBcLeBs09R/OwQu3OjK0k/HwfNDg==", "requires": { "@babel/helper-function-name": "^7.19.0", "@babel/template": "^7.18.10", "@babel/traverse": "^7.19.0", "@babel/types": "^7.19.0" } }, "@babel/helpers": { "version": "7.20.1", "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.20.1.tgz", "integrity": "sha512-J77mUVaDTUJFZ5BpP6mMn6OIl3rEWymk2ZxDBQJUG3P+PbmyMcF3bYWvz0ma69Af1oobDqT/iAsvzhB58xhQUg==", "requires": { "@babel/template": "^7.18.10", "@babel/traverse": "^7.20.1", "@babel/types": "^7.20.0" } }, "@babel/highlight": { "version": "7.18.6", "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.18.6.tgz", "integrity": "sha512-u7stbOuYjaPezCuLj29hNW1v64M2Md2qupEKP1fHc7WdOA3DgLh37suiSrZYY7haUB7iBeQZ9P1uiRF359do3g==", "requires": { "@babel/helper-validator-identifier": "^7.18.6", "chalk": "^2.0.0", "js-tokens": "^4.0.0" } }, "@babel/parser": { "version": "7.22.5", "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.22.5.tgz", "integrity": "sha512-DFZMC9LJUG9PLOclRC32G63UXwzqS2koQC8dkx+PLdmt1xSePYpbT/NbsrJy8Q/muXz7o/h/d4A7Fuyixm559Q==" }, "@babel/plugin-proposal-function-sent": { "version": "7.12.13", "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-function-sent/-/plugin-proposal-function-sent-7.12.13.tgz", "integrity": "sha512-nw5dSsy0+o+WBE372ooERkkZmFv2KJcujzTB5SdhQPKIElVA1pa7hclD23Vzl4VlcoJsC7KCCXpww2qAkbrrKA==", "requires": { "@babel/helper-plugin-utils": "^7.12.13", "@babel/helper-wrap-function": "^7.12.13", "@babel/plugin-syntax-function-sent": "^7.12.13" } }, "@babel/plugin-syntax-async-generators": { "version": "7.8.4", "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-async-generators/-/plugin-syntax-async-generators-7.8.4.tgz", "integrity": "sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw==", "requires": { "@babel/helper-plugin-utils": "^7.8.0" } }, "@babel/plugin-syntax-function-sent": { "version": "7.12.13", "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-function-sent/-/plugin-syntax-function-sent-7.12.13.tgz", "integrity": "sha512-Uv9lAv+/vX8hmvC2rTUvywJacR517eRqTKfLZrtLAoMGUjfQSZ0nPEFJWmfJs1H54zBaIj15ATfUnkheZnSK9w==", "requires": { "@babel/helper-plugin-utils": "^7.12.13" } }, "@babel/plugin-transform-arrow-functions": { "version": "7.18.6", "resolved": "https://registry.npmjs.org/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.18.6.tgz", "integrity": "sha512-9S9X9RUefzrsHZmKMbDXxweEH+YlE8JJEuat9FdvW9Qh1cw7W64jELCtWNkPBPX5En45uy28KGvA/AySqUh8CQ==", "requires": { "@babel/helper-plugin-utils": "^7.18.6" } }, "@babel/plugin-transform-block-scoping": { "version": "7.19.4", "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.19.4.tgz", "integrity": "sha512-934S2VLLlt2hRJwPf4MczaOr4hYF0z+VKPwqTNxyKX7NthTiPfhuKFWQZHXRM0vh/wo/VyXB3s4bZUNA08l+tQ==", "requires": { "@babel/helper-plugin-utils": "^7.19.0" } }, "@babel/plugin-transform-classes": { "version": "7.19.0", "resolved": "https://registry.npmjs.org/@babel/plugin-transform-classes/-/plugin-transform-classes-7.19.0.tgz", "integrity": "sha512-YfeEE9kCjqTS9IitkgfJuxjcEtLUHMqa8yUJ6zdz8vR7hKuo6mOy2C05P0F1tdMmDCeuyidKnlrw/iTppHcr2A==", "requires": { "@babel/helper-annotate-as-pure": "^7.18.6", "@babel/helper-compilation-targets": "^7.19.0", "@babel/helper-environment-visitor": "^7.18.9", "@babel/helper-function-name": "^7.19.0", "@babel/helper-optimise-call-expression": "^7.18.6", "@babel/helper-plugin-utils": "^7.19.0", "@babel/helper-replace-supers": "^7.18.9", "@babel/helper-split-export-declaration": "^7.18.6", "globals": "^11.1.0" } }, "@babel/plugin-transform-for-of": { "version": "7.18.8", "resolved": "https://registry.npmjs.org/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.18.8.tgz", "integrity": "sha512-yEfTRnjuskWYo0k1mHUqrVWaZwrdq8AYbfrpqULOJOaucGSp4mNMVps+YtA8byoevxS/urwU75vyhQIxcCgiBQ==", "requires": { "@babel/helper-plugin-utils": "^7.18.6" } }, "@babel/plugin-transform-modules-commonjs": { "version": "7.19.6", "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.19.6.tgz", "integrity": "sha512-8PIa1ym4XRTKuSsOUXqDG0YaOlEuTVvHMe5JCfgBMOtHvJKw/4NGovEGN33viISshG/rZNVrACiBmPQLvWN8xQ==", "dev": true, "requires": { "@babel/helper-module-transforms": "^7.19.6", "@babel/helper-plugin-utils": "^7.19.0", "@babel/helper-simple-access": "^7.19.4" } }, "@babel/plugin-transform-parameters": { "version": "7.22.5", "resolved": "https://registry.npmjs.org/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.22.5.tgz", "integrity": "sha512-AVkFUBurORBREOmHRKo06FjHYgjrabpdqRSwq6+C7R5iTCZOsM4QbcB27St0a4U6fffyAOqh3s/qEfybAhfivg==", "dev": true, "requires": { "@babel/helper-plugin-utils": "^7.22.5" } }, "@babel/runtime": { "version": "7.22.5", "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.22.5.tgz", "integrity": "sha512-ecjvYlnAaZ/KVneE/OdKYBYfgXV3Ptu6zQWmgEF7vwKhQnvVS6bjMD2XYgj+SNvQ1GfK/pjgokfPkC/2CO8CuA==", "requires": { "regenerator-runtime": "^0.13.11" } }, "@babel/template": { "version": "7.18.10", "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.18.10.tgz", "integrity": "sha512-TI+rCtooWHr3QJ27kJxfjutghu44DLnasDMwpDqCXVTal9RLp3RSYNh4NdBrRP2cQAoG9A8juOQl6P6oZG4JxA==", "requires": { "@babel/code-frame": "^7.18.6", "@babel/parser": "^7.18.10", "@babel/types": "^7.18.10" } }, "@babel/traverse": { "version": "7.20.1", "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.20.1.tgz", "integrity": "sha512-d3tN8fkVJwFLkHkBN479SOsw4DMZnz8cdbL/gvuDuzy3TS6Nfw80HuQqhw1pITbIruHyh7d1fMA47kWzmcUEGA==", "requires": { "@babel/code-frame": "^7.18.6", "@babel/generator": "^7.20.1", "@babel/helper-environment-visitor": "^7.18.9", "@babel/helper-function-name": "^7.19.0", "@babel/helper-hoist-variables": "^7.18.6", "@babel/helper-split-export-declaration": "^7.18.6", "@babel/parser": "^7.20.1", "@babel/types": "^7.20.0", "debug": "^4.1.0", "globals": "^11.1.0" } }, "@babel/types": { "version": "7.22.5", "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.22.5.tgz", "integrity": "sha512-zo3MIHGOkPOfoRXitsgHLjEXmlDaD/5KU1Uzuc9GNiZPhSqVxVRtxuPaSBZDsYZ9qV88AjtMtWW7ww98loJ9KA==", "requires": { "@babel/helper-string-parser": "^7.22.5", "@babel/helper-validator-identifier": "^7.22.5", "to-fast-properties": "^2.0.0" } }, "@jridgewell/gen-mapping": { "version": "0.3.2", "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.2.tgz", "integrity": "sha512-mh65xKQAzI6iBcFzwv28KVWSmCkdRBWoOh+bYQGW3+6OZvbbN3TqMGo5hqYxQniRcH9F2VZIoJCm4pa3BPDK/A==", "requires": { "@jridgewell/set-array": "^1.0.1", "@jridgewell/sourcemap-codec": "^1.4.10", "@jridgewell/trace-mapping": "^0.3.9" } }, "@jridgewell/resolve-uri": { "version": "3.1.0", "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.0.tgz", "integrity": "sha512-F2msla3tad+Mfht5cJq7LSXcdudKTWCVYUgw6pLFOOHSTtZlj6SWNYAp+AhuqLmWdBO2X5hPrLcu8cVP8fy28w==" }, "@jridgewell/set-array": { "version": "1.1.2", "resolved": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.1.2.tgz", "integrity": "sha512-xnkseuNADM0gt2bs+BvhO0p78Mk762YnZdsuzFV018NoG1Sj1SCQvpSqa7XUaTam5vAGasABV9qXASMKnFMwMw==" }, "@jridgewell/sourcemap-codec": { "version": "1.4.14", "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.14.tgz", "integrity": "sha512-XPSJHWmi394fuUuzDnGz1wiKqWfo1yXecHQMRf2l6hztTO+nPru658AyDngaBe7isIxEkRsPR3FZh+s7iVa4Uw==" }, "@jridgewell/trace-mapping": { "version": "0.3.16", "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.16.tgz", "integrity": "sha512-LCQ+NeThyJ4k1W2d+vIKdxuSt9R3pQSZ4P92m7EakaYuXcVWbHuT5bjNcqLd4Rdgi6xYWYDvBJZJLZSLanjDcA==", "requires": { "@jridgewell/resolve-uri": "3.1.0", "@jridgewell/sourcemap-codec": "1.4.14" } }, "@nicolo-ribaudo/chokidar-2": { "version": "2.1.8-no-fsevents.3", "resolved": "https://registry.npmjs.org/@nicolo-ribaudo/chokidar-2/-/chokidar-2-2.1.8-no-fsevents.3.tgz", "integrity": "sha512-s88O1aVtXftvp5bCPB7WnmXc5IwOZZ7YPuwNPt+GtOOXpPvad1LfbmjYv+qII7zP6RU2QGnqve27dnLycEnyEQ==", "dev": true, "optional": true }, "acorn": { "version": "5.7.4", "resolved": "https://registry.npmjs.org/acorn/-/acorn-5.7.4.tgz", "integrity": "sha512-1D++VG7BhrtvQpNbBzovKNc1FLGGEE/oGe7b9xJm/RFHMBeUaUGpluV9RLjZa47YFdPcDAenEYuq9pQPcMdLJg==" }, "acorn-node": { "version": "1.8.2", "resolved": "https://registry.npmjs.org/acorn-node/-/acorn-node-1.8.2.tgz", "integrity": "sha512-8mt+fslDufLYntIoPAaIMUe/lrbrehIiwmR3t2k9LljIzoigEPF27eLk2hy8zSGzmR/ogr7zbRKINMo1u0yh5A==", "dev": true, "requires": { "acorn": "^7.0.0", "acorn-walk": "^7.0.0", "xtend": "^4.0.2" }, "dependencies": { "acorn": { "version": "7.4.1", "resolved": "https://registry.npmjs.org/acorn/-/acorn-7.4.1.tgz", "integrity": "sha512-nQyp0o1/mNdbTO1PO6kHkwSrmgZ0MT/jCCpNiwbUjGoRN4dlBhqJtoQuCnEOKzgTVwg0ZWiCoQy6SxMebQVh8A==", "dev": true } } }, "acorn-walk": { "version": "7.2.0", "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-7.2.0.tgz", "integrity": "sha512-OPdCF6GsMIP+Az+aWfAAOEt2/+iVDKE7oy6lJ098aoe59oAmK76qV6Gw60SbZ8jHuG2wH058GF4pLFbYamYrVA==", "dev": true }, "ansi-colors": { "version": "4.1.1", "resolved": "https://registry.npmjs.org/ansi-colors/-/ansi-colors-4.1.1.tgz", "integrity": "sha512-JoX0apGbHaUJBNl6yF+p6JAFYZ666/hhCGKN5t9QFjbJQKUU/g8MNbFDbvfrgKXvI1QpZplPOnwIo99lX/AAmA==", "dev": true }, "ansi-regex": { "version": "5.0.1", "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", "dev": true }, "ansi-styles": { "version": "3.2.1", "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", "requires": { "color-convert": "^1.9.0" } }, "argparse": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==", "dev": true }, "array-filter": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/array-filter/-/array-filter-1.0.0.tgz", "integrity": "sha1-uveeYubvTCpMC4MSMtr/7CUfnYM=", "dev": true }, "asap": { "version": "2.0.6", "resolved": "https://registry.npmjs.org/asap/-/asap-2.0.6.tgz", "integrity": "sha1-5QNHYR1+aQlDIIu9r+vLwvuGbUY=", "dev": true }, "asn1.js": { "version": "5.4.1", "resolved": "https://registry.npmjs.org/asn1.js/-/asn1.js-5.4.1.tgz", "integrity": "sha512-+I//4cYPccV8LdmBLiX8CYvf9Sp3vQsrqu2QNXRcrbiWvcx/UdlFiqUJJzxRQxgsZmvhXhn4cSKeSmoFjVdupA==", "dev": true, "requires": { "bn.js": "^4.0.0", "inherits": "^2.0.1", "minimalistic-assert": "^1.0.0", "safer-buffer": "^2.1.0" }, "dependencies": { "bn.js": { "version": "4.12.0", "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz", "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==", "dev": true } } }, "assert": { "version": "1.5.0", "resolved": "https://registry.npmjs.org/assert/-/assert-1.5.0.tgz", "integrity": "sha512-EDsgawzwoun2CZkCgtxJbv392v4nbk9XDD06zI+kQYoBM/3RBWLlEyJARDOmhAAosBjWACEkKL6S+lIZtcAubA==", "dev": true, "requires": { "object-assign": "^4.1.1", "util": "0.10.3" }, "dependencies": { "inherits": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.1.tgz", "integrity": "sha1-sX0I0ya0Qj5Wjv9xn5GwscvfafE=", "dev": true }, "util": { "version": "0.10.3", "resolved": "https://registry.npmjs.org/util/-/util-0.10.3.tgz", "integrity": "sha1-evsa/lCAUkZInj23/g7TeTNqwPk=", "dev": true, "requires": { "inherits": "2.0.1" } } } }, "ast-types": { "version": "0.9.6", "resolved": "https://registry.npmjs.org/ast-types/-/ast-types-0.9.6.tgz", "integrity": "sha1-ECyenpAF0+fjgpvwxPok7oYu6bk=" }, "available-typed-arrays": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.2.tgz", "integrity": "sha512-XWX3OX8Onv97LMk/ftVyBibpGwY5a8SmuxZPzeOxqmuEqUCOM9ZE+uIaD1VNJ5QnvU2UQusvmKbuM1FR8QWGfQ==", "dev": true, "requires": { "array-filter": "^1.0.0" } }, "babel-check-duplicated-nodes": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/babel-check-duplicated-nodes/-/babel-check-duplicated-nodes-1.0.0.tgz", "integrity": "sha512-luUr6B28RzichAHdhCaGY6z53sm4+PAxzSedNlhZ9LtdW9txpR3G2Y5983iOnBosky88V08LeaUiDB/NR7vWvQ==", "dev": true }, "balanced-match": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz", "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c=" }, "base64-js": { "version": "1.5.1", "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz", "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==", "dev": true }, "bn.js": { "version": "5.2.0", "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-5.2.0.tgz", "integrity": "sha512-D7iWRBvnZE8ecXiLj/9wbxH7Tk79fAh8IHaTNq1RWRixsS02W+5qS+iE9yq6RYl0asXx5tw0bLhmT5pIfbSquw==", "dev": true }, "brace-expansion": { "version": "1.1.11", "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", "requires": { "balanced-match": "^1.0.0", "concat-map": "0.0.1" } }, "brorand": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/brorand/-/brorand-1.1.0.tgz", "integrity": "sha1-EsJe/kCkXjwyPrhnWgoM5XsiNx8=", "dev": true }, "browser-pack": { "version": "6.1.0", "resolved": "https://registry.npmjs.org/browser-pack/-/browser-pack-6.1.0.tgz", "integrity": "sha512-erYug8XoqzU3IfcU8fUgyHqyOXqIE4tUTTQ+7mqUjQlvnXkOO6OlT9c/ZoJVHYoAaqGxr09CN53G7XIsO4KtWA==", "dev": true, "requires": { "combine-source-map": "~0.8.0", "defined": "^1.0.0", "JSONStream": "^1.0.3", "safe-buffer": "^5.1.1", "through2": "^2.0.0", "umd": "^3.0.0" } }, "browser-resolve": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/browser-resolve/-/browser-resolve-2.0.0.tgz", "integrity": "sha512-7sWsQlYL2rGLy2IWm8WL8DCTJvYLc/qlOnsakDac87SOoCd16WLsaAMdCiAqsTNHIe+SXfaqyxyo6THoWqs8WQ==", "dev": true, "requires": { "resolve": "^1.17.0" } }, "browser-stdout": { "version": "1.3.1", "resolved": "https://registry.npmjs.org/browser-stdout/-/browser-stdout-1.3.1.tgz", "integrity": "sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw==", "dev": true }, "browserify": { "version": "17.0.0", "resolved": "https://registry.npmjs.org/browserify/-/browserify-17.0.0.tgz", "integrity": "sha512-SaHqzhku9v/j6XsQMRxPyBrSP3gnwmE27gLJYZgMT2GeK3J0+0toN+MnuNYDfHwVGQfLiMZ7KSNSIXHemy905w==", "dev": true, "requires": { "assert": "^1.4.0", "browser-pack": "^6.0.1", "browser-resolve": "^2.0.0", "browserify-zlib": "~0.2.0", "buffer": "~5.2.1", "cached-path-relative": "^1.0.0", "concat-stream": "^1.6.0", "console-browserify": "^1.1.0", "constants-browserify": "~1.0.0", "crypto-browserify": "^3.0.0", "defined": "^1.0.0", "deps-sort": "^2.0.1", "domain-browser": "^1.2.0", "duplexer2": "~0.1.2", "events": "^3.0.0", "glob": "^7.1.0", "has": "^1.0.0", "htmlescape": "^1.1.0", "https-browserify": "^1.0.0", "inherits": "~2.0.1", "insert-module-globals": "^7.2.1", "JSONStream": "^1.0.3", "labeled-stream-splicer": "^2.0.0", "mkdirp-classic": "^0.5.2", "module-deps": "^6.2.3", "os-browserify": "~0.3.0", "parents": "^1.0.1", "path-browserify": "^1.0.0", "process": "~0.11.0", "punycode": "^1.3.2", "querystring-es3": "~0.2.0", "read-only-stream": "^2.0.0", "readable-stream": "^2.0.2", "resolve": "^1.1.4", "shasum-object": "^1.0.0", "shell-quote": "^1.6.1", "stream-browserify": "^3.0.0", "stream-http": "^3.0.0", "string_decoder": "^1.1.1", "subarg": "^1.0.0", "syntax-error": "^1.1.1", "through2": "^2.0.0", "timers-browserify": "^1.0.1", "tty-browserify": "0.0.1", "url": "~0.11.0", "util": "~0.12.0", "vm-browserify": "^1.0.0", "xtend": "^4.0.0" }, "dependencies": { "glob": { "version": "7.1.6", "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.6.tgz", "integrity": "sha512-LwaxwyZ72Lk7vZINtNNrywX0ZuLyStrdDtabefZKAY5ZGJhVtgdznluResxNmPitE0SAO+O26sWTHeKSI2wMBA==", "dev": true, "requires": { "fs.realpath": "^1.0.0", "inflight": "^1.0.4", "inherits": "2", "minimatch": "^3.0.4", "once": "^1.3.0", "path-is-absolute": "^1.0.0" } } } }, "browserify-aes": { "version": "1.2.0", "resolved": "https://registry.npmjs.org/browserify-aes/-/browserify-aes-1.2.0.tgz", "integrity": "sha512-+7CHXqGuspUn/Sl5aO7Ea0xWGAtETPXNSAjHo48JfLdPWcMng33Xe4znFvQweqc/uzk5zSOI3H52CYnjCfb5hA==", "dev": true, "requires": { "buffer-xor": "^1.0.3", "cipher-base": "^1.0.0", "create-hash": "^1.1.0", "evp_bytestokey": "^1.0.3", "inherits": "^2.0.1", "safe-buffer": "^5.0.1" } }, "browserify-cipher": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/browserify-cipher/-/browserify-cipher-1.0.1.tgz", "integrity": "sha512-sPhkz0ARKbf4rRQt2hTpAHqn47X3llLkUGn+xEJzLjwY8LRs2p0v7ljvI5EyoRO/mexrNunNECisZs+gw2zz1w==", "dev": true, "requires": { "browserify-aes": "^1.0.4", "browserify-des": "^1.0.0", "evp_bytestokey": "^1.0.0" } }, "browserify-des": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/browserify-des/-/browserify-des-1.0.2.tgz", "integrity": "sha512-BioO1xf3hFwz4kc6iBhI3ieDFompMhrMlnDFC4/0/vd5MokpuAc3R+LYbwTA9A5Yc9pq9UYPqffKpW2ObuwX5A==", "dev": true, "requires": { "cipher-base": "^1.0.1", "des.js": "^1.0.0", "inherits": "^2.0.1", "safe-buffer": "^5.1.2" } }, "browserify-rsa": { "version": "4.1.0", "resolved": "https://registry.npmjs.org/browserify-rsa/-/browserify-rsa-4.1.0.tgz", "integrity": "sha512-AdEER0Hkspgno2aR97SAf6vi0y0k8NuOpGnVH3O99rcA5Q6sh8QxcngtHuJ6uXwnfAXNM4Gn1Gb7/MV1+Ymbog==", "dev": true, "requires": { "bn.js": "^5.0.0", "randombytes": "^2.0.1" } }, "browserify-sign": { "version": "4.2.1", "resolved": "https://registry.npmjs.org/browserify-sign/-/browserify-sign-4.2.1.tgz", "integrity": "sha512-/vrA5fguVAKKAVTNJjgSm1tRQDHUU6DbwO9IROu/0WAzC8PKhucDSh18J0RMvVeHAn5puMd+QHC2erPRNf8lmg==", "dev": true, "requires": { "bn.js": "^5.1.1", "browserify-rsa": "^4.0.1", "create-hash": "^1.2.0", "create-hmac": "^1.1.7", "elliptic": "^6.5.3", "inherits": "^2.0.4", "parse-asn1": "^5.1.5", "readable-stream": "^3.6.0", "safe-buffer": "^5.2.0" }, "dependencies": { "readable-stream": { "version": "3.6.0", "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.0.tgz", "integrity": "sha512-BViHy7LKeTz4oNnkcLJ+lVSL6vpiFeX6/d3oSH8zCW7UxP2onchk+vTGB143xuFjHS3deTgkKoXXymXqymiIdA==", "dev": true, "requires": { "inherits": "^2.0.3", "string_decoder": "^1.1.1", "util-deprecate": "^1.0.1" } }, "safe-buffer": { "version": "5.2.1", "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz", "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==", "dev": true } } }, "browserify-zlib": { "version": "0.2.0", "resolved": "https://registry.npmjs.org/browserify-zlib/-/browserify-zlib-0.2.0.tgz", "integrity": "sha512-Z942RysHXmJrhqk88FmKBVq/v5tqmSkDz7p54G/MGyjMnCFFnC79XWNbg+Vta8W6Wb2qtSZTSxIGkJrRpCFEiA==", "dev": true, "requires": { "pako": "~1.0.5" } }, "browserslist": { "version": "4.21.4", "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.21.4.tgz", "integrity": "sha512-CBHJJdDmgjl3daYjN5Cp5kbTf1mUhZoS+beLklHIvkOWscs83YAhLlF3Wsh/lciQYAcbBJgTOD44VtG31ZM4Hw==", "requires": { "caniuse-lite": "^1.0.30001400", "electron-to-chromium": "^1.4.251", "node-releases": "^2.0.6", "update-browserslist-db": "^1.0.9" } }, "buffer": { "version": "5.2.1", "resolved": "https://registry.npmjs.org/buffer/-/buffer-5.2.1.tgz", "integrity": "sha512-c+Ko0loDaFfuPWiL02ls9Xd3GO3cPVmUobQ6t3rXNUk304u6hGq+8N/kFi+QEIKhzK3uwolVhLzszmfLmMLnqg==", "dev": true, "requires": { "base64-js": "^1.0.2", "ieee754": "^1.1.4" } }, "buffer-from": { "version": "1.1.1", "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.1.tgz", "integrity": "sha512-MQcXEUbCKtEo7bhqEs6560Hyd4XaovZlO/k9V3hjVUF/zwW7KBVdSK4gIt/bzwS9MbR5qob+F5jusZsb0YQK2A==", "dev": true }, "buffer-xor": { "version": "1.0.3", "resolved": "https://registry.npmjs.org/buffer-xor/-/buffer-xor-1.0.3.tgz", "integrity": "sha1-JuYe0UIvtw3ULm42cp7VHYVf6Nk=", "dev": true }, "builtin-status-codes": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/builtin-status-codes/-/builtin-status-codes-3.0.0.tgz", "integrity": "sha1-hZgoeOIbmOHGZCXgPQF0eI9Wnug=", "dev": true }, "cached-path-relative": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/cached-path-relative/-/cached-path-relative-1.1.0.tgz", "integrity": "sha512-WF0LihfemtesFcJgO7xfOoOcnWzY/QHR4qeDqV44jPU3HTI54+LnfXK3SA27AVVGCdZFgjjFFaqUA9Jx7dMJZA==", "dev": true }, "call-bind": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.2.tgz", "integrity": "sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==", "dev": true, "requires": { "function-bind": "^1.1.1", "get-intrinsic": "^1.0.2" } }, "camelcase": { "version": "6.3.0", "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz", "integrity": "sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==", "dev": true }, "caniuse-lite": { "version": "1.0.30001419", "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001419.tgz", "integrity": "sha512-aFO1r+g6R7TW+PNQxKzjITwLOyDhVRLjW0LcwS/HCZGUUKTGNp9+IwLC4xyDSZBygVL/mxaFR3HIV6wEKQuSzw==" }, "chalk": { "version": "2.4.2", "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", "requires": { "ansi-styles": "^3.2.1", "escape-string-regexp": "^1.0.5", "supports-color": "^5.3.0" } }, "chokidar": { "version": "3.5.1", "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.1.tgz", "integrity": "sha512-9+s+Od+W0VJJzawDma/gvBNQqkTiqYTWLuZoyAsivsI4AaWTCzHG06/TMjsf1cYe9Cb97UCEhjz7HvnPk2p/tw==", "dev": true, "optional": true, "requires": { "anymatch": "~3.1.1", "braces": "~3.0.2", "fsevents": "~2.3.1", "glob-parent": "~5.1.0", "is-binary-path": "~2.1.0", "is-glob": "~4.0.1", "normalize-path": "~3.0.0", "readdirp": "~3.5.0" }, "dependencies": { "anymatch": { "version": "3.1.1", "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.1.tgz", "integrity": "sha512-mM8522psRCqzV+6LhomX5wgp25YVibjh8Wj23I5RPkPppSVSjyKD2A2mBJmWGa+KN7f2D6LNh9jkBCeyLktzjg==", "dev": true, "optional": true, "requires": { "normalize-path": "^3.0.0", "picomatch": "^2.0.4" } }, "binary-extensions": { "version": "2.2.0", "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz", "integrity": "sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==", "dev": true, "optional": true }, "braces": { "version": "3.0.2", "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz", "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==", "dev": true, "optional": true, "requires": { "fill-range": "^7.0.1" } }, "fill-range": { "version": "7.0.1", "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz", "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==", "dev": true, "optional": true, "requires": { "to-regex-range": "^5.0.1" } }, "glob-parent": { "version": "5.1.2", "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", "dev": true, "optional": true, "requires": { "is-glob": "^4.0.1" } }, "is-binary-path": { "version": "2.1.0", "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz", "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==", "dev": true, "optional": true, "requires": { "binary-extensions": "^2.0.0" } }, "is-number": { "version": "7.0.0", "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", "dev": true, "optional": true }, "readdirp": { "version": "3.5.0", "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.5.0.tgz", "integrity": "sha512-cMhu7c/8rdhkHXWsY+osBhfSy0JikwpHK/5+imo+LpeasTF8ouErHrlYkwT0++njiyuDvc7OFY5T3ukvZ8qmFQ==", "dev": true, "optional": true, "requires": { "picomatch": "^2.2.1" } }, "to-regex-range": { "version": "5.0.1", "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", "dev": true, "optional": true, "requires": { "is-number": "^7.0.0" } } } }, "cipher-base": { "version": "1.0.4", "resolved": "https://registry.npmjs.org/cipher-base/-/cipher-base-1.0.4.tgz", "integrity": "sha512-Kkht5ye6ZGmwv40uUDZztayT2ThLQGfnj/T71N/XzeZeo3nf8foyW7zGTsPYkEya3m5f3cAypH+qe7YOrM1U2Q==", "dev": true, "requires": { "inherits": "^2.0.1", "safe-buffer": "^5.0.1" } }, "cliui": { "version": "7.0.4", "resolved": "https://registry.npmjs.org/cliui/-/cliui-7.0.4.tgz", "integrity": "sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==", "dev": true, "requires": { "string-width": "^4.2.0", "strip-ansi": "^6.0.0", "wrap-ansi": "^7.0.0" } }, "color-convert": { "version": "1.9.3", "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz", "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==", "requires": { "color-name": "1.1.3" } }, "color-name": { "version": "1.1.3", "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz", "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==" }, "combine-source-map": { "version": "0.8.0", "resolved": "https://registry.npmjs.org/combine-source-map/-/combine-source-map-0.8.0.tgz", "integrity": "sha1-pY0N8ELBhvz4IqjoAV9UUNLXmos=", "dev": true, "requires": { "convert-source-map": "~1.1.0", "inline-source-map": "~0.6.0", "lodash.memoize": "~3.0.3", "source-map": "~0.5.3" }, "dependencies": { "convert-source-map": { "version": "1.1.3", "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.1.3.tgz", "integrity": "sha1-SCnId+n+SbMWHzvzZziI4gRpmGA=", "dev": true } } }, "commander": { "version": "2.20.3", "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz", "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==" }, "commoner": { "version": "0.10.8", "resolved": "https://registry.npmjs.org/commoner/-/commoner-0.10.8.tgz", "integrity": "sha1-NPw2cs0kOT6LtH5wyqApOBH08sU=", "requires": { "commander": "^2.5.0", "detective": "^4.3.1", "glob": "^5.0.15", "graceful-fs": "^4.1.2", "iconv-lite": "^0.4.5", "mkdirp": "^0.5.0", "private": "^0.1.6", "q": "^1.1.2", "recast": "^0.11.17" }, "dependencies": { "recast": { "version": "0.11.23", "resolved": "https://registry.npmjs.org/recast/-/recast-0.11.23.tgz", "integrity": "sha1-RR/TAEqx5N+bTktmN2sqIZEkYtM=", "requires": { "ast-types": "0.9.6", "esprima": "~3.1.0", "private": "~0.1.5", "source-map": "~0.5.0" } } } }, "concat-map": { "version": "0.0.1", "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=" }, "concat-stream": { "version": "1.6.2", "resolved": "https://registry.npmjs.org/concat-stream/-/concat-stream-1.6.2.tgz", "integrity": "sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==", "dev": true, "requires": { "buffer-from": "^1.0.0", "inherits": "^2.0.3", "readable-stream": "^2.2.2", "typedarray": "^0.0.6" } }, "console-browserify": { "version": "1.2.0", "resolved": "https://registry.npmjs.org/console-browserify/-/console-browserify-1.2.0.tgz", "integrity": "sha512-ZMkYO/LkF17QvCPqM0gxw8yUzigAOZOSWSHg91FH6orS7vcEj5dVZTidN2fQ14yBSdg97RqhSNwLUXInd52OTA==", "dev": true }, "constants-browserify": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/constants-browserify/-/constants-browserify-1.0.0.tgz", "integrity": "sha1-wguW2MYXdIqvHBYCF2DNJ/y4y3U=", "dev": true }, "convert-source-map": { "version": "1.7.0", "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.7.0.tgz", "integrity": "sha512-4FJkXzKXEDB1snCFZlLP4gpC3JILicCpGbzG9f9G7tGqGCzETQ2hWPrcinA9oU4wtf2biUaEH5065UnMeR33oA==", "requires": { "safe-buffer": "~5.1.1" } }, "core-util-is": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz", "integrity": "sha1-tf1UIgqivFq1eqtxQMlAdUUDwac=", "dev": true }, "create-ecdh": { "version": "4.0.4", "resolved": "https://registry.npmjs.org/create-ecdh/-/create-ecdh-4.0.4.tgz", "integrity": "sha512-mf+TCx8wWc9VpuxfP2ht0iSISLZnt0JgWlrOKZiNqyUZWnjIaCIVNQArMHnCZKfEYRg6IM7A+NeJoN8gf/Ws0A==", "dev": true, "requires": { "bn.js": "^4.1.0", "elliptic": "^6.5.3" }, "dependencies": { "bn.js": { "version": "4.12.0", "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz", "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==", "dev": true } } }, "create-hash": { "version": "1.2.0", "resolved": "https://registry.npmjs.org/create-hash/-/create-hash-1.2.0.tgz", "integrity": "sha512-z00bCGNHDG8mHAkP7CtT1qVu+bFQUPjYq/4Iv3C3kWjTFV10zIjfSoeqXo9Asws8gwSHDGj/hl2u4OGIjapeCg==", "dev": true, "requires": { "cipher-base": "^1.0.1", "inherits": "^2.0.1", "md5.js": "^1.3.4", "ripemd160": "^2.0.1", "sha.js": "^2.4.0" } }, "create-hmac": { "version": "1.1.7", "resolved": "https://registry.npmjs.org/create-hmac/-/create-hmac-1.1.7.tgz", "integrity": "sha512-MJG9liiZ+ogc4TzUwuvbER1JRdgvUFSB5+VR/g5h82fGaIRWMWddtKBHi7/sVhfjQZ6SehlyhvQYrcYkaUIpLg==", "dev": true, "requires": { "cipher-base": "^1.0.3", "create-hash": "^1.1.0", "inherits": "^2.0.1", "ripemd160": "^2.0.0", "safe-buffer": "^5.0.1", "sha.js": "^2.4.8" } }, "crypto-browserify": { "version": "3.12.0", "resolved": "https://registry.npmjs.org/crypto-browserify/-/crypto-browserify-3.12.0.tgz", "integrity": "sha512-fz4spIh+znjO2VjL+IdhEpRJ3YN6sMzITSBijk6FK2UvTqruSQW+/cCZTSNsMiZNvUeq0CqurF+dAbyiGOY6Wg==", "dev": true, "requires": { "browserify-cipher": "^1.0.0", "browserify-sign": "^4.0.0", "create-ecdh": "^4.0.0", "create-hash": "^1.1.0", "create-hmac": "^1.1.0", "diffie-hellman": "^5.0.0", "inherits": "^2.0.1", "pbkdf2": "^3.0.3", "public-encrypt": "^4.0.0", "randombytes": "^2.0.0", "randomfill": "^1.0.3" } }, "dash-ast": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/dash-ast/-/dash-ast-1.0.0.tgz", "integrity": "sha512-Vy4dx7gquTeMcQR/hDkYLGUnwVil6vk4FOOct+djUnHOUWt+zJPJAaRIXaAFkPXtJjvlY7o3rfRu0/3hpnwoUA==", "dev": true }, "debug": { "version": "4.1.1", "resolved": "https://registry.npmjs.org/debug/-/debug-4.1.1.tgz", "integrity": "sha512-pYAIzeRo8J6KPEaJ0VWOh5Pzkbw/RetuzehGM7QRRX5he4fPHx2rdKMB256ehJCkX+XRQm16eZLqLNS8RSZXZw==", "requires": { "ms": "^2.1.1" } }, "decamelize": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-4.0.0.tgz", "integrity": "sha512-9iE1PgSik9HeIIw2JO94IidnE3eBoQrFJ3w7sFuzSX4DpmZ3v5sZpUiV5Swcf6mQEF+Y0ru8Neo+p+nyh2J+hQ==", "dev": true }, "define-properties": { "version": "1.1.3", "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.1.3.tgz", "integrity": "sha512-3MqfYKj2lLzdMSf8ZIZE/V+Zuy+BgD6f164e8K2w7dgnpKArBDerGYpM46IYYcjnkdPNMjPk9A6VFB8+3SKlXQ==", "dev": true, "requires": { "object-keys": "^1.0.12" } }, "defined": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/defined/-/defined-1.0.0.tgz", "integrity": "sha1-yY2bzvdWdBiOEQlpFRGZ45sfppM=" }, "deps-sort": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/deps-sort/-/deps-sort-2.0.1.tgz", "integrity": "sha512-1orqXQr5po+3KI6kQb9A4jnXT1PBwggGl2d7Sq2xsnOeI9GPcE/tGcF9UiSZtZBM7MukY4cAh7MemS6tZYipfw==", "dev": true, "requires": { "JSONStream": "^1.0.3", "shasum-object": "^1.0.0", "subarg": "^1.0.0", "through2": "^2.0.0" } }, "des.js": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/des.js/-/des.js-1.0.1.tgz", "integrity": "sha512-Q0I4pfFrv2VPd34/vfLrFOoRmlYj3OV50i7fskps1jZWK1kApMWWT9G6RRUeYedLcBDIhnSDaUvJMb3AhUlaEA==", "dev": true, "requires": { "inherits": "^2.0.1", "minimalistic-assert": "^1.0.0" } }, "detective": { "version": "4.7.1", "resolved": "https://registry.npmjs.org/detective/-/detective-4.7.1.tgz", "integrity": "sha512-H6PmeeUcZloWtdt4DAkFyzFL94arpHr3NOwwmVILFiy+9Qd4JTxxXrzfyGk/lmct2qVGBwTSwSXagqu2BxmWig==", "requires": { "acorn": "^5.2.1", "defined": "^1.0.0" } }, "diff": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/diff/-/diff-5.0.0.tgz", "integrity": "sha512-/VTCrvm5Z0JGty/BWHljh+BAiw3IK+2j87NGMu8Nwc/f48WoDAC395uomO9ZD117ZOBaHmkX1oyLvkVM/aIT3w==", "dev": true }, "diffie-hellman": { "version": "5.0.3", "resolved": "https://registry.npmjs.org/diffie-hellman/-/diffie-hellman-5.0.3.tgz", "integrity": "sha512-kqag/Nl+f3GwyK25fhUMYj81BUOrZ9IuJsjIcDE5icNM9FJHAVm3VcUDxdLPoQtTuUylWm6ZIknYJwwaPxsUzg==", "dev": true, "requires": { "bn.js": "^4.1.0", "miller-rabin": "^4.0.0", "randombytes": "^2.0.0" }, "dependencies": { "bn.js": { "version": "4.12.0", "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz", "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==", "dev": true } } }, "domain-browser": { "version": "1.2.0", "resolved": "https://registry.npmjs.org/domain-browser/-/domain-browser-1.2.0.tgz", "integrity": "sha512-jnjyiM6eRyZl2H+W8Q/zLMA481hzi0eszAaBUzIVnmYVDBbnLxVNnfu1HgEBvCbL+71FrxMl3E6lpKH7Ge3OXA==", "dev": true }, "duplexer2": { "version": "0.1.4", "resolved": "https://registry.npmjs.org/duplexer2/-/duplexer2-0.1.4.tgz", "integrity": "sha1-ixLauHjA1p4+eJEFFmKjL8a93ME=", "dev": true, "requires": { "readable-stream": "^2.0.2" } }, "electron-to-chromium": { "version": "1.4.281", "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.4.281.tgz", "integrity": "sha512-yer0w5wCYdFoZytfmbNhwiGI/3cW06+RV7E23ln4490DVMxs7PvYpbsrSmAiBn/V6gode8wvJlST2YfWgvzWIg==" }, "elliptic": { "version": "6.5.4", "resolved": "https://registry.npmjs.org/elliptic/-/elliptic-6.5.4.tgz", "integrity": "sha512-iLhC6ULemrljPZb+QutR5TQGB+pdW6KGD5RSegS+8sorOZT+rdQFbsQFJgvN3eRqNALqJer4oQ16YvJHlU8hzQ==", "dev": true, "requires": { "bn.js": "^4.11.9", "brorand": "^1.1.0", "hash.js": "^1.0.0", "hmac-drbg": "^1.0.1", "inherits": "^2.0.4", "minimalistic-assert": "^1.0.1", "minimalistic-crypto-utils": "^1.0.1" }, "dependencies": { "bn.js": { "version": "4.12.0", "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz", "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==", "dev": true } } }, "emoji-regex": { "version": "8.0.0", "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", "dev": true }, "es-abstract": { "version": "1.18.0", "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.18.0.tgz", "integrity": "sha512-LJzK7MrQa8TS0ja2w3YNLzUgJCGPdPOV1yVvezjNnS89D+VR08+Szt2mz3YB2Dck/+w5tfIq/RoUAFqJJGM2yw==", "dev": true, "requires": { "call-bind": "^1.0.2", "es-to-primitive": "^1.2.1", "function-bind": "^1.1.1", "get-intrinsic": "^1.1.1", "has": "^1.0.3", "has-symbols": "^1.0.2", "is-callable": "^1.2.3", "is-negative-zero": "^2.0.1", "is-regex": "^1.1.2", "is-string": "^1.0.5", "object-inspect": "^1.9.0", "object-keys": "^1.1.1", "object.assign": "^4.1.2", "string.prototype.trimend": "^1.0.4", "string.prototype.trimstart": "^1.0.4", "unbox-primitive": "^1.0.0" }, "dependencies": { "has-symbols": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.2.tgz", "integrity": "sha512-chXa79rL/UC2KlX17jo3vRGz0azaWEx5tGqZg5pO3NUyEJVB17dMruQlzCCOfUvElghKcm5194+BCRvi2Rv/Gw==", "dev": true }, "object.assign": { "version": "4.1.2", "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.2.tgz", "integrity": "sha512-ixT2L5THXsApyiUPYKmW+2EHpXXe5Ii3M+f4e+aJFAHao5amFRW6J0OO6c/LU8Be47utCx2GL89hxGB6XSmKuQ==", "dev": true, "requires": { "call-bind": "^1.0.0", "define-properties": "^1.1.3", "has-symbols": "^1.0.1", "object-keys": "^1.1.1" } } } }, "es-to-primitive": { "version": "1.2.1", "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.2.1.tgz", "integrity": "sha512-QCOllgZJtaUo9miYBcLChTUaHNjJF3PYs1VidD7AwiEj1kYxKeQTctLAezAOH5ZKRH0g2IgPn6KwB4IT8iRpvA==", "dev": true, "requires": { "is-callable": "^1.1.4", "is-date-object": "^1.0.1", "is-symbol": "^1.0.2" } }, "escalade": { "version": "3.1.1", "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz", "integrity": "sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==" }, "escape-string-regexp": { "version": "1.0.5", "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==" }, "esprima": { "version": "3.1.3", "resolved": "https://registry.npmjs.org/esprima/-/esprima-3.1.3.tgz", "integrity": "sha1-/cpRzuYTOJXjyI1TXOSdv/YqRjM=" }, "events": { "version": "3.3.0", "resolved": "https://registry.npmjs.org/events/-/events-3.3.0.tgz", "integrity": "sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==", "dev": true }, "evp_bytestokey": { "version": "1.0.3", "resolved": "https://registry.npmjs.org/evp_bytestokey/-/evp_bytestokey-1.0.3.tgz", "integrity": "sha512-/f2Go4TognH/KvCISP7OUsHn85hT9nUkxxA9BEWxFn+Oj9o8ZNLm/40hdlgSLyuOimsrTKLUMEorQexp/aPQeA==", "dev": true, "requires": { "md5.js": "^1.3.4", "safe-buffer": "^5.1.1" } }, "fast-safe-stringify": { "version": "2.0.7", "resolved": "https://registry.npmjs.org/fast-safe-stringify/-/fast-safe-stringify-2.0.7.tgz", "integrity": "sha512-Utm6CdzT+6xsDk2m8S6uL8VHxNwI6Jub+e9NYTcAms28T84pTa25GJQV9j0CY0N1rM8hK4x6grpF2BQf+2qwVA==", "dev": true }, "find-up": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", "dev": true, "requires": { "locate-path": "^6.0.0", "path-exists": "^4.0.0" } }, "flat": { "version": "5.0.2", "resolved": "https://registry.npmjs.org/flat/-/flat-5.0.2.tgz", "integrity": "sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==", "dev": true }, "foreach": { "version": "2.0.5", "resolved": "https://registry.npmjs.org/foreach/-/foreach-2.0.5.tgz", "integrity": "sha1-C+4AUBiusmDQo6865ljdATbsG5k=", "dev": true }, "fs-readdir-recursive": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/fs-readdir-recursive/-/fs-readdir-recursive-1.1.0.tgz", "integrity": "sha512-GNanXlVr2pf02+sPN40XN8HG+ePaNcvM0q5mZBd668Obwb0yD5GiUbZOFgwn8kGMY6I3mdyDJzieUy3PTYyTRA==", "dev": true }, "fs.realpath": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=", "dev": true }, "fsevents": { "version": "2.3.2", "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz", "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==", "dev": true, "optional": true }, "function-bind": { "version": "1.1.1", "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz", "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==", "dev": true }, "gensync": { "version": "1.0.0-beta.2", "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz", "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==" }, "get-assigned-identifiers": { "version": "1.2.0", "resolved": "https://registry.npmjs.org/get-assigned-identifiers/-/get-assigned-identifiers-1.2.0.tgz", "integrity": "sha512-mBBwmeGTrxEMO4pMaaf/uUEFHnYtwr8FTe8Y/mer4rcV/bye0qGm6pw1bGZFGStxC5O76c5ZAVBGnqHmOaJpdQ==", "dev": true }, "get-caller-file": { "version": "2.0.5", "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz", "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==", "dev": true }, "get-intrinsic": { "version": "1.1.1", "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.1.1.tgz", "integrity": "sha512-kWZrnVM42QCiEA2Ig1bG8zjoIMOgxWwYCEeNdwY6Tv/cOSeGpcoX4pXHfKUxNKVoArnrEr2e9srnAxxGIraS9Q==", "dev": true, "requires": { "function-bind": "^1.1.1", "has": "^1.0.3", "has-symbols": "^1.0.1" } }, "glob": { "version": "5.0.15", "resolved": "https://registry.npmjs.org/glob/-/glob-5.0.15.tgz", "integrity": "sha1-G8k2ueAvSmA/zCIuz3Yz0wuLk7E=", "requires": { "inflight": "^1.0.4", "inherits": "2", "minimatch": "2 || 3", "once": "^1.3.0", "path-is-absolute": "^1.0.0" } }, "glob-parent": { "version": "5.1.2", "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", "dev": true, "requires": { "is-glob": "^4.0.1" } }, "globals": { "version": "11.12.0", "resolved": "https://registry.npmjs.org/globals/-/globals-11.12.0.tgz", "integrity": "sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==" }, "graceful-fs": { "version": "4.2.3", "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.3.tgz", "integrity": "sha512-a30VEBm4PEdx1dRB7MFK7BejejvCvBronbLjht+sHuGYj8PHs7M/5Z+rt5lw551vZ7yfTCj4Vuyy3mSJytDWRQ==" }, "has": { "version": "1.0.3", "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz", "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==", "dev": true, "requires": { "function-bind": "^1.1.1" } }, "has-bigints": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/has-bigints/-/has-bigints-1.0.1.tgz", "integrity": "sha512-LSBS2LjbNBTf6287JEbEzvJgftkF5qFkmCo9hDRpAzKhUOlJ+hx8dd4USs00SgsUNwc4617J9ki5YtEClM2ffA==", "dev": true }, "has-flag": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==" }, "has-symbols": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.1.tgz", "integrity": "sha512-PLcsoqu++dmEIZB+6totNFKq/7Do+Z0u4oT0zKOJNl3lYK6vGwwu2hjHs+68OEZbTjiUE9bgOABXbP/GvrS0Kg==", "dev": true }, "hash-base": { "version": "3.1.0", "resolved": "https://registry.npmjs.org/hash-base/-/hash-base-3.1.0.tgz", "integrity": "sha512-1nmYp/rhMDiE7AYkDw+lLwlAzz0AntGIe51F3RfFfEqyQ3feY2eI/NcwC6umIQVOASPMsWJLJScWKSSvzL9IVA==", "dev": true, "requires": { "inherits": "^2.0.4", "readable-stream": "^3.6.0", "safe-buffer": "^5.2.0" }, "dependencies": { "readable-stream": { "version": "3.6.0", "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.0.tgz", "integrity": "sha512-BViHy7LKeTz4oNnkcLJ+lVSL6vpiFeX6/d3oSH8zCW7UxP2onchk+vTGB143xuFjHS3deTgkKoXXymXqymiIdA==", "dev": true, "requires": { "inherits": "^2.0.3", "string_decoder": "^1.1.1", "util-deprecate": "^1.0.1" } }, "safe-buffer": { "version": "5.2.1", "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz", "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==", "dev": true } } }, "hash.js": { "version": "1.1.7", "resolved": "https://registry.npmjs.org/hash.js/-/hash.js-1.1.7.tgz", "integrity": "sha512-taOaskGt4z4SOANNseOviYDvjEJinIkRgmp7LbKP2YTTmVxWBl87s/uzK9r+44BclBSp2X7K1hqeNfz9JbBeXA==", "dev": true, "requires": { "inherits": "^2.0.3", "minimalistic-assert": "^1.0.1" } }, "he": { "version": "1.2.0", "resolved": "https://registry.npmjs.org/he/-/he-1.2.0.tgz", "integrity": "sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==", "dev": true }, "hmac-drbg": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/hmac-drbg/-/hmac-drbg-1.0.1.tgz", "integrity": "sha1-0nRXAQJabHdabFRXk+1QL8DGSaE=", "dev": true, "requires": { "hash.js": "^1.0.3", "minimalistic-assert": "^1.0.0", "minimalistic-crypto-utils": "^1.0.1" } }, "htmlescape": { "version": "1.1.1", "resolved": "https://registry.npmjs.org/htmlescape/-/htmlescape-1.1.1.tgz", "integrity": "sha1-OgPtwiFLyjtmQko+eVk0lQnLA1E=", "dev": true }, "https-browserify": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/https-browserify/-/https-browserify-1.0.0.tgz", "integrity": "sha1-7AbBDgo0wPL68Zn3/X/Hj//QPHM=", "dev": true }, "iconv-lite": { "version": "0.4.24", "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz", "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==", "requires": { "safer-buffer": ">= 2.1.2 < 3" } }, "ieee754": { "version": "1.2.1", "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz", "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==", "dev": true }, "inflight": { "version": "1.0.6", "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=", "requires": { "once": "^1.3.0", "wrappy": "1" } }, "inherits": { "version": "2.0.4", "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==" }, "inline-source-map": { "version": "0.6.2", "resolved": "https://registry.npmjs.org/inline-source-map/-/inline-source-map-0.6.2.tgz", "integrity": "sha1-+Tk0ccGKedFyT4Y/o4tYY3Ct4qU=", "dev": true, "requires": { "source-map": "~0.5.3" } }, "insert-module-globals": { "version": "7.2.1", "resolved": "https://registry.npmjs.org/insert-module-globals/-/insert-module-globals-7.2.1.tgz", "integrity": "sha512-ufS5Qq9RZN+Bu899eA9QCAYThY+gGW7oRkmb0vC93Vlyu/CFGcH0OYPEjVkDXA5FEbTt1+VWzdoOD3Ny9N+8tg==", "dev": true, "requires": { "acorn-node": "^1.5.2", "combine-source-map": "^0.8.0", "concat-stream": "^1.6.1", "is-buffer": "^1.1.0", "JSONStream": "^1.0.3", "path-is-absolute": "^1.0.1", "process": "~0.11.0", "through2": "^2.0.0", "undeclared-identifiers": "^1.1.2", "xtend": "^4.0.0" } }, "is-arguments": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/is-arguments/-/is-arguments-1.1.0.tgz", "integrity": "sha512-1Ij4lOMPl/xB5kBDn7I+b2ttPMKa8szhEIrXDuXQD/oe3HJLTLhqhgGspwgyGd6MOywBUqVvYicF72lkgDnIHg==", "dev": true, "requires": { "call-bind": "^1.0.0" } }, "is-bigint": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/is-bigint/-/is-bigint-1.0.1.tgz", "integrity": "sha512-J0ELF4yHFxHy0cmSxZuheDOz2luOdVvqjwmEcj8H/L1JHeuEDSDbeRP+Dk9kFVk5RTFzbucJ2Kb9F7ixY2QaCg==", "dev": true }, "is-boolean-object": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/is-boolean-object/-/is-boolean-object-1.1.0.tgz", "integrity": "sha512-a7Uprx8UtD+HWdyYwnD1+ExtTgqQtD2k/1yJgtXP6wnMm8byhkoTZRl+95LLThpzNZJ5aEvi46cdH+ayMFRwmA==", "dev": true, "requires": { "call-bind": "^1.0.0" } }, "is-buffer": { "version": "1.1.6", "resolved": "https://registry.npmjs.org/is-buffer/-/is-buffer-1.1.6.tgz", "integrity": "sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==", "dev": true }, "is-callable": { "version": "1.2.3", "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.2.3.tgz", "integrity": "sha512-J1DcMe8UYTBSrKezuIUTUwjXsho29693unXM2YhJUTR2txK/eG47bvNa/wipPFmZFgr/N6f1GA66dv0mEyTIyQ==", "dev": true }, "is-core-module": { "version": "2.2.0", "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.2.0.tgz", "integrity": "sha512-XRAfAdyyY5F5cOXn7hYQDqh2Xmii+DEfIcQGxK/uNwMHhIkPWO0g8msXcbzLe+MpGoR951MlqM/2iIlU4vKDdQ==", "dev": true, "requires": { "has": "^1.0.3" } }, "is-date-object": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.2.tgz", "integrity": "sha512-USlDT524woQ08aoZFzh3/Z6ch9Y/EWXEHQ/AaRN0SkKq4t2Jw2R2339tSXmwuVoY7LLlBCbOIlx2myP/L5zk0g==", "dev": true }, "is-extglob": { "version": "2.1.1", "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", "integrity": "sha1-qIwCU1eR8C7TfHahueqXc8gz+MI=", "dev": true }, "is-fullwidth-code-point": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", "dev": true }, "is-generator-function": { "version": "1.0.8", "resolved": "https://registry.npmjs.org/is-generator-function/-/is-generator-function-1.0.8.tgz", "integrity": "sha512-2Omr/twNtufVZFr1GhxjOMFPAj2sjc/dKaIqBhvo4qciXfJmITGH6ZGd8eZYNHza8t1y0e01AuqRhJwfWp26WQ==", "dev": true }, "is-glob": { "version": "4.0.1", "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.1.tgz", "integrity": "sha512-5G0tKtBTFImOqDnLB2hG6Bp2qcKEFduo4tZu9MT/H6NQv/ghhy30o55ufafxJ/LdH79LLs2Kfrn85TLKyA7BUg==", "dev": true, "requires": { "is-extglob": "^2.1.1" } }, "is-negative-zero": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/is-negative-zero/-/is-negative-zero-2.0.1.tgz", "integrity": "sha512-2z6JzQvZRa9A2Y7xC6dQQm4FSTSTNWjKIYYTt4246eMTJmIo0Q+ZyOsU66X8lxK1AbB92dFeglPLrhwpeRKO6w==", "dev": true }, "is-number-object": { "version": "1.0.4", "resolved": "https://registry.npmjs.org/is-number-object/-/is-number-object-1.0.4.tgz", "integrity": "sha512-zohwelOAur+5uXtk8O3GPQ1eAcu4ZX3UwxQhUlfFFMNpUd83gXgjbhJh6HmB6LUNV/ieOLQuDwJO3dWJosUeMw==", "dev": true }, "is-plain-obj": { "version": "2.1.0", "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-2.1.0.tgz", "integrity": "sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==", "dev": true }, "is-regex": { "version": "1.1.2", "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.1.2.tgz", "integrity": "sha512-axvdhb5pdhEVThqJzYXwMlVuZwC+FF2DpcOhTS+y/8jVq4trxyPgfcwIxIKiyeuLlSQYKkmUaPQJ8ZE4yNKXDg==", "dev": true, "requires": { "call-bind": "^1.0.2", "has-symbols": "^1.0.1" } }, "is-string": { "version": "1.0.5", "resolved": "https://registry.npmjs.org/is-string/-/is-string-1.0.5.tgz", "integrity": "sha512-buY6VNRjhQMiF1qWDouloZlQbRhDPCebwxSjxMjxgemYT46YMd2NR0/H+fBhEfWX4A/w9TBJ+ol+okqJKFE6vQ==", "dev": true }, "is-symbol": { "version": "1.0.3", "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.3.tgz", "integrity": "sha512-OwijhaRSgqvhm/0ZdAcXNZt9lYdKFpcRDT5ULUuYXPoT794UNOdU+gpT6Rzo7b4V2HUl/op6GqY894AZwv9faQ==", "dev": true, "requires": { "has-symbols": "^1.0.1" } }, "is-typed-array": { "version": "1.1.5", "resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.5.tgz", "integrity": "sha512-S+GRDgJlR3PyEbsX/Fobd9cqpZBuvUS+8asRqYDMLCb2qMzt1oz5m5oxQCxOgUDxiWsOVNi4yaF+/uvdlHlYug==", "dev": true, "requires": { "available-typed-arrays": "^1.0.2", "call-bind": "^1.0.2", "es-abstract": "^1.18.0-next.2", "foreach": "^2.0.5", "has-symbols": "^1.0.1" } }, "is-unicode-supported": { "version": "0.1.0", "resolved": "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-0.1.0.tgz", "integrity": "sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw==", "dev": true }, "isarray": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=", "dev": true }, "js-tokens": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz", "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==" }, "js-yaml": { "version": "4.1.0", "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz", "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==", "dev": true, "requires": { "argparse": "^2.0.1" } }, "jsesc": { "version": "2.5.2", "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-2.5.2.tgz", "integrity": "sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA==" }, "json5": { "version": "2.2.3", "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz", "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==" }, "jsonparse": { "version": "1.3.1", "resolved": "https://registry.npmjs.org/jsonparse/-/jsonparse-1.3.1.tgz", "integrity": "sha1-P02uSpH6wxX3EGL4UhzCOfE2YoA=", "dev": true }, "JSONStream": { "version": "1.3.5", "resolved": "https://registry.npmjs.org/JSONStream/-/JSONStream-1.3.5.tgz", "integrity": "sha512-E+iruNOY8VV9s4JEbe1aNEm6MiszPRr/UfcHMz0TQh1BXSxHK+ASV1R6W4HpjBhSeS+54PIsAMCBmwD06LLsqQ==", "dev": true, "requires": { "jsonparse": "^1.2.0", "through": ">=2.2.7 <3" } }, "labeled-stream-splicer": { "version": "2.0.2", "resolved": "https://registry.npmjs.org/labeled-stream-splicer/-/labeled-stream-splicer-2.0.2.tgz", "integrity": "sha512-Ca4LSXFFZUjPScRaqOcFxneA0VpKZr4MMYCljyQr4LIewTLb3Y0IUTIsnBBsVubIeEfxeSZpSjSsRM8APEQaAw==", "dev": true, "requires": { "inherits": "^2.0.1", "stream-splicer": "^2.0.0" } }, "locate-path": { "version": "6.0.0", "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", "dev": true, "requires": { "p-locate": "^5.0.0" } }, "lodash.memoize": { "version": "3.0.4", "resolved": "https://registry.npmjs.org/lodash.memoize/-/lodash.memoize-3.0.4.tgz", "integrity": "sha1-LcvSwofLwKVcxCMovQxzYVDVPj8=", "dev": true }, "log-symbols": { "version": "4.1.0", "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-4.1.0.tgz", "integrity": "sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg==", "dev": true, "requires": { "chalk": "^4.1.0", "is-unicode-supported": "^0.1.0" }, "dependencies": { "ansi-styles": { "version": "4.3.0", "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", "dev": true, "requires": { "color-convert": "^2.0.1" } }, "chalk": { "version": "4.1.2", "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", "dev": true, "requires": { "ansi-styles": "^4.1.0", "supports-color": "^7.1.0" } }, "color-convert": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", "dev": true, "requires": { "color-name": "~1.1.4" } }, "color-name": { "version": "1.1.4", "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", "dev": true }, "has-flag": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", "dev": true }, "supports-color": { "version": "7.2.0", "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", "dev": true, "requires": { "has-flag": "^4.0.0" } } } }, "lru-cache": { "version": "6.0.0", "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz", "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==", "dev": true, "requires": { "yallist": "^4.0.0" } }, "make-dir": { "version": "2.1.0", "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-2.1.0.tgz", "integrity": "sha512-LS9X+dc8KLxXCb8dni79fLIIUA5VyZoyjSMCwTluaXA0o27cCK0bhXkpgw+sTXVpPy/lSO57ilRixqk0vDmtRA==", "dev": true, "requires": { "pify": "^4.0.1", "semver": "^5.6.0" }, "dependencies": { "semver": { "version": "5.7.1", "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz", "integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==", "dev": true } } }, "md5.js": { "version": "1.3.5", "resolved": "https://registry.npmjs.org/md5.js/-/md5.js-1.3.5.tgz", "integrity": "sha512-xitP+WxNPcTTOgnTJcrhM0xvdPepipPSf3I8EIpGKeFLjt3PlJLIDG3u8EX53ZIubkb+5U2+3rELYpEhHhzdkg==", "dev": true, "requires": { "hash-base": "^3.0.0", "inherits": "^2.0.1", "safe-buffer": "^5.1.2" } }, "miller-rabin": { "version": "4.0.1", "resolved": "https://registry.npmjs.org/miller-rabin/-/miller-rabin-4.0.1.tgz", "integrity": "sha512-115fLhvZVqWwHPbClyntxEVfVDfl9DLLTuJvq3g2O/Oxi8AiNouAHvDSzHS0viUJc+V5vm3eq91Xwqn9dp4jRA==", "dev": true, "requires": { "bn.js": "^4.0.0", "brorand": "^1.0.1" }, "dependencies": { "bn.js": { "version": "4.12.0", "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz", "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==", "dev": true } } }, "minimalistic-assert": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz", "integrity": "sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==", "dev": true }, "minimalistic-crypto-utils": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/minimalistic-crypto-utils/-/minimalistic-crypto-utils-1.0.1.tgz", "integrity": "sha1-9sAMHAsIIkblxNmd+4x8CDsrWCo=", "dev": true }, "minimatch": { "version": "3.1.2", "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", "requires": { "brace-expansion": "^1.1.7" } }, "minimist": { "version": "1.2.6", "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.6.tgz", "integrity": "sha512-Jsjnk4bw3YJqYzbdyBiNsPWHPfO++UGG749Cxs6peCu5Xg4nrena6OVxOYxrQTqww0Jmwt+Ref8rggumkTLz9Q==" }, "mkdirp": { "version": "0.5.3", "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.3.tgz", "integrity": "sha512-P+2gwrFqx8lhew375MQHHeTlY8AuOJSrGf0R5ddkEndUkmwpgUob/vQuBD1V22/Cw1/lJr4x+EjllSezBThzBg==", "requires": { "minimist": "^1.2.5" } }, "mkdirp-classic": { "version": "0.5.3", "resolved": "https://registry.npmjs.org/mkdirp-classic/-/mkdirp-classic-0.5.3.tgz", "integrity": "sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A==", "dev": true }, "mocha": { "version": "10.1.0", "resolved": "https://registry.npmjs.org/mocha/-/mocha-10.1.0.tgz", "integrity": "sha512-vUF7IYxEoN7XhQpFLxQAEMtE4W91acW4B6En9l97MwE9stL1A9gusXfoHZCLVHDUJ/7V5+lbCM6yMqzo5vNymg==", "dev": true, "requires": { "ansi-colors": "4.1.1", "browser-stdout": "1.3.1", "chokidar": "3.5.3", "debug": "4.3.4", "diff": "5.0.0", "escape-string-regexp": "4.0.0", "find-up": "5.0.0", "glob": "7.2.0", "he": "1.2.0", "js-yaml": "4.1.0", "log-symbols": "4.1.0", "minimatch": "5.0.1", "ms": "2.1.3", "nanoid": "3.3.3", "serialize-javascript": "6.0.0", "strip-json-comments": "3.1.1", "supports-color": "8.1.1", "workerpool": "6.2.1", "yargs": "16.2.0", "yargs-parser": "20.2.4", "yargs-unparser": "2.0.0" }, "dependencies": { "anymatch": { "version": "3.1.2", "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.2.tgz", "integrity": "sha512-P43ePfOAIupkguHUycrc4qJ9kz8ZiuOUijaETwX7THt0Y/GNK7v0aa8rY816xWjZ7rJdA5XdMcpVFTKMq+RvWg==", "dev": true, "requires": { "normalize-path": "^3.0.0", "picomatch": "^2.0.4" } }, "binary-extensions": { "version": "2.2.0", "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz", "integrity": "sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==", "dev": true }, "braces": { "version": "3.0.2", "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz", "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==", "dev": true, "requires": { "fill-range": "^7.0.1" } }, "chokidar": { "version": "3.5.3", "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.3.tgz", "integrity": "sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==", "dev": true, "requires": { "anymatch": "~3.1.2", "braces": "~3.0.2", "fsevents": "~2.3.2", "glob-parent": "~5.1.2", "is-binary-path": "~2.1.0", "is-glob": "~4.0.1", "normalize-path": "~3.0.0", "readdirp": "~3.6.0" } }, "debug": { "version": "4.3.4", "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz", "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==", "dev": true, "requires": { "ms": "2.1.2" }, "dependencies": { "ms": { "version": "2.1.2", "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==", "dev": true } } }, "escape-string-regexp": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==", "dev": true }, "fill-range": { "version": "7.0.1", "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz", "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==", "dev": true, "requires": { "to-regex-range": "^5.0.1" } }, "glob": { "version": "7.2.0", "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.0.tgz", "integrity": "sha512-lmLf6gtyrPq8tTjSmrO94wBeQbFR3HbLHbuyD69wuyQkImp2hWqMGB47OX65FBkPffO641IP9jWa1z4ivqG26Q==", "dev": true, "requires": { "fs.realpath": "^1.0.0", "inflight": "^1.0.4", "inherits": "2", "minimatch": "^3.0.4", "once": "^1.3.0", "path-is-absolute": "^1.0.0" }, "dependencies": { "minimatch": { "version": "3.1.2", "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", "dev": true, "requires": { "brace-expansion": "^1.1.7" } } } }, "has-flag": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", "dev": true }, "is-binary-path": { "version": "2.1.0", "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz", "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==", "dev": true, "requires": { "binary-extensions": "^2.0.0" } }, "is-number": { "version": "7.0.0", "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", "dev": true }, "minimatch": { "version": "5.0.1", "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.0.1.tgz", "integrity": "sha512-nLDxIFRyhDblz3qMuq+SoRZED4+miJ/G+tdDrjkkkRnjAsBexeGpgjLEQ0blJy7rHhR2b93rhQY4SvyWu9v03g==", "dev": true, "requires": { "brace-expansion": "^2.0.1" }, "dependencies": { "brace-expansion": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz", "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==", "dev": true, "requires": { "balanced-match": "^1.0.0" } } } }, "ms": { "version": "2.1.3", "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", "dev": true }, "readdirp": { "version": "3.6.0", "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz", "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==", "dev": true, "requires": { "picomatch": "^2.2.1" } }, "supports-color": { "version": "8.1.1", "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz", "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==", "dev": true, "requires": { "has-flag": "^4.0.0" } }, "to-regex-range": { "version": "5.0.1", "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", "dev": true, "requires": { "is-number": "^7.0.0" } } } }, "module-deps": { "version": "6.2.3", "resolved": "https://registry.npmjs.org/module-deps/-/module-deps-6.2.3.tgz", "integrity": "sha512-fg7OZaQBcL4/L+AK5f4iVqf9OMbCclXfy/znXRxTVhJSeW5AIlS9AwheYwDaXM3lVW7OBeaeUEY3gbaC6cLlSA==", "dev": true, "requires": { "browser-resolve": "^2.0.0", "cached-path-relative": "^1.0.2", "concat-stream": "~1.6.0", "defined": "^1.0.0", "detective": "^5.2.0", "duplexer2": "^0.1.2", "inherits": "^2.0.1", "JSONStream": "^1.0.3", "parents": "^1.0.0", "readable-stream": "^2.0.2", "resolve": "^1.4.0", "stream-combiner2": "^1.1.1", "subarg": "^1.0.0", "through2": "^2.0.0", "xtend": "^4.0.0" }, "dependencies": { "detective": { "version": "5.2.0", "resolved": "https://registry.npmjs.org/detective/-/detective-5.2.0.tgz", "integrity": "sha512-6SsIx+nUUbuK0EthKjv0zrdnajCCXVYGmbYYiYjFVpzcjwEs/JMDZ8tPRG29J/HhN56t3GJp2cGSWDRjjot8Pg==", "dev": true, "requires": { "acorn-node": "^1.6.1", "defined": "^1.0.0", "minimist": "^1.1.1" } } } }, "ms": { "version": "2.1.2", "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==" }, "nanoid": { "version": "3.3.3", "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.3.tgz", "integrity": "sha512-p1sjXuopFs0xg+fPASzQ28agW1oHD7xDsd9Xkf3T15H3c/cifrFHVwrh74PdoklAPi+i7MdRsE47vm2r6JoB+w==", "dev": true }, "node-releases": { "version": "2.0.6", "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.6.tgz", "integrity": "sha512-PiVXnNuFm5+iYkLBNeq5211hvO38y63T0i2KKh2KnUs3RpzJ+JtODFjkD8yjLwnDkTYF1eKXheUwdssR+NRZdg==" }, "normalize-path": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz", "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==", "dev": true }, "object-assign": { "version": "4.1.1", "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", "integrity": "sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM=", "dev": true }, "object-inspect": { "version": "1.9.0", "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.9.0.tgz", "integrity": "sha512-i3Bp9iTqwhaLZBxGkRfo5ZbE07BQRT7MGu8+nNgwW9ItGp1TzCTw2DLEoWwjClxBjOFI/hWljTAmYGCEwmtnOw==", "dev": true }, "object-keys": { "version": "1.1.1", "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz", "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==", "dev": true }, "once": { "version": "1.4.0", "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=", "requires": { "wrappy": "1" } }, "os-browserify": { "version": "0.3.0", "resolved": "https://registry.npmjs.org/os-browserify/-/os-browserify-0.3.0.tgz", "integrity": "sha1-hUNzx/XCMVkU/Jv8a9gjj92h7Cc=", "dev": true }, "p-limit": { "version": "3.1.0", "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", "dev": true, "requires": { "yocto-queue": "^0.1.0" } }, "p-locate": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", "dev": true, "requires": { "p-limit": "^3.0.2" } }, "pako": { "version": "1.0.11", "resolved": "https://registry.npmjs.org/pako/-/pako-1.0.11.tgz", "integrity": "sha512-4hLB8Py4zZce5s4yd9XzopqwVv/yGNhV1Bl8NTmCq1763HeK2+EwVTv+leGeL13Dnh2wfbqowVPXCIO0z4taYw==", "dev": true }, "parents": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/parents/-/parents-1.0.1.tgz", "integrity": "sha1-/t1NK/GTp3dF/nHjcdc8MwfZx1E=", "dev": true, "requires": { "path-platform": "~0.11.15" } }, "parse-asn1": { "version": "5.1.6", "resolved": "https://registry.npmjs.org/parse-asn1/-/parse-asn1-5.1.6.tgz", "integrity": "sha512-RnZRo1EPU6JBnra2vGHj0yhp6ebyjBZpmUCLHWiFhxlzvBCCpAuZ7elsBp1PVAbQN0/04VD/19rfzlBSwLstMw==", "dev": true, "requires": { "asn1.js": "^5.2.0", "browserify-aes": "^1.0.0", "evp_bytestokey": "^1.0.0", "pbkdf2": "^3.0.3", "safe-buffer": "^5.1.1" } }, "path-browserify": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/path-browserify/-/path-browserify-1.0.1.tgz", "integrity": "sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g==", "dev": true }, "path-exists": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", "dev": true }, "path-is-absolute": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=" }, "path-parse": { "version": "1.0.7", "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz", "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==", "dev": true }, "path-platform": { "version": "0.11.15", "resolved": "https://registry.npmjs.org/path-platform/-/path-platform-0.11.15.tgz", "integrity": "sha1-6GQhf3TDaFDwhSt43Hv31KVyG/I=", "dev": true }, "pbkdf2": { "version": "3.1.1", "resolved": "https://registry.npmjs.org/pbkdf2/-/pbkdf2-3.1.1.tgz", "integrity": "sha512-4Ejy1OPxi9f2tt1rRV7Go7zmfDQ+ZectEQz3VGUQhgq62HtIRPDyG/JtnwIxs6x3uNMwo2V7q1fMvKjb+Tnpqg==", "dev": true, "requires": { "create-hash": "^1.1.2", "create-hmac": "^1.1.4", "ripemd160": "^2.0.1", "safe-buffer": "^5.0.1", "sha.js": "^2.4.8" } }, "picocolors": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.0.0.tgz", "integrity": "sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==" }, "picomatch": { "version": "2.2.1", "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.2.1.tgz", "integrity": "sha512-ISBaA8xQNmwELC7eOjqFKMESB2VIqt4PPDD0nsS95b/9dZXvVKOlz9keMSnoGGKcOHXfTvDD6WMaRoSc9UuhRA==", "dev": true }, "pify": { "version": "4.0.1", "resolved": "https://registry.npmjs.org/pify/-/pify-4.0.1.tgz", "integrity": "sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g==", "dev": true }, "private": { "version": "0.1.8", "resolved": "https://registry.npmjs.org/private/-/private-0.1.8.tgz", "integrity": "sha512-VvivMrbvd2nKkiG38qjULzlc+4Vx4wm/whI9pQD35YrARNnhxeiRktSOhSukRLFNlzg6Br/cJPet5J/u19r/mg==" }, "process": { "version": "0.11.10", "resolved": "https://registry.npmjs.org/process/-/process-0.11.10.tgz", "integrity": "sha1-czIwDoQBYb2j5podHZGn1LwW8YI=", "dev": true }, "process-nextick-args": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz", "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==", "dev": true }, "promise": { "version": "8.2.0", "resolved": "https://registry.npmjs.org/promise/-/promise-8.2.0.tgz", "integrity": "sha512-+CMAlLHqwRYwBMXKCP+o8ns7DN+xHDUiI+0nArsiJ9y+kJVPLFxEaSw6Ha9s9H0tftxg2Yzl25wqj9G7m5wLZg==", "dev": true, "requires": { "asap": "~2.0.6" } }, "public-encrypt": { "version": "4.0.3", "resolved": "https://registry.npmjs.org/public-encrypt/-/public-encrypt-4.0.3.tgz", "integrity": "sha512-zVpa8oKZSz5bTMTFClc1fQOnyyEzpl5ozpi1B5YcvBrdohMjH2rfsBtyXcuNuwjsDIXmBYlF2N5FlJYhR29t8Q==", "dev": true, "requires": { "bn.js": "^4.1.0", "browserify-rsa": "^4.0.0", "create-hash": "^1.1.0", "parse-asn1": "^5.0.0", "randombytes": "^2.0.1", "safe-buffer": "^5.1.2" }, "dependencies": { "bn.js": { "version": "4.12.0", "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz", "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==", "dev": true } } }, "punycode": { "version": "1.4.1", "resolved": "https://registry.npmjs.org/punycode/-/punycode-1.4.1.tgz", "integrity": "sha1-wNWmOycYgArY4esPpSachN1BhF4=", "dev": true }, "q": { "version": "1.5.1", "resolved": "https://registry.npmjs.org/q/-/q-1.5.1.tgz", "integrity": "sha1-fjL3W0E4EpHQRhHxvxQQmsAGUdc=" }, "querystring": { "version": "0.2.0", "resolved": "https://registry.npmjs.org/querystring/-/querystring-0.2.0.tgz", "integrity": "sha1-sgmEkgO7Jd+CDadW50cAWHhSFiA=", "dev": true }, "querystring-es3": { "version": "0.2.1", "resolved": "https://registry.npmjs.org/querystring-es3/-/querystring-es3-0.2.1.tgz", "integrity": "sha1-nsYfeQSYdXB9aUFFlv2Qek1xHnM=", "dev": true }, "randombytes": { "version": "2.1.0", "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz", "integrity": "sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==", "dev": true, "requires": { "safe-buffer": "^5.1.0" } }, "randomfill": { "version": "1.0.4", "resolved": "https://registry.npmjs.org/randomfill/-/randomfill-1.0.4.tgz", "integrity": "sha512-87lcbR8+MhcWcUiQ+9e+Rwx8MyR2P7qnt15ynUlbm3TU/fjbgz4GsvfSUDTemtCCtVCqb4ZcEFlyPNTh9bBTLw==", "dev": true, "requires": { "randombytes": "^2.0.5", "safe-buffer": "^5.1.0" } }, "read-only-stream": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/read-only-stream/-/read-only-stream-2.0.0.tgz", "integrity": "sha1-JyT9aoET1zdkrCiNQ4YnDB2/F/A=", "dev": true, "requires": { "readable-stream": "^2.0.2" } }, "readable-stream": { "version": "2.3.7", "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.7.tgz", "integrity": "sha512-Ebho8K4jIbHAxnuxi7o42OrZgF/ZTNcsZj6nRKyUmkhLFq8CHItp/fy6hQZuZmP/n3yZ9VBUbp4zz/mX8hmYPw==", "dev": true, "requires": { "core-util-is": "~1.0.0", "inherits": "~2.0.3", "isarray": "~1.0.0", "process-nextick-args": "~2.0.0", "safe-buffer": "~5.1.1", "string_decoder": "~1.1.1", "util-deprecate": "~1.0.1" } }, "recast": { "version": "0.21.5", "resolved": "https://registry.npmjs.org/recast/-/recast-0.21.5.tgz", "integrity": "sha512-hjMmLaUXAm1hIuTqOdeYObMslq/q+Xff6QE3Y2P+uoHAg2nmVlLBps2hzh1UJDdMtDTMXOFewK6ky51JQIeECg==", "requires": { "ast-types": "0.15.2", "esprima": "~4.0.0", "source-map": "~0.6.1", "tslib": "^2.0.1" }, "dependencies": { "ast-types": { "version": "0.15.2", "resolved": "https://registry.npmjs.org/ast-types/-/ast-types-0.15.2.tgz", "integrity": "sha512-c27loCv9QkZinsa5ProX751khO9DJl/AcB5c2KNtA6NRvHKS0PgLfcftz72KVq504vB0Gku5s2kUZzDBvQWvHg==", "requires": { "tslib": "^2.0.1" } }, "esprima": { "version": "4.0.1", "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz", "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==" }, "source-map": { "version": "0.6.1", "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==" } } }, "regenerator-preset": { "version": "0.14.1", "resolved": "https://registry.npmjs.org/regenerator-preset/-/regenerator-preset-0.14.1.tgz", "integrity": "sha512-7zEo8AK6N87TvOtFXEGec+LAGvCjgZyP/pbxm5NYAoWsmQCCd/IUKBwBqoOffiIhr1UOlgCGsRtwlR71Hl3Ewg==", "requires": { "@babel/plugin-proposal-function-sent": "^7.8.3", "@babel/plugin-syntax-async-generators": "^7.8.4", "@babel/plugin-transform-arrow-functions": "^7.8.3", "@babel/plugin-transform-block-scoping": "^7.8.3", "@babel/plugin-transform-classes": "^7.8.3", "@babel/plugin-transform-for-of": "^7.8.4", "regenerator-transform": "^0.15.0" } }, "regenerator-runtime": { "version": "0.13.11", "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.13.11.tgz", "integrity": "sha512-kY1AZVr2Ra+t+piVaJ4gxaFaReZVH40AKNo7UCX6W+dEwBo/2oZJzqfuN1qLq1oL45o56cPaTXELwrTh8Fpggg==" }, "regenerator-transform": { "version": "0.15.1", "resolved": "https://registry.npmjs.org/regenerator-transform/-/regenerator-transform-0.15.1.tgz", "integrity": "sha512-knzmNAcuyxV+gQCufkYcvOqX/qIIfHLv0u5x79kRxuGojfYVky1f15TzZEu2Avte8QGepvUNTnLskf8E6X6Vyg==", "requires": { "@babel/runtime": "^7.8.4" } }, "require-directory": { "version": "2.1.1", "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz", "integrity": "sha1-jGStX9MNqxyXbiNE/+f3kqam30I=", "dev": true }, "resolve": { "version": "1.20.0", "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.20.0.tgz", "integrity": "sha512-wENBPt4ySzg4ybFQW2TT1zMQucPK95HSh/nq2CFTZVOGut2+pQvSsgtda4d26YrYcr067wjbmzOG8byDPBX63A==", "dev": true, "requires": { "is-core-module": "^2.2.0", "path-parse": "^1.0.6" } }, "ripemd160": { "version": "2.0.2", "resolved": "https://registry.npmjs.org/ripemd160/-/ripemd160-2.0.2.tgz", "integrity": "sha512-ii4iagi25WusVoiC4B4lq7pbXfAp3D9v5CwfkY33vffw2+pkDjY1D8GaN7spsxvCSx8dkPqOZCEZyfxcmJG2IA==", "dev": true, "requires": { "hash-base": "^3.0.0", "inherits": "^2.0.1" } }, "safe-buffer": { "version": "5.1.2", "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz", "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==" }, "safer-buffer": { "version": "2.1.2", "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz", "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==" }, "semver": { "version": "7.5.2", "resolved": "https://registry.npmjs.org/semver/-/semver-7.5.2.tgz", "integrity": "sha512-SoftuTROv/cRjCze/scjGyiDtcUyxw1rgYQSZY7XTmtR5hX+dm76iDbTH8TkLPHCQmlbQVSSbNZCPM2hb0knnQ==", "dev": true, "requires": { "lru-cache": "^6.0.0" } }, "serialize-javascript": { "version": "6.0.0", "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.0.tgz", "integrity": "sha512-Qr3TosvguFt8ePWqsvRfrKyQXIiW+nGbYpy8XK24NQHE83caxWt+mIymTT19DGFbNWNLfEwsrkSmN64lVWB9ag==", "dev": true, "requires": { "randombytes": "^2.1.0" } }, "sha.js": { "version": "2.4.11", "resolved": "https://registry.npmjs.org/sha.js/-/sha.js-2.4.11.tgz", "integrity": "sha512-QMEp5B7cftE7APOjk5Y6xgrbWu+WkLVQwk8JNjZ8nKRciZaByEW6MubieAiToS7+dwvrjGhH8jRXz3MVd0AYqQ==", "dev": true, "requires": { "inherits": "^2.0.1", "safe-buffer": "^5.0.1" } }, "shasum-object": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/shasum-object/-/shasum-object-1.0.0.tgz", "integrity": "sha512-Iqo5rp/3xVi6M4YheapzZhhGPVs0yZwHj7wvwQ1B9z8H6zk+FEnI7y3Teq7qwnekfEhu8WmG2z0z4iWZaxLWVg==", "dev": true, "requires": { "fast-safe-stringify": "^2.0.7" } }, "shell-quote": { "version": "1.7.3", "resolved": "https://registry.npmjs.org/shell-quote/-/shell-quote-1.7.3.tgz", "integrity": "sha512-Vpfqwm4EnqGdlsBFNmHhxhElJYrdfcxPThu+ryKS5J8L/fhAwLazFZtq+S+TWZ9ANj2piSQLGj6NQg+lKPmxrw==", "dev": true }, "simple-concat": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/simple-concat/-/simple-concat-1.0.1.tgz", "integrity": "sha512-cSFtAPtRhljv69IK0hTVZQ+OfE9nePi/rtJmw5UjHeVyVroEqJXP1sFztKUy1qU+xvz3u/sfYJLa947b7nAN2Q==", "dev": true }, "slash": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/slash/-/slash-2.0.0.tgz", "integrity": "sha512-ZYKh3Wh2z1PpEXWr0MpSBZ0V6mZHAQfYevttO11c51CaWjGTaadiKZ+wVt1PbMlDV5qhMFslpZCemhwOK7C89A==", "dev": true }, "source-map": { "version": "0.5.7", "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz", "integrity": "sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=" }, "stream-browserify": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/stream-browserify/-/stream-browserify-3.0.0.tgz", "integrity": "sha512-H73RAHsVBapbim0tU2JwwOiXUj+fikfiaoYAKHF3VJfA0pe2BCzkhAHBlLG6REzE+2WNZcxOXjK7lkso+9euLA==", "dev": true, "requires": { "inherits": "~2.0.4", "readable-stream": "^3.5.0" }, "dependencies": { "readable-stream": { "version": "3.6.0", "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.0.tgz", "integrity": "sha512-BViHy7LKeTz4oNnkcLJ+lVSL6vpiFeX6/d3oSH8zCW7UxP2onchk+vTGB143xuFjHS3deTgkKoXXymXqymiIdA==", "dev": true, "requires": { "inherits": "^2.0.3", "string_decoder": "^1.1.1", "util-deprecate": "^1.0.1" } } } }, "stream-combiner2": { "version": "1.1.1", "resolved": "https://registry.npmjs.org/stream-combiner2/-/stream-combiner2-1.1.1.tgz", "integrity": "sha1-+02KFCDqNidk4hrUeAOXvry0HL4=", "dev": true, "requires": { "duplexer2": "~0.1.0", "readable-stream": "^2.0.2" } }, "stream-http": { "version": "3.1.1", "resolved": "https://registry.npmjs.org/stream-http/-/stream-http-3.1.1.tgz", "integrity": "sha512-S7OqaYu0EkFpgeGFb/NPOoPLxFko7TPqtEeFg5DXPB4v/KETHG0Ln6fRFrNezoelpaDKmycEmmZ81cC9DAwgYg==", "dev": true, "requires": { "builtin-status-codes": "^3.0.0", "inherits": "^2.0.4", "readable-stream": "^3.6.0", "xtend": "^4.0.2" }, "dependencies": { "readable-stream": { "version": "3.6.0", "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.0.tgz", "integrity": "sha512-BViHy7LKeTz4oNnkcLJ+lVSL6vpiFeX6/d3oSH8zCW7UxP2onchk+vTGB143xuFjHS3deTgkKoXXymXqymiIdA==", "dev": true, "requires": { "inherits": "^2.0.3", "string_decoder": "^1.1.1", "util-deprecate": "^1.0.1" } } } }, "stream-splicer": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/stream-splicer/-/stream-splicer-2.0.1.tgz", "integrity": "sha512-Xizh4/NPuYSyAXyT7g8IvdJ9HJpxIGL9PjyhtywCZvvP0OPIdqyrr4dMikeuvY8xahpdKEBlBTySe583totajg==", "dev": true, "requires": { "inherits": "^2.0.1", "readable-stream": "^2.0.2" } }, "string_decoder": { "version": "1.1.1", "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz", "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==", "dev": true, "requires": { "safe-buffer": "~5.1.0" } }, "string-width": { "version": "4.2.3", "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", "dev": true, "requires": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", "strip-ansi": "^6.0.1" } }, "string.prototype.trimend": { "version": "1.0.4", "resolved": "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.4.tgz", "integrity": "sha512-y9xCjw1P23Awk8EvTpcyL2NIr1j7wJ39f+k6lvRnSMz+mz9CGz9NYPelDk42kOz6+ql8xjfK8oYzy3jAP5QU5A==", "dev": true, "requires": { "call-bind": "^1.0.2", "define-properties": "^1.1.3" } }, "string.prototype.trimstart": { "version": "1.0.4", "resolved": "https://registry.npmjs.org/string.prototype.trimstart/-/string.prototype.trimstart-1.0.4.tgz", "integrity": "sha512-jh6e984OBfvxS50tdY2nRZnoC5/mLFKOREQfw8t5yytkoUsJRNxvI/E39qu1sD0OtWI3OC0XgKSmcWwziwYuZw==", "dev": true, "requires": { "call-bind": "^1.0.2", "define-properties": "^1.1.3" } }, "strip-ansi": { "version": "6.0.1", "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", "dev": true, "requires": { "ansi-regex": "^5.0.1" } }, "strip-json-comments": { "version": "3.1.1", "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz", "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==", "dev": true }, "subarg": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/subarg/-/subarg-1.0.0.tgz", "integrity": "sha1-9izxdYHplrSPyWVpn1TAauJouNI=", "dev": true, "requires": { "minimist": "^1.1.0" } }, "supports-color": { "version": "5.5.0", "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", "requires": { "has-flag": "^3.0.0" } }, "syntax-error": { "version": "1.4.0", "resolved": "https://registry.npmjs.org/syntax-error/-/syntax-error-1.4.0.tgz", "integrity": "sha512-YPPlu67mdnHGTup2A8ff7BC2Pjq0e0Yp/IyTFN03zWO0RcK07uLcbi7C2KpGR2FvWbaB0+bfE27a+sBKebSo7w==", "dev": true, "requires": { "acorn-node": "^1.2.0" } }, "through": { "version": "2.3.8", "resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz", "integrity": "sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU=" }, "through2": { "version": "2.0.5", "resolved": "https://registry.npmjs.org/through2/-/through2-2.0.5.tgz", "integrity": "sha512-/mrRod8xqpA+IHSLyGCQ2s8SPHiCDEeQJSep1jqLYeEUClOFG2Qsh+4FU6G9VeqpZnGW/Su8LQGc4YKni5rYSQ==", "dev": true, "requires": { "readable-stream": "~2.3.6", "xtend": "~4.0.1" } }, "timers-browserify": { "version": "1.4.2", "resolved": "https://registry.npmjs.org/timers-browserify/-/timers-browserify-1.4.2.tgz", "integrity": "sha1-ycWLV1voQHN1y14kYtrO50NZ9B0=", "dev": true, "requires": { "process": "~0.11.0" } }, "to-fast-properties": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-2.0.0.tgz", "integrity": "sha1-3F5pjL0HkmW8c+A3doGk5Og/YW4=" }, "tslib": { "version": "2.4.0", "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.4.0.tgz", "integrity": "sha512-d6xOpEDfsi2CZVlPQzGeux8XMwLT9hssAsaPYExaQMuYskwb+x1x7J371tWlbBdWHroy99KnVB6qIkUbs5X3UQ==" }, "tty-browserify": { "version": "0.0.1", "resolved": "https://registry.npmjs.org/tty-browserify/-/tty-browserify-0.0.1.tgz", "integrity": "sha512-C3TaO7K81YvjCgQH9Q1S3R3P3BtN3RIM8n+OvX4il1K1zgE8ZhI0op7kClgkxtutIE8hQrcrHBXvIheqKUUCxw==", "dev": true }, "typedarray": { "version": "0.0.6", "resolved": "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz", "integrity": "sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c=", "dev": true }, "uglify-js": { "version": "3.17.4", "resolved": "https://registry.npmjs.org/uglify-js/-/uglify-js-3.17.4.tgz", "integrity": "sha512-T9q82TJI9e/C1TAxYvfb16xO120tMVFZrGA3f9/P4424DNu6ypK103y0GPFVa17yotwSyZW5iYXgjYHkGrJW/g==", "dev": true }, "umd": { "version": "3.0.3", "resolved": "https://registry.npmjs.org/umd/-/umd-3.0.3.tgz", "integrity": "sha512-4IcGSufhFshvLNcMCV80UnQVlZ5pMOC8mvNPForqwA4+lzYQuetTESLDQkeLmihq8bRcnpbQa48Wb8Lh16/xow==", "dev": true }, "unbox-primitive": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.0.1.tgz", "integrity": "sha512-tZU/3NqK3dA5gpE1KtyiJUrEB0lxnGkMFHptJ7q6ewdZ8s12QrODwNbhIJStmJkd1QDXa1NRA8aF2A1zk/Ypyw==", "dev": true, "requires": { "function-bind": "^1.1.1", "has-bigints": "^1.0.1", "has-symbols": "^1.0.2", "which-boxed-primitive": "^1.0.2" }, "dependencies": { "has-symbols": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.2.tgz", "integrity": "sha512-chXa79rL/UC2KlX17jo3vRGz0azaWEx5tGqZg5pO3NUyEJVB17dMruQlzCCOfUvElghKcm5194+BCRvi2Rv/Gw==", "dev": true } } }, "undeclared-identifiers": { "version": "1.1.3", "resolved": "https://registry.npmjs.org/undeclared-identifiers/-/undeclared-identifiers-1.1.3.tgz", "integrity": "sha512-pJOW4nxjlmfwKApE4zvxLScM/njmwj/DiUBv7EabwE4O8kRUy+HIwxQtZLBPll/jx1LJyBcqNfB3/cpv9EZwOw==", "dev": true, "requires": { "acorn-node": "^1.3.0", "dash-ast": "^1.0.0", "get-assigned-identifiers": "^1.2.0", "simple-concat": "^1.0.0", "xtend": "^4.0.1" } }, "update-browserslist-db": { "version": "1.0.10", "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.0.10.tgz", "integrity": "sha512-OztqDenkfFkbSG+tRxBeAnCVPckDBcvibKd35yDONx6OU8N7sqgwc7rCbkJ/WcYtVRZ4ba68d6byhC21GFh7sQ==", "requires": { "escalade": "^3.1.1", "picocolors": "^1.0.0" } }, "url": { "version": "0.11.0", "resolved": "https://registry.npmjs.org/url/-/url-0.11.0.tgz", "integrity": "sha1-ODjpfPxgUh63PFJajlW/3Z4uKPE=", "dev": true, "requires": { "punycode": "1.3.2", "querystring": "0.2.0" }, "dependencies": { "punycode": { "version": "1.3.2", "resolved": "https://registry.npmjs.org/punycode/-/punycode-1.3.2.tgz", "integrity": "sha1-llOgNvt8HuQjQvIyXM7v6jkmxI0=", "dev": true } } }, "util": { "version": "0.12.3", "resolved": "https://registry.npmjs.org/util/-/util-0.12.3.tgz", "integrity": "sha512-I8XkoQwE+fPQEhy9v012V+TSdH2kp9ts29i20TaaDUXsg7x/onePbhFJUExBfv/2ay1ZOp/Vsm3nDlmnFGSAog==", "dev": true, "requires": { "inherits": "^2.0.3", "is-arguments": "^1.0.4", "is-generator-function": "^1.0.7", "is-typed-array": "^1.1.3", "safe-buffer": "^5.1.2", "which-typed-array": "^1.1.2" } }, "util-deprecate": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", "integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=", "dev": true }, "vm-browserify": { "version": "1.1.2", "resolved": "https://registry.npmjs.org/vm-browserify/-/vm-browserify-1.1.2.tgz", "integrity": "sha512-2ham8XPWTONajOR0ohOKOHXkm3+gaBmGut3SRuu75xLd/RRaY6vqgh8NBYYk7+RW3u5AtzPQZG8F10LHkl0lAQ==", "dev": true }, "which-boxed-primitive": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/which-boxed-primitive/-/which-boxed-primitive-1.0.2.tgz", "integrity": "sha512-bwZdv0AKLpplFY2KZRX6TvyuN7ojjr7lwkg6ml0roIy9YeuSr7JS372qlNW18UQYzgYK9ziGcerWqZOmEn9VNg==", "dev": true, "requires": { "is-bigint": "^1.0.1", "is-boolean-object": "^1.1.0", "is-number-object": "^1.0.4", "is-string": "^1.0.5", "is-symbol": "^1.0.3" } }, "which-typed-array": { "version": "1.1.4", "resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.4.tgz", "integrity": "sha512-49E0SpUe90cjpoc7BOJwyPHRqSAd12c10Qm2amdEZrJPCY2NDxaW01zHITrem+rnETY3dwrbH3UUrUwagfCYDA==", "dev": true, "requires": { "available-typed-arrays": "^1.0.2", "call-bind": "^1.0.0", "es-abstract": "^1.18.0-next.1", "foreach": "^2.0.5", "function-bind": "^1.1.1", "has-symbols": "^1.0.1", "is-typed-array": "^1.1.3" } }, "workerpool": { "version": "6.2.1", "resolved": "https://registry.npmjs.org/workerpool/-/workerpool-6.2.1.tgz", "integrity": "sha512-ILEIE97kDZvF9Wb9f6h5aXK4swSlKGUcOEGiIYb2OOu/IrDU9iwj0fD//SsA6E5ibwJxpEvhullJY4Sl4GcpAw==", "dev": true }, "wrap-ansi": { "version": "7.0.0", "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", "dev": true, "requires": { "ansi-styles": "^4.0.0", "string-width": "^4.1.0", "strip-ansi": "^6.0.0" }, "dependencies": { "ansi-styles": { "version": "4.3.0", "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", "dev": true, "requires": { "color-convert": "^2.0.1" } }, "color-convert": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", "dev": true, "requires": { "color-name": "~1.1.4" } }, "color-name": { "version": "1.1.4", "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", "dev": true } } }, "wrappy": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=" }, "xtend": { "version": "4.0.2", "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz", "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==", "dev": true }, "y18n": { "version": "5.0.8", "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz", "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==", "dev": true }, "yallist": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==", "dev": true }, "yargs": { "version": "16.2.0", "resolved": "https://registry.npmjs.org/yargs/-/yargs-16.2.0.tgz", "integrity": "sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==", "dev": true, "requires": { "cliui": "^7.0.2", "escalade": "^3.1.1", "get-caller-file": "^2.0.5", "require-directory": "^2.1.1", "string-width": "^4.2.0", "y18n": "^5.0.5", "yargs-parser": "^20.2.2" } }, "yargs-parser": { "version": "20.2.4", "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-20.2.4.tgz", "integrity": "sha512-WOkpgNhPTlE73h4VFAFsOnomJVaovO8VqLDzy5saChRBFQFBoMYirowyW+Q9HB4HFF4Z7VZTiG3iSzJJA29yRA==", "dev": true }, "yargs-unparser": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/yargs-unparser/-/yargs-unparser-2.0.0.tgz", "integrity": "sha512-7pRTIA9Qc1caZ0bZ6RYRGbHJthJWuakf+WmHK0rVeLkNrrGhfoabBNdue6kdINI6r4if7ocq9aD/n7xwKOdzOA==", "dev": true, "requires": { "camelcase": "^6.0.0", "decamelize": "^4.0.0", "flat": "^5.0.2", "is-plain-obj": "^2.1.0" } }, "yocto-queue": { "version": "0.1.0", "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", "dev": true } } } regenerator-regenerator-transform-0.15.2/package.json000066400000000000000000000026511446323212200227310ustar00rootroot00000000000000{ "author": "Ben Newman ", "name": "regenerator", "description": "Source transformer enabling ECMAScript 6 generator functions (yield) in JavaScript-of-today (ES5)", "keywords": [ "generator", "yield", "coroutine", "rewriting", "transformation", "syntax", "codegen", "rewriting", "refactoring", "transpiler", "desugaring", "ES6" ], "version": "0.14.10", "homepage": "http://github.com/facebook/regenerator", "repository": { "type": "git", "url": "git://github.com/facebook/regenerator.git" }, "main": "main.js", "bin": "bin/regenerator", "scripts": { "test": "test/run.sh" }, "dependencies": { "@babel/core": "^7.8.4", "@babel/runtime": "^7.8.4", "@babel/types": "^7.8.3", "commoner": "^0.10.8", "private": "^0.1.8", "recast": "^0.21.5", "regenerator-preset": "^0.14.1", "regenerator-runtime": "^0.13.11", "regenerator-transform": "^0.15.1", "through": "^2.3.8" }, "devDependencies": { "@babel/cli": "^7.8.4", "@babel/parser": "^7.8.4", "@babel/plugin-transform-modules-commonjs": "^7.8.3", "@babel/plugin-transform-parameters": "^7.8.4", "babel-check-duplicated-nodes": "^1.0.0", "browserify": "^17.0.0", "mocha": "^10.0.0", "promise": "^8.0.3", "semver": "^7.1.3", "uglify-js": "^3.14.0" }, "license": "MIT", "engines": { "node": ">= 0.6" } } regenerator-regenerator-transform-0.15.2/packages/000077500000000000000000000000001446323212200222155ustar00rootroot00000000000000regenerator-regenerator-transform-0.15.2/packages/preset/000077500000000000000000000000001446323212200235175ustar00rootroot00000000000000regenerator-regenerator-transform-0.15.2/packages/preset/.gitignore000066400000000000000000000000151446323212200255030ustar00rootroot00000000000000node_modules regenerator-regenerator-transform-0.15.2/packages/preset/LICENSE000066400000000000000000000020701446323212200245230ustar00rootroot00000000000000MIT License Copyright (c) 2014-present, Facebook, Inc. 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. regenerator-regenerator-transform-0.15.2/packages/preset/README.md000066400000000000000000000002401446323212200247720ustar00rootroot00000000000000# regenerator-preset Babel preset for easy use of [regenerator-transform](https://github.com/facebook/regenerator/tree/master/packages/regenerator-transform). regenerator-regenerator-transform-0.15.2/packages/preset/index.js000066400000000000000000000011041446323212200251600ustar00rootroot00000000000000/** * Copyright (c) 2014-present, Facebook, Inc. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ module.exports = { plugins: [ require("@babel/plugin-syntax-async-generators"), require("@babel/plugin-proposal-function-sent"), require("@babel/plugin-transform-classes"), require("@babel/plugin-transform-arrow-functions"), require("@babel/plugin-transform-block-scoping"), require("@babel/plugin-transform-for-of"), require("regenerator-transform").default ] }; regenerator-regenerator-transform-0.15.2/packages/preset/package.json000066400000000000000000000014461446323212200260120ustar00rootroot00000000000000{ "name": "regenerator-preset", "author": "Ben Newman ", "description": "Babel preset for easy use of regenerator-transform.", "version": "0.14.1", "main": "index.js", "keywords": [ "regenerator", "runtime", "generator", "async" ], "repository": { "type": "git", "url": "https://github.com/facebook/regenerator/tree/main/packages/preset" }, "license": "MIT", "dependencies": { "@babel/plugin-proposal-function-sent": "^7.8.3", "@babel/plugin-syntax-async-generators": "^7.8.4", "@babel/plugin-transform-arrow-functions": "^7.8.3", "@babel/plugin-transform-block-scoping": "^7.8.3", "@babel/plugin-transform-classes": "^7.8.3", "@babel/plugin-transform-for-of": "^7.8.4", "regenerator-transform": "^0.15.0" } } regenerator-regenerator-transform-0.15.2/packages/runtime/000077500000000000000000000000001446323212200237005ustar00rootroot00000000000000regenerator-regenerator-transform-0.15.2/packages/runtime/.gitignore000066400000000000000000000000411446323212200256630ustar00rootroot00000000000000npm-debug.log node_modules .idea regenerator-regenerator-transform-0.15.2/packages/runtime/.npmignore000066400000000000000000000000241446323212200256730ustar00rootroot00000000000000/node_modules /test regenerator-regenerator-transform-0.15.2/packages/runtime/LICENSE000066400000000000000000000020701446323212200247040ustar00rootroot00000000000000MIT License Copyright (c) 2014-present, Facebook, Inc. 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. regenerator-regenerator-transform-0.15.2/packages/runtime/README.md000066400000000000000000000013711446323212200251610ustar00rootroot00000000000000# regenerator-runtime Standalone runtime for [Regenerator](https://github.com/facebook/regenerator)-compiled generator and `async` functions. To import the runtime as a module (recommended), either of the following import styles will work: ```js // CommonJS const regeneratorRuntime = require("regenerator-runtime"); // ECMAScript 2015 import regeneratorRuntime from "regenerator-runtime"; ``` To ensure that `regeneratorRuntime` is defined globally, either of the following styles will work: ```js // CommonJS require("regenerator-runtime/runtime"); // ECMAScript 2015 import "regenerator-runtime/runtime.js"; ``` To get the absolute file system path of `runtime.js`, evaluate the following expression: ```js require("regenerator-runtime/path").path ``` regenerator-regenerator-transform-0.15.2/packages/runtime/package.json000066400000000000000000000007201446323212200261650ustar00rootroot00000000000000{ "name": "regenerator-runtime", "author": "Ben Newman ", "description": "Runtime for Regenerator-compiled generator and async functions.", "version": "0.13.11", "main": "runtime.js", "keywords": [ "regenerator", "runtime", "generator", "async" ], "sideEffects": true, "repository": { "type": "git", "url": "https://github.com/facebook/regenerator/tree/main/packages/runtime" }, "license": "MIT" } regenerator-regenerator-transform-0.15.2/packages/runtime/path.js000066400000000000000000000003741446323212200251760ustar00rootroot00000000000000/** * Copyright (c) 2014-present, Facebook, Inc. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ exports.path = require("path").join( __dirname, "runtime.js" ); regenerator-regenerator-transform-0.15.2/packages/runtime/runtime.js000066400000000000000000000611621446323212200257270ustar00rootroot00000000000000/** * Copyright (c) 2014-present, Facebook, Inc. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ var runtime = (function (exports) { "use strict"; var Op = Object.prototype; var hasOwn = Op.hasOwnProperty; var defineProperty = Object.defineProperty || function (obj, key, desc) { obj[key] = desc.value; }; var undefined; // More compressible than void 0. var $Symbol = typeof Symbol === "function" ? Symbol : {}; var iteratorSymbol = $Symbol.iterator || "@@iterator"; var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator"; var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag"; function define(obj, key, value) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); return obj[key]; } try { // IE 8 has a broken Object.defineProperty that only works on DOM objects. define({}, ""); } catch (err) { define = function(obj, key, value) { return obj[key] = value; }; } function wrap(innerFn, outerFn, self, tryLocsList) { // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator. var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator; var generator = Object.create(protoGenerator.prototype); var context = new Context(tryLocsList || []); // The ._invoke method unifies the implementations of the .next, // .throw, and .return methods. defineProperty(generator, "_invoke", { value: makeInvokeMethod(innerFn, self, context) }); return generator; } exports.wrap = wrap; // Try/catch helper to minimize deoptimizations. Returns a completion // record like context.tryEntries[i].completion. This interface could // have been (and was previously) designed to take a closure to be // invoked without arguments, but in all the cases we care about we // already have an existing method we want to call, so there's no need // to create a new function object. We can even get away with assuming // the method takes exactly one argument, since that happens to be true // in every case, so we don't have to touch the arguments object. The // only additional allocation required is the completion record, which // has a stable shape and so hopefully should be cheap to allocate. function tryCatch(fn, obj, arg) { try { return { type: "normal", arg: fn.call(obj, arg) }; } catch (err) { return { type: "throw", arg: err }; } } var GenStateSuspendedStart = "suspendedStart"; var GenStateSuspendedYield = "suspendedYield"; var GenStateExecuting = "executing"; var GenStateCompleted = "completed"; // Returning this object from the innerFn has the same effect as // breaking out of the dispatch switch statement. var ContinueSentinel = {}; // Dummy constructor functions that we use as the .constructor and // .constructor.prototype properties for functions that return Generator // objects. For full spec compliance, you may wish to configure your // minifier not to mangle the names of these two functions. function Generator() {} function GeneratorFunction() {} function GeneratorFunctionPrototype() {} // This is a polyfill for %IteratorPrototype% for environments that // don't natively support it. var IteratorPrototype = {}; define(IteratorPrototype, iteratorSymbol, function () { return this; }); var getProto = Object.getPrototypeOf; var NativeIteratorPrototype = getProto && getProto(getProto(values([]))); if (NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) { // This environment has a native %IteratorPrototype%; use it instead // of the polyfill. IteratorPrototype = NativeIteratorPrototype; } var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype); GeneratorFunction.prototype = GeneratorFunctionPrototype; defineProperty(Gp, "constructor", { value: GeneratorFunctionPrototype, configurable: true }); defineProperty( GeneratorFunctionPrototype, "constructor", { value: GeneratorFunction, configurable: true } ); GeneratorFunction.displayName = define( GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction" ); // Helper for defining the .next, .throw, and .return methods of the // Iterator interface in terms of a single ._invoke method. function defineIteratorMethods(prototype) { ["next", "throw", "return"].forEach(function(method) { define(prototype, method, function(arg) { return this._invoke(method, arg); }); }); } exports.isGeneratorFunction = function(genFun) { var ctor = typeof genFun === "function" && genFun.constructor; return ctor ? ctor === GeneratorFunction || // For the native GeneratorFunction constructor, the best we can // do is to check its .name property. (ctor.displayName || ctor.name) === "GeneratorFunction" : false; }; exports.mark = function(genFun) { if (Object.setPrototypeOf) { Object.setPrototypeOf(genFun, GeneratorFunctionPrototype); } else { genFun.__proto__ = GeneratorFunctionPrototype; define(genFun, toStringTagSymbol, "GeneratorFunction"); } genFun.prototype = Object.create(Gp); return genFun; }; // Within the body of any async function, `await x` is transformed to // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test // `hasOwn.call(value, "__await")` to determine if the yielded value is // meant to be awaited. exports.awrap = function(arg) { return { __await: arg }; }; function AsyncIterator(generator, PromiseImpl) { function invoke(method, arg, resolve, reject) { var record = tryCatch(generator[method], generator, arg); if (record.type === "throw") { reject(record.arg); } else { var result = record.arg; var value = result.value; if (value && typeof value === "object" && hasOwn.call(value, "__await")) { return PromiseImpl.resolve(value.__await).then(function(value) { invoke("next", value, resolve, reject); }, function(err) { invoke("throw", err, resolve, reject); }); } return PromiseImpl.resolve(value).then(function(unwrapped) { // When a yielded Promise is resolved, its final value becomes // the .value of the Promise<{value,done}> result for the // current iteration. result.value = unwrapped; resolve(result); }, function(error) { // If a rejected Promise was yielded, throw the rejection back // into the async generator function so it can be handled there. return invoke("throw", error, resolve, reject); }); } } var previousPromise; function enqueue(method, arg) { function callInvokeWithMethodAndArg() { return new PromiseImpl(function(resolve, reject) { invoke(method, arg, resolve, reject); }); } return previousPromise = // If enqueue has been called before, then we want to wait until // all previous Promises have been resolved before calling invoke, // so that results are always delivered in the correct order. If // enqueue has not been called before, then it is important to // call invoke immediately, without waiting on a callback to fire, // so that the async generator function has the opportunity to do // any necessary setup in a predictable way. This predictability // is why the Promise constructor synchronously invokes its // executor callback, and why async functions synchronously // execute code before the first await. Since we implement simple // async functions in terms of async generators, it is especially // important to get this right, even though it requires care. previousPromise ? previousPromise.then( callInvokeWithMethodAndArg, // Avoid propagating failures to Promises returned by later // invocations of the iterator. callInvokeWithMethodAndArg ) : callInvokeWithMethodAndArg(); } // Define the unified helper method that is used to implement .next, // .throw, and .return (see defineIteratorMethods). defineProperty(this, "_invoke", { value: enqueue }); } defineIteratorMethods(AsyncIterator.prototype); define(AsyncIterator.prototype, asyncIteratorSymbol, function () { return this; }); exports.AsyncIterator = AsyncIterator; // Note that simple async functions are implemented on top of // AsyncIterator objects; they just return a Promise for the value of // the final result produced by the iterator. exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) { if (PromiseImpl === void 0) PromiseImpl = Promise; var iter = new AsyncIterator( wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl ); return exports.isGeneratorFunction(outerFn) ? iter // If outerFn is a generator, return the full iterator. : iter.next().then(function(result) { return result.done ? result.value : iter.next(); }); }; function makeInvokeMethod(innerFn, self, context) { var state = GenStateSuspendedStart; return function invoke(method, arg) { if (state === GenStateExecuting) { throw new Error("Generator is already running"); } if (state === GenStateCompleted) { if (method === "throw") { throw arg; } // Be forgiving, per 25.3.3.3.3 of the spec: // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume return doneResult(); } context.method = method; context.arg = arg; while (true) { var delegate = context.delegate; if (delegate) { var delegateResult = maybeInvokeDelegate(delegate, context); if (delegateResult) { if (delegateResult === ContinueSentinel) continue; return delegateResult; } } if (context.method === "next") { // Setting context._sent for legacy support of Babel's // function.sent implementation. context.sent = context._sent = context.arg; } else if (context.method === "throw") { if (state === GenStateSuspendedStart) { state = GenStateCompleted; throw context.arg; } context.dispatchException(context.arg); } else if (context.method === "return") { context.abrupt("return", context.arg); } state = GenStateExecuting; var record = tryCatch(innerFn, self, context); if (record.type === "normal") { // If an exception is thrown from innerFn, we leave state === // GenStateExecuting and loop back for another invocation. state = context.done ? GenStateCompleted : GenStateSuspendedYield; if (record.arg === ContinueSentinel) { continue; } return { value: record.arg, done: context.done }; } else if (record.type === "throw") { state = GenStateCompleted; // Dispatch the exception by looping back around to the // context.dispatchException(context.arg) call above. context.method = "throw"; context.arg = record.arg; } } }; } // Call delegate.iterator[context.method](context.arg) and handle the // result, either by returning a { value, done } result from the // delegate iterator, or by modifying context.method and context.arg, // setting context.delegate to null, and returning the ContinueSentinel. function maybeInvokeDelegate(delegate, context) { var methodName = context.method; var method = delegate.iterator[methodName]; if (method === undefined) { // A .throw or .return when the delegate iterator has no .throw // method, or a missing .next mehtod, always terminate the // yield* loop. context.delegate = null; // Note: ["return"] must be used for ES3 parsing compatibility. if (methodName === "throw" && delegate.iterator["return"]) { // If the delegate iterator has a return method, give it a // chance to clean up. context.method = "return"; context.arg = undefined; maybeInvokeDelegate(delegate, context); if (context.method === "throw") { // If maybeInvokeDelegate(context) changed context.method from // "return" to "throw", let that override the TypeError below. return ContinueSentinel; } } if (methodName !== "return") { context.method = "throw"; context.arg = new TypeError( "The iterator does not provide a '" + methodName + "' method"); } return ContinueSentinel; } var record = tryCatch(method, delegate.iterator, context.arg); if (record.type === "throw") { context.method = "throw"; context.arg = record.arg; context.delegate = null; return ContinueSentinel; } var info = record.arg; if (! info) { context.method = "throw"; context.arg = new TypeError("iterator result is not an object"); context.delegate = null; return ContinueSentinel; } if (info.done) { // Assign the result of the finished delegate to the temporary // variable specified by delegate.resultName (see delegateYield). context[delegate.resultName] = info.value; // Resume execution at the desired location (see delegateYield). context.next = delegate.nextLoc; // If context.method was "throw" but the delegate handled the // exception, let the outer generator proceed normally. If // context.method was "next", forget context.arg since it has been // "consumed" by the delegate iterator. If context.method was // "return", allow the original .return call to continue in the // outer generator. if (context.method !== "return") { context.method = "next"; context.arg = undefined; } } else { // Re-yield the result returned by the delegate method. return info; } // The delegate iterator is finished, so forget it and continue with // the outer generator. context.delegate = null; return ContinueSentinel; } // Define Generator.prototype.{next,throw,return} in terms of the // unified ._invoke helper method. defineIteratorMethods(Gp); define(Gp, toStringTagSymbol, "Generator"); // A Generator should always return itself as the iterator object when the // @@iterator function is called on it. Some browsers' implementations of the // iterator prototype chain incorrectly implement this, causing the Generator // object to not be returned from this call. This ensures that doesn't happen. // See https://github.com/facebook/regenerator/issues/274 for more details. define(Gp, iteratorSymbol, function() { return this; }); define(Gp, "toString", function() { return "[object Generator]"; }); function pushTryEntry(locs) { var entry = { tryLoc: locs[0] }; if (1 in locs) { entry.catchLoc = locs[1]; } if (2 in locs) { entry.finallyLoc = locs[2]; entry.afterLoc = locs[3]; } this.tryEntries.push(entry); } function resetTryEntry(entry) { var record = entry.completion || {}; record.type = "normal"; delete record.arg; entry.completion = record; } function Context(tryLocsList) { // The root entry object (effectively a try statement without a catch // or a finally block) gives us a place to store values thrown from // locations where there is no enclosing try statement. this.tryEntries = [{ tryLoc: "root" }]; tryLocsList.forEach(pushTryEntry, this); this.reset(true); } exports.keys = function(val) { var object = Object(val); var keys = []; for (var key in object) { keys.push(key); } keys.reverse(); // Rather than returning an object with a next method, we keep // things simple and return the next function itself. return function next() { while (keys.length) { var key = keys.pop(); if (key in object) { next.value = key; next.done = false; return next; } } // To avoid creating an additional object, we just hang the .value // and .done properties off the next function object itself. This // also ensures that the minifier will not anonymize the function. next.done = true; return next; }; }; function values(iterable) { if (iterable) { var iteratorMethod = iterable[iteratorSymbol]; if (iteratorMethod) { return iteratorMethod.call(iterable); } if (typeof iterable.next === "function") { return iterable; } if (!isNaN(iterable.length)) { var i = -1, next = function next() { while (++i < iterable.length) { if (hasOwn.call(iterable, i)) { next.value = iterable[i]; next.done = false; return next; } } next.value = undefined; next.done = true; return next; }; return next.next = next; } } // Return an iterator with no values. return { next: doneResult }; } exports.values = values; function doneResult() { return { value: undefined, done: true }; } Context.prototype = { constructor: Context, reset: function(skipTempReset) { this.prev = 0; this.next = 0; // Resetting context._sent for legacy support of Babel's // function.sent implementation. this.sent = this._sent = undefined; this.done = false; this.delegate = null; this.method = "next"; this.arg = undefined; this.tryEntries.forEach(resetTryEntry); if (!skipTempReset) { for (var name in this) { // Not sure about the optimal order of these conditions: if (name.charAt(0) === "t" && hasOwn.call(this, name) && !isNaN(+name.slice(1))) { this[name] = undefined; } } } }, stop: function() { this.done = true; var rootEntry = this.tryEntries[0]; var rootRecord = rootEntry.completion; if (rootRecord.type === "throw") { throw rootRecord.arg; } return this.rval; }, dispatchException: function(exception) { if (this.done) { throw exception; } var context = this; function handle(loc, caught) { record.type = "throw"; record.arg = exception; context.next = loc; if (caught) { // If the dispatched exception was caught by a catch block, // then let that catch block handle the exception normally. context.method = "next"; context.arg = undefined; } return !! caught; } for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; var record = entry.completion; if (entry.tryLoc === "root") { // Exception thrown outside of any try block that could handle // it, so set the completion value of the entire function to // throw the exception. return handle("end"); } if (entry.tryLoc <= this.prev) { var hasCatch = hasOwn.call(entry, "catchLoc"); var hasFinally = hasOwn.call(entry, "finallyLoc"); if (hasCatch && hasFinally) { if (this.prev < entry.catchLoc) { return handle(entry.catchLoc, true); } else if (this.prev < entry.finallyLoc) { return handle(entry.finallyLoc); } } else if (hasCatch) { if (this.prev < entry.catchLoc) { return handle(entry.catchLoc, true); } } else if (hasFinally) { if (this.prev < entry.finallyLoc) { return handle(entry.finallyLoc); } } else { throw new Error("try statement without catch or finally"); } } } }, abrupt: function(type, arg) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) { var finallyEntry = entry; break; } } if (finallyEntry && (type === "break" || type === "continue") && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc) { // Ignore the finally entry if control is not jumping to a // location outside the try/catch block. finallyEntry = null; } var record = finallyEntry ? finallyEntry.completion : {}; record.type = type; record.arg = arg; if (finallyEntry) { this.method = "next"; this.next = finallyEntry.finallyLoc; return ContinueSentinel; } return this.complete(record); }, complete: function(record, afterLoc) { if (record.type === "throw") { throw record.arg; } if (record.type === "break" || record.type === "continue") { this.next = record.arg; } else if (record.type === "return") { this.rval = this.arg = record.arg; this.method = "return"; this.next = "end"; } else if (record.type === "normal" && afterLoc) { this.next = afterLoc; } return ContinueSentinel; }, finish: function(finallyLoc) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.finallyLoc === finallyLoc) { this.complete(entry.completion, entry.afterLoc); resetTryEntry(entry); return ContinueSentinel; } } }, "catch": function(tryLoc) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.tryLoc === tryLoc) { var record = entry.completion; if (record.type === "throw") { var thrown = record.arg; resetTryEntry(entry); } return thrown; } } // The context.catch method must only be called with a location // argument that corresponds to a known catch block. throw new Error("illegal catch attempt"); }, delegateYield: function(iterable, resultName, nextLoc) { this.delegate = { iterator: values(iterable), resultName: resultName, nextLoc: nextLoc }; if (this.method === "next") { // Deliberately forget the last sent value so that we don't // accidentally pass it on to the delegate. this.arg = undefined; } return ContinueSentinel; } }; // Regardless of whether this script is executing as a CommonJS module // or not, return the runtime object so that we can declare the variable // regeneratorRuntime in the outer scope, which allows this module to be // injected easily by `bin/regenerator --include-runtime script.js`. return exports; }( // If this script is executing as a CommonJS module, use module.exports // as the regeneratorRuntime namespace. Otherwise create a new empty // object. Either way, the resulting object will be used to initialize // the regeneratorRuntime variable at the top of this file. typeof module === "object" ? module.exports : {} )); try { regeneratorRuntime = runtime; } catch (accidentalStrictMode) { // This module should not be running in strict mode, so the above // assignment should always work unless something is misconfigured. Just // in case runtime.js accidentally runs in strict mode, in modern engines // we can explicitly access globalThis. In older engines we can escape // strict mode using a global Function call. This could conceivably fail // if a Content Security Policy forbids using Function, but in that case // the proper solution is to fix the accidental strict mode problem. If // you've misconfigured your bundler to force strict mode and applied a // CSP to forbid Function, and you're not willing to fix either of those // problems, please detail your unique predicament in a GitHub issue. if (typeof globalThis === "object") { globalThis.regeneratorRuntime = runtime; } else { Function("r", "regeneratorRuntime = r")(runtime); } } regenerator-regenerator-transform-0.15.2/packages/transform/000077500000000000000000000000001446323212200242305ustar00rootroot00000000000000regenerator-regenerator-transform-0.15.2/packages/transform/.gitignore000066400000000000000000000000211446323212200262110ustar00rootroot00000000000000node_modules lib regenerator-regenerator-transform-0.15.2/packages/transform/.npmignore000066400000000000000000000000161446323212200262240ustar00rootroot00000000000000/node_modules regenerator-regenerator-transform-0.15.2/packages/transform/LICENSE000066400000000000000000000020701446323212200252340ustar00rootroot00000000000000MIT License Copyright (c) 2014-present, Facebook, Inc. 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. regenerator-regenerator-transform-0.15.2/packages/transform/README.md000066400000000000000000000013241446323212200255070ustar00rootroot00000000000000# regenerator-transform Transform async/generator functions with [regenerator](https://github.com/facebook/regenerator) ## Installation ```sh $ npm install regenerator-transform ``` ## Usage ### Via `.babelrc` (Recommended) **.babelrc** ```js // without options { "plugins": ["regenerator-transform"] } // with options { "plugins": [ ["regenerator-transform", { asyncGenerators: false, // true by default generators: false, // true by default async: false // true by default }] ] } ``` ### Via CLI ```sh $ babel --plugins regenerator-transform script.js ``` ### Via Node API ```javascript require("@babel/core").transformSync("code", { plugins: ["regenerator-transform"] }); ``` regenerator-regenerator-transform-0.15.2/packages/transform/package.json000066400000000000000000000016421446323212200265210ustar00rootroot00000000000000{ "name": "regenerator-transform", "author": "Ben Newman ", "description": "Explode async and generator functions into a state machine.", "version": "0.15.2", "main": "lib/index.js", "keywords": [ "regenerator", "runtime", "generator", "async" ], "repository": { "type": "git", "url": "https://github.com/facebook/regenerator/tree/main/packages/transform" }, "license": "MIT", "scripts": { "prepublish": "npx babel src/ --out-dir lib/" }, "babel": { "plugins": [ "@babel/plugin-transform-runtime" ], "presets": [ [ "@babel/preset-env", { "loose": true } ] ] }, "dependencies": { "@babel/runtime": "^7.8.4" }, "devDependencies": { "@babel/cli": "^7.8.4", "@babel/core": "^7.8.4", "@babel/plugin-transform-runtime": "^7.8.3", "@babel/preset-env": "^7.8.4" } } regenerator-regenerator-transform-0.15.2/packages/transform/src/000077500000000000000000000000001446323212200250175ustar00rootroot00000000000000regenerator-regenerator-transform-0.15.2/packages/transform/src/emit.js000066400000000000000000001101631446323212200263150ustar00rootroot00000000000000/** * Copyright (c) 2014-present, Facebook, Inc. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ import assert from "assert"; import * as leap from "./leap"; import * as meta from "./meta"; import * as util from "./util"; let hasOwn = Object.prototype.hasOwnProperty; function Emitter(contextId) { assert.ok(this instanceof Emitter); util.getTypes().assertIdentifier(contextId); // Used to generate unique temporary names. this.nextTempId = 0; // In order to make sure the context object does not collide with // anything in the local scope, we might have to rename it, so we // refer to it symbolically instead of just assuming that it will be // called "context". this.contextId = contextId; // An append-only list of Statements that grows each time this.emit is // called. this.listing = []; // A sparse array whose keys correspond to locations in this.listing // that have been marked as branch/jump targets. this.marked = [true]; this.insertedLocs = new Set(); // The last location will be marked when this.getDispatchLoop is // called. this.finalLoc = this.loc(); // A list of all leap.TryEntry statements emitted. this.tryEntries = []; // Each time we evaluate the body of a loop, we tell this.leapManager // to enter a nested loop context that determines the meaning of break // and continue statements therein. this.leapManager = new leap.LeapManager(this); } let Ep = Emitter.prototype; exports.Emitter = Emitter; // Offsets into this.listing that could be used as targets for branches or // jumps are represented as numeric Literal nodes. This representation has // the amazingly convenient benefit of allowing the exact value of the // location to be determined at any time, even after generating code that // refers to the location. // We use 'Number.MAX_VALUE' to mark uninitialized location. We can safely do // so because no code can realistically have about 1.8e+308 locations before // hitting memory limit of the machine it's running on. For comparison, the // estimated number of atoms in the observable universe is around 1e+80. const PENDING_LOCATION = Number.MAX_VALUE; Ep.loc = function() { const l = util.getTypes().numericLiteral(PENDING_LOCATION) this.insertedLocs.add(l); return l; } Ep.getInsertedLocs = function() { return this.insertedLocs; } Ep.getContextId = function() { return util.getTypes().clone(this.contextId); } // Sets the exact value of the given location to the offset of the next // Statement emitted. Ep.mark = function(loc) { util.getTypes().assertLiteral(loc); let index = this.listing.length; if (loc.value === PENDING_LOCATION) { loc.value = index; } else { // Locations can be marked redundantly, but their values cannot change // once set the first time. assert.strictEqual(loc.value, index); } this.marked[index] = true; return loc; }; Ep.emit = function(node) { const t = util.getTypes(); if (t.isExpression(node)) { node = t.expressionStatement(node); } t.assertStatement(node); this.listing.push(node); }; // Shorthand for emitting assignment statements. This will come in handy // for assignments to temporary variables. Ep.emitAssign = function(lhs, rhs) { this.emit(this.assign(lhs, rhs)); return lhs; }; // Shorthand for an assignment statement. Ep.assign = function(lhs, rhs) { const t = util.getTypes(); return t.expressionStatement( t.assignmentExpression("=", t.cloneDeep(lhs), rhs)); }; // Convenience function for generating expressions like context.next, // context.sent, and context.rval. Ep.contextProperty = function(name, computed) { const t = util.getTypes(); return t.memberExpression( this.getContextId(), computed ? t.stringLiteral(name) : t.identifier(name), !!computed ); }; // Shorthand for setting context.rval and jumping to `context.stop()`. Ep.stop = function(rval) { if (rval) { this.setReturnValue(rval); } this.jump(this.finalLoc); }; Ep.setReturnValue = function(valuePath) { util.getTypes().assertExpression(valuePath.value); this.emitAssign( this.contextProperty("rval"), this.explodeExpression(valuePath) ); }; Ep.clearPendingException = function(tryLoc, assignee) { const t = util.getTypes(); t.assertLiteral(tryLoc); let catchCall = t.callExpression( this.contextProperty("catch", true), [t.clone(tryLoc)] ); if (assignee) { this.emitAssign(assignee, catchCall); } else { this.emit(catchCall); } }; // Emits code for an unconditional jump to the given location, even if the // exact value of the location is not yet known. Ep.jump = function(toLoc) { this.emitAssign(this.contextProperty("next"), toLoc); this.emit(util.getTypes().breakStatement()); }; // Conditional jump. Ep.jumpIf = function(test, toLoc) { const t = util.getTypes(); t.assertExpression(test); t.assertLiteral(toLoc); this.emit(t.ifStatement( test, t.blockStatement([ this.assign(this.contextProperty("next"), toLoc), t.breakStatement() ]) )); }; // Conditional jump, with the condition negated. Ep.jumpIfNot = function(test, toLoc) { const t = util.getTypes(); t.assertExpression(test); t.assertLiteral(toLoc); let negatedTest; if (t.isUnaryExpression(test) && test.operator === "!") { // Avoid double negation. negatedTest = test.argument; } else { negatedTest = t.unaryExpression("!", test); } this.emit(t.ifStatement( negatedTest, t.blockStatement([ this.assign(this.contextProperty("next"), toLoc), t.breakStatement() ]) )); }; // Returns a unique MemberExpression that can be used to store and // retrieve temporary values. Since the object of the member expression is // the context object, which is presumed to coexist peacefully with all // other local variables, and since we just increment `nextTempId` // monotonically, uniqueness is assured. Ep.makeTempVar = function() { return this.contextProperty("t" + this.nextTempId++); }; Ep.getContextFunction = function(id) { const t = util.getTypes(); return t.functionExpression( id || null/*Anonymous*/, [this.getContextId()], t.blockStatement([this.getDispatchLoop()]), false, // Not a generator anymore! false // Nor an expression. ); }; // Turns this.listing into a loop of the form // // while (1) switch (context.next) { // case 0: // ... // case n: // return context.stop(); // } // // Each marked location in this.listing will correspond to one generated // case statement. Ep.getDispatchLoop = function() { const self = this; const t = util.getTypes(); let cases = []; let current; // If we encounter a break, continue, or return statement in a switch // case, we can skip the rest of the statements until the next case. let alreadyEnded = false; self.listing.forEach(function(stmt, i) { if (self.marked.hasOwnProperty(i)) { cases.push(t.switchCase( t.numericLiteral(i), current = [])); alreadyEnded = false; } if (!alreadyEnded) { current.push(stmt); if (t.isCompletionStatement(stmt)) alreadyEnded = true; } }); // Now that we know how many statements there will be in this.listing, // we can finally resolve this.finalLoc.value. this.finalLoc.value = this.listing.length; cases.push( t.switchCase(this.finalLoc, [ // Intentionally fall through to the "end" case... ]), // So that the runtime can jump to the final location without having // to know its offset, we provide the "end" case as a synonym. t.switchCase(t.stringLiteral("end"), [ // This will check/clear both context.thrown and context.rval. t.returnStatement( t.callExpression(this.contextProperty("stop"), []) ) ]) ); return t.whileStatement( t.numericLiteral(1), t.switchStatement( t.assignmentExpression( "=", this.contextProperty("prev"), this.contextProperty("next") ), cases ) ); }; Ep.getTryLocsList = function() { if (this.tryEntries.length === 0) { // To avoid adding a needless [] to the majority of runtime.wrap // argument lists, force the caller to handle this case specially. return null; } const t = util.getTypes(); let lastLocValue = 0; return t.arrayExpression( this.tryEntries.map(function(tryEntry) { let thisLocValue = tryEntry.firstLoc.value; assert.ok(thisLocValue >= lastLocValue, "try entries out of order"); lastLocValue = thisLocValue; let ce = tryEntry.catchEntry; let fe = tryEntry.finallyEntry; let locs = [ tryEntry.firstLoc, // The null here makes a hole in the array. ce ? ce.firstLoc : null ]; if (fe) { locs[2] = fe.firstLoc; locs[3] = fe.afterLoc; } return t.arrayExpression(locs.map(loc => loc && t.clone(loc))); }) ); }; // All side effects must be realized in order. // If any subexpression harbors a leap, all subexpressions must be // neutered of side effects. // No destructive modification of AST nodes. Ep.explode = function(path, ignoreResult) { const t = util.getTypes(); let node = path.node; let self = this; t.assertNode(node); if (t.isDeclaration(node)) throw getDeclError(node); if (t.isStatement(node)) return self.explodeStatement(path); if (t.isExpression(node)) return self.explodeExpression(path, ignoreResult); switch (node.type) { case "Program": return path.get("body").map( self.explodeStatement, self ); case "VariableDeclarator": throw getDeclError(node); // These node types should be handled by their parent nodes // (ObjectExpression, SwitchStatement, and TryStatement, respectively). case "Property": case "SwitchCase": case "CatchClause": throw new Error( node.type + " nodes should be handled by their parents"); default: throw new Error( "unknown Node of type " + JSON.stringify(node.type)); } }; function getDeclError(node) { return new Error( "all declarations should have been transformed into " + "assignments before the Exploder began its work: " + JSON.stringify(node)); } Ep.explodeStatement = function(path, labelId) { const t = util.getTypes(); let stmt = path.node; let self = this; let before, after, head; t.assertStatement(stmt); if (labelId) { t.assertIdentifier(labelId); } else { labelId = null; } // Explode BlockStatement nodes even if they do not contain a yield, // because we don't want or need the curly braces. if (t.isBlockStatement(stmt)) { path.get("body").forEach(function (path) { self.explodeStatement(path); }); return; } if (!meta.containsLeap(stmt)) { // Technically we should be able to avoid emitting the statement // altogether if !meta.hasSideEffects(stmt), but that leads to // confusing generated code (for instance, `while (true) {}` just // disappears) and is probably a more appropriate job for a dedicated // dead code elimination pass. self.emit(stmt); return; } switch (stmt.type) { case "ExpressionStatement": self.explodeExpression(path.get("expression"), true); break; case "LabeledStatement": after = this.loc(); // Did you know you can break from any labeled block statement or // control structure? Well, you can! Note: when a labeled loop is // encountered, the leap.LabeledEntry created here will immediately // enclose a leap.LoopEntry on the leap manager's stack, and both // entries will have the same label. Though this works just fine, it // may seem a bit redundant. In theory, we could check here to // determine if stmt knows how to handle its own label; for example, // stmt happens to be a WhileStatement and so we know it's going to // establish its own LoopEntry when we explode it (below). Then this // LabeledEntry would be unnecessary. Alternatively, we might be // tempted not to pass stmt.label down into self.explodeStatement, // because we've handled the label here, but that's a mistake because // labeled loops may contain labeled continue statements, which is not // something we can handle in this generic case. All in all, I think a // little redundancy greatly simplifies the logic of this case, since // it's clear that we handle all possible LabeledStatements correctly // here, regardless of whether they interact with the leap manager // themselves. Also remember that labels and break/continue-to-label // statements are rare, and all of this logic happens at transform // time, so it has no additional runtime cost. self.leapManager.withEntry( new leap.LabeledEntry(after, stmt.label), function() { self.explodeStatement(path.get("body"), stmt.label); } ); self.mark(after); break; case "WhileStatement": before = this.loc(); after = this.loc(); self.mark(before); self.jumpIfNot(self.explodeExpression(path.get("test")), after); self.leapManager.withEntry( new leap.LoopEntry(after, before, labelId), function() { self.explodeStatement(path.get("body")); } ); self.jump(before); self.mark(after); break; case "DoWhileStatement": let first = this.loc(); let test = this.loc(); after = this.loc(); self.mark(first); self.leapManager.withEntry( new leap.LoopEntry(after, test, labelId), function() { self.explode(path.get("body")); } ); self.mark(test); self.jumpIf(self.explodeExpression(path.get("test")), first); self.mark(after); break; case "ForStatement": head = this.loc(); let update = this.loc(); after = this.loc(); if (stmt.init) { // We pass true here to indicate that if stmt.init is an expression // then we do not care about its result. self.explode(path.get("init"), true); } self.mark(head); if (stmt.test) { self.jumpIfNot(self.explodeExpression(path.get("test")), after); } else { // No test means continue unconditionally. } self.leapManager.withEntry( new leap.LoopEntry(after, update, labelId), function() { self.explodeStatement(path.get("body")); } ); self.mark(update); if (stmt.update) { // We pass true here to indicate that if stmt.update is an // expression then we do not care about its result. self.explode(path.get("update"), true); } self.jump(head); self.mark(after); break; case "TypeCastExpression": return self.explodeExpression(path.get("expression")); case "ForInStatement": head = this.loc(); after = this.loc(); let keyIterNextFn = self.makeTempVar(); self.emitAssign( keyIterNextFn, t.callExpression( util.runtimeProperty("keys"), [self.explodeExpression(path.get("right"))] ) ); self.mark(head); let keyInfoTmpVar = self.makeTempVar(); self.jumpIf( t.memberExpression( t.assignmentExpression( "=", keyInfoTmpVar, t.callExpression(t.cloneDeep(keyIterNextFn), []) ), t.identifier("done"), false ), after ); self.emitAssign( stmt.left, t.memberExpression( t.cloneDeep(keyInfoTmpVar), t.identifier("value"), false ) ); self.leapManager.withEntry( new leap.LoopEntry(after, head, labelId), function() { self.explodeStatement(path.get("body")); } ); self.jump(head); self.mark(after); break; case "BreakStatement": self.emitAbruptCompletion({ type: "break", target: self.leapManager.getBreakLoc(stmt.label) }); break; case "ContinueStatement": self.emitAbruptCompletion({ type: "continue", target: self.leapManager.getContinueLoc(stmt.label) }); break; case "SwitchStatement": // Always save the discriminant into a temporary variable in case the // test expressions overwrite values like context.sent. let disc = self.emitAssign( self.makeTempVar(), self.explodeExpression(path.get("discriminant")) ); after = this.loc(); let defaultLoc = this.loc(); let condition = defaultLoc; let caseLocs = []; // If there are no cases, .cases might be undefined. let cases = stmt.cases || []; for (let i = cases.length - 1; i >= 0; --i) { let c = cases[i]; t.assertSwitchCase(c); if (c.test) { condition = t.conditionalExpression( t.binaryExpression("===", t.cloneDeep(disc), c.test), caseLocs[i] = this.loc(), condition ); } else { caseLocs[i] = defaultLoc; } } let discriminant = path.get("discriminant"); util.replaceWithOrRemove(discriminant, condition); self.jump(self.explodeExpression(discriminant)); self.leapManager.withEntry( new leap.SwitchEntry(after), function() { path.get("cases").forEach(function(casePath) { let i = casePath.key; self.mark(caseLocs[i]); casePath.get("consequent").forEach(function (path) { self.explodeStatement(path); }); }); } ); self.mark(after); if (defaultLoc.value === PENDING_LOCATION) { self.mark(defaultLoc); assert.strictEqual(after.value, defaultLoc.value); } break; case "IfStatement": let elseLoc = stmt.alternate && this.loc(); after = this.loc(); self.jumpIfNot( self.explodeExpression(path.get("test")), elseLoc || after ); self.explodeStatement(path.get("consequent")); if (elseLoc) { self.jump(after); self.mark(elseLoc); self.explodeStatement(path.get("alternate")); } self.mark(after); break; case "ReturnStatement": self.emitAbruptCompletion({ type: "return", value: self.explodeExpression(path.get("argument")) }); break; case "WithStatement": throw new Error("WithStatement not supported in generator functions."); case "TryStatement": after = this.loc(); let handler = stmt.handler; let catchLoc = handler && this.loc(); let catchEntry = catchLoc && new leap.CatchEntry( catchLoc, handler.param ); let finallyLoc = stmt.finalizer && this.loc(); let finallyEntry = finallyLoc && new leap.FinallyEntry(finallyLoc, after); let tryEntry = new leap.TryEntry( self.getUnmarkedCurrentLoc(), catchEntry, finallyEntry ); self.tryEntries.push(tryEntry); self.updateContextPrevLoc(tryEntry.firstLoc); self.leapManager.withEntry(tryEntry, function() { self.explodeStatement(path.get("block")); if (catchLoc) { if (finallyLoc) { // If we have both a catch block and a finally block, then // because we emit the catch block first, we need to jump over // it to the finally block. self.jump(finallyLoc); } else { // If there is no finally block, then we need to jump over the // catch block to the fall-through location. self.jump(after); } self.updateContextPrevLoc(self.mark(catchLoc)); let bodyPath = path.get("handler.body"); let safeParam = self.makeTempVar(); self.clearPendingException(tryEntry.firstLoc, safeParam); bodyPath.traverse(catchParamVisitor, { getSafeParam: () => t.cloneDeep(safeParam), catchParamName: handler.param.name }); self.leapManager.withEntry(catchEntry, function() { self.explodeStatement(bodyPath); }); } if (finallyLoc) { self.updateContextPrevLoc(self.mark(finallyLoc)); self.leapManager.withEntry(finallyEntry, function() { self.explodeStatement(path.get("finalizer")); }); self.emit(t.returnStatement(t.callExpression( self.contextProperty("finish"), [finallyEntry.firstLoc] ))); } }); self.mark(after); break; case "ThrowStatement": self.emit(t.throwStatement( self.explodeExpression(path.get("argument")) )); break; case "ClassDeclaration": self.emit(self.explodeClass(path)); break; default: throw new Error( "unknown Statement of type " + JSON.stringify(stmt.type)); } }; let catchParamVisitor = { Identifier: function(path, state) { if (path.node.name === state.catchParamName && util.isReference(path)) { util.replaceWithOrRemove(path, state.getSafeParam()); } }, Scope: function(path, state) { if (path.scope.hasOwnBinding(state.catchParamName)) { // Don't descend into nested scopes that shadow the catch // parameter with their own declarations. path.skip(); } } }; Ep.emitAbruptCompletion = function(record) { if (!isValidCompletion(record)) { assert.ok( false, "invalid completion record: " + JSON.stringify(record) ); } assert.notStrictEqual( record.type, "normal", "normal completions are not abrupt" ); const t = util.getTypes(); let abruptArgs = [t.stringLiteral(record.type)]; if (record.type === "break" || record.type === "continue") { t.assertLiteral(record.target); abruptArgs[1] = this.insertedLocs.has(record.target) ? record.target : t.cloneDeep(record.target); } else if (record.type === "return" || record.type === "throw") { if (record.value) { t.assertExpression(record.value); abruptArgs[1] = this.insertedLocs.has(record.value) ? record.value : t.cloneDeep(record.value); } } this.emit( t.returnStatement( t.callExpression( this.contextProperty("abrupt"), abruptArgs ) ) ); }; function isValidCompletion(record) { let type = record.type; if (type === "normal") { return !hasOwn.call(record, "target"); } if (type === "break" || type === "continue") { return !hasOwn.call(record, "value") && util.getTypes().isLiteral(record.target); } if (type === "return" || type === "throw") { return hasOwn.call(record, "value") && !hasOwn.call(record, "target"); } return false; } // Not all offsets into emitter.listing are potential jump targets. For // example, execution typically falls into the beginning of a try block // without jumping directly there. This method returns the current offset // without marking it, so that a switch case will not necessarily be // generated for this offset (I say "not necessarily" because the same // location might end up being marked in the process of emitting other // statements). There's no logical harm in marking such locations as jump // targets, but minimizing the number of switch cases keeps the generated // code shorter. Ep.getUnmarkedCurrentLoc = function() { return util.getTypes().numericLiteral(this.listing.length); }; // The context.prev property takes the value of context.next whenever we // evaluate the switch statement discriminant, which is generally good // enough for tracking the last location we jumped to, but sometimes // context.prev needs to be more precise, such as when we fall // successfully out of a try block and into a finally block without // jumping. This method exists to update context.prev to the freshest // available location. If we were implementing a full interpreter, we // would know the location of the current instruction with complete // precision at all times, but we don't have that luxury here, as it would // be costly and verbose to set context.prev before every statement. Ep.updateContextPrevLoc = function(loc) { const t = util.getTypes(); if (loc) { t.assertLiteral(loc); if (loc.value === PENDING_LOCATION) { // If an uninitialized location literal was passed in, set its value // to the current this.listing.length. loc.value = this.listing.length; } else { // Otherwise assert that the location matches the current offset. assert.strictEqual(loc.value, this.listing.length); } } else { loc = this.getUnmarkedCurrentLoc(); } // Make sure context.prev is up to date in case we fell into this try // statement without jumping to it. TODO Consider avoiding this // assignment when we know control must have jumped here. this.emitAssign(this.contextProperty("prev"), loc); }; // In order to save the rest of explodeExpression from a combinatorial // trainwreck of special cases, explodeViaTempVar is responsible for // deciding when a subexpression needs to be "exploded," which is my // very technical term for emitting the subexpression as an assignment // to a temporary variable and the substituting the temporary variable // for the original subexpression. Think of exploded view diagrams, not // Michael Bay movies. The point of exploding subexpressions is to // control the precise order in which the generated code realizes the // side effects of those subexpressions. Ep.explodeViaTempVar = function(tempVar, childPath, hasLeapingChildren, ignoreChildResult) { assert.ok( !ignoreChildResult || !tempVar, "Ignoring the result of a child expression but forcing it to " + "be assigned to a temporary variable?" ); const t = util.getTypes(); let result = this.explodeExpression(childPath, ignoreChildResult); if (ignoreChildResult) { // Side effects already emitted above. } else if (tempVar || (hasLeapingChildren && !t.isLiteral(result))) { // If tempVar was provided, then the result will always be assigned // to it, even if the result does not otherwise need to be assigned // to a temporary variable. When no tempVar is provided, we have // the flexibility to decide whether a temporary variable is really // necessary. Unfortunately, in general, a temporary variable is // required whenever any child contains a yield expression, since it // is difficult to prove (at all, let alone efficiently) whether // this result would evaluate to the same value before and after the // yield (see #206). One narrow case where we can prove it doesn't // matter (and thus we do not need a temporary variable) is when the // result in question is a Literal value. result = this.emitAssign( tempVar || this.makeTempVar(), result ); } return result; }; Ep.explodeExpression = function(path, ignoreResult) { const t = util.getTypes(); let expr = path.node; if (expr) { t.assertExpression(expr); } else { return expr; } let self = this; let result; // Used optionally by several cases below. let after; function finish(expr) { t.assertExpression(expr); if (ignoreResult) { self.emit(expr); } return expr; } // If the expression does not contain a leap, then we either emit the // expression as a standalone statement or return it whole. if (!meta.containsLeap(expr)) { return finish(expr); } // If any child contains a leap (such as a yield or labeled continue or // break statement), then any sibling subexpressions will almost // certainly have to be exploded in order to maintain the order of their // side effects relative to the leaping child(ren). let hasLeapingChildren = meta.containsLeap.onlyChildren(expr); // If ignoreResult is true, then we must take full responsibility for // emitting the expression with all its side effects, and we should not // return a result. switch (expr.type) { case "MemberExpression": return finish(t.memberExpression( self.explodeExpression(path.get("object")), expr.computed ? self.explodeViaTempVar(null, path.get("property"), hasLeapingChildren) : expr.property, expr.computed )); case "CallExpression": let calleePath = path.get("callee"); let argsPath = path.get("arguments"); let newCallee; let newArgs; let hasLeapingArgs = argsPath.some( argPath => meta.containsLeap(argPath.node) ); let injectFirstArg = null; if (t.isMemberExpression(calleePath.node)) { if (hasLeapingArgs) { // If the arguments of the CallExpression contained any yield // expressions, then we need to be sure to evaluate the callee // before evaluating the arguments, but if the callee was a member // expression, then we must be careful that the object of the // member expression still gets bound to `this` for the call. let newObject = self.explodeViaTempVar( // Assign the exploded callee.object expression to a temporary // variable so that we can use it twice without reevaluating it. self.makeTempVar(), calleePath.get("object"), hasLeapingChildren ); let newProperty = calleePath.node.computed ? self.explodeViaTempVar(null, calleePath.get("property"), hasLeapingChildren) : calleePath.node.property; injectFirstArg = newObject; newCallee = t.memberExpression( t.memberExpression( t.cloneDeep(newObject), newProperty, calleePath.node.computed ), t.identifier("call"), false ); } else { newCallee = self.explodeExpression(calleePath); } } else { newCallee = self.explodeViaTempVar(null, calleePath, hasLeapingChildren); if (t.isMemberExpression(newCallee)) { // If the callee was not previously a MemberExpression, then the // CallExpression was "unqualified," meaning its `this` object // should be the global object. If the exploded expression has // become a MemberExpression (e.g. a context property, probably a // temporary variable), then we need to force it to be unqualified // by using the (0, object.property)(...) trick; otherwise, it // will receive the object of the MemberExpression as its `this` // object. newCallee = t.sequenceExpression([ t.numericLiteral(0), t.cloneDeep(newCallee) ]); } } if (hasLeapingArgs) { newArgs = argsPath.map(argPath => self.explodeViaTempVar(null, argPath, hasLeapingChildren)); if (injectFirstArg) newArgs.unshift(injectFirstArg); newArgs = newArgs.map(arg => t.cloneDeep(arg)); } else { newArgs = path.node.arguments; } return finish(t.callExpression(newCallee, newArgs)); case "NewExpression": return finish(t.newExpression( self.explodeViaTempVar(null, path.get("callee"), hasLeapingChildren), path.get("arguments").map(function(argPath) { return self.explodeViaTempVar(null, argPath, hasLeapingChildren); }) )); case "ObjectExpression": return finish(t.objectExpression( path.get("properties").map(function(propPath) { if (propPath.isObjectProperty()) { return t.objectProperty( propPath.node.key, self.explodeViaTempVar(null, propPath.get("value"), hasLeapingChildren), propPath.node.computed ); } else { return propPath.node; } }) )); case "ArrayExpression": return finish(t.arrayExpression( path.get("elements").map(function(elemPath) { if (!elemPath.node) { return null; } if (elemPath.isSpreadElement()) { return t.spreadElement( self.explodeViaTempVar(null, elemPath.get("argument"), hasLeapingChildren) ); } else { return self.explodeViaTempVar(null, elemPath, hasLeapingChildren); } }) )); case "SequenceExpression": let lastIndex = expr.expressions.length - 1; path.get("expressions").forEach(function(exprPath) { if (exprPath.key === lastIndex) { result = self.explodeExpression(exprPath, ignoreResult); } else { self.explodeExpression(exprPath, true); } }); return result; case "LogicalExpression": after = this.loc(); if (!ignoreResult) { result = self.makeTempVar(); } let left = self.explodeViaTempVar(result, path.get("left"), hasLeapingChildren); if (expr.operator === "&&") { self.jumpIfNot(left, after); } else { assert.strictEqual(expr.operator, "||"); self.jumpIf(left, after); } self.explodeViaTempVar(result, path.get("right"), hasLeapingChildren, ignoreResult); self.mark(after); return result; case "ConditionalExpression": let elseLoc = this.loc(); after = this.loc(); let test = self.explodeExpression(path.get("test")); self.jumpIfNot(test, elseLoc); if (!ignoreResult) { result = self.makeTempVar(); } self.explodeViaTempVar(result, path.get("consequent"), hasLeapingChildren, ignoreResult); self.jump(after); self.mark(elseLoc); self.explodeViaTempVar(result, path.get("alternate"), hasLeapingChildren, ignoreResult); self.mark(after); return result; case "UnaryExpression": return finish(t.unaryExpression( expr.operator, // Can't (and don't need to) break up the syntax of the argument. // Think about delete a[b]. self.explodeExpression(path.get("argument")), !!expr.prefix )); case "BinaryExpression": return finish(t.binaryExpression( expr.operator, self.explodeViaTempVar(null, path.get("left"), hasLeapingChildren), self.explodeViaTempVar(null, path.get("right"), hasLeapingChildren) )); case "AssignmentExpression": if (expr.operator === "=") { // If this is a simple assignment, the left hand side does not need // to be read before the right hand side is evaluated, so we can // avoid the more complicated logic below. return finish(t.assignmentExpression( expr.operator, self.explodeExpression(path.get("left")), self.explodeExpression(path.get("right")) )); } const lhs = self.explodeExpression(path.get("left")); const temp = self.emitAssign(self.makeTempVar(), lhs); // For example, // // x += yield y // // becomes // // context.t0 = x // x = context.t0 += yield y // // so that the left-hand side expression is read before the yield. // Fixes https://github.com/facebook/regenerator/issues/345. return finish(t.assignmentExpression( "=", t.cloneDeep(lhs), t.assignmentExpression( expr.operator, t.cloneDeep(temp), self.explodeExpression(path.get("right")) ) )); case "UpdateExpression": return finish(t.updateExpression( expr.operator, self.explodeExpression(path.get("argument")), expr.prefix )); case "YieldExpression": after = this.loc(); let arg = expr.argument && self.explodeExpression(path.get("argument")); if (arg && expr.delegate) { let result = self.makeTempVar(); let ret = t.returnStatement(t.callExpression( self.contextProperty("delegateYield"), [ arg, t.stringLiteral(result.property.name), after ] )); ret.loc = expr.loc; self.emit(ret); self.mark(after); return result; } self.emitAssign(self.contextProperty("next"), after); let ret = t.returnStatement(t.cloneDeep(arg) || null); // Preserve the `yield` location so that source mappings for the statements // link back to the yield properly. ret.loc = expr.loc; self.emit(ret); self.mark(after); return self.contextProperty("sent"); case "ClassExpression": return finish(self.explodeClass(path)); default: throw new Error( "unknown Expression of type " + JSON.stringify(expr.type)); } }; Ep.explodeClass = function(path) { const explodingChildren = []; if (path.node.superClass) { explodingChildren.push(path.get("superClass")); } path.get("body.body").forEach(member => { if (member.node.computed) { explodingChildren.push(member.get("key")); } }); const hasLeapingChildren = explodingChildren.some( child => meta.containsLeap(child)); for (let i = 0; i < explodingChildren.length; i++) { const child = explodingChildren[i]; const isLast = i === explodingChildren.length - 1; if (isLast) { child.replaceWith(this.explodeExpression(child)); } else { child.replaceWith(this.explodeViaTempVar(null, child, hasLeapingChildren)); } } return path.node; }; regenerator-regenerator-transform-0.15.2/packages/transform/src/hoist.js000066400000000000000000000112741446323212200265100ustar00rootroot00000000000000/** * Copyright (c) 2014-present, Facebook, Inc. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ import * as util from "./util"; let hasOwn = Object.prototype.hasOwnProperty; // The hoist function takes a FunctionExpression or FunctionDeclaration // and replaces any Declaration nodes in its body with assignments, then // returns a VariableDeclaration containing just the names of the removed // declarations. exports.hoist = function(funPath) { const t = util.getTypes(); t.assertFunction(funPath.node); let vars = {}; function varDeclToExpr({ node: vdec, scope }, includeIdentifiers) { t.assertVariableDeclaration(vdec); // TODO assert.equal(vdec.kind, "var"); let exprs = []; vdec.declarations.forEach(function(dec) { // Note: We duplicate 'dec.id' here to ensure that the variable declaration IDs don't // have the same 'loc' value, since that can make sourcemaps and retainLines behave poorly. vars[dec.id.name] = t.identifier(dec.id.name); // Remove the binding, to avoid "duplicate declaration" errors when it will // be injected again. scope.removeBinding(dec.id.name); if (dec.init) { exprs.push(t.assignmentExpression( "=", dec.id, dec.init )); } else if (includeIdentifiers) { exprs.push(dec.id); } }); if (exprs.length === 0) return null; if (exprs.length === 1) return exprs[0]; return t.sequenceExpression(exprs); } funPath.get("body").traverse({ VariableDeclaration: { exit: function(path) { let expr = varDeclToExpr(path, false); if (expr === null) { path.remove(); } else { // We don't need to traverse this expression any further because // there can't be any new declarations inside an expression. util.replaceWithOrRemove(path, t.expressionStatement(expr)); } // Since the original node has been either removed or replaced, // avoid traversing it any further. path.skip(); } }, ForStatement: function(path) { let init = path.get("init"); if (init.isVariableDeclaration()) { util.replaceWithOrRemove(init, varDeclToExpr(init, false)); } }, ForXStatement: function(path) { let left = path.get("left"); if (left.isVariableDeclaration()) { util.replaceWithOrRemove(left, varDeclToExpr(left, true)); } }, FunctionDeclaration: function(path) { let node = path.node; vars[node.id.name] = node.id; let assignment = t.expressionStatement( t.assignmentExpression( "=", t.clone(node.id), t.functionExpression( path.scope.generateUidIdentifierBasedOnNode(node), node.params, node.body, node.generator, node.expression ) ) ); if (path.parentPath.isBlockStatement()) { // Insert the assignment form before the first statement in the // enclosing block. path.parentPath.unshiftContainer("body", assignment); // Remove the function declaration now that we've inserted the // equivalent assignment form at the beginning of the block. path.remove(); } else { // If the parent node is not a block statement, then we can just // replace the declaration with the equivalent assignment form // without worrying about hoisting it. util.replaceWithOrRemove(path, assignment); } // Remove the binding, to avoid "duplicate declaration" errors when it will // be injected again. path.scope.removeBinding(node.id.name); // Don't hoist variables out of inner functions. path.skip(); }, FunctionExpression: function(path) { // Don't descend into nested function expressions. path.skip(); }, ArrowFunctionExpression: function(path) { // Don't descend into nested function expressions. path.skip(); } }); let paramNames = {}; funPath.get("params").forEach(function(paramPath) { let param = paramPath.node; if (t.isIdentifier(param)) { paramNames[param.name] = param; } else { // Variables declared by destructuring parameter patterns will be // harmlessly re-declared. } }); let declarations = []; Object.keys(vars).forEach(function(name) { if (!hasOwn.call(paramNames, name)) { declarations.push(t.variableDeclarator(vars[name], null)); } }); if (declarations.length === 0) { return null; // Be sure to handle this case! } return t.variableDeclaration("var", declarations); }; regenerator-regenerator-transform-0.15.2/packages/transform/src/index.js000066400000000000000000000014721446323212200264700ustar00rootroot00000000000000/** * Copyright (c) 2014-present, Facebook, Inc. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ import { getVisitor } from "./visit"; export default function (context) { const plugin = { visitor: getVisitor(context), }; // Some presets manually call child presets, but fail to pass along the // context object. Out of an abundance of caution, we verify that it // exists first to avoid causing unnecessary breaking changes. const version = context && context.version; // The "name" property is not allowed in older versions of Babel (6.x) // and will cause the plugin validator to throw an exception. if (version && parseInt(version, 10) >= 7) { plugin.name = "regenerator-transform"; } return plugin; } regenerator-regenerator-transform-0.15.2/packages/transform/src/leap.js000066400000000000000000000073401446323212200263020ustar00rootroot00000000000000/** * Copyright (c) 2014-present, Facebook, Inc. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ import assert from "assert"; import { Emitter } from "./emit"; import { inherits } from "util"; import { getTypes } from "./util"; function Entry() { assert.ok(this instanceof Entry); } function FunctionEntry(returnLoc) { Entry.call(this); getTypes().assertLiteral(returnLoc); this.returnLoc = returnLoc; } inherits(FunctionEntry, Entry); exports.FunctionEntry = FunctionEntry; function LoopEntry(breakLoc, continueLoc, label) { Entry.call(this); const t = getTypes(); t.assertLiteral(breakLoc); t.assertLiteral(continueLoc); if (label) { t.assertIdentifier(label); } else { label = null; } this.breakLoc = breakLoc; this.continueLoc = continueLoc; this.label = label; } inherits(LoopEntry, Entry); exports.LoopEntry = LoopEntry; function SwitchEntry(breakLoc) { Entry.call(this); getTypes().assertLiteral(breakLoc); this.breakLoc = breakLoc; } inherits(SwitchEntry, Entry); exports.SwitchEntry = SwitchEntry; function TryEntry(firstLoc, catchEntry, finallyEntry) { Entry.call(this); const t = getTypes(); t.assertLiteral(firstLoc); if (catchEntry) { assert.ok(catchEntry instanceof CatchEntry); } else { catchEntry = null; } if (finallyEntry) { assert.ok(finallyEntry instanceof FinallyEntry); } else { finallyEntry = null; } // Have to have one or the other (or both). assert.ok(catchEntry || finallyEntry); this.firstLoc = firstLoc; this.catchEntry = catchEntry; this.finallyEntry = finallyEntry; } inherits(TryEntry, Entry); exports.TryEntry = TryEntry; function CatchEntry(firstLoc, paramId) { Entry.call(this); const t = getTypes(); t.assertLiteral(firstLoc); t.assertIdentifier(paramId); this.firstLoc = firstLoc; this.paramId = paramId; } inherits(CatchEntry, Entry); exports.CatchEntry = CatchEntry; function FinallyEntry(firstLoc, afterLoc) { Entry.call(this); const t = getTypes(); t.assertLiteral(firstLoc); t.assertLiteral(afterLoc); this.firstLoc = firstLoc; this.afterLoc = afterLoc; } inherits(FinallyEntry, Entry); exports.FinallyEntry = FinallyEntry; function LabeledEntry(breakLoc, label) { Entry.call(this); const t = getTypes(); t.assertLiteral(breakLoc); t.assertIdentifier(label); this.breakLoc = breakLoc; this.label = label; } inherits(LabeledEntry, Entry); exports.LabeledEntry = LabeledEntry; function LeapManager(emitter) { assert.ok(this instanceof LeapManager); assert.ok(emitter instanceof Emitter); this.emitter = emitter; this.entryStack = [new FunctionEntry(emitter.finalLoc)]; } let LMp = LeapManager.prototype; exports.LeapManager = LeapManager; LMp.withEntry = function(entry, callback) { assert.ok(entry instanceof Entry); this.entryStack.push(entry); try { callback.call(this.emitter); } finally { let popped = this.entryStack.pop(); assert.strictEqual(popped, entry); } }; LMp._findLeapLocation = function(property, label) { for (let i = this.entryStack.length - 1; i >= 0; --i) { let entry = this.entryStack[i]; let loc = entry[property]; if (loc) { if (label) { if (entry.label && entry.label.name === label.name) { return loc; } } else if (entry instanceof LabeledEntry) { // Ignore LabeledEntry entries unless we are actually breaking to // a label. } else { return loc; } } } return null; }; LMp.getBreakLoc = function(label) { return this._findLeapLocation("breakLoc", label); }; LMp.getContinueLoc = function(label) { return this._findLeapLocation("continueLoc", label); }; regenerator-regenerator-transform-0.15.2/packages/transform/src/meta.js000066400000000000000000000055031446323212200263060ustar00rootroot00000000000000/** * Copyright (c) 2014-present, Facebook, Inc. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ import assert from "assert"; import { getTypes } from "./util.js"; const mMap = new WeakMap(); function m(node) { if (!mMap.has(node)) { mMap.set(node, {}); } return mMap.get(node); } const hasOwn = Object.prototype.hasOwnProperty; function makePredicate(propertyName, knownTypes) { function onlyChildren(node) { const t = getTypes(); t.assertNode(node); // Assume no side effects until we find out otherwise. let result = false; function check(child) { if (result) { // Do nothing. } else if (Array.isArray(child)) { child.some(check); } else if (t.isNode(child)) { assert.strictEqual(result, false); result = predicate(child); } return result; } let keys = t.VISITOR_KEYS[node.type]; if (keys) { for (let i = 0; i < keys.length; i++) { let key = keys[i]; let child = node[key]; check(child); } } return result; } function predicate(node) { getTypes().assertNode(node); let meta = m(node); if (hasOwn.call(meta, propertyName)) return meta[propertyName]; // Certain types are "opaque," which means they have no side // effects or leaps and we don't care about their subexpressions. if (hasOwn.call(opaqueTypes, node.type)) return meta[propertyName] = false; if (hasOwn.call(knownTypes, node.type)) return meta[propertyName] = true; return meta[propertyName] = onlyChildren(node); } predicate.onlyChildren = onlyChildren; return predicate; } let opaqueTypes = { FunctionExpression: true, ArrowFunctionExpression: true }; // These types potentially have side effects regardless of what side // effects their subexpressions have. let sideEffectTypes = { CallExpression: true, // Anything could happen! ForInStatement: true, // Modifies the key variable. UnaryExpression: true, // Think delete. BinaryExpression: true, // Might invoke .toString() or .valueOf(). AssignmentExpression: true, // Side-effecting by definition. UpdateExpression: true, // Updates are essentially assignments. NewExpression: true // Similar to CallExpression. }; // These types are the direct cause of all leaps in control flow. let leapTypes = { YieldExpression: true, BreakStatement: true, ContinueStatement: true, ReturnStatement: true, ThrowStatement: true }; // All leap types are also side effect types. for (let type in leapTypes) { if (hasOwn.call(leapTypes, type)) { sideEffectTypes[type] = leapTypes[type]; } } exports.hasSideEffects = makePredicate("hasSideEffects", sideEffectTypes); exports.containsLeap = makePredicate("containsLeap", leapTypes); regenerator-regenerator-transform-0.15.2/packages/transform/src/replaceShorthandObjectMethod.js000066400000000000000000000047721446323212200331450ustar00rootroot00000000000000/** * Copyright (c) 2014-present, Facebook, Inc. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ import * as util from "./util"; // this function converts a shorthand object generator method into a normal // (non-shorthand) object property which is a generator function expression. for // example, this: // // var foo = { // *bar(baz) { return 5; } // } // // should be replaced with: // // var foo = { // bar: function*(baz) { return 5; } // } // // to do this, it clones the parameter array and the body of the object generator // method into a new FunctionExpression. // // this method can be passed any Function AST node path, and it will return // either: // a) the path that was passed in (iff the path did not need to be replaced) or // b) the path of the new FunctionExpression that was created as a replacement // (iff the path did need to be replaced) // // In either case, though, the caller can count on the fact that the return value // is a Function AST node path. // // If this function is called with an AST node path that is not a Function (or with an // argument that isn't an AST node path), it will throw an error. export default function replaceShorthandObjectMethod(path) { const t = util.getTypes(); if (!path.node || !t.isFunction(path.node)) { throw new Error("replaceShorthandObjectMethod can only be called on Function AST node paths."); } // this function only replaces shorthand object methods (called ObjectMethod // in Babel-speak). if (!t.isObjectMethod(path.node)) { return path; } // this function only replaces generators. if (!path.node.generator) { return path; } const parameters = path.node.params.map(function (param) { return t.cloneDeep(param); }) const functionExpression = t.functionExpression( null, // id parameters, // params t.cloneDeep(path.node.body), // body path.node.generator, path.node.async ); util.replaceWithOrRemove(path, t.objectProperty( t.cloneDeep(path.node.key), // key functionExpression, //value path.node.computed, // computed false // shorthand ) ); // path now refers to the ObjectProperty AST node path, but we want to return a // Function AST node path for the function expression we created. we know that // the FunctionExpression we just created is the value of the ObjectProperty, // so return the "value" path off of this path. return path.get("value"); } regenerator-regenerator-transform-0.15.2/packages/transform/src/util.js000066400000000000000000000017001446323212200263300ustar00rootroot00000000000000/** * Copyright (c) 2014-present, Facebook, Inc. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ let currentTypes = null; export function wrapWithTypes(types, fn) { return function (...args) { const oldTypes = currentTypes; currentTypes = types; try { return fn.apply(this, args); } finally { currentTypes = oldTypes; } }; } export function getTypes() { return currentTypes; } export function runtimeProperty(name) { const t = getTypes(); return t.memberExpression( t.identifier("regeneratorRuntime"), t.identifier(name), false ); } export function isReference(path) { return path.isReferenced() || path.parentPath.isAssignmentExpression({ left: path.node }); } export function replaceWithOrRemove(path, replacement) { if (replacement) { path.replaceWith(replacement) } else { path.remove(); } } regenerator-regenerator-transform-0.15.2/packages/transform/src/visit.js000066400000000000000000000251341446323212200265200ustar00rootroot00000000000000/** * Copyright (c) 2014-present, Facebook, Inc. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ "use strict"; import assert from "assert"; import { hoist } from "./hoist"; import { Emitter } from "./emit"; import replaceShorthandObjectMethod from "./replaceShorthandObjectMethod"; import * as util from "./util"; exports.getVisitor = ({ types: t }) => ({ Method(path, state) { let node = path.node; if (!shouldRegenerate(node, state)) return; const container = t.functionExpression( null, [], t.cloneNode(node.body, false), node.generator, node.async, ); path.get("body").set("body", [ t.returnStatement( t.callExpression(container, []), ), ]); // Regardless of whether or not the wrapped function is a an async method // or generator the outer function should not be node.async = false; node.generator = false; // Unwrap the wrapper IIFE's environment so super and this and such still work. path .get("body.body.0.argument.callee") .unwrapFunctionEnvironment(); }, Function: { exit: util.wrapWithTypes(t, function(path, state) { let node = path.node; if (!shouldRegenerate(node, state)) return; // if this is an ObjectMethod, we need to convert it to an ObjectProperty path = replaceShorthandObjectMethod(path); node = path.node; let contextId = path.scope.generateUidIdentifier("context"); let argsId = path.scope.generateUidIdentifier("args"); path.ensureBlock(); let bodyBlockPath = path.get("body"); if (node.async) { bodyBlockPath.traverse(awaitVisitor); } bodyBlockPath.traverse(functionSentVisitor, { context: contextId }); let outerBody = []; let innerBody = []; bodyBlockPath.get("body").forEach(function(childPath) { let node = childPath.node; if (t.isExpressionStatement(node) && t.isStringLiteral(node.expression)) { // Babylon represents directives like "use strict" as elements // of a bodyBlockPath.node.directives array, but they could just // as easily be represented (by other parsers) as traditional // string-literal-valued expression statements, so we need to // handle that here. (#248) outerBody.push(node); } else if (node && node._blockHoist != null) { outerBody.push(node); } else { innerBody.push(node); } }); if (outerBody.length > 0) { // Only replace the inner body if we actually hoisted any statements // to the outer body. bodyBlockPath.node.body = innerBody; } let outerFnExpr = getOuterFnExpr(path); // Note that getOuterFnExpr has the side-effect of ensuring that the // function has a name (so node.id will always be an Identifier), even // if a temporary name has to be synthesized. t.assertIdentifier(node.id); let innerFnId = t.identifier(node.id.name + "$"); // Turn all declarations into vars, and replace the original // declarations with equivalent assignment expressions. let vars = hoist(path); let context = { usesThis: false, usesArguments: false, getArgsId: () => t.clone(argsId), }; path.traverse(argumentsThisVisitor, context); if (context.usesArguments) { vars = vars || t.variableDeclaration("var", []); vars.declarations.push(t.variableDeclarator( t.clone(argsId), t.identifier("arguments"), )); } let emitter = new Emitter(contextId); emitter.explode(path.get("body")); if (vars && vars.declarations.length > 0) { outerBody.push(vars); } let wrapArgs = [emitter.getContextFunction(innerFnId)]; let tryLocsList = emitter.getTryLocsList(); if (node.generator) { wrapArgs.push(outerFnExpr); } else if (context.usesThis || tryLocsList || node.async) { // Async functions that are not generators don't care about the // outer function because they don't need it to be marked and don't // inherit from its .prototype. wrapArgs.push(t.nullLiteral()); } if (context.usesThis) { wrapArgs.push(t.thisExpression()); } else if (tryLocsList || node.async) { wrapArgs.push(t.nullLiteral()); } if (tryLocsList) { wrapArgs.push(tryLocsList); } else if (node.async) { wrapArgs.push(t.nullLiteral()); } if (node.async) { // Rename any locally declared "Promise" variable, // to use the global one. let currentScope = path.scope; do { if (currentScope.hasOwnBinding("Promise")) currentScope.rename("Promise"); } while (currentScope = currentScope.parent); wrapArgs.push(t.identifier("Promise")); } let wrapCall = t.callExpression( util.runtimeProperty(node.async ? "async" : "wrap"), wrapArgs ); outerBody.push(t.returnStatement(wrapCall)); node.body = t.blockStatement(outerBody); // We injected a few new variable declarations (for every hoisted var), // so we need to add them to the scope. path.get("body.body").forEach(p => p.scope.registerDeclaration(p)); const oldDirectives = bodyBlockPath.node.directives; if (oldDirectives) { // Babylon represents directives like "use strict" as elements of // a bodyBlockPath.node.directives array. (#248) node.body.directives = oldDirectives; } let wasGeneratorFunction = node.generator; if (wasGeneratorFunction) { node.generator = false; } if (node.async) { node.async = false; } if (wasGeneratorFunction && t.isExpression(node)) { util.replaceWithOrRemove(path, t.callExpression(util.runtimeProperty("mark"), [node])) path.addComment("leading", "#__PURE__"); } const insertedLocs = emitter.getInsertedLocs(); path.traverse({ NumericLiteral(path) { if (!insertedLocs.has(path.node)) { return; } path.replaceWith(t.numericLiteral(path.node.value)); }, }) // Generators are processed in 'exit' handlers so that regenerator only has to run on // an ES5 AST, but that means traversal will not pick up newly inserted references // to things like 'regeneratorRuntime'. To avoid this, we explicitly requeue. path.requeue(); }) } }); // Check if a node should be transformed by regenerator function shouldRegenerate(node, state) { if (node.generator) { if (node.async) { // Async generator return state.opts.asyncGenerators !== false; } else { // Plain generator return state.opts.generators !== false; } } else if (node.async) { // Async function return state.opts.async !== false; } else { // Not a generator or async function. return false; } } // Given a NodePath for a Function, return an Expression node that can be // used to refer reliably to the function object from inside the function. // This expression is essentially a replacement for arguments.callee, with // the key advantage that it works in strict mode. function getOuterFnExpr(funPath) { const t = util.getTypes(); let node = funPath.node; t.assertFunction(node); if (!node.id) { // Default-exported function declarations, and function expressions may not // have a name to reference, so we explicitly add one. node.id = funPath.scope.parent.generateUidIdentifier("callee"); } if (node.generator && // Non-generator functions don't need to be marked. t.isFunctionDeclaration(node)) { // Return the identifier returned by runtime.mark(). return getMarkedFunctionId(funPath); } return t.clone(node.id); } const markInfo = new WeakMap(); function getMarkInfo(node) { if (!markInfo.has(node)) { markInfo.set(node, {}); } return markInfo.get(node); } function getMarkedFunctionId(funPath) { const t = util.getTypes(); const node = funPath.node; t.assertIdentifier(node.id); const blockPath = funPath.findParent(function (path) { return path.isProgram() || path.isBlockStatement(); }); if (!blockPath) { return node.id; } const block = blockPath.node; assert.ok(Array.isArray(block.body)); const info = getMarkInfo(block); if (!info.decl) { info.decl = t.variableDeclaration("var", []); blockPath.unshiftContainer("body", info.decl); info.declPath = blockPath.get("body.0"); } assert.strictEqual(info.declPath.node, info.decl); // Get a new unique identifier for our marked variable. const markedId = blockPath.scope.generateUidIdentifier("marked"); const markCallExp = t.callExpression( util.runtimeProperty("mark"), [t.clone(node.id)] ); const index = info.decl.declarations.push( t.variableDeclarator(markedId, markCallExp) ) - 1; const markCallExpPath = info.declPath.get("declarations." + index + ".init"); assert.strictEqual(markCallExpPath.node, markCallExp); markCallExpPath.addComment("leading", "#__PURE__"); return t.clone(markedId); } let argumentsThisVisitor = { "FunctionExpression|FunctionDeclaration|Method": function(path) { path.skip(); }, Identifier: function(path, state) { if (path.node.name === "arguments" && util.isReference(path)) { util.replaceWithOrRemove(path, state.getArgsId()); state.usesArguments = true; } }, ThisExpression: function(path, state) { state.usesThis = true; } }; let functionSentVisitor = { MetaProperty(path) { let { node } = path; if (node.meta.name === "function" && node.property.name === "sent") { const t = util.getTypes(); util.replaceWithOrRemove( path, t.memberExpression( t.clone(this.context), t.identifier("_sent") ) ); } } }; let awaitVisitor = { Function: function(path) { path.skip(); // Don't descend into nested function scopes. }, AwaitExpression: function(path) { const t = util.getTypes(); // Convert await expressions to yield expressions. let argument = path.node.argument; // Transforming `await x` to `yield regeneratorRuntime.awrap(x)` // causes the argument to be wrapped in such a way that the runtime // can distinguish between awaited and merely yielded values. util.replaceWithOrRemove(path, t.yieldExpression( t.callExpression( util.runtimeProperty("awrap"), [argument] ), false )); } }; regenerator-regenerator-transform-0.15.2/runtime-module.js000066400000000000000000000005501446323212200237430ustar00rootroot00000000000000/** * Copyright (c) 2014-present, Facebook, Inc. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ console.warn( "The regenerator/runtime-module module is deprecated; " + "please import regenerator-runtime instead." ); module.exports = require("regenerator-runtime"); regenerator-regenerator-transform-0.15.2/runtime.js000066400000000000000000000005611446323212200224620ustar00rootroot00000000000000/** * Copyright (c) 2014-present, Facebook, Inc. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ console.warn( "The regenerator/runtime module is deprecated; " + "please import regenerator-runtime/runtime instead." ); module.exports = require("regenerator-runtime/runtime"); regenerator-regenerator-transform-0.15.2/test/000077500000000000000000000000001446323212200214165ustar00rootroot00000000000000regenerator-regenerator-transform-0.15.2/test/async-custom-promise.js000066400000000000000000000047151446323212200260640ustar00rootroot00000000000000/** * Copyright (c) 2014-present, Facebook, Inc. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ var assert = require("assert"); function SyncPromise(run) { this.resolved = null; this.value = null; try { run( val => { this.resolved = true; this.value = val; }, val => { this.resolved = false; this.value = val; } ); } catch (e) { this.resolved = false; this.value = e; } if (this.resolved === null) { throw new Error("SyncPromise must be run synchronously"); } if (this.value instanceof SyncPromise) this.value = this.value.value; } SyncPromise.prototype.then = function(onRes, onRej) { try { if (this.resolved) return SyncPromise.resolve(onRes(this.value)); if (onRej) return SyncPromise.resolve(onRej(this.value)); return this; } catch (e) { return SyncPromise.reject(e); } }; SyncPromise.prototype.catch = function(onRej) { try { if (this.resolved) return this; return SyncPromise.resolve(onRej(this.value)); } catch (e) { return SyncPromise.reject(e); } }; SyncPromise.resolve = val => new SyncPromise(res => res(val)); SyncPromise.reject = val => new SyncPromise((_, rej) => rej(val)); describe("custom Promise polyfills", function() { it("should work with async functions", function() { babelInjectPromise: SyncPromise; async function fn() { var first = await SyncPromise.resolve(2); var second = await 3; return 4 * first * second; } assert.ok(fn() instanceof SyncPromise); assert.ok(fn().resolved); assert.strictEqual(fn().value, 24); }); it("should correctly handle rejections", function() { babelInjectPromise: SyncPromise; async function fn() { throw 2; } assert.ok(fn() instanceof SyncPromise); assert.strictEqual(fn().resolved, false); assert.strictEqual(fn().value, 2); }); it("should work with async generators", function() { babelInjectPromise: SyncPromise; async function* fn() { await 1; var input = yield 2; await 3; return input; } var it = fn(); var val = it.next(); assert.ok(val instanceof SyncPromise); assert.ok(val.resolved); assert.deepStrictEqual(val.value, { done: false, value: 2 }); val = it.next(7); assert.ok(val instanceof SyncPromise); assert.ok(val.resolved); assert.deepStrictEqual(val.value, { done: true, value: 7 }); }); }); regenerator-regenerator-transform-0.15.2/test/async.js000066400000000000000000000343271446323212200231020ustar00rootroot00000000000000/** * Copyright (c) 2014-present, Facebook, Inc. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ var assert = require("assert"); assert( function*() {}.toString().indexOf("regenerator") !== -1, "regenerator-transform should be enabled" ); describe("async functions and await expressions", function() { Promise = require("promise"); describe("regeneratorRuntime", function() { it("should be defined globally", function() { var global = Function("return this")(); assert.ok("regeneratorRuntime" in global); assert.strictEqual(global.regeneratorRuntime, regeneratorRuntime); }); it("should have a .wrap method", function() { assert.strictEqual(typeof regeneratorRuntime.wrap, "function"); }); }); describe("Promise", function() { it("should be defined globally", function() { var global = Function("return this")(); assert.ok("Promise" in global); assert.strictEqual(global.Promise, Promise); }); it("should be a function", function() { assert.strictEqual(typeof Promise, "function"); }); }); describe("no-await async function", function() { it("should return a Promise", function(done) { var called = false; async function noAwait(value) { called = true; return value; } var promise = noAwait("asdf"); assert.strictEqual(called, true); promise.then(function(value) { assert.strictEqual(called, true); assert.strictEqual(value, "asdf"); done(); }).catch(done); }); }); describe("one-await async function", function() { it("should finish asynchronously", function(done) { var flag1 = false; var flag2 = false; async function oneAwait(value) { flag1 = true; var result = await value; flag2 = true; return result; } var promise = oneAwait("asdf"); assert.strictEqual(flag1, true); assert.strictEqual(flag2, false); promise.then(function(value) { assert.strictEqual(flag2, true); assert.strictEqual(value, "asdf"); done(); }).catch(done); }); }); describe("nested async function calls", function() { it("should evaluate in the right order", function(done) { var markers = []; async function innerMost(marker) { markers.push(marker); return await marker; } async function inner(marker) { markers.push(marker); assert.strictEqual( await innerMost(marker + 1), marker + 1 ); markers.push(marker + 2); assert.strictEqual( await innerMost(marker + 3), marker + 3 ); markers.push(marker + 4); } async function outer() { markers.push(0); await inner(1); markers.push(6); await inner(7); markers.push(12); } outer().then(function() { var expected = []; for (var i = 0; i <= 12; ++i) expected.push(i); assert.deepEqual(markers, expected); done(); }).catch(done); }); }); describe("dependent promises", function() { it("should be awaitable out of order", function(done) { async function outer(value) { var resolved = false; var p1 = new Promise(function(resolve) { setTimeout(function() { resolve(value + 1); resolved = true; }, 0); }); assert.strictEqual(resolved, false); var v2 = await p1.then(function(value) { return value + 1; }); assert.strictEqual(resolved, true); var v1 = await p1; return [v1, v2]; } outer(1).then(function(pair) { assert.deepEqual(pair, [2, 3]); done(); }).catch(done); }); }); describe("rejected promises", function() { it("should cause await expressions to throw", function(done) { var error = new Error("rejected"); async function f(arg) { try { return await arg; } catch (e) { assert.strictEqual(e, error); return "did throw"; } } Promise.all([ f(Promise.reject(error)), f(Promise.resolve("did not throw")) ]).then(function(results) { assert.deepEqual(results, [ "did throw", "did not throw" ]); done(); }).catch(done); }); it("should be returned by exceptional async functions", function(done) { var error = new Error("rejected"); async function e(arg) { if (arg) { throw arg; } return "did not throw"; } async function f(arg) { return await e(arg); } async function g(arg) { return await f(arg); } async function h(arg) { return await Promise.all([ g(arg), Promise.resolve("dummy") ]); } Promise.all([ h(error).then(function() { done(new Error("should not have resolved")); }, function(e) { assert.strictEqual(e, error); return "ok1"; }), h(null).then(function(result) { assert.deepEqual(result, [ "did not throw", "dummy" ]); return "ok2"; }) ]).then(function(results) { assert.deepEqual(results, ["ok1", "ok2"]); done(); }).catch(done); }); it("should propagate failure when returned", function() { var rejection = new Error("rejection"); async function f() { return new Promise(function(resolve, reject) { reject(rejection); }); } return f().then(function(result) { assert.ok(false, "should have been rejected"); }, function(error) { assert.strictEqual(error, rejection); }); }); }); describe("async function expressions", function() { it("should be allowed", function(done) { (async function(arg) { return await arg; })(Promise.resolve(1234)).then(function(value) { assert.strictEqual(value, 1234); done(); }).catch(done); }); }); describe("the this object", function () { it("should default to undefined (strict)", function (done) { async function f() { "use strict"; return this; } f().then(function(value) { assert.strictEqual(value, undefined); done(); }).catch(done); }); it("should respect .call's this", function (done) { async function f() { return this; } var self = {}; f.call(self).then(function(value) { assert.strictEqual(value, self); done(); }).catch(done); }); it("shouldn't capture this when not needed", function () { // https://github.com/babel/babel/issues/4056 async function f() { return 0; } var source = String(f); assert.strictEqual(source.indexOf("this"), -1); }); }); }); describe("async generator functions", function() { it("should return a working AsyncIterator", function() { var markers = []; async function *gen(arg) { markers.push(0); var sent = yield arg; markers.push(1); var result = await sent; markers.push(2); assert.strictEqual(await (yield "second"), "sent after second"); markers.push(3); return result; } var iter = gen("initial argument"); assert.deepEqual(markers, []); var firstPromise = iter.next(); assert.deepEqual(markers, [0]); return firstPromise.then(function(firstResult) { assert.deepEqual(firstResult, { value: "initial argument", done: false }); assert.deepEqual(markers, [0]); return iter.next(new Promise(function(resolve) { setTimeout(resolve, 100); }).then(function() { assert.deepEqual(markers, [0, 1]); return "will become final result"; })); }).then(function(secondResult) { assert.deepEqual(secondResult, { value: "second", done: false }); assert.deepEqual(markers, [0, 1, 2]); return iter.next("sent after second"); }).then(function(finalResult) { assert.deepEqual(markers, [0, 1, 2, 3]); assert.deepEqual(finalResult, { value: "will become final result", done: true }); }); }); it("should keep results in order", function() { async function *range(limit) { var before = []; var after = []; for (var i = 0; i < limit; ++i) { before.push(i); yield i; after.push(i); } assert.deepEqual(before, after); return before; } var limit = 10; var iter = range(limit); var promises = []; var results = []; for (var i = 0; i < limit; ++i) { var promise = iter.next(); promises.push(promise); promise.then(function(result) { assert.strictEqual(result.done, false); results.push(result); }); } assert.deepEqual(results, []); return Promise.all(promises).then(function(promiseResults) { assert.deepEqual(results, promiseResults); return iter.next(); }).then(function(finalResult) { assert.deepEqual(results.map(function(result) { return result.value; }), finalResult.value); assert.strictEqual(finalResult.done, true); }); }); it("should be able to handle many awaits", function() { var awaitCount = 0; function countAwait(i) { return Promise.resolve(i).then(function() { ++awaitCount; }); } async function *gen(limit) { await countAwait(0); yield 1; await countAwait(2); await countAwait(3); yield 4; await countAwait(5); await countAwait(6); await countAwait(7); yield 8; for (var i = 0; i < limit; ++i) { await countAwait(i); } return "done"; } var iter = gen(100); return iter.next().then(function(result) { assert.strictEqual(awaitCount, 1); assert.deepEqual(result, { value: 1, done: false }); return iter.next(); }).then(function(result) { assert.strictEqual(awaitCount, 3); assert.deepEqual(result, { value: 4, done: false }); return iter.next(); }).then(function(result) { assert.strictEqual(awaitCount, 6); assert.deepEqual(result, { value: 8, done: false }); return iter.next(); }).then(function(result) { assert.strictEqual(awaitCount, 6 + 100); assert.deepEqual(result, { value: "done", done: true }); return iter.next(); }).then(function(result) { assert.deepEqual(result, { value: void 0, done: true }); }); }); it("should not propagate exceptions between iterations", function() { async function *gen() { yield 1; yield 2; } var iter = gen(); return iter.next().then(function(result) { assert.deepEqual(result, { value: 1, done: false }); return iter.throw(new Error("thrown from first yield")); }).then(function() { throw new Error("should have thrown"); }, function(error) { assert.strictEqual(error.message, "thrown from first yield"); return iter.next(); }).then(function(result) { assert.deepEqual(result, { value: void 0, done: true }); }); }); it("should allow yielding a rejected Promise", function() { var yielded = new Error("yielded rejection"); var returned = new Error("returned rejection"); async function *gen() { assert.strictEqual(yield "first yielded", "first sent"); try { assert.strictEqual(yield Promise.reject(yielded), "not reached"); } catch (e) { assert.strictEqual(yield e, "second sent"); return Promise.reject(returned); } } var iter = gen(); return iter.next().then(function(result) { assert.deepEqual(result, { value: "first yielded", done: false }); return iter.next("first sent"); }).then(function (result) { assert.deepEqual(result, { value: yielded, done: false }); return iter.next("second sent"); }).then(function(result) { assert.ok(false, "should have returned a rejected Promise"); }, function(error) { assert.strictEqual(error, returned); }); }); it("should work with nested arrow functions", async function () { var a = async b => { return await (async () => { return await b(); })(); }; assert.strictEqual( await a(() => Promise.resolve(1234)), 1234 ); }); it("should support super.method(...) in async methods", async function () { class A { async method() { return "from A"; } } class B extends A { async method() { return "from B " + (await super.method()); } } assert.strictEqual(await new B().method(), "from B from A"); }); }); describe("update operators", function() { it("should read left side before yielding", function() { let x = 0; function* test() { x += yield; } var gen = test(); gen.next(); x += 1; assert.strictEqual(x, 1); gen.next(2); assert.strictEqual(x, 2); }); it("should explode left side before yielding", function() { let obj = { count: 0 }; function* test() { obj[yield "key"] += yield "value"; } var gen = test(); assert.deepEqual(gen.next(), { value: "key", done: false }); assert.strictEqual(obj.count, 0); assert.deepEqual(gen.next("count"), { value: "value", done: false }); assert.strictEqual(obj.count, 0); obj.count += 1; assert.strictEqual(obj.count, 1); assert.deepEqual(gen.next(2), { value: void 0, done: true }); assert.strictEqual(obj.count, 2); }); it("should read left side before awaiting", function() { let x = 0; async function test(val) { x += await val; return x; } const promise = test(2); x += 1; return promise.then(result => { assert.strictEqual(result, 2); }); }); }); regenerator-regenerator-transform-0.15.2/test/class.js000066400000000000000000000051021446323212200230570ustar00rootroot00000000000000/** * Copyright (c) 2014-present, Facebook, Inc. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ var assert = require("assert"); var shared = require("./shared.js"); var check = shared.check; assert( function*() {}.toString().indexOf("regenerator") !== -1, "regenerator-transform should be enabled" ); describe("class methods", function () { it("should work if the generator is a class method", function () { class Foo { *gen(x) { yield x; } } check(new Foo().gen("boom"), ["boom"]); }); it("should work if the generator is a computed class method", function () { var fnName = "gen"; class Foo { *[fnName](x) { yield x; } } check(new Foo().gen("boom"), ["boom"]); }); it("should work with this", function () { class A { *gen() { yield this } } const a = new A; check(a.gen(), [a]); }) it("should work with super", function () { class A { *gen() { yield 1 } } class B extends A { *gen() { yield super.gen; } } check(new B().gen(), [A.prototype.gen]); }); it("should work with arguments", function () { class A { *gen() { yield arguments } } const args = new A().gen(1, 2, 3).next().value; assert.strictEqual(args.length, 3); assert.strictEqual(args[0], 1); assert.strictEqual(args[1], 2); assert.strictEqual(args[2], 3) }); it("should allow yield as super expression", function () { function* gen() { return class extends (yield) {} } class B {} const it = gen(); it.next(); const res = it.next(B).value; assert.ok(new res instanceof B); }); it("should allow yield as super expression with argument", function () { function* gen() { return class extends (yield 123) {} } class B {} const it = gen(); assert.deepEqual(it.next(), { value: 123, done: false }); const res = it.next(B).value; assert.ok(new res instanceof B); }); it("should allow yield as computed key", function () { if (class {}.toString().indexOf("class") !== 0) { return; // The class transform is broken: // https://github.com/babel/babel/issues/8300 } function* gen() { return class { [yield]() { return 1 } [yield]() { return 2 } } } const it = gen(); it.next(); it.next("one"); const res = it.next("two").value; assert.strictEqual(new res().one(), 1); assert.strictEqual(new res().two(), 2); }); }); regenerator-regenerator-transform-0.15.2/test/frozen-intrinsics.js000066400000000000000000000025111446323212200254410ustar00rootroot00000000000000/** * Copyright (c) 2014-present, Facebook, Inc. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ var assert = require("assert"); var getPrototypeOf = Reflect.getPrototypeOf; function getConstructorOf(obj) { return getPrototypeOf(obj).constructor; } var SymbolIterator = (typeof Symbol && Symbol.iterator) || '@@iterator'; var ArrayIteratorObject = new Array()[SymbolIterator](); var ArrayIteratorPrototype = getPrototypeOf(ArrayIteratorObject); var IteratorPrototype = getPrototypeOf(ArrayIteratorPrototype); async function* AsyncGeneratorFunctionInstance() {} var AsyncGeneratorFunction = getConstructorOf( AsyncGeneratorFunctionInstance, ); var AsyncGenerator = AsyncGeneratorFunction.prototype; var AsyncGeneratorPrototype = AsyncGenerator.prototype; var AsyncIteratorPrototype = getPrototypeOf(AsyncGeneratorPrototype); // freeze relevant intrinsics Object.freeze(Object.prototype); Object.freeze(IteratorPrototype); Object.freeze(ArrayIteratorPrototype); Object.freeze(AsyncGenerator); Object.freeze(AsyncGeneratorPrototype); Object.freeze(AsyncIteratorPrototype); describe("Frozen intrinsics test", function () { it("regenerator-runtime doesn't fail to initialize when Object prototype is frozen", function() { require("./runtime.js"); }); }); regenerator-regenerator-transform-0.15.2/test/index.html000066400000000000000000000007431446323212200234170ustar00rootroot00000000000000 Mocha
regenerator-regenerator-transform-0.15.2/test/non-native.js000066400000000000000000000051341446323212200240350ustar00rootroot00000000000000/** * Copyright (c) 2014-present, Facebook, Inc. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ // These tests run only in translation, not in native Node. var assert = require("assert"); var shared = require("./shared.js"); var Symbol = shared.Symbol; var check = shared.check; var assertAlreadyFinished = shared.assertAlreadyFinished; describe("@@iterator", function() { it("is defined on Generator.prototype and returns this", function() { function *gen(){} var iterator = gen(); assert.ok(!iterator.hasOwnProperty(Symbol.iterator)); assert.ok(!Object.getPrototypeOf(iterator).hasOwnProperty(Symbol.iterator)); assert.ok(Object.getPrototypeOf(Object.getPrototypeOf( Object.getPrototypeOf(iterator) )).hasOwnProperty(Symbol.iterator)); assert.strictEqual(iterator[Symbol.iterator](), iterator); }); }); describe("throw", function() { it("should complete throwing generator", function() { function *gen(x) { throw 1; } var u = gen(); try { u.next(); } catch (err) { assert.strictEqual(err, 1); } assertAlreadyFinished(u); }); it("should complete yielding/throwing generator", function () { function *gen(x) { yield 2; throw 1; } var u = gen(); u.next(); try { u.throw(2); } catch (err) { assert.strictEqual(err, 2); } assertAlreadyFinished(u); }); }); describe("completed generator", function() { function *gen() { return "ALL DONE"; } it("should refuse to resume", function() { var g = gen(); assert.deepEqual(g.next(), { value: "ALL DONE", done: true }); assertAlreadyFinished(g); }); }); describe("delegate yield", function() { it("should support any iterable argument", function() { function *gen() { yield 0; yield* [ yield "one", yield "two", yield "three" ]; yield 5; } check(gen(), [0, "one", "two", "three", 2, 3, 4, 5]); function *string() { return yield* "asdf"; } check(string(), ["a", "s", "d", "f"]); }); }); describe("newborn generators", function () { it("should be able to access function.sent", function () { function *gen() { var sent = yield function.sent; assert.strictEqual(sent, function.sent); return function.sent; } var g = gen(); assert.deepEqual(g.next("first"), { value: "first", done: false }); assert.deepEqual(g.next("second"), { value: "second", done: true }); }); }); regenerator-regenerator-transform-0.15.2/test/non-writable-tostringtag-property.js000066400000000000000000000023161446323212200306040ustar00rootroot00000000000000/** * Copyright (c) 2014-present, Facebook, Inc. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ var assert = require("assert"); var getProto = Object.getPrototypeOf; var NativeIteratorPrototype = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" && typeof [][Symbol.iterator] === "function" && getProto && getProto(getProto([][Symbol.iterator]())); // https://tc39.es/proposal-iterator-helpers/#sec-iteratorprototype-@@tostringtag Object.defineProperty(NativeIteratorPrototype, Symbol.toStringTag, { configurable: true, value: "Iterator", }); (NativeIteratorPrototype ? describe : describe.skip)("Symbol.toStringTag safety (#399, #400)", function () { it("regenerator-runtime doesn't fail to initialize when native iterator prototype has a non-writable @@toStringTag property", function() { require("./runtime.js"); }); it("regenerator-runtime's polyfilled generator prototype has the correct @@toStringTag value", function() { require("./runtime.js"); function foo() {} regeneratorRuntime.mark(foo); assert.strictEqual(foo.prototype[Symbol.toStringTag], "Generator"); }); }); regenerator-regenerator-transform-0.15.2/test/nothing-to-transform.js000066400000000000000000000001211446323212200260450ustar00rootroot00000000000000function asdf() { return "no generators or a-s-y-n-c functions to see here"; } regenerator-regenerator-transform-0.15.2/test/regression.js000066400000000000000000000010641446323212200241350ustar00rootroot00000000000000/** * Copyright (c) 2017-present, Facebook, Inc. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ var assert = require("assert"); describe("regressions", function() { it("should correctly hoist arguments", async function () { function test(fn) { return async (...args) => { return fn(...args); }; } const result = []; await test((arg1, arg2) => { result.push(arg1, arg2); })(1, "foo"); assert.deepEqual(result, [1, "foo"]); }); }); regenerator-regenerator-transform-0.15.2/test/replaceWith-falsy.js000066400000000000000000000000541446323212200253360ustar00rootroot00000000000000async function foo() { for (let i; i;); } regenerator-regenerator-transform-0.15.2/test/run.js000066400000000000000000000235051446323212200225650ustar00rootroot00000000000000/** * Copyright (c) 2014-present, Facebook, Inc. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ var fs = require("fs"); var path = require("path"); var semver = require("semver"); var spawn = require("child_process").spawn; var babel = require("@babel/core"); var checkDuplicatedNodes = require("babel-check-duplicated-nodes").default; var regenerator = require("../main"); var mochaDir = path.dirname(require.resolve("mocha")); function convert(es6File, es5File, callback) { var transformOptions = { presets:[require("regenerator-preset")], parserOpts: { strictMode: false, }, ast: true }; fs.readFile(es6File, "utf-8", function(err, es6) { if (err) { return callback(err); } var { code: es5, ast } = babel.transformSync(es6, transformOptions); fs.writeFileSync(es5File, es5); try { checkDuplicatedNodes(babel, ast); } catch (err) { err.message = "Occured while transforming: " + es6File + "\n" + err.message; throw err; } callback(); }); } function bundle(es5Files, browserFile, callback) { var bundle = require("browserify")(); es5Files.forEach(bundle.add, bundle); bundle.bundle(function(err, src) { if (err) { return callback(err); } fs.writeFile(browserFile, src, callback); }); } var queue = []; function enqueue(cmd, args, quiet) { queue.push({ cmd: cmd, args: args || [], quiet: !!quiet }); } function flush() { var entry = queue.shift(); if (entry) { var cmd = entry.cmd; if (typeof cmd === "function") { cmd.apply(null, entry.args.concat(asyncCallback)); } else { spawn(cmd, entry.args, { stdio: [ process.stdin, entry.quiet ? "ignore" : process.stdout, process.stderr ] }).on("exit", asyncCallback); } } } function asyncCallback(err) { if (err) { console.error("process exited abnormally:", err); process.exit(typeof err === "number" ? err : -1); } else { process.nextTick(flush); } } function makeMochaCopyFunction(fileName) { return function copy(callback) { var src = path.join(mochaDir, fileName); var dst = path.join(__dirname, fileName); fs.unlink(dst, function() { fs.symlink(src, dst, callback); }); }; } enqueue(convert, [ "./test/tests.es6.js", "./test/tests.es5.js" ]); if (semver.gte(process.version, "4.0.0")) { enqueue(convert, [ "./test/tests-node4.es6.js", "./test/tests-node4.es5.js" ]); } else { // we are on an older platform, but we still need to create an empty // tests-node4.es5.js file so that the test commands below have a file to refer // to. fs.writeFileSync("./test/tests-node4.es5.js", ""); } enqueue(convert, [ "./test/non-native.js", "./test/non-native.es5.js" ]); enqueue(convert, [ "./test/async.js", "./test/async.es5.js" ]); enqueue(convert, [ "./test/class.js", "./test/class.es5.js" ]); enqueue(convertWithRegeneratorPluginOnly, [ "./test/class.js", "./test/class.regenerator.js" ]); Error.stackTraceLimit = 1000; /** * Comvert without using the preset (which also transforms things like classes and arrows) */ function convertWithRegeneratorPluginOnly(inputFile, outputFile, callback) { var transformOptions = { plugins:[require("regenerator-transform")], parserOpts: { sourceType: "module", allowImportExportEverywhere: true, allowReturnOutsideFunction: true, allowSuperOutsideMethod: true, strictMode: false, plugins: ["*", "jsx", "flow"] }, ast: true }; fs.readFile(inputFile, "utf-8", function(err, input) { if (err) { return callback(err); } var { code: output, ast } = babel.transformSync(input, transformOptions); fs.writeFileSync(outputFile, output); try { checkDuplicatedNodes(babel, ast); } catch (err) { err.message = "Occured while transforming: " + inputFile + "\n" + err.message; throw err; } callback(); }); } function convertWithParamsTransform(es6File, es5File, callback) { var transformOptions = { presets:[require("regenerator-preset")], plugins: [ require("@babel/plugin-transform-parameters") ], parserOpts: { sourceType: "module", allowImportExportEverywhere: true, allowReturnOutsideFunction: true, allowSuperOutsideMethod: true, strictMode: false, plugins: ["*", "jsx", "flow"] }, ast: true }; fs.readFile(es6File, "utf-8", function(err, es6) { if (err) { return callback(err); } var { code: es5, ast } = babel.transformSync(es6, transformOptions); fs.writeFileSync(es5File, es5); try { checkDuplicatedNodes(babel, ast); } catch (err) { err.message = "Occured while transforming: " + es6File + "\n" + err.message; throw err; } callback(); }); } enqueue(convertWithParamsTransform, [ "./test/regression.js", "./test/regression.es5.js" ]); function convertWithCustomPromiseReplacer(es6File, es5File, callback) { var transformOptions = { presets: [require("regenerator-preset")], plugins: [function(babel) { return { visitor: { FunctionExpression: { exit(path) { const stmt = path.get("body.body").find(function (stmt) { return stmt.isLabeledStatement() && stmt.get("label").isIdentifier({ name: "babelInjectPromise" }); }); if (!stmt) return; path.traverse({ ReferencedIdentifier(path) { if (path.node.name === "Promise") { path.replaceWith( babel.types.cloneNode(stmt.node.body.expression) ); } } }); } } } }; }], parserOpts: { strictMode: false, }, ast: true }; fs.readFile(es6File, "utf-8", function(err, es6) { if (err) { return callback(err); } var { code: es5, ast } = babel.transformSync(es6, transformOptions); fs.writeFileSync(es5File, es5); try { checkDuplicatedNodes(babel, ast); } catch (err) { err.message = "Occured while transforming: " + es6File + "\n" + err.message; callback(err); } callback(); }); } enqueue(convertWithCustomPromiseReplacer, [ "./test/async-custom-promise.js", "./test/async-custom-promise.es5.js" ]) enqueue(makeMochaCopyFunction("mocha.js")); enqueue(makeMochaCopyFunction("mocha.css")); // uglify-js does not work properly due to Node 0.11.7 bug. // (https://github.com/joyent/node/issues/6235) if (!semver.eq(process.version, "0.11.7")) { try { require.resolve("browserify"); // Throws if missing. enqueue(bundle, [ [ "./test/runtime.js", "./test/tests.es5.js", "./test/tests-node4.es5.js", "./test/non-native.es5.js", "./test/async.es5.js", "./test/regression.es5.js" ], "./test/tests.browser.js" ]); } catch (ignored) { console.error("browserify not installed; skipping bundle step"); } } enqueue("mocha", [ "--reporter", "spec", "--require", "./test/runtime.js", "./test/tests.es5.js", "./test/tests-node4.es5.js", "./test/non-native.es5.js", "./test/async.es5.js", "./test/async-custom-promise.es5.js", "./test/regression.es5.js", "./test/tests.transform.js" ]); // Run command-line tool with available options to make sure it works. enqueue("./bin/regenerator", [ "./test/async.es5.js" ], true); enqueue("./bin/regenerator", [ "--include-runtime", "./test/async.es5.js" ], true); enqueue("./bin/regenerator", [ "--disable-async", "./test/async.es5.js" ], true); enqueue("./bin/regenerator", [ "--include-runtime", "--disable-async", "./test/async.es5.js" ], true); // Make sure we run the command-line tool on a file that does not need any // transformation, too. enqueue("./bin/regenerator", [ "./test/nothing-to-transform.js" ], true); enqueue("./bin/regenerator", [ "--include-runtime", "./test/nothing-to-transform.js" ], true); enqueue("./bin/regenerator", [ "--disable-async", "./test/nothing-to-transform.js" ], true); enqueue("./bin/regenerator", [ "--include-runtime", "--disable-async", "./test/nothing-to-transform.js" ], true); // Make sure we run the command-line tool on a file that would trigger this error: // // You passed `path.replaceWith()` a falsy node, use `path.remove()` instead enqueue("./bin/regenerator", [ "./test/replaceWith-falsy.js" ], true); enqueue("./bin/regenerator", [ "--include-runtime", "./test/replaceWith-falsy.js" ], true); enqueue("./bin/regenerator", [ "--disable-async", "./test/replaceWith-falsy.js" ], true); enqueue("./bin/regenerator", [ "--include-runtime", "--disable-async", "./test/replaceWith-falsy.js" ], true); enqueue("mocha", [ "--harmony", "--reporter", "spec", "--require", "./test/runtime.js", "./test/tests.es5.js", ]); enqueue("mocha", [ "--harmony", "--reporter", "spec", "--require", "./test/runtime.js", "./test/async.es5.js", ]); if (semver.gte(process.version, "6.0.0")) { enqueue("mocha", [ "--harmony", "--reporter", "spec", "--require", "./test/runtime.js", "./test/class.regenerator.js", ]); } enqueue("mocha", [ "--harmony", "--reporter", "spec", "--require", "./test/runtime.js", "./test/class.es5.js", ]); if (semver.gte(process.version, "4.0.0")) { enqueue("mocha", [ "--harmony", "--reporter", "spec", "--require", "./test/runtime.js", "./test/tests-node4.es6.js", ]); } if (semver.gte(process.version, "4.0.0")) { enqueue("mocha", [ "--harmony", "--reporter", "spec", "./test/non-writable-tostringtag-property.js", ]); } enqueue("mocha", [ "--harmony", "--reporter", "spec", "./test/frozen-intrinsics.js", ]); flush(); regenerator-regenerator-transform-0.15.2/test/run.sh000077500000000000000000000012361446323212200225630ustar00rootroot00000000000000#!/usr/bin/env bash set -e set -u cd $(dirname $0)/.. ROOT_DIR=$(pwd) npm install install() { npm install ./packages/$1 pushd node_modules/regenerator-$1 npm install # Force the child packages to look in $ROOT_DIR/node_modules to find # one another. rm -rf node_modules popd } PKG=$( package.json echo "$PKG_LOCK" > package-lock.json # We need to use the symlink paths rather than the real paths, so that the # regenerator-* packages appear to reside in node_modules. node test/run.js regenerator-regenerator-transform-0.15.2/test/runtime.js000066400000000000000000000003301446323212200234330ustar00rootroot00000000000000/** * Copyright (c) 2014-present, Facebook, Inc. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ require("regenerator-runtime"); regenerator-regenerator-transform-0.15.2/test/shared.js000066400000000000000000000015721446323212200232270ustar00rootroot00000000000000/** * Copyright (c) 2014-present, Facebook, Inc. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ var assert = require("assert"); if (typeof Symbol === "function") { exports.Symbol = Symbol; } else { exports.Symbol = function Symbol() {}; } if (! exports.Symbol.iterator) { exports.Symbol.iterator = "@@iterator"; } exports.check = function check(g, yields, returnValue) { for (var i = 0; i < yields.length; ++i) { var info = g.next(i); assert.deepEqual(info.value, yields[i]); assert.strictEqual(info.done, false); } assert.deepEqual( i > 0 ? g.next(i) : g.next(), { value: returnValue, done: true } ); }; exports.assertAlreadyFinished = function assertAlreadyFinished(generator) { assert.deepEqual(generator.next(), { value: void 0, done: true }); }; regenerator-regenerator-transform-0.15.2/test/tests-node4.es6.js000066400000000000000000000020361446323212200246220ustar00rootroot00000000000000/** * Copyright (c) 2014-present, Facebook, Inc. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ // tests that should be run only in node 4 and higher, as they use // language features not supported by versions < 4 (even with --harmony). var shared = require("./shared.js"); var check = shared.check; describe("object properties", function () { it("should work if the generator is a simple object property", function () { var obj = { gen: function*(x) { yield x; } }; check(obj.gen("oyez"), ["oyez"]); }); it("should work if the generator is a shorthand object method", function () { var obj = { *gen(x) { yield x; } }; check(obj.gen("oyez"), ["oyez"]); }); it("should work if the generator is a shorthand computed object method", function () { var fnName = "gen"; var obj = { *[fnName](x) { yield x; } }; check(obj.gen("oyez"), ["oyez"]); }); }); regenerator-regenerator-transform-0.15.2/test/tests.es6.js000066400000000000000000001755701446323212200236310ustar00rootroot00000000000000/** * Copyright (c) 2014-present, Facebook, Inc. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ var assert = require("assert"); var runningInTranslation = /\.wrap\(/.test(function*(){}); var shared = require("./shared.js"); var Symbol = shared.Symbol; var check = shared.check; var assertAlreadyFinished = shared.assertAlreadyFinished; var fullCompatibility = runningInTranslation || require("semver").gte(process.version, "7.0.0"); assert( function*() {}.toString().indexOf("regenerator") !== -1, "regenerator-transform should be enabled" ); // A version of `throw` whose behavior can't be statically analyzed. // Useful for testing dynamic exception dispatching. function raise(argument) { throw argument; } describe("regeneratorRuntime", function() { it("should be defined globally", function() { var global = Function("return this")(); assert.ok("regeneratorRuntime" in global); assert.strictEqual(global.regeneratorRuntime, regeneratorRuntime); }); it("should have a .wrap method", function() { assert.strictEqual(typeof regeneratorRuntime.wrap, "function"); }); it("should have a .mark method", function() { assert.strictEqual(typeof regeneratorRuntime.mark, "function"); }); it("should be the object name returned by util.runtimeProperty", function() { assert.strictEqual( require("../lib/util").runtimeProperty("foo").object.name, "regeneratorRuntime" ); }); }); describe("simple argument yielder", function() { it("should yield only its first argument", function() { function *gen(x) { yield x; } check(gen("oyez"), ["oyez"]); check(gen("foo", "bar"), ["foo"]); }); it("should support multiple yields in expression", function() { function *gen() { return (yield 0) + (yield 0); } var itr = gen(); itr.next(); itr.next(1); assert.equal(itr.next(2).value, 3); }); }); function *range(n) { for (var i = 0; i < n; ++i) { yield i; } } describe("range generator", function() { it("should yield the empty range", function() { check(range(0), []); }) it("should yield the range 0..n-1", function() { check(range(5), [0, 1, 2, 3, 4]); }); }); describe("collatz generator", function() { function *gen(n) { var count = 0; yield n; while (n !== 1) { count += 1; if (n % 2) { yield n = n * 3 + 1; } else { yield n >>= 1; } } return count; } function collatz(n) { var result = [n]; while (n !== 1) { if (n % 2) { n *= 3; n += 1; } else { n >>= 1; } result.push(n); } return result; } var seven = collatz(7); var fiftyTwo = seven.slice(seven.indexOf(52)); var eightyTwo = collatz(82); it("seven", function() { check(gen(7), seven, 16); }); it("fifty two", function() { check(gen(52), fiftyTwo, 11); }); it("eighty two", function() { check(gen(82), eightyTwo, 110); }); }); describe("try-catch generator", function() { function *usingThrow(x) { yield 0; try { yield 1; if (x % 2 === 0) throw 2; yield x; } catch (x) { yield x; } yield 3; } function *usingRaise(x) { yield 0; try { yield 1; if (x % 2 === 0) raise(2); yield x; } catch (x) { yield x; } yield 3; } it("should catch static exceptions properly", function() { check(usingThrow(4), [0, 1, 2, 3]); check(usingThrow(5), [0, 1, 5, 3]); }); it("should catch dynamic exceptions properly", function() { check(usingRaise(4), [0, 1, 2, 3]); check(usingRaise(5), [0, 1, 5, 3]); }); }); describe("nested generators in try-catch", function() { function *gen() { try { nonExistent; } catch (e) { yield function* () { yield e; } } } it('should get a reference to the caught error', function () { var genFun2 = gen().next().value; assert.ok(regeneratorRuntime.isGeneratorFunction(genFun2)); var gen2 = genFun2(); var res = gen2.next(); assert.ok(res.value instanceof ReferenceError); // Note that we don't do strict equality over the message because it varies // across browsers (if we ever want to run tests in browsers). assert.ok(res.value.message.match(/nonExistent/)); }); }); describe("try-finally generator", function() { function *usingThrow(condition) { yield 0; try { yield 1; throw 2; yield 3; } finally { if (condition) { yield 4; return 5; } yield 6; return 7; } } function *usingRaise(condition) { yield 0; try { yield 1; raise(2); yield 3; } finally { if (condition) { yield 4; return 5; } yield 6; return 7; } } function *usingAbrupt(abruptType, finallyAbruptType) { yield 0; for (;;) { try { yield 1; if (abruptType === "return") { return 2; } else if (abruptType === "break") { break; } else if (abruptType === "continue") { abruptType = "return"; continue; } } finally { yield 3; if (finallyAbruptType === "return") { return 4; } else if (finallyAbruptType === "break") { break; } else if (finallyAbruptType === "continue") { finallyAbruptType = null; continue; } } } return 5; } it("should honor return", function() { check(usingAbrupt("return", null), [0, 1, 3], 2); }); it("should honor break", function() { check(usingAbrupt("break", null), [0, 1, 3], 5); }); it("should honor continue", function() { check(usingAbrupt("continue", null), [0, 1, 3, 1, 3], 2); }); it("should override abrupt with return", function() { check(usingAbrupt("return", "return"), [0, 1, 3], 4); check(usingAbrupt("break", "return"), [0, 1, 3], 4); check(usingAbrupt("continue", "return"), [0, 1, 3], 4); }); it("should override abrupt with break", function() { check(usingAbrupt("return", "break"), [0, 1, 3], 5); check(usingAbrupt("break", "break"), [0, 1, 3], 5); check(usingAbrupt("continue", "break"), [0, 1, 3], 5); }); it("should override abrupt with continue", function() { check(usingAbrupt("return", "continue"), [0, 1, 3, 1, 3], 2); check(usingAbrupt("break", "continue"), [0, 1, 3, 1, 3], 5); check(usingAbrupt("continue", "continue"), [0, 1, 3, 1, 3], 2); }); it("should execute finally blocks statically", function() { check(usingThrow(true), [0, 1, 4], 5); check(usingThrow(false), [0, 1, 6], 7); }); it("should execute finally blocks dynamically", function() { check(usingRaise(true), [0, 1, 4], 5); check(usingRaise(false), [0, 1, 6], 7); }); it("should execute finally blocks before throwing", function() { var uncaughtError = new Error("uncaught"); function *uncaught(condition) { try { yield 0; if (condition) { yield 1; raise(uncaughtError); } yield 2; } finally { yield 3; } yield 4; } check(uncaught(false), [0, 2, 3, 4]); var u = uncaught(true); assert.deepEqual(u.next(), { value: 0, done: false }); assert.deepEqual(u.next(), { value: 1, done: false }); assert.deepEqual(u.next(), { value: 3, done: false }); try { u.next(); assert.ok(false, "should have thrown an exception"); } catch (err) { assert.strictEqual(err, uncaughtError); } }); it("should throw correct error when finally contains catch", function() { var right = new Error("right"); var wrong = new Error("wrong"); function *gen() { try { yield 0; raise(right); } finally { yield 1; try { raise(wrong); } catch (err) { assert.strictEqual(err, wrong); yield 2; } } } var g = gen(); assert.deepEqual(g.next(), { value: 0, done: false }); assert.deepEqual(g.next(), { value: 1, done: false }); assert.deepEqual(g.next(), { value: 2, done: false }); try { g.next(); assert.ok(false, "should have thrown an exception"); } catch (err) { assert.strictEqual(err, right); } }); it("should run finally after break within try", function() { function *gen() { try { yield 0; while (true) { yield 1; break; } } finally { yield 2; } yield 3; } check(gen(), [0, 1, 2, 3]); }); it("should return the correct value when overridden by finally", function() { function* gen() { try { return yield 1; } finally { return 3; } } var g = gen(); assert.deepEqual(g.next(), { value: 1, done: false }); if (typeof g.return === "function") { assert.deepEqual(g.return(5), { value: 3, done: true }); } else { assert.deepEqual(g.next(5), { value: 3, done: true }); } }); it("should let the last finally block override all others", function() { function* gen(condition) { try { try { return yield 1; } finally { return 2; } } finally { try { return 3; } finally { if (condition) { return 4; } } } } var g1 = gen(true); assert.deepEqual(g1.next(), { value: 1, done: false }); // The generator function has been carefully constructed so that .next // and .return have the same effect, so that these tests should pass // in versions of Node that do not support .return. var method = g1.return || g1.next; assert.deepEqual(method.call(g1, 5), { value: 4, done: true }); var g2 = gen(false); assert.deepEqual(g2.next(), { value: 1, done: false }); assert.deepEqual(method.call(g2, 5), { value: 3, done: true }); }); it("should allow additional yields during finally propagation", function() { function* gen(condition) { try { try { return yield 1; } finally { return 2; } } finally { try { return yield "oyez"; } finally { if (condition) { return 4; } } } } var g1 = gen(true); assert.deepEqual(g1.next(), { value: 1, done: false }); // The generator function has been carefully constructed so that .next // and .return have the same effect, so that these tests should pass // in versions of Node that do not support .return. var method = g1.return || g1.next; assert.deepEqual(method.call(g1, 5), { value: "oyez", done: false }); assert.deepEqual(method.call(g1, 5), { value: 4, done: true }); var g2 = gen(false); assert.deepEqual(g2.next(), { value: 1, done: false }); assert.deepEqual(method.call(g2, 5), { value: "oyez", done: false }); assert.deepEqual(method.call(g2, 5), { value: 5, done: true }); }); }); describe("try-catch-finally generator", function() { function *usingThrow() { yield 0; try { try { yield 1; throw 2; yield 3; } catch (x) { throw yield x; } finally { yield 5; } } catch (thrown) { yield thrown; } yield 6; } function *usingRaise() { yield 0; try { try { yield 1; raise(2); yield 3; } catch (x) { throw yield x; } finally { yield 5; } } catch (thrown) { yield thrown; } yield 6; } it("should statically catch and then finalize", function() { check(usingThrow(), [0, 1, 2, 5, 3, 6]); }); it("should dynamically catch and then finalize", function() { check(usingRaise(), [0, 1, 2, 5, 3, 6]); }); it("should execute catch and finally blocks at most once", function() { var error = new Error(); function *gen() { try { switch (1) { case 1: yield "a"; break; default: break; } throw error; } catch (e) { assert.strictEqual(e, error); yield "b"; do { do { yield "c"; break; } while (false); yield "d"; break; } while (false); yield "e"; } finally { yield "f"; } } check(gen(), ["a", "b", "c", "d", "e", "f"]); }); it("should handle backwards jumps in labeled loops", function() { function *gen() { var firstTime = true; outer: while (true) { yield 0; try { while (true) { yield 1; if (firstTime) { firstTime = false; yield 2; continue outer; } else { yield 3; break; } } yield 4; break; } finally { yield 5; } yield 6; } yield 7; } check(gen(), [0, 1, 2, 5, 0, 1, 3, 4, 5, 7]); }); it("should handle loop continue statements properly", function() { var error = new Error("thrown"); var markers = []; function *gen() { var c = 2; while (c > 0) { try { markers.push("try"); yield c; } catch (e) { assert.strictEqual(e, error); markers.push("catch"); continue; } finally { markers.push("finally"); } markers.push("decrement"); --c; } } var g = gen(); assert.deepEqual(g.next(), { value: 2, done: false }); assert.deepEqual(g.throw(error), { value: 2, done: false }); assert.deepEqual(g.next(), { value: 1, done: false }); assert.deepEqual(g.next(), { value: void 0, done: true }); assert.deepEqual(markers, [ "try", "catch", "finally", "try", "finally", "decrement", "try", "finally", "decrement" ]); }); }); describe("dynamic exception", function() { function *gen(x, fname) { try { return fns[fname](x); } catch (thrown) { yield thrown; } } var fns = { f: function(x) { throw x; }, g: function(x) { return x; } }; it("should be dispatched correctly", function() { check(gen("asdf", "f"), ["asdf"]); check(gen("asdf", "g"), [], "asdf"); }); }); describe("nested finally blocks", function() { function *usingThrow() { try { try { try { throw "thrown"; } finally { yield 1; } } catch (thrown) { yield thrown; } finally { yield 2; } } finally { yield 3; } } function *usingRaise() { try { try { try { raise("thrown"); } finally { yield 1; } } catch (thrown) { yield thrown; } finally { yield 2; } } finally { yield 3; } } it("should statically execute in order", function() { check(usingThrow(), [1, "thrown", 2, 3]); }); it("should dynamically execute in order", function() { check(usingRaise(), [1, "thrown", 2, 3]); }); }); describe("for-in loop generator", function() { it("should handle the simple case", function() { function *gen() { var count = 0; var obj = {foo: 1, bar: 2}; for (var key in obj) { assert(obj.hasOwnProperty(key), key + " must be own property"); yield [key, obj[key]]; count += 1; } return count; } check(gen(), [["foo", 1], ["bar", 2]], 2); }); it("should handle break in loop", function() { function *gen(obj) { var count = 0; for (var key in (yield "why not", obj)) { if (obj.hasOwnProperty(key)) { if (key === "skip") { break; } count += 1; yield [key, obj[key]]; } } return count; } check( gen({ a: 1, b: 2, skip: 3, c: 4 }), ["why not", ["a", 1], ["b", 2]], 2 ); }); it("should handle property deletion in loop", function() { function *gen() { var count = 0; var obj = {foo: 1, bar: 2}; for (var key in obj) { assert(obj.hasOwnProperty(key), key + " must be own property"); yield [key, obj[key]]; delete obj.bar; count += 1; } return count; } check(gen(), [["foo", 1]], 1); }); it("should loop over inherited properties", function() { function *gen() { var count = 0; function Foo() { this.baz = 1 } Foo.prototype.bar = 2; var foo = new Foo(); for (var key in foo) { yield [key, foo[key]]; count += 1; } return count; } check(gen(), [["baz", 1], ["bar", 2]], 2); }); it("should handle risky object expressions", function() { function a(sent) { assert.strictEqual(sent, 1); a.called = true; } function b(sent) { assert.strictEqual(sent, 2); b.called = true; return { callee: b }; } function *gen() { assert.ok(!a.called); assert.ok(!b.called); for (var key in a(yield 0), b(yield 1)) { assert.ok(a.called); assert.ok(b.called); assert.strictEqual(yield key, 3); } for (var key in a(1), { foo: "foo", bar: "bar" }) { yield key; } } check(gen(), [0, 1, "callee", "foo", "bar"]); }); it("should allow non-Identifier left-hand expressions", function() { var obj = {}; var baz = { a: 1, b: 2, c: 3 }; var markers = []; function foo() { markers.push("called foo"); return obj; } function *gen() { for (foo().bar in baz) { markers.push(obj.bar); yield obj.bar; } } check(gen(), ["a", "b", "c"]); assert.deepEqual(markers, [ "called foo", "a", "called foo", "b", "called foo", "c" ]); }); it("should work with primitives", function () { function *gen() { for (var key in "abc") yield key; } check(gen(), [0, 1, 2]); }) }); describe("yield chain", function() { function *gen(n) { return yield yield yield yield n; } it("should have correct associativity", function() { check(gen(5), [5, 1, 2, 3], 4); check(gen("asdf"), ["asdf", 1, 2, 3], 4); }); }); describe("call expression ordering", function test() { it("should be correct with chained calls (#244)", function () { var g = (function *gen() { return (yield 1)(yield 2)(yield 3); })(); assert.deepEqual(g.next(), { value: 1, done: false }); assert.deepEqual(g.next(function (sent2) { assert.strictEqual(sent2, "sent 2"); return function (sent3) { assert.strictEqual(sent3, "sent 3") return "done"; }; }), { value: 2, done: false }); assert.deepEqual(g.next("sent 2"), { value: 3, done: false }); assert.deepEqual(g.next("sent 3"), { value: "done", done: true }); }); describe("when the callee is a member expression", function() { it("should allow vars assigned in the callee to be used in the args (#379)", function() { var g = (function* fn() { var _ref; (_ref = yield).method(_ref); })(); var res; var obj = { method(arg) { res = arg; } }; g.next(); g.next(obj); assert.strictEqual(obj, res); }); it("should be correct when only the callee contains yield", function() { var order = []; function step(n) { order.push(n); return { method() {} } } var g = (function* fn() { (yield, step(1)).method(step(2)); })(); g.next(); g.next(); assert.deepStrictEqual(order, [1, 2]); }); it("should be correct when only the arguments contains yield", function() { var order = []; function step(n) { order.push(n); return { method() {} } } var g = (function* fn() { (step(1)).method(step(2), yield, step(3)); })(); g.next(); g.next(); assert.deepStrictEqual(order, [1, 2, 3]); }); it("should be correct when the callee and the arguments contain yield", function() { var order = []; function step(n) { order.push(n); return { method() {} } } var g = (function* fn() { (yield, step(1)).method(step(2), yield, step(3)); })(); g.next(); g.next(); g.next(); assert.deepStrictEqual(order, [1, 2, 3]); }); }); }); describe("object literal generator", function() { function *gen(a, b) { yield { a: a - (yield a), b: yield b }; } it("should yield the correct object", function() { check(gen(1, 2), [1, 2, { a: 0, b: 2 }]); check(gen(4, 2), [4, 2, { a: 3, b: 2 }]); }); }); describe("switch statement generator", function() { function *gen(a) { switch (yield a) { case (yield "x") - a: return "first case"; case (yield "y") - a: return "second case"; } } it("should jump to the correct cases", function() { check(gen(1), [1, "x"], "first case"); check(gen(2), [2, "x", "y"], "second case"); }); }); describe("infinite sequence generator", function() { function *gen(start, step) { step = step || 1; while (true) { yield start; start += step; } } function *limit(g, stop) { while (true) { var info = g.next(); if (info.done) { return; } else if (info.value < stop) { yield info.value; } else { return; } } } it("should generate a lot of plausible values", function() { var g = gen(10, 2); assert.deepEqual(g.next(), { value: 10, done: false }); assert.deepEqual(g.next(), { value: 12, done: false }); assert.deepEqual(g.next(), { value: 14, done: false }); assert.deepEqual(g.next(), { value: 16, done: false }); var sum = 10 + 12 + 14 + 16; for (var n = 0; n < 1000; ++n) { var info = g.next(); sum += info.value; assert.strictEqual(info.done, false); } assert.strictEqual(sum, 1017052); }); it("should allow limiting", function() { check(limit(gen(10, 3), 20), [10, 13, 16, 19]); }); }); describe("generator function expression", function() { it("should behave just like a declared generator", function() { check(function *(x, y) { yield x; yield y; yield x + y; return x * y; }(3, 7), [3, 7, 10], 21); }) }); describe("generator reentry attempt", function() { function *gen(x) { try { (yield x).next(x); } catch (err) { yield err; } return x + 1; } it("should complain with a TypeError", function() { var g = gen(3); assert.deepEqual(g.next(), { value: 3, done: false }); var complaint = g.next(g); // Sending the generator to itself. assert.ok(complaint.value instanceof Error); assert.strictEqual( complaint.value.message, "Generator is already running" ); assert.deepEqual(g.next(), { value: 4, done: true }); }); }); describe("delegated yield", function() { it("should delegate correctly", function() { function *gen(condition) { yield 0; if (condition) { yield 1; yield* gen(false); yield 2; } yield 3; } check(gen(true), [0, 1, 0, 3, 2, 3]); check(gen(false), [0, 3]); }); it("should cope with empty delegatees", function() { function *gen(condition) { if (condition) { yield 0; yield* gen(false); yield 1; } } check(gen(true), [0, 1]); check(gen(false), []); }); it("should support deeper nesting", function() { function *outer(n) { yield n; yield* middle(n - 1, inner(n + 10)); yield n + 1; } function *middle(n, plusTen) { yield n; yield* inner(n - 1); yield n + 1; yield* plusTen; } function *inner(n) { yield n; } check(outer(5), [5, 4, 3, 5, 15, 6]); }); it("should pass sent values through", function() { function *outer(n) { yield* inner(n << 1); yield "zxcv"; } function *inner(n) { return yield yield yield n; } var g = outer(3); assert.deepEqual(g.next(), { value: 6, done: false }); assert.deepEqual(g.next(1), { value: 1, done: false }); assert.deepEqual(g.next(2), { value: 2, done: false }); assert.deepEqual(g.next(4), { value: "zxcv", done: false }); assert.deepEqual(g.next(5), { value: void 0, done: true }); }); it("should be governed by enclosing try statements", function() { var error = new Error("thrown"); function *outer(n) { try { yield 0; yield* inner(n); yield 1; } catch (err) { yield err.message; } yield 4; } function *inner(n) { while (n --> 0) { try { if (n === 3) { raise(error); } } finally { yield n; } } } check(outer(3), [0, 2, 1, 0, 1, 4]); check(outer(5), [0, 4, 3, "thrown", 4]); }); it("should dispatch .thrown exceptions correctly", function() { var count = 0; function *gen() { yield* inner(); try { yield* inner(); } catch (err) { // pass } return yield* inner(); } function *inner() { return yield count++; } var g = gen(); assert.deepEqual(g.next(), { value: 0, done: false }); assert.deepEqual(g.next(), { value: 1, done: false }); assert.deepEqual(g.throw(new Error("lol")), { value: 2, done: false, }); assert.deepEqual(g.next("sent"), { value: "sent", done: true }); }); it("should call .return methods of delegate iterators", function() { var throwee = new Error("argument to gen.throw"); var thrownFromThrow = new Error("thrown from throw method"); var thrownFromReturn = new Error("thrown from return method"); function *gen(delegate) { try { return yield* delegate; } catch (err) { return err; } } function check(throwMethod, returnMethod) { var throwCalled = false; var returnCalled = false; var count = 0; var iterator = { next: function() { return { value: count++, done: false }; } }; iterator[Symbol.iterator] = function() { return this; }; if (throwMethod) { iterator["throw"] = function() { throwCalled = true; return throwMethod.apply(this, arguments); }; } if (returnMethod) { iterator["return"] = function() { returnCalled = true; return returnMethod.apply(this, arguments); }; } var g = gen(iterator); assert.deepEqual(g.next(), { value: 0, done: false }); assert.deepEqual(g.next(), { value: 1, done: false }); assert.deepEqual(g.next(), { value: 2, done: false }); assert.deepEqual(g.next(), { value: 3, done: false }); assert.strictEqual(throwCalled, false); assert.strictEqual(returnCalled, false); var result = {}; result.throwResult = g.throw(throwee); result.throwCalled = throwCalled; result.returnCalled = returnCalled; return result; } var checkResult = check(undefined, function() { throw thrownFromReturn; }); if (fullCompatibility) { // BUG: Nodes [], }; }(); assert.throws(() => { it.next(); }, TypeError); }); }); (fullCompatibility ? describe // run these tests : xdescribe // skip running these tests )("generator return method", function() { it("should work with newborn generators", function() { function *gen() { yield 0; } var g = gen(); assert.deepEqual(g.return("argument"), { value: "argument", done: true }); assertAlreadyFinished(g); }); it("should behave as if generator actually returned", function() { var executedFinally = false; function *gen() { try { yield 0; } catch (err) { assert.ok(false, "should not have executed the catch handler"); } finally { executedFinally = true; } } var g = gen(); assert.deepEqual(g.next(), { value: 0, done: false }); assert.deepEqual(g.return("argument"), { value: "argument", done: true }); assert.strictEqual(executedFinally, true); assertAlreadyFinished(g); }); it("should return both delegate and delegator", function() { var checkpoints = []; function* callee(errorToThrow) { try { yield 1; yield 2; } finally { checkpoints.push("callee finally"); if (errorToThrow) { throw errorToThrow; } } } function* caller(errorToThrow) { try { yield 0; yield* callee(errorToThrow); yield 3; } finally { checkpoints.push("caller finally"); } } var g1 = caller(); assert.deepEqual(g1.next(), { value: 0, done: false }); assert.deepEqual(g1.next(), { value: 1, done: false }); assert.deepEqual(g1.return(-1), { value: -1, done: true }); assert.deepEqual(checkpoints, [ "callee finally", "caller finally" ]); var error = new Error("thrown from callee"); var g2 = caller(error); assert.deepEqual(g2.next(), { value: 0, done: false }); assert.deepEqual(g2.next(), { value: 1, done: false }); try { g2.return(-1); assert.ok(false, "should have thrown an exception"); } catch (thrown) { assert.strictEqual(thrown, error); } assert.deepEqual(checkpoints, [ "callee finally", "caller finally", "callee finally", "caller finally" ]); }); }); describe("function declaration hoisting", function() { it("should work even if the declarations are out of order", function() { function *gen(n) { yield increment(n); function increment(x) { return x + 1; } if (n % 2) { yield halve(decrement(n)); function halve(x) { return x >> 1; } function decrement(x) { return x - 1; } } else { // The behavior of function declarations nested inside conditional // blocks is notoriously underspecified, and in V8 it appears the // halve function is still defined when we take this branch, so // "undefine" it for consistency with regenerator semantics. halve = void 0; } yield increment(increment(n)); } check(gen(3), [4, 1, 5]); check(gen(4), [5, 6]); }); it("should work for nested generator function declarations", function() { function *outer(n) { yield 0; assert.ok(regeneratorRuntime.isGeneratorFunction(inner)); return yield* inner(n); // Note that this function declaration comes after everything else // in the outer function, but needs to be fully available above. function *inner(n) { yield n - 1; yield n; return yield n + 1; } } check(outer(2), [0, 1, 2, 3], 4); }); it("should not interfere with function rebinding", function() { function rebindTo(value) { var oldValue = toBeRebound; toBeRebound = value; return oldValue; } function *toBeRebound() { var originalValue = toBeRebound; yield toBeRebound; assert.strictEqual(rebindTo(42), originalValue); yield toBeRebound; assert.strictEqual(rebindTo("asdf"), 42); yield toBeRebound; } var original = toBeRebound; check(toBeRebound(), [original, 42, "asdf"]); function attemptToRebind(value) { var oldValue = safe; safe = value; return oldValue; } var safe = function *safe() { var originalValue = safe; yield safe; assert.strictEqual(attemptToRebind(42), originalValue); yield safe; assert.strictEqual(attemptToRebind("asdf"), 42); yield safe; } original = safe; check(safe(), [safe, safe, safe]); }); it("should not interfere with nested function rebinding itself", function() { function *parent() { function toBeRebound() { toBeRebound = 42; } toBeRebound(); yield toBeRebound; } check(parent(), [42]); }); }); describe("the arguments object", function() { it("should work in simple variadic functions", function() { function *sum() { var result = 0; for (var i = 0; i < arguments.length; ++i) { yield result += arguments[i]; } return result; } check(sum(1, 2, 3), [1, 3, 6], 6); check(sum(9, -5, 3, 0, 2), [9, 4, 7, 7, 9], 9); }); it("should alias function parameters", function() { function *gen(x, y) { yield x; ++arguments[0]; yield x; yield y; --arguments[1]; yield y; var temp = y; y = x; x = temp; yield x; yield y; } check(gen(3, 7), [3, 4, 7, 6, 6, 4]); check(gen(10, -5), [10, 11, -5, -6, -6, 11]); }); it("should be shadowable by explicit declarations (sloppy)", function() { function *asParameter(x, arguments) { arguments = arguments + 1; yield x + arguments; } check(asParameter(4, 5), [10]); check(asParameter("asdf", "zxcv"), ["asdfzxcv1"]); function *asVariable(x) { // TODO References to arguments before the variable declaration // seem to see the object instead of the undefined value. var arguments = x + 1; yield arguments; } check(asVariable(4), [5]); check(asVariable("asdf"), ["asdf1"]); }); it("should not get confused by properties", function() { function *gen(args) { var obj = { arguments: args }; yield obj.arguments; obj.arguments = "oyez"; yield obj; } check(gen(42), [42, { arguments: "oyez" }]); }); it("supports .callee", function() { function *gen(doYield) { yield 1; if (doYield) { yield 2; } else { yield 3 yield* arguments.callee(true); yield 4 } yield 5; } check(gen(false), [1, 3, 1, 2, 5, 4, 5]); }); }); describe("the this object", function () { it("should default to undefined (strict)", function () { function *gen() { "use strict"; yield this; return this; } var it = gen(); assert.strictEqual(it.next().value, undefined); assert.strictEqual(it.next().value, undefined); }); it("should respect .call's this", function () { function *gen() { yield this; return this; } var self = {}; var it = gen.call(self); assert.strictEqual(it.next().value, self); assert.strictEqual(it.next().value, self); }); it("shouldn't capture this when not needed", function () { // https://github.com/babel/babel/issues/4056 function *gen() { return 0; } var source = String(gen); assert.strictEqual(source.indexOf("this"), -1); }); }); describe("directive strings", function () { function *strict() { "use strict"; yield ! this; } function *sloppy() { yield ! this; } it("should be kept at top of outer function", function () { var strictCode = String(strict); var useStrictIndex = strictCode.indexOf("use strict"); var thisIndex = strictCode.indexOf("this"); assert.notStrictEqual(useStrictIndex, -1); assert.ok(thisIndex > useStrictIndex); assert.strictEqual(String(sloppy).indexOf("use strict"), -1); check(strict(), [true]); check(sloppy(), [false]); }); }); describe("catch parameter shadowing", function() { it("should leave outer variables unmodified", function() { function *gen(x) { var y = x + 1; try { throw x + 2; } catch (x) { yield x; x += 1; yield x; } yield x; try { throw x + 3; } catch (y) { yield y; y *= 2; yield y; } yield y; } check(gen(1), [3, 4, 1, 4, 8, 2]); check(gen(2), [4, 5, 2, 5, 10, 3]); }); // This test will be fixed by https://github.com/babel/babel/pull/4880. (fullCompatibility ? xit : it)( "should not replace variables defined in inner scopes", function() { function *gen(x) { try { throw x; } catch (x) { yield x; yield (function(x) { return x += 1; }(x + 1)); yield (function() { var x = arguments[0]; return x * 2; }(x + 2)); yield (function() { function notCalled(x) { throw x; } x >>= 1; return x; }()); yield x -= 1; } yield x; } check(gen(10), [10, 12, 24, 5, 4, 10]); check(gen(11), [11, 13, 26, 5, 4, 11]); }); it("should allow nested catch parameters of the same name", function() { function *gen() { try { raise("e1"); } catch (e) { yield e; try { raise("e2"); } catch (e) { yield e; } yield e; } } check(gen(), ["e1", "e2", "e1"]); }); it("should not interfere with non-referential identifiers", function() { function *gen() { try { yield 1; raise(new Error("oyez")); yield 2; } catch (e) { yield 3; e.e = "e.e"; e[e.message] = "e.oyez"; return { e: e, identity: function(x) { var e = x; return e; } }; } yield 4; } var g = gen(); assert.deepEqual(g.next(), { value: 1, done: false }); assert.deepEqual(g.next(), { value: 3, done: false }); var info = g.next(); assert.strictEqual(info.done, true); assert.strictEqual(info.value.e.message, "oyez"); assert.strictEqual(info.value.e.e, "e.e"); assert.strictEqual(info.value.e.oyez, "e.oyez"); assert.strictEqual(info.value.identity("same"), "same"); }); }); describe("empty while loops", function() { it("should be preserved in generated code", function() { function *gen(x) { while (x) { // empty while loop } do { // empty do-while loop } while (x); return gen.toString(); } var info = gen(false).next(); assert.strictEqual(info.done, true); assert.ok(/empty while loop/.test(info.value)); assert.ok(/empty do-while loop/.test(info.value)); }); }); describe("object literals with multiple yields", function() { it("should receive different sent values", function() { function *gen(fn) { return { a: yield "a", b: yield "b", c: fn(yield "c", yield "d"), d: [yield "e", yield "f"] }; } check(gen(function sum(x, y) { return x + y; }), ["a", "b", "c", "d", "e", "f"], { a: 1, b: 2, c: 3 + 4, d: [5, 6] }); }); }); describe("generator .throw method", function() { it("should work after the final call to .next", function() { function *gen() { yield 1; } var g = gen(); assert.deepEqual(g.next(), { value: 1, done: false }); var exception = new Error("unhandled exception"); try { g.throw(exception); assert.ok(false, "should have thrown an exception"); } catch (err) { assert.strictEqual(err, exception); } }); it("should immediately complete a new-born generator", function() { var began = false; function *gen() { began = true; yield 1; } var g = gen(); var exception = new Error("unhandled exception"); try { g.throw(exception); assert.ok(false, "should have thrown an exception"); } catch (err) { assert.strictEqual(err, exception); assert.strictEqual(began, false); } }); it("should not propagate errors handled inside a delegate", function() { function *outer() { try { yield* inner(); } catch (err) { return -1; } return 1; } function *inner() { try { yield void 0; } catch (e) { return; } } var g = outer(); g.next(); assert.equal(g.throw(new Error('foo')).value, 1); }); it("should propagate errors unhandled inside a delegate", function() { function *outer() { try { yield* inner(); } catch (err) { return -1; } return 1; } function *inner() { yield void 0; } var g = outer(); g.next(); assert.equal(g.throw(new Error('foo')).value, -1); }); }); describe("unqualified function calls", function() { it("should have a global `this` object", function() { function getThis() { return this; } // This is almost certainly the global object, but there's a chance it // might be null or undefined (in strict mode). var unqualifiedThis = getThis(); function *invoke() { // It seems like a bug in the ES6 spec that we have to yield an // argument instead of just calling (yield)(). return (yield "dummy")(); } var g = invoke(); var info = g.next(); assert.deepEqual(info, { value: "dummy", done: false }); info = g.next(getThis); // Avoid using assert.strictEqual when the arguments might equal the // global object, since JSON.stringify chokes on circular structures. assert.ok(info.value === unqualifiedThis); assert.strictEqual(info.done, true); }); }); describe("yield* expression results", function () { it("have correct values", function () { function* foo() { yield 0; return yield* bar(); } function* bar() { yield 1; return 2; } check(foo(), [0, 1], 2); }); it("can be used in complex expressions", function () { function pumpNumber(gen) { var n = 0; while (true) { var res = n > 0 ? gen.next(n) : gen.next(); n = res.value; if (res.done) { return n; } } } function* foo() { return (yield* bar()) + (yield* bar()); } function* bar() { return (yield 2) + (yield 3); } assert.strictEqual(pumpNumber(bar()), 5); assert.strictEqual(pumpNumber(foo()), 10); }); }); describe("isGeneratorFunction", function() { it("should work for function declarations", function() { // Do the assertions up here to make sure the generator function is // marked at the beginning of the block the function is declared in. assert.strictEqual( regeneratorRuntime.isGeneratorFunction(genFun), true ); assert.strictEqual( regeneratorRuntime.isGeneratorFunction(normalFun), false ); function normalFun() { return 0; } function *genFun() { yield 0; } }); it("should work for function expressions", function() { assert.strictEqual( regeneratorRuntime.isGeneratorFunction(function *genFun() { yield 0; }), true ); assert.strictEqual( regeneratorRuntime.isGeneratorFunction(function normalFun() { return 0; }), false ); }); }); describe("new expressions", function() { it("should be able to contain yield sub-expressions", function() { function A(first, second) { this.first = first; this.second = second; } function *gen() { return yield new (yield 0)(yield 1, yield 2); } var g = gen(); assert.deepEqual(g.next(), { value: 0, done: false }); assert.deepEqual(g.next(A), { value: 1, done: false }); assert.deepEqual(g.next("asdf"), { value: 2, done: false }); var info = g.next("zxcv"); assert.strictEqual(info.done, false); assert.ok(info.value instanceof A); assert.strictEqual(info.value.first, "asdf"); assert.strictEqual(info.value.second, "zxcv"); assert.deepEqual(g.next("qwer"), { value: "qwer", done: true }); }); }); describe("block binding", function() { it("should translate block binding correctly", function() { "use strict"; function *gen() { var a$0 = 0, a$1 = 1; let a = 3; { let a = 1; yield a + a$0; } { let a = 2; yield a - 1 + a$1; } yield a; } var g = gen(); assert.deepEqual(g.next(), { value: 1, done: false }); assert.deepEqual(g.next(), { value: 2, done: false }); assert.deepEqual(g.next(), { value: 3, done: false }); assert.deepEqual(g.next(), { value: void 0, done: true }); }); it("should translate block binding with iife correctly", function() { "use strict"; function *gen() { let arr = []; for (let x = 0; x < 3; x++) { let y = x; arr.push(function() { return y; }); } { let x; while( x = arr.pop() ) { yield x; } } } var g = gen(); assert.equal(g.next().value(), 2); assert.equal(g.next().value(), 1); assert.equal(g.next().value(), 0); assert.deepEqual(g.next(), { value: void 0, done: true }); }); }); describe("newborn generators", function() { it("should be able to yield* non-newborn generators", function() { function *inner() { return [yield 1, yield 2]; } function *outer(delegate) { return yield* delegate; } var n = inner(); assert.deepEqual(n.next(), { value: 1, done: false }); var g = outer(n); // I would really like to be able to pass 3 to g.next here, but V8 // ignores values sent to newborn generators, and SpiderMonkey throws // a TypeError. assert.deepEqual(g.next(), { value: 2, done: false }); assert.deepEqual(g.next(4), { value: [void 0, 4], done: true }); }); it("should support the ignore-initial-yield wrapper idiom", function() { var markers = []; function *inner() { markers.push(0); var sent1 = yield 1; markers.push(2); var sent2 = yield 2; markers.push(3); return [sent1, sent2]; } function wrapper(delegate) { var gen = (function*() { // This yield is the "initial yield" whose argument we ignore. var sent = yield "ignored", info; markers.push(1); while (!(info = delegate.next(sent)).done) { sent = yield info.value; } markers.push(4); return info.value; })(); // Ensure that gen is not newborn and that the next invocation of // gen.next(value) can send value to the initial yield expression. gen.next(); return gen; } var n = inner(); assert.deepEqual(n.next(), { value: 1, done: false }); var g = wrapper(n); // Unlike in the previous spec, it's fine to pass 3 to g.next here, // because g is not newborn, because g.next was already called once // before g was returned from the wrapper function. assert.deepEqual(g.next(3), { value: 2, done: false }); assert.deepEqual(g.next(4), { value: [3, 4], done: true }); // Ensure we encountered the marker points in the expected order. assert.deepEqual(markers, [0, 1, 2, 3, 4]); }); it("should allow chaining newborn and non-newborn generators", function() { function *range(n) { for (var i = 0; i < n; ++i) { yield i; } } function *chain(a, b) { yield* a; yield* b; } check(chain(range(3), range(5)), [0, 1, 2, 0, 1, 2, 3, 4]); function *y3(x) { return yield yield yield x; } function *y5(x) { return yield yield yield yield yield x; } check( chain(y3("foo"), y5("bar")), ["foo", 1, 2, "bar", 4, 5, 6, 7] ); var g3 = y3("three"); assert.deepEqual(g3.next(), { value: "three", done: false }); var g5 = y5("five"); assert.deepEqual(g5.next(), { value: "five", done: false }); var undef; // A little easier to read than void 0. check(chain(g3, g5), [undef, 1, undef, 3, 4, 5]); }); }); describe("labeled break and continue statements", function() { it("should be able to exit multiple try statements", function() { var e1 = "first"; var e2 = "second"; var e3 = "third"; var e4 = "fourth"; function *gen(n, which) { try { yield 0; raise(e1); } finally { yield 1; loop: for (var i = 0; i < n; ++i) { yield i; try { raise(e2); } finally { yield 2; try { raise(e3); } finally { yield 3; try { raise(e4); } finally { yield 4; if (which === "break") { yield "breaking"; break loop; } if (which === "continue") { yield "continuing"; continue loop; } yield 5; } } } } yield 6; } } try { check(gen(1, "break"), [ 0, 1, 0, 2, 3, 4, "breaking", 6 ]); assert.ok(false, "should have thrown an exception"); } catch (err) { assert.strictEqual(err, e1); } try { check(gen(3, "continue"), [ 0, 1, 0, 2, 3, 4, "continuing", 1, 2, 3, 4, "continuing", 2, 2, 3, 4, "continuing", 6 // Loop finished naturally. ]); assert.ok(false, "should have thrown an exception"); } catch (err) { assert.strictEqual(err, e1); } try { check(gen(3, "neither"), [ 0, 1, 0, 2, 3, 4, 5 ]); assert.ok(false, "should have thrown an exception"); } catch (err) { assert.strictEqual(err, e4); } }); it("should allow breaking from any labeled statement", function() { function* gen(limit) { yield 0; for (var i = 0; i < limit; ++i) { yield 1; label1: { yield 2; break label1; yield 3; } label2: if (limit === 3) label3: { yield 4; if (i === 0) break label2; yield 5; if (i === 1) break label3; label4: yield 6; // This should break from the for-loop. if (i === 2) xxx: break; yield 7; } // This should be a no-op. xxx: break xxx; yield 8 } yield 9; } check(gen(0), [0, 9]); check(gen(1), [0, 1, 2, 8, 9]); check(gen(2), [0, 1, 2, 8, 1, 2, 8, 9]); check(gen(3), [0, 1, 2, 4, 8, 1, 2, 4, 5, 8, 1, 2, 4, 5, 6, 9]); }); }); describe("for loop with var decl and no update expression", function() { // https://github.com/facebook/regenerator/issues/103 function *range() { for (var i = 0; false; ) { } } it("should compile and run", function() { check(range(), []); }); }); describe("generator function prototype", function() { function getProto(obj) { return Object.getPrototypeOf ? Object.getPrototypeOf(obj) : obj.__proto__; } it("should follow the expected object model", function() { var GeneratorFunctionPrototype = getProto(f); var GeneratorFunction = GeneratorFunctionPrototype.constructor; assert.strictEqual(GeneratorFunction.name, 'GeneratorFunction'); assert.strictEqual(GeneratorFunction.prototype, GeneratorFunctionPrototype); assert.strictEqual(GeneratorFunctionPrototype.prototype.constructor, GeneratorFunctionPrototype); assert.strictEqual(GeneratorFunctionPrototype.prototype, getProto(f.prototype)); assert.strictEqual(getProto(GeneratorFunctionPrototype), Function.prototype); if (typeof process === "undefined" || process.version.slice(1, 3) === "0.") { // Node version strings start with 0. assert.strictEqual(GeneratorFunctionPrototype.name, "GeneratorFunctionPrototype"); } else if (process.version.slice(1, 3) === "1.") { // iojs version strings start with 1., and iojs gets this .name // property wrong. TODO report this? assert.strictEqual(GeneratorFunctionPrototype.name, ""); } assert.strictEqual(typeof f2, "function"); assert.strictEqual(f2.constructor, GeneratorFunction); assert.ok(f2 instanceof GeneratorFunction); assert.strictEqual(f2.name, "f2"); var g = f(); assert.ok(g instanceof f); assert.strictEqual(getProto(g), f.prototype); assert.deepEqual([], Object.getOwnPropertyNames(f.prototype)); // assert.deepEqual([], Object.getOwnPropertyNames(g)); f.prototype.x = 42; var g2 = f(); assert.strictEqual(g2.x, 42); function* f2() { yield 1; } assert.strictEqual(getProto(f), getProto(f2)); assert.strictEqual(f.hasOwnProperty('constructor'), false); assert.strictEqual(getProto(f).constructor.name, 'GeneratorFunction'); // Intentionally at the end to test hoisting. function* f() { yield this; } function* f() { yield 1; } var f2 = f; f = 42; var g = f2(); assert.deepEqual(g.next(), { value: 1, done: false }); assert.deepEqual(g.next(), { value: void 0, done: true }); assert.ok(g instanceof f2); }); }); describe("for-of loops", function() { var arraysAreIterable = typeof Array.prototype[Symbol.iterator] === "function"; (fullCompatibility && arraysAreIterable ? it : xit) ("should work for Arrays", function() { var sum = 0; for (var x of [1, 2].concat(3)) { sum += x; } assert.strictEqual(sum, 6); }); it("should work for generators", function() { var value, values = []; for (value of range(3)) values.push(value); assert.deepEqual(values, [0, 1, 2]); }); it("should work inside of generators", function() { function *yieldPermutations(list) { if (list.length < 2) { yield list; return 1; } var count = 0; var first = list.slice(0, 1); var genRest = yieldPermutations(list.slice(1)); for (var perm of genRest) { for (var i = 0; i < list.length; ++i) { var prefix = perm.slice(0, i); var suffix = perm.slice(i); yield prefix.concat(first, suffix); } count += i; } return count; } var count = 0; for (var perm of yieldPermutations([])) { assert.deepEqual(perm, []); ++count; } assert.strictEqual(count, 1); check(yieldPermutations([1]), [[1]], 1); check(yieldPermutations([2, 1]), [ [2, 1], [1, 2] ], 2); check(yieldPermutations([1,3,2]), [ [1, 3, 2], [3, 1, 2], [3, 2, 1], [1, 2, 3], [2, 1, 3], [2, 3, 1] ], 6); }); }); describe("expressions containing yield subexpressions", function() { it("should evaluate all subexpressions before yielding", function() { function *gen(x) { return x * (yield (function(y) { x = y })); } var g = gen(2); var result = g.next(); assert.strictEqual(result.done, false); result.value(5); assert.deepEqual(g.next(5), { value: 10, done: true }); }); it("should work even with getter member expressions", function() { function *gen() { return a.b + (yield "asdf"); } var a = {}; var b = 0; Object.defineProperty(a, "b", { get: function() { return ++b; } }); var g = gen(); assert.strictEqual(a.b, 1); assert.deepEqual(g.next(), { value: "asdf", done: false }); assert.strictEqual(a.b, 3); assert.deepEqual(g.next(2), { value: 4, done: true }); }); it("should evaluate all array elements before yielding", function() { function *gen() { return [a, yield "asdf", a]; } var a = 1; var g = gen(); assert.deepEqual(g.next(), { value: "asdf", done: false }); a = 3; assert.deepEqual(g.next(2), { value: [1, 2, 3], done: true }); }); it("should handle callee member expressions correctly", function() { function *gen() { a = a.slice(0).concat(yield "asdf"); return a; } var a = []; var g = gen(); assert.deepEqual(g.next(), { value: "asdf", done: false }); a.push(1); assert.deepEqual(g.next(2), { value: [2], done: true }); }); it("should handle implicit stringification correctly", function() { function *gen() { return a + (yield "asdf"); } var a = [1, 2]; var g = gen(); assert.deepEqual(g.next(), { value: "asdf", done: false }); a = [4,5]; assert.deepEqual(g.next(",3"), { value: "1,2,3", done: true }); }); it("should work when yield is in an array spread", function() { function *gen() { return [0, ...(yield "foo"), 3]; } var g = gen(); assert.deepEqual(g.next(), { value: "foo", done: false, }); assert.deepEqual(g.next([1, 2]), { value: [0, 1, 2, 3], done: true, }); }); it("should work when yield is in a sparse array", function() { function *gen() { return [0, yield "foo", , 3]; } var g = gen(); assert.deepEqual(g.next(), { value: "foo", done: false, }); assert.deepEqual(g.next(1), { value: [0, 1, , 3], done: true, }); }); }); regenerator-regenerator-transform-0.15.2/test/tests.transform.js000066400000000000000000000252131446323212200251330ustar00rootroot00000000000000/** * Copyright (c) 2014-present, Facebook, Inc. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ var assert = require("assert"); var recast = require("recast"); var v8 = require("v8"); var types = recast.types; var n = types.namedTypes; var transform = require("..").transform; var compile = require("..").compile; var UglifyJS = require("uglify-js"); describe("_blockHoist nodes", function() { it("should be hoisted to the outer body", function() { var foo; var names = []; var ast = recast.parse([ "function *foo(doNotHoistMe, hoistMe) {", " var sent = yield doNotHoistMe();", " hoistMe();", " names.push(sent);", " return 123;", "}" ].join("\n"), { parser: require("@babel/parser") }); var hoistMeStmt = ast.program.body[0].body.body[1]; n.ExpressionStatement.assert(hoistMeStmt); n.CallExpression.assert(hoistMeStmt.expression); n.Identifier.assert(hoistMeStmt.expression.callee); assert.strictEqual(hoistMeStmt.expression.callee.name, "hoistMe"); hoistMeStmt._blockHoist = 1; eval(recast.print(transform(ast)).code); assert.strictEqual(typeof foo, "function"); assert.ok(regeneratorRuntime.isGeneratorFunction(foo)); assert.strictEqual(names.length, 0); var g = foo(function doNotHoistMe() { names.push("doNotHoistMe"); return "yielded"; }, function hoistMe() { names.push("hoistMe"); }); assert.deepEqual(names, ["hoistMe"]); assert.deepEqual(g.next(), { value: "yielded", done: false }); assert.deepEqual(names, ["hoistMe", "doNotHoistMe"]); assert.deepEqual(g.next("oyez"), { value: 123, done: true }); assert.deepEqual(names, ["hoistMe", "doNotHoistMe", "oyez"]); }); }); describe("uglifyjs dead code removal", function() { function uglifyAndParse(file1, file2) { var code = { "file1.js": file1, "file2.js": file2 }; var options = { toplevel: true, // don't mangle function or variable names so we can find them mangle: false, output: { // make it easier to parse the output beautify: true } }; // uglify our code var result = UglifyJS.minify(code, options); // parse and return the output return recast.parse(result.code, { parser: require("@babel/parser") }); } it("works with function expressions", function() { var file1 = compile([ 'var foo = function* () {};', 'var bar = function* () {};' ].join("\n")).code; var file2 = compile('console.log(foo());').code; var ast = uglifyAndParse(file1, file2); // the results should have a single variable declaration var variableDeclarations = ast.program.body.filter(function(b) { return b.type === 'VariableDeclaration'; }); assert.strictEqual(variableDeclarations.length, 1); assert.strictEqual(variableDeclarations[0].declarations.length, 1); var declaration = variableDeclarations[0].declarations[0]; // named foo assert.strictEqual(declaration.id.name, 'foo'); }); it("works with function declarations", function() { var file1 = compile([ 'function* foo() {};', 'function* bar() {};' ].join("\n")).code; var file2 = compile('console.log(foo());').code; var ast = uglifyAndParse(file1, file2); // the results should have our foo() function assert.ok(ast.program.body.some(function(b) { return b.type === 'FunctionDeclaration' && b.id.name === 'foo'; })); // but not our bar() function assert.ok(!ast.program.body.some(function(b) { return b.type === 'FunctionDeclaration' && b.id.name === 'bar'; })); // and a single mark declaration var variableDeclarations = ast.program.body.filter(function(b) { return b.type === 'VariableDeclaration'; }); assert.strictEqual(variableDeclarations.length, 1); var declarations = variableDeclarations[0].declarations; assert.strictEqual(declarations.length, 1); var declaration = declarations[0]; // with our function name as an argument' assert.strictEqual(declaration.init.arguments.length, 1); assert.strictEqual(declaration.init.arguments[0].name, 'foo'); }); }) context("functions", function() { function marksCorrectly(marked, varName) { // marked should be a VariableDeclarator n.VariableDeclarator.assert(marked); // using our variable name assert.strictEqual(marked.id.name, varName); assertMarkCall(marked.init); } function assertMarkCall(node) { // assiging a call expression to regeneratorRuntime.mark() n.CallExpression.assert(node); assert.strictEqual(node.callee.object.name, 'regeneratorRuntime') assert.strictEqual(node.callee.property.name, 'mark') // with said call expression marked as a pure function assert.strictEqual(node.leadingComments[0].value, '#__PURE__'); } describe("function declarations", function() { it("should work with a single function", function() { var ast = recast.parse('function* foo(){};', { parser: require("@babel/parser") }); // get our declarations const declaration = transform(ast).program.body[0]; n.VariableDeclaration.assert(declaration); const declarations = declaration.declarations; // verify our declaration is marked correctly marksCorrectly(declarations[0], '_marked'); // and has our function name as its first argument assert.strictEqual(declarations[0].init.arguments[0].name, 'foo'); }); it("should work with multiple functions", function() { var ast = recast.parse([ 'function* foo() {};', 'function* bar() {};' ].join("\n"), { parser: require("@babel/parser") }); // get our declarations const declaration = transform(ast).program.body[0]; n.VariableDeclaration.assert(declaration); const declarations = declaration.declarations; // verify our declarations are marked correctly and have our function name // as their first argument marksCorrectly(declarations[0], '_marked'); n.Identifier.assert(declarations[0].init.arguments[0]); assert.strictEqual(declarations[0].init.arguments[0].name, 'foo'); marksCorrectly(declarations[1], '_marked2'); n.Identifier.assert(declarations[1].init.arguments[0]); assert.strictEqual(declarations[1].init.arguments[0].name, 'bar'); }); }); describe("function expressions", function() { it("should work with a named function", function() { var ast = recast.parse('var a = function* foo(){};', { parser: require("@babel/parser") }); // get our declarations const declaration = transform(ast).program.body[0]; n.VariableDeclaration.assert(declaration); const declarator = declaration.declarations[0]; // verify our declaration is marked correctly marksCorrectly(declarator, 'a'); // and that our first argument is our original function expression n.FunctionExpression.assert(declarator.init.arguments[0]); assert.strictEqual(declarator.init.arguments[0].id.name, 'foo'); }); it("should work with an anonymous function", function() { var ast = recast.parse('var a = function* (){};', { parser: require("@babel/parser") }); // get our declarations const declaration = transform(ast).program.body[0]; n.VariableDeclaration.assert(declaration); const declarator = declaration.declarations[0]; // verify our declaration is marked correctly marksCorrectly(declarator, 'a'); // and that our first argument is our original function expression n.FunctionExpression.assert(declarator.init.arguments[0]); assert.strictEqual(declarator.init.arguments[0].id.name, '_callee'); }); }); describe("class methods", function() { it("should be correctly wrapped", function () { const input = ` class A { *foo() {} } `; // The regenerator preset also transpiles classes const { ast } = require("@babel/core").transformSync(input, { configFile: false, ast: true, plugins: [require("../packages/transform")], }); const method = ast.program.body[0].body.body[0]; n.ClassMethod.assert(method); const return_ = method.body.body[0]; n.ReturnStatement.assert(return_); n.CallExpression.assert(return_.argument); assertMarkCall(return_.argument.callee); /* class A { foo() { return ( #__PURE__ regeneratorRuntime.mark(function _callee() { return regeneratorRuntime.wrap(function _callee$(_context) { while (1) switch (_context.prev = _context.next) { case 0: case "end": return _context.stop(); } }, _callee); })() ); } } */ }); }); describe("variables hoisting", function() { it("shouldn't throw about duplicate bindings", function() { // https://github.com/babel/babel/issues/6923 const code = ` async function foo() { (async function f(number) { const tmp = number }) } `; assert.doesNotThrow(function() { require("@babel/core").transformSync(code, { configFile: false, plugins: [require("../packages/transform")], }); }); }); it("should register hoisted variable bindings", function() { // https://github.com/babel/babel/issues/10193 const code = ` import { someAction } from 'actions'; function* foo() { const someAction = bar; } `; const compiled = require("@babel/core").transformSync(code, { configFile: false, plugins: [ require("../packages/transform"), require("@babel/plugin-transform-modules-commonjs") ] }).code; assert.strictEqual(compiled.indexOf("throw"), -1); assert.strictEqual(compiled.indexOf("read-only"), -1); }); }); }); describe("ast serialization", function() { function getAST() { return require("@babel/core").transformSync( `function* foo() { arguments; }`, { ast: true, configFile: false, plugins: [require("../packages/transform")], }, ).ast; } it("produces an ast that is JSON serializable", function() { assert.doesNotThrow(function() { JSON.stringify(getAST()); }); }) it("produces an ast that is serializable with v8's serializer", function() { assert.doesNotThrow(function() { v8.serialize(getAST()); }); }) })