diff --git a/CHANGELOG.md b/CHANGELOG.md
index 910fcda0a60927..07561fa6ca06a5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -35,7 +35,8 @@ release.
-19.6.1
+19.7.0
+19.6.1
19.6.0
19.5.0
19.4.0
diff --git a/deps/cares/src/lib/ares_library_init.h b/deps/cares/src/lib/ares_library_init.h
new file mode 100644
index 00000000000000..b3896d9f7bbed0
--- /dev/null
+++ b/deps/cares/src/lib/ares_library_init.h
@@ -0,0 +1,43 @@
+#ifndef HEADER_CARES_LIBRARY_INIT_H
+#define HEADER_CARES_LIBRARY_INIT_H
+
+
+/* Copyright 1998 by the Massachusetts Institute of Technology.
+ * Copyright (C) 2004-2011 by Daniel Stenberg
+ *
+ * Permission to use, copy, modify, and distribute this
+ * software and its documentation for any purpose and without
+ * fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting
+ * documentation, and that the name of M.I.T. not be used in
+ * advertising or publicity pertaining to distribution of the
+ * software without specific, written prior permission.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose. It is provided "as is"
+ * without express or implied warranty.
+ */
+
+#include "ares_setup.h"
+
+#ifdef USE_WINSOCK
+
+#include
+#include "ares_iphlpapi.h"
+
+typedef DWORD (WINAPI *fpGetNetworkParams_t) (FIXED_INFO*, DWORD*);
+typedef BOOLEAN (APIENTRY *fpSystemFunction036_t) (void*, ULONG);
+typedef ULONG (WINAPI *fpGetAdaptersAddresses_t) ( ULONG, ULONG, void*, IP_ADAPTER_ADDRESSES*, ULONG* );
+typedef NETIO_STATUS (WINAPI *fpGetBestRoute2_t) ( NET_LUID *, NET_IFINDEX, const SOCKADDR_INET *, const SOCKADDR_INET *, ULONG, PMIB_IPFORWARD_ROW2, SOCKADDR_INET * );
+/* Forward-declaration of variables defined in ares_library_init.c */
+/* that are global and unique instances for whole c-ares library. */
+
+extern fpGetNetworkParams_t ares_fpGetNetworkParams;
+extern fpSystemFunction036_t ares_fpSystemFunction036;
+extern fpGetAdaptersAddresses_t ares_fpGetAdaptersAddresses;
+extern fpGetBestRoute2_t ares_fpGetBestRoute2;
+
+#endif /* USE_WINSOCK */
+
+#endif /* HEADER_CARES_LIBRARY_INIT_H */
+
diff --git a/deps/corepack/dist/vcc.js b/deps/corepack/dist/vcc.js
new file mode 100644
index 00000000000000..2a8c9014b546d1
--- /dev/null
+++ b/deps/corepack/dist/vcc.js
@@ -0,0 +1,424 @@
+#!/usr/bin/env node
+/* eslint-disable */
+/******/ (() => { // webpackBootstrap
+/******/ var __webpack_modules__ = ({
+
+/***/ "../../../.yarn/berry/cache/v8-compile-cache-npm-2.3.0-961375f150-9.zip/node_modules/v8-compile-cache/v8-compile-cache.js":
+/*!********************************************************************************************************************************!*\
+ !*** ../../../.yarn/berry/cache/v8-compile-cache-npm-2.3.0-961375f150-9.zip/node_modules/v8-compile-cache/v8-compile-cache.js ***!
+ \********************************************************************************************************************************/
+/***/ (function(module, exports) {
+
+'use strict';
+
+const Module = require('module');
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const vm = require('vm');
+const os = require('os');
+
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+
+//------------------------------------------------------------------------------
+// FileSystemBlobStore
+//------------------------------------------------------------------------------
+
+class FileSystemBlobStore {
+ constructor(directory, prefix) {
+ const name = prefix ? slashEscape(prefix + '.') : '';
+ this._blobFilename = path.join(directory, name + 'BLOB');
+ this._mapFilename = path.join(directory, name + 'MAP');
+ this._lockFilename = path.join(directory, name + 'LOCK');
+ this._directory = directory;
+ this._load();
+ }
+
+ has(key, invalidationKey) {
+ if (hasOwnProperty.call(this._memoryBlobs, key)) {
+ return this._invalidationKeys[key] === invalidationKey;
+ } else if (hasOwnProperty.call(this._storedMap, key)) {
+ return this._storedMap[key][0] === invalidationKey;
+ }
+ return false;
+ }
+
+ get(key, invalidationKey) {
+ if (hasOwnProperty.call(this._memoryBlobs, key)) {
+ if (this._invalidationKeys[key] === invalidationKey) {
+ return this._memoryBlobs[key];
+ }
+ } else if (hasOwnProperty.call(this._storedMap, key)) {
+ const mapping = this._storedMap[key];
+ if (mapping[0] === invalidationKey) {
+ return this._storedBlob.slice(mapping[1], mapping[2]);
+ }
+ }
+ }
+
+ set(key, invalidationKey, buffer) {
+ this._invalidationKeys[key] = invalidationKey;
+ this._memoryBlobs[key] = buffer;
+ this._dirty = true;
+ }
+
+ delete(key) {
+ if (hasOwnProperty.call(this._memoryBlobs, key)) {
+ this._dirty = true;
+ delete this._memoryBlobs[key];
+ }
+ if (hasOwnProperty.call(this._invalidationKeys, key)) {
+ this._dirty = true;
+ delete this._invalidationKeys[key];
+ }
+ if (hasOwnProperty.call(this._storedMap, key)) {
+ this._dirty = true;
+ delete this._storedMap[key];
+ }
+ }
+
+ isDirty() {
+ return this._dirty;
+ }
+
+ save() {
+ const dump = this._getDump();
+ const blobToStore = Buffer.concat(dump[0]);
+ const mapToStore = JSON.stringify(dump[1]);
+
+ try {
+ mkdirpSync(this._directory);
+ fs.writeFileSync(this._lockFilename, 'LOCK', {flag: 'wx'});
+ } catch (error) {
+ // Swallow the exception if we fail to acquire the lock.
+ return false;
+ }
+
+ try {
+ fs.writeFileSync(this._blobFilename, blobToStore);
+ fs.writeFileSync(this._mapFilename, mapToStore);
+ } finally {
+ fs.unlinkSync(this._lockFilename);
+ }
+
+ return true;
+ }
+
+ _load() {
+ try {
+ this._storedBlob = fs.readFileSync(this._blobFilename);
+ this._storedMap = JSON.parse(fs.readFileSync(this._mapFilename));
+ } catch (e) {
+ this._storedBlob = Buffer.alloc(0);
+ this._storedMap = {};
+ }
+ this._dirty = false;
+ this._memoryBlobs = {};
+ this._invalidationKeys = {};
+ }
+
+ _getDump() {
+ const buffers = [];
+ const newMap = {};
+ let offset = 0;
+
+ function push(key, invalidationKey, buffer) {
+ buffers.push(buffer);
+ newMap[key] = [invalidationKey, offset, offset + buffer.length];
+ offset += buffer.length;
+ }
+
+ for (const key of Object.keys(this._memoryBlobs)) {
+ const buffer = this._memoryBlobs[key];
+ const invalidationKey = this._invalidationKeys[key];
+ push(key, invalidationKey, buffer);
+ }
+
+ for (const key of Object.keys(this._storedMap)) {
+ if (hasOwnProperty.call(newMap, key)) continue;
+ const mapping = this._storedMap[key];
+ const buffer = this._storedBlob.slice(mapping[1], mapping[2]);
+ push(key, mapping[0], buffer);
+ }
+
+ return [buffers, newMap];
+ }
+}
+
+//------------------------------------------------------------------------------
+// NativeCompileCache
+//------------------------------------------------------------------------------
+
+class NativeCompileCache {
+ constructor() {
+ this._cacheStore = null;
+ this._previousModuleCompile = null;
+ }
+
+ setCacheStore(cacheStore) {
+ this._cacheStore = cacheStore;
+ }
+
+ install() {
+ const self = this;
+ const hasRequireResolvePaths = typeof require.resolve.paths === 'function';
+ this._previousModuleCompile = Module.prototype._compile;
+ Module.prototype._compile = function(content, filename) {
+ const mod = this;
+
+ function require(id) {
+ return mod.require(id);
+ }
+
+ // https://github.com/nodejs/node/blob/v10.15.3/lib/internal/modules/cjs/helpers.js#L28
+ function resolve(request, options) {
+ return Module._resolveFilename(request, mod, false, options);
+ }
+ require.resolve = resolve;
+
+ // https://github.com/nodejs/node/blob/v10.15.3/lib/internal/modules/cjs/helpers.js#L37
+ // resolve.resolve.paths was added in v8.9.0
+ if (hasRequireResolvePaths) {
+ resolve.paths = function paths(request) {
+ return Module._resolveLookupPaths(request, mod, true);
+ };
+ }
+
+ require.main = process.mainModule;
+
+ // Enable support to add extra extension types
+ require.extensions = Module._extensions;
+ require.cache = Module._cache;
+
+ const dirname = path.dirname(filename);
+
+ const compiledWrapper = self._moduleCompile(filename, content);
+
+ // We skip the debugger setup because by the time we run, node has already
+ // done that itself.
+
+ // `Buffer` is included for Electron.
+ // See https://github.com/zertosh/v8-compile-cache/pull/10#issuecomment-518042543
+ const args = [mod.exports, require, mod, filename, dirname, process, global, Buffer];
+ return compiledWrapper.apply(mod.exports, args);
+ };
+ }
+
+ uninstall() {
+ Module.prototype._compile = this._previousModuleCompile;
+ }
+
+ _moduleCompile(filename, content) {
+ // https://github.com/nodejs/node/blob/v7.5.0/lib/module.js#L511
+
+ // Remove shebang
+ var contLen = content.length;
+ if (contLen >= 2) {
+ if (content.charCodeAt(0) === 35/*#*/ &&
+ content.charCodeAt(1) === 33/*!*/) {
+ if (contLen === 2) {
+ // Exact match
+ content = '';
+ } else {
+ // Find end of shebang line and slice it off
+ var i = 2;
+ for (; i < contLen; ++i) {
+ var code = content.charCodeAt(i);
+ if (code === 10/*\n*/ || code === 13/*\r*/) break;
+ }
+ if (i === contLen) {
+ content = '';
+ } else {
+ // Note that this actually includes the newline character(s) in the
+ // new output. This duplicates the behavior of the regular
+ // expression that was previously used to replace the shebang line
+ content = content.slice(i);
+ }
+ }
+ }
+ }
+
+ // create wrapper function
+ var wrapper = Module.wrap(content);
+
+ var invalidationKey = crypto
+ .createHash('sha1')
+ .update(content, 'utf8')
+ .digest('hex');
+
+ var buffer = this._cacheStore.get(filename, invalidationKey);
+
+ var script = new vm.Script(wrapper, {
+ filename: filename,
+ lineOffset: 0,
+ displayErrors: true,
+ cachedData: buffer,
+ produceCachedData: true,
+ });
+
+ if (script.cachedDataProduced) {
+ this._cacheStore.set(filename, invalidationKey, script.cachedData);
+ } else if (script.cachedDataRejected) {
+ this._cacheStore.delete(filename);
+ }
+
+ var compiledWrapper = script.runInThisContext({
+ filename: filename,
+ lineOffset: 0,
+ columnOffset: 0,
+ displayErrors: true,
+ });
+
+ return compiledWrapper;
+ }
+}
+
+//------------------------------------------------------------------------------
+// utilities
+//
+// https://github.com/substack/node-mkdirp/blob/f2003bb/index.js#L55-L98
+// https://github.com/zertosh/slash-escape/blob/e7ebb99/slash-escape.js
+//------------------------------------------------------------------------------
+
+function mkdirpSync(p_) {
+ _mkdirpSync(path.resolve(p_), 0o777);
+}
+
+function _mkdirpSync(p, mode) {
+ try {
+ fs.mkdirSync(p, mode);
+ } catch (err0) {
+ if (err0.code === 'ENOENT') {
+ _mkdirpSync(path.dirname(p));
+ _mkdirpSync(p);
+ } else {
+ try {
+ const stat = fs.statSync(p);
+ if (!stat.isDirectory()) { throw err0; }
+ } catch (err1) {
+ throw err0;
+ }
+ }
+ }
+}
+
+function slashEscape(str) {
+ const ESCAPE_LOOKUP = {
+ '\\': 'zB',
+ ':': 'zC',
+ '/': 'zS',
+ '\x00': 'z0',
+ 'z': 'zZ',
+ };
+ const ESCAPE_REGEX = /[\\:/\x00z]/g; // eslint-disable-line no-control-regex
+ return str.replace(ESCAPE_REGEX, match => ESCAPE_LOOKUP[match]);
+}
+
+function supportsCachedData() {
+ const script = new vm.Script('""', {produceCachedData: true});
+ // chakracore, as of v1.7.1.0, returns `false`.
+ return script.cachedDataProduced === true;
+}
+
+function getCacheDir() {
+ const v8_compile_cache_cache_dir = process.env.V8_COMPILE_CACHE_CACHE_DIR;
+ if (v8_compile_cache_cache_dir) {
+ return v8_compile_cache_cache_dir;
+ }
+
+ // Avoid cache ownership issues on POSIX systems.
+ const dirname = typeof process.getuid === 'function'
+ ? 'v8-compile-cache-' + process.getuid()
+ : 'v8-compile-cache';
+ const version = typeof process.versions.v8 === 'string'
+ ? process.versions.v8
+ : typeof process.versions.chakracore === 'string'
+ ? 'chakracore-' + process.versions.chakracore
+ : 'node-' + process.version;
+ const cacheDir = path.join(os.tmpdir(), dirname, version);
+ return cacheDir;
+}
+
+function getMainName() {
+ // `require.main.filename` is undefined or null when:
+ // * node -e 'require("v8-compile-cache")'
+ // * node -r 'v8-compile-cache'
+ // * Or, requiring from the REPL.
+ const mainName = require.main && typeof require.main.filename === 'string'
+ ? require.main.filename
+ : process.cwd();
+ return mainName;
+}
+
+//------------------------------------------------------------------------------
+// main
+//------------------------------------------------------------------------------
+
+if (!process.env.DISABLE_V8_COMPILE_CACHE && supportsCachedData()) {
+ const cacheDir = getCacheDir();
+ const prefix = getMainName();
+ const blobStore = new FileSystemBlobStore(cacheDir, prefix);
+
+ const nativeCompileCache = new NativeCompileCache();
+ nativeCompileCache.setCacheStore(blobStore);
+ nativeCompileCache.install();
+
+ process.once('exit', () => {
+ if (blobStore.isDirty()) {
+ blobStore.save();
+ }
+ nativeCompileCache.uninstall();
+ });
+}
+
+module.exports.__TEST__ = {
+ FileSystemBlobStore,
+ NativeCompileCache,
+ mkdirpSync,
+ slashEscape,
+ supportsCachedData,
+ getCacheDir,
+ getMainName,
+};
+
+
+/***/ })
+
+/******/ });
+/************************************************************************/
+/******/ // The module cache
+/******/ var __webpack_module_cache__ = {};
+/******/
+/******/ // The require function
+/******/ function __webpack_require__(moduleId) {
+/******/ // Check if module is in cache
+/******/ var cachedModule = __webpack_module_cache__[moduleId];
+/******/ if (cachedModule !== undefined) {
+/******/ return cachedModule.exports;
+/******/ }
+/******/ // Create a new module (and put it into the cache)
+/******/ var module = __webpack_module_cache__[moduleId] = {
+/******/ // no module.id needed
+/******/ // no module.loaded needed
+/******/ exports: {}
+/******/ };
+/******/
+/******/ // Execute the module function
+/******/ __webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ // Return the exports of the module
+/******/ return module.exports;
+/******/ }
+/******/
+/************************************************************************/
+/******/
+/******/ // startup
+/******/ // Load entry module and return exports
+/******/ // This entry module doesn't tell about it's top-level declarations so it can't be inlined
+/******/ var __webpack_exports__ = __webpack_require__("../../../.yarn/berry/cache/v8-compile-cache-npm-2.3.0-961375f150-9.zip/node_modules/v8-compile-cache/v8-compile-cache.js");
+/******/ var __webpack_export_target__ = exports;
+/******/ for(var i in __webpack_exports__) __webpack_export_target__[i] = __webpack_exports__[i];
+/******/ if(__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_target__, "__esModule", { value: true });
+/******/
+/******/ })()
+;
\ No newline at end of file
diff --git a/deps/corepack/dist/vendors-_yarn_berry_cache_proxy-agent-npm-5_0_0-41772f4b01-9_zip_node_modules_proxy-agent_index_js.js b/deps/corepack/dist/vendors-_yarn_berry_cache_proxy-agent-npm-5_0_0-41772f4b01-9_zip_node_modules_proxy-agent_index_js.js
new file mode 100644
index 00000000000000..b2c2dd247a4e8c
--- /dev/null
+++ b/deps/corepack/dist/vendors-_yarn_berry_cache_proxy-agent-npm-5_0_0-41772f4b01-9_zip_node_modules_proxy-agent_index_js.js
@@ -0,0 +1,41282 @@
+exports.id = "vendors-_yarn_berry_cache_proxy-agent-npm-5_0_0-41772f4b01-9_zip_node_modules_proxy-agent_index_js";
+exports.ids = ["vendors-_yarn_berry_cache_proxy-agent-npm-5_0_0-41772f4b01-9_zip_node_modules_proxy-agent_index_js"];
+exports.modules = {
+
+/***/ "../../../.yarn/berry/cache/@tootallnate-once-npm-1.1.2-0517220057-9.zip/node_modules/@tootallnate/once/dist/index.js":
+/*!****************************************************************************************************************************!*\
+ !*** ../../../.yarn/berry/cache/@tootallnate-once-npm-1.1.2-0517220057-9.zip/node_modules/@tootallnate/once/dist/index.js ***!
+ \****************************************************************************************************************************/
+/***/ ((module) => {
+
+"use strict";
+
+function noop() { }
+function once(emitter, name) {
+ const o = once.spread(emitter, name);
+ const r = o.then((args) => args[0]);
+ r.cancel = o.cancel;
+ return r;
+}
+(function (once) {
+ function spread(emitter, name) {
+ let c = null;
+ const p = new Promise((resolve, reject) => {
+ function cancel() {
+ emitter.removeListener(name, onEvent);
+ emitter.removeListener('error', onError);
+ p.cancel = noop;
+ }
+ function onEvent(...args) {
+ cancel();
+ resolve(args);
+ }
+ function onError(err) {
+ cancel();
+ reject(err);
+ }
+ c = cancel;
+ emitter.on(name, onEvent);
+ emitter.on('error', onError);
+ });
+ if (!c) {
+ throw new TypeError('Could not get `cancel()` function');
+ }
+ p.cancel = c;
+ return p;
+ }
+ once.spread = spread;
+})(once || (once = {}));
+module.exports = once;
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+
+/***/ "../../../.yarn/berry/cache/agent-base-npm-6.0.2-428f325a93-9.zip/node_modules/agent-base/dist/src/index.js":
+/*!******************************************************************************************************************!*\
+ !*** ../../../.yarn/berry/cache/agent-base-npm-6.0.2-428f325a93-9.zip/node_modules/agent-base/dist/src/index.js ***!
+ \******************************************************************************************************************/
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+ return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const events_1 = __webpack_require__(/*! events */ "events");
+const debug_1 = __importDefault(__webpack_require__(/*! debug */ "./.yarn/__virtual__/debug-virtual-450dae1bfe/4/.yarn/berry/cache/debug-npm-4.3.4-4513954577-9.zip/node_modules/debug/src/index.js"));
+const promisify_1 = __importDefault(__webpack_require__(/*! ./promisify */ "../../../.yarn/berry/cache/agent-base-npm-6.0.2-428f325a93-9.zip/node_modules/agent-base/dist/src/promisify.js"));
+const debug = debug_1.default('agent-base');
+function isAgent(v) {
+ return Boolean(v) && typeof v.addRequest === 'function';
+}
+function isSecureEndpoint() {
+ const { stack } = new Error();
+ if (typeof stack !== 'string')
+ return false;
+ return stack.split('\n').some(l => l.indexOf('(https.js:') !== -1 || l.indexOf('node:https:') !== -1);
+}
+function createAgent(callback, opts) {
+ return new createAgent.Agent(callback, opts);
+}
+(function (createAgent) {
+ /**
+ * Base `http.Agent` implementation.
+ * No pooling/keep-alive is implemented by default.
+ *
+ * @param {Function} callback
+ * @api public
+ */
+ class Agent extends events_1.EventEmitter {
+ constructor(callback, _opts) {
+ super();
+ let opts = _opts;
+ if (typeof callback === 'function') {
+ this.callback = callback;
+ }
+ else if (callback) {
+ opts = callback;
+ }
+ // Timeout for the socket to be returned from the callback
+ this.timeout = null;
+ if (opts && typeof opts.timeout === 'number') {
+ this.timeout = opts.timeout;
+ }
+ // These aren't actually used by `agent-base`, but are required
+ // for the TypeScript definition files in `@types/node` :/
+ this.maxFreeSockets = 1;
+ this.maxSockets = 1;
+ this.maxTotalSockets = Infinity;
+ this.sockets = {};
+ this.freeSockets = {};
+ this.requests = {};
+ this.options = {};
+ }
+ get defaultPort() {
+ if (typeof this.explicitDefaultPort === 'number') {
+ return this.explicitDefaultPort;
+ }
+ return isSecureEndpoint() ? 443 : 80;
+ }
+ set defaultPort(v) {
+ this.explicitDefaultPort = v;
+ }
+ get protocol() {
+ if (typeof this.explicitProtocol === 'string') {
+ return this.explicitProtocol;
+ }
+ return isSecureEndpoint() ? 'https:' : 'http:';
+ }
+ set protocol(v) {
+ this.explicitProtocol = v;
+ }
+ callback(req, opts, fn) {
+ throw new Error('"agent-base" has no default implementation, you must subclass and override `callback()`');
+ }
+ /**
+ * Called by node-core's "_http_client.js" module when creating
+ * a new HTTP request with this Agent instance.
+ *
+ * @api public
+ */
+ addRequest(req, _opts) {
+ const opts = Object.assign({}, _opts);
+ if (typeof opts.secureEndpoint !== 'boolean') {
+ opts.secureEndpoint = isSecureEndpoint();
+ }
+ if (opts.host == null) {
+ opts.host = 'localhost';
+ }
+ if (opts.port == null) {
+ opts.port = opts.secureEndpoint ? 443 : 80;
+ }
+ if (opts.protocol == null) {
+ opts.protocol = opts.secureEndpoint ? 'https:' : 'http:';
+ }
+ if (opts.host && opts.path) {
+ // If both a `host` and `path` are specified then it's most
+ // likely the result of a `url.parse()` call... we need to
+ // remove the `path` portion so that `net.connect()` doesn't
+ // attempt to open that as a unix socket file.
+ delete opts.path;
+ }
+ delete opts.agent;
+ delete opts.hostname;
+ delete opts._defaultAgent;
+ delete opts.defaultPort;
+ delete opts.createConnection;
+ // Hint to use "Connection: close"
+ // XXX: non-documented `http` module API :(
+ req._last = true;
+ req.shouldKeepAlive = false;
+ let timedOut = false;
+ let timeoutId = null;
+ const timeoutMs = opts.timeout || this.timeout;
+ const onerror = (err) => {
+ if (req._hadError)
+ return;
+ req.emit('error', err);
+ // For Safety. Some additional errors might fire later on
+ // and we need to make sure we don't double-fire the error event.
+ req._hadError = true;
+ };
+ const ontimeout = () => {
+ timeoutId = null;
+ timedOut = true;
+ const err = new Error(`A "socket" was not created for HTTP request before ${timeoutMs}ms`);
+ err.code = 'ETIMEOUT';
+ onerror(err);
+ };
+ const callbackError = (err) => {
+ if (timedOut)
+ return;
+ if (timeoutId !== null) {
+ clearTimeout(timeoutId);
+ timeoutId = null;
+ }
+ onerror(err);
+ };
+ const onsocket = (socket) => {
+ if (timedOut)
+ return;
+ if (timeoutId != null) {
+ clearTimeout(timeoutId);
+ timeoutId = null;
+ }
+ if (isAgent(socket)) {
+ // `socket` is actually an `http.Agent` instance, so
+ // relinquish responsibility for this `req` to the Agent
+ // from here on
+ debug('Callback returned another Agent instance %o', socket.constructor.name);
+ socket.addRequest(req, opts);
+ return;
+ }
+ if (socket) {
+ socket.once('free', () => {
+ this.freeSocket(socket, opts);
+ });
+ req.onSocket(socket);
+ return;
+ }
+ const err = new Error(`no Duplex stream was returned to agent-base for \`${req.method} ${req.path}\``);
+ onerror(err);
+ };
+ if (typeof this.callback !== 'function') {
+ onerror(new Error('`callback` is not defined'));
+ return;
+ }
+ if (!this.promisifiedCallback) {
+ if (this.callback.length >= 3) {
+ debug('Converting legacy callback function to promise');
+ this.promisifiedCallback = promisify_1.default(this.callback);
+ }
+ else {
+ this.promisifiedCallback = this.callback;
+ }
+ }
+ if (typeof timeoutMs === 'number' && timeoutMs > 0) {
+ timeoutId = setTimeout(ontimeout, timeoutMs);
+ }
+ if ('port' in opts && typeof opts.port !== 'number') {
+ opts.port = Number(opts.port);
+ }
+ try {
+ debug('Resolving socket for %o request: %o', opts.protocol, `${req.method} ${req.path}`);
+ Promise.resolve(this.promisifiedCallback(req, opts)).then(onsocket, callbackError);
+ }
+ catch (err) {
+ Promise.reject(err).catch(callbackError);
+ }
+ }
+ freeSocket(socket, opts) {
+ debug('Freeing socket %o %o', socket.constructor.name, opts);
+ socket.destroy();
+ }
+ destroy() {
+ debug('Destroying agent %o', this.constructor.name);
+ }
+ }
+ createAgent.Agent = Agent;
+ // So that `instanceof` works correctly
+ createAgent.prototype = createAgent.Agent.prototype;
+})(createAgent || (createAgent = {}));
+module.exports = createAgent;
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+
+/***/ "../../../.yarn/berry/cache/agent-base-npm-6.0.2-428f325a93-9.zip/node_modules/agent-base/dist/src/promisify.js":
+/*!**********************************************************************************************************************!*\
+ !*** ../../../.yarn/berry/cache/agent-base-npm-6.0.2-428f325a93-9.zip/node_modules/agent-base/dist/src/promisify.js ***!
+ \**********************************************************************************************************************/
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+function promisify(fn) {
+ return function (req, opts) {
+ return new Promise((resolve, reject) => {
+ fn.call(this, req, opts, (err, rtn) => {
+ if (err) {
+ reject(err);
+ }
+ else {
+ resolve(rtn);
+ }
+ });
+ });
+ };
+}
+exports["default"] = promisify;
+//# sourceMappingURL=promisify.js.map
+
+/***/ }),
+
+/***/ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/babel-core.js":
+/*!*****************************************************************************************************************!*\
+ !*** ../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/babel-core.js ***!
+ \*****************************************************************************************************************/
+/***/ ((module, exports, __webpack_require__) => {
+
+"use strict";
+;
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var tslib_1 = __webpack_require__(/*! tslib */ "../../../.yarn/berry/cache/tslib-npm-2.4.0-9cb6dc5030-9.zip/node_modules/tslib/tslib.es6.js");
+var types_1 = tslib_1.__importDefault(__webpack_require__(/*! ../lib/types */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/types.js"));
+var shared_1 = tslib_1.__importDefault(__webpack_require__(/*! ../lib/shared */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/shared.js"));
+var es7_1 = tslib_1.__importDefault(__webpack_require__(/*! ./es7 */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/es7.js"));
+function default_1(fork) {
+ fork.use(es7_1.default);
+ var types = fork.use(types_1.default);
+ var defaults = fork.use(shared_1.default).defaults;
+ var def = types.Type.def;
+ var or = types.Type.or;
+ def("Noop")
+ .bases("Statement")
+ .build();
+ def("DoExpression")
+ .bases("Expression")
+ .build("body")
+ .field("body", [def("Statement")]);
+ def("Super")
+ .bases("Expression")
+ .build();
+ def("BindExpression")
+ .bases("Expression")
+ .build("object", "callee")
+ .field("object", or(def("Expression"), null))
+ .field("callee", def("Expression"));
+ def("Decorator")
+ .bases("Node")
+ .build("expression")
+ .field("expression", def("Expression"));
+ def("Property")
+ .field("decorators", or([def("Decorator")], null), defaults["null"]);
+ def("MethodDefinition")
+ .field("decorators", or([def("Decorator")], null), defaults["null"]);
+ def("MetaProperty")
+ .bases("Expression")
+ .build("meta", "property")
+ .field("meta", def("Identifier"))
+ .field("property", def("Identifier"));
+ def("ParenthesizedExpression")
+ .bases("Expression")
+ .build("expression")
+ .field("expression", def("Expression"));
+ def("ImportSpecifier")
+ .bases("ModuleSpecifier")
+ .build("imported", "local")
+ .field("imported", def("Identifier"));
+ def("ImportDefaultSpecifier")
+ .bases("ModuleSpecifier")
+ .build("local");
+ def("ImportNamespaceSpecifier")
+ .bases("ModuleSpecifier")
+ .build("local");
+ def("ExportDefaultDeclaration")
+ .bases("Declaration")
+ .build("declaration")
+ .field("declaration", or(def("Declaration"), def("Expression")));
+ def("ExportNamedDeclaration")
+ .bases("Declaration")
+ .build("declaration", "specifiers", "source")
+ .field("declaration", or(def("Declaration"), null))
+ .field("specifiers", [def("ExportSpecifier")], defaults.emptyArray)
+ .field("source", or(def("Literal"), null), defaults["null"]);
+ def("ExportSpecifier")
+ .bases("ModuleSpecifier")
+ .build("local", "exported")
+ .field("exported", def("Identifier"));
+ def("ExportNamespaceSpecifier")
+ .bases("Specifier")
+ .build("exported")
+ .field("exported", def("Identifier"));
+ def("ExportDefaultSpecifier")
+ .bases("Specifier")
+ .build("exported")
+ .field("exported", def("Identifier"));
+ def("ExportAllDeclaration")
+ .bases("Declaration")
+ .build("exported", "source")
+ .field("exported", or(def("Identifier"), null))
+ .field("source", def("Literal"));
+ def("CommentBlock")
+ .bases("Comment")
+ .build("value", /*optional:*/ "leading", "trailing");
+ def("CommentLine")
+ .bases("Comment")
+ .build("value", /*optional:*/ "leading", "trailing");
+ def("Directive")
+ .bases("Node")
+ .build("value")
+ .field("value", def("DirectiveLiteral"));
+ def("DirectiveLiteral")
+ .bases("Node", "Expression")
+ .build("value")
+ .field("value", String, defaults["use strict"]);
+ def("InterpreterDirective")
+ .bases("Node")
+ .build("value")
+ .field("value", String);
+ def("BlockStatement")
+ .bases("Statement")
+ .build("body")
+ .field("body", [def("Statement")])
+ .field("directives", [def("Directive")], defaults.emptyArray);
+ def("Program")
+ .bases("Node")
+ .build("body")
+ .field("body", [def("Statement")])
+ .field("directives", [def("Directive")], defaults.emptyArray)
+ .field("interpreter", or(def("InterpreterDirective"), null), defaults["null"]);
+ // Split Literal
+ def("StringLiteral")
+ .bases("Literal")
+ .build("value")
+ .field("value", String);
+ def("NumericLiteral")
+ .bases("Literal")
+ .build("value")
+ .field("value", Number)
+ .field("raw", or(String, null), defaults["null"])
+ .field("extra", {
+ rawValue: Number,
+ raw: String
+ }, function getDefault() {
+ return {
+ rawValue: this.value,
+ raw: this.value + ""
+ };
+ });
+ def("BigIntLiteral")
+ .bases("Literal")
+ .build("value")
+ // Only String really seems appropriate here, since BigInt values
+ // often exceed the limits of JS numbers.
+ .field("value", or(String, Number))
+ .field("extra", {
+ rawValue: String,
+ raw: String
+ }, function getDefault() {
+ return {
+ rawValue: String(this.value),
+ raw: this.value + "n"
+ };
+ });
+ def("NullLiteral")
+ .bases("Literal")
+ .build()
+ .field("value", null, defaults["null"]);
+ def("BooleanLiteral")
+ .bases("Literal")
+ .build("value")
+ .field("value", Boolean);
+ def("RegExpLiteral")
+ .bases("Literal")
+ .build("pattern", "flags")
+ .field("pattern", String)
+ .field("flags", String)
+ .field("value", RegExp, function () {
+ return new RegExp(this.pattern, this.flags);
+ });
+ var ObjectExpressionProperty = or(def("Property"), def("ObjectMethod"), def("ObjectProperty"), def("SpreadProperty"), def("SpreadElement"));
+ // Split Property -> ObjectProperty and ObjectMethod
+ def("ObjectExpression")
+ .bases("Expression")
+ .build("properties")
+ .field("properties", [ObjectExpressionProperty]);
+ // ObjectMethod hoist .value properties to own properties
+ def("ObjectMethod")
+ .bases("Node", "Function")
+ .build("kind", "key", "params", "body", "computed")
+ .field("kind", or("method", "get", "set"))
+ .field("key", or(def("Literal"), def("Identifier"), def("Expression")))
+ .field("params", [def("Pattern")])
+ .field("body", def("BlockStatement"))
+ .field("computed", Boolean, defaults["false"])
+ .field("generator", Boolean, defaults["false"])
+ .field("async", Boolean, defaults["false"])
+ .field("accessibility", // TypeScript
+ or(def("Literal"), null), defaults["null"])
+ .field("decorators", or([def("Decorator")], null), defaults["null"]);
+ def("ObjectProperty")
+ .bases("Node")
+ .build("key", "value")
+ .field("key", or(def("Literal"), def("Identifier"), def("Expression")))
+ .field("value", or(def("Expression"), def("Pattern")))
+ .field("accessibility", // TypeScript
+ or(def("Literal"), null), defaults["null"])
+ .field("computed", Boolean, defaults["false"]);
+ var ClassBodyElement = or(def("MethodDefinition"), def("VariableDeclarator"), def("ClassPropertyDefinition"), def("ClassProperty"), def("ClassPrivateProperty"), def("ClassMethod"), def("ClassPrivateMethod"));
+ // MethodDefinition -> ClassMethod
+ def("ClassBody")
+ .bases("Declaration")
+ .build("body")
+ .field("body", [ClassBodyElement]);
+ def("ClassMethod")
+ .bases("Declaration", "Function")
+ .build("kind", "key", "params", "body", "computed", "static")
+ .field("key", or(def("Literal"), def("Identifier"), def("Expression")));
+ def("ClassPrivateMethod")
+ .bases("Declaration", "Function")
+ .build("key", "params", "body", "kind", "computed", "static")
+ .field("key", def("PrivateName"));
+ ["ClassMethod",
+ "ClassPrivateMethod",
+ ].forEach(function (typeName) {
+ def(typeName)
+ .field("kind", or("get", "set", "method", "constructor"), function () { return "method"; })
+ .field("body", def("BlockStatement"))
+ .field("computed", Boolean, defaults["false"])
+ .field("static", or(Boolean, null), defaults["null"])
+ .field("abstract", or(Boolean, null), defaults["null"])
+ .field("access", or("public", "private", "protected", null), defaults["null"])
+ .field("accessibility", or("public", "private", "protected", null), defaults["null"])
+ .field("decorators", or([def("Decorator")], null), defaults["null"])
+ .field("optional", or(Boolean, null), defaults["null"]);
+ });
+ def("ClassPrivateProperty")
+ .bases("ClassProperty")
+ .build("key", "value")
+ .field("key", def("PrivateName"))
+ .field("value", or(def("Expression"), null), defaults["null"]);
+ def("PrivateName")
+ .bases("Expression", "Pattern")
+ .build("id")
+ .field("id", def("Identifier"));
+ var ObjectPatternProperty = or(def("Property"), def("PropertyPattern"), def("SpreadPropertyPattern"), def("SpreadProperty"), // Used by Esprima
+ def("ObjectProperty"), // Babel 6
+ def("RestProperty") // Babel 6
+ );
+ // Split into RestProperty and SpreadProperty
+ def("ObjectPattern")
+ .bases("Pattern")
+ .build("properties")
+ .field("properties", [ObjectPatternProperty])
+ .field("decorators", or([def("Decorator")], null), defaults["null"]);
+ def("SpreadProperty")
+ .bases("Node")
+ .build("argument")
+ .field("argument", def("Expression"));
+ def("RestProperty")
+ .bases("Node")
+ .build("argument")
+ .field("argument", def("Expression"));
+ def("ForAwaitStatement")
+ .bases("Statement")
+ .build("left", "right", "body")
+ .field("left", or(def("VariableDeclaration"), def("Expression")))
+ .field("right", def("Expression"))
+ .field("body", def("Statement"));
+ // The callee node of a dynamic import(...) expression.
+ def("Import")
+ .bases("Expression")
+ .build();
+}
+exports["default"] = default_1;
+module.exports = exports["default"];
+
+
+/***/ }),
+
+/***/ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/babel.js":
+/*!************************************************************************************************************!*\
+ !*** ../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/babel.js ***!
+ \************************************************************************************************************/
+/***/ ((module, exports, __webpack_require__) => {
+
+"use strict";
+;
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var tslib_1 = __webpack_require__(/*! tslib */ "../../../.yarn/berry/cache/tslib-npm-2.4.0-9cb6dc5030-9.zip/node_modules/tslib/tslib.es6.js");
+var babel_core_1 = tslib_1.__importDefault(__webpack_require__(/*! ./babel-core */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/babel-core.js"));
+var flow_1 = tslib_1.__importDefault(__webpack_require__(/*! ./flow */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/flow.js"));
+function default_1(fork) {
+ fork.use(babel_core_1.default);
+ fork.use(flow_1.default);
+}
+exports["default"] = default_1;
+module.exports = exports["default"];
+
+
+/***/ }),
+
+/***/ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/core.js":
+/*!***********************************************************************************************************!*\
+ !*** ../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/core.js ***!
+ \***********************************************************************************************************/
+/***/ ((module, exports, __webpack_require__) => {
+
+"use strict";
+;
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var tslib_1 = __webpack_require__(/*! tslib */ "../../../.yarn/berry/cache/tslib-npm-2.4.0-9cb6dc5030-9.zip/node_modules/tslib/tslib.es6.js");
+var types_1 = tslib_1.__importDefault(__webpack_require__(/*! ../lib/types */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/types.js"));
+var shared_1 = tslib_1.__importDefault(__webpack_require__(/*! ../lib/shared */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/shared.js"));
+function default_1(fork) {
+ var types = fork.use(types_1.default);
+ var Type = types.Type;
+ var def = Type.def;
+ var or = Type.or;
+ var shared = fork.use(shared_1.default);
+ var defaults = shared.defaults;
+ var geq = shared.geq;
+ // Abstract supertype of all syntactic entities that are allowed to have a
+ // .loc field.
+ def("Printable")
+ .field("loc", or(def("SourceLocation"), null), defaults["null"], true);
+ def("Node")
+ .bases("Printable")
+ .field("type", String)
+ .field("comments", or([def("Comment")], null), defaults["null"], true);
+ def("SourceLocation")
+ .field("start", def("Position"))
+ .field("end", def("Position"))
+ .field("source", or(String, null), defaults["null"]);
+ def("Position")
+ .field("line", geq(1))
+ .field("column", geq(0));
+ def("File")
+ .bases("Node")
+ .build("program", "name")
+ .field("program", def("Program"))
+ .field("name", or(String, null), defaults["null"]);
+ def("Program")
+ .bases("Node")
+ .build("body")
+ .field("body", [def("Statement")]);
+ def("Function")
+ .bases("Node")
+ .field("id", or(def("Identifier"), null), defaults["null"])
+ .field("params", [def("Pattern")])
+ .field("body", def("BlockStatement"))
+ .field("generator", Boolean, defaults["false"])
+ .field("async", Boolean, defaults["false"]);
+ def("Statement").bases("Node");
+ // The empty .build() here means that an EmptyStatement can be constructed
+ // (i.e. it's not abstract) but that it needs no arguments.
+ def("EmptyStatement").bases("Statement").build();
+ def("BlockStatement")
+ .bases("Statement")
+ .build("body")
+ .field("body", [def("Statement")]);
+ // TODO Figure out how to silently coerce Expressions to
+ // ExpressionStatements where a Statement was expected.
+ def("ExpressionStatement")
+ .bases("Statement")
+ .build("expression")
+ .field("expression", def("Expression"));
+ def("IfStatement")
+ .bases("Statement")
+ .build("test", "consequent", "alternate")
+ .field("test", def("Expression"))
+ .field("consequent", def("Statement"))
+ .field("alternate", or(def("Statement"), null), defaults["null"]);
+ def("LabeledStatement")
+ .bases("Statement")
+ .build("label", "body")
+ .field("label", def("Identifier"))
+ .field("body", def("Statement"));
+ def("BreakStatement")
+ .bases("Statement")
+ .build("label")
+ .field("label", or(def("Identifier"), null), defaults["null"]);
+ def("ContinueStatement")
+ .bases("Statement")
+ .build("label")
+ .field("label", or(def("Identifier"), null), defaults["null"]);
+ def("WithStatement")
+ .bases("Statement")
+ .build("object", "body")
+ .field("object", def("Expression"))
+ .field("body", def("Statement"));
+ def("SwitchStatement")
+ .bases("Statement")
+ .build("discriminant", "cases", "lexical")
+ .field("discriminant", def("Expression"))
+ .field("cases", [def("SwitchCase")])
+ .field("lexical", Boolean, defaults["false"]);
+ def("ReturnStatement")
+ .bases("Statement")
+ .build("argument")
+ .field("argument", or(def("Expression"), null));
+ def("ThrowStatement")
+ .bases("Statement")
+ .build("argument")
+ .field("argument", def("Expression"));
+ def("TryStatement")
+ .bases("Statement")
+ .build("block", "handler", "finalizer")
+ .field("block", def("BlockStatement"))
+ .field("handler", or(def("CatchClause"), null), function () {
+ return this.handlers && this.handlers[0] || null;
+ })
+ .field("handlers", [def("CatchClause")], function () {
+ return this.handler ? [this.handler] : [];
+ }, true) // Indicates this field is hidden from eachField iteration.
+ .field("guardedHandlers", [def("CatchClause")], defaults.emptyArray)
+ .field("finalizer", or(def("BlockStatement"), null), defaults["null"]);
+ def("CatchClause")
+ .bases("Node")
+ .build("param", "guard", "body")
+ // https://github.com/tc39/proposal-optional-catch-binding
+ .field("param", or(def("Pattern"), null), defaults["null"])
+ .field("guard", or(def("Expression"), null), defaults["null"])
+ .field("body", def("BlockStatement"));
+ def("WhileStatement")
+ .bases("Statement")
+ .build("test", "body")
+ .field("test", def("Expression"))
+ .field("body", def("Statement"));
+ def("DoWhileStatement")
+ .bases("Statement")
+ .build("body", "test")
+ .field("body", def("Statement"))
+ .field("test", def("Expression"));
+ def("ForStatement")
+ .bases("Statement")
+ .build("init", "test", "update", "body")
+ .field("init", or(def("VariableDeclaration"), def("Expression"), null))
+ .field("test", or(def("Expression"), null))
+ .field("update", or(def("Expression"), null))
+ .field("body", def("Statement"));
+ def("ForInStatement")
+ .bases("Statement")
+ .build("left", "right", "body")
+ .field("left", or(def("VariableDeclaration"), def("Expression")))
+ .field("right", def("Expression"))
+ .field("body", def("Statement"));
+ def("DebuggerStatement").bases("Statement").build();
+ def("Declaration").bases("Statement");
+ def("FunctionDeclaration")
+ .bases("Function", "Declaration")
+ .build("id", "params", "body")
+ .field("id", def("Identifier"));
+ def("FunctionExpression")
+ .bases("Function", "Expression")
+ .build("id", "params", "body");
+ def("VariableDeclaration")
+ .bases("Declaration")
+ .build("kind", "declarations")
+ .field("kind", or("var", "let", "const"))
+ .field("declarations", [def("VariableDeclarator")]);
+ def("VariableDeclarator")
+ .bases("Node")
+ .build("id", "init")
+ .field("id", def("Pattern"))
+ .field("init", or(def("Expression"), null), defaults["null"]);
+ def("Expression").bases("Node");
+ def("ThisExpression").bases("Expression").build();
+ def("ArrayExpression")
+ .bases("Expression")
+ .build("elements")
+ .field("elements", [or(def("Expression"), null)]);
+ def("ObjectExpression")
+ .bases("Expression")
+ .build("properties")
+ .field("properties", [def("Property")]);
+ // TODO Not in the Mozilla Parser API, but used by Esprima.
+ def("Property")
+ .bases("Node") // Want to be able to visit Property Nodes.
+ .build("kind", "key", "value")
+ .field("kind", or("init", "get", "set"))
+ .field("key", or(def("Literal"), def("Identifier")))
+ .field("value", def("Expression"));
+ def("SequenceExpression")
+ .bases("Expression")
+ .build("expressions")
+ .field("expressions", [def("Expression")]);
+ var UnaryOperator = or("-", "+", "!", "~", "typeof", "void", "delete");
+ def("UnaryExpression")
+ .bases("Expression")
+ .build("operator", "argument", "prefix")
+ .field("operator", UnaryOperator)
+ .field("argument", def("Expression"))
+ // Esprima doesn't bother with this field, presumably because it's
+ // always true for unary operators.
+ .field("prefix", Boolean, defaults["true"]);
+ var BinaryOperator = or("==", "!=", "===", "!==", "<", "<=", ">", ">=", "<<", ">>", ">>>", "+", "-", "*", "/", "%", "**", "&", // TODO Missing from the Parser API.
+ "|", "^", "in", "instanceof");
+ def("BinaryExpression")
+ .bases("Expression")
+ .build("operator", "left", "right")
+ .field("operator", BinaryOperator)
+ .field("left", def("Expression"))
+ .field("right", def("Expression"));
+ var AssignmentOperator = or("=", "+=", "-=", "*=", "/=", "%=", "<<=", ">>=", ">>>=", "|=", "^=", "&=");
+ def("AssignmentExpression")
+ .bases("Expression")
+ .build("operator", "left", "right")
+ .field("operator", AssignmentOperator)
+ .field("left", or(def("Pattern"), def("MemberExpression")))
+ .field("right", def("Expression"));
+ var UpdateOperator = or("++", "--");
+ def("UpdateExpression")
+ .bases("Expression")
+ .build("operator", "argument", "prefix")
+ .field("operator", UpdateOperator)
+ .field("argument", def("Expression"))
+ .field("prefix", Boolean);
+ var LogicalOperator = or("||", "&&");
+ def("LogicalExpression")
+ .bases("Expression")
+ .build("operator", "left", "right")
+ .field("operator", LogicalOperator)
+ .field("left", def("Expression"))
+ .field("right", def("Expression"));
+ def("ConditionalExpression")
+ .bases("Expression")
+ .build("test", "consequent", "alternate")
+ .field("test", def("Expression"))
+ .field("consequent", def("Expression"))
+ .field("alternate", def("Expression"));
+ def("NewExpression")
+ .bases("Expression")
+ .build("callee", "arguments")
+ .field("callee", def("Expression"))
+ // The Mozilla Parser API gives this type as [or(def("Expression"),
+ // null)], but null values don't really make sense at the call site.
+ // TODO Report this nonsense.
+ .field("arguments", [def("Expression")]);
+ def("CallExpression")
+ .bases("Expression")
+ .build("callee", "arguments")
+ .field("callee", def("Expression"))
+ // See comment for NewExpression above.
+ .field("arguments", [def("Expression")]);
+ def("MemberExpression")
+ .bases("Expression")
+ .build("object", "property", "computed")
+ .field("object", def("Expression"))
+ .field("property", or(def("Identifier"), def("Expression")))
+ .field("computed", Boolean, function () {
+ var type = this.property.type;
+ if (type === 'Literal' ||
+ type === 'MemberExpression' ||
+ type === 'BinaryExpression') {
+ return true;
+ }
+ return false;
+ });
+ def("Pattern").bases("Node");
+ def("SwitchCase")
+ .bases("Node")
+ .build("test", "consequent")
+ .field("test", or(def("Expression"), null))
+ .field("consequent", [def("Statement")]);
+ def("Identifier")
+ .bases("Expression", "Pattern")
+ .build("name")
+ .field("name", String)
+ .field("optional", Boolean, defaults["false"]);
+ def("Literal")
+ .bases("Expression")
+ .build("value")
+ .field("value", or(String, Boolean, null, Number, RegExp))
+ .field("regex", or({
+ pattern: String,
+ flags: String
+ }, null), function () {
+ if (this.value instanceof RegExp) {
+ var flags = "";
+ if (this.value.ignoreCase)
+ flags += "i";
+ if (this.value.multiline)
+ flags += "m";
+ if (this.value.global)
+ flags += "g";
+ return {
+ pattern: this.value.source,
+ flags: flags
+ };
+ }
+ return null;
+ });
+ // Abstract (non-buildable) comment supertype. Not a Node.
+ def("Comment")
+ .bases("Printable")
+ .field("value", String)
+ // A .leading comment comes before the node, whereas a .trailing
+ // comment comes after it. These two fields should not both be true,
+ // but they might both be false when the comment falls inside a node
+ // and the node has no children for the comment to lead or trail,
+ // e.g. { /*dangling*/ }.
+ .field("leading", Boolean, defaults["true"])
+ .field("trailing", Boolean, defaults["false"]);
+}
+exports["default"] = default_1;
+module.exports = exports["default"];
+
+
+/***/ }),
+
+/***/ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/es-proposals.js":
+/*!*******************************************************************************************************************!*\
+ !*** ../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/es-proposals.js ***!
+ \*******************************************************************************************************************/
+/***/ ((module, exports, __webpack_require__) => {
+
+"use strict";
+;
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var tslib_1 = __webpack_require__(/*! tslib */ "../../../.yarn/berry/cache/tslib-npm-2.4.0-9cb6dc5030-9.zip/node_modules/tslib/tslib.es6.js");
+var types_1 = tslib_1.__importDefault(__webpack_require__(/*! ../lib/types */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/types.js"));
+var shared_1 = tslib_1.__importDefault(__webpack_require__(/*! ../lib/shared */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/shared.js"));
+var core_1 = tslib_1.__importDefault(__webpack_require__(/*! ./core */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/core.js"));
+function default_1(fork) {
+ fork.use(core_1.default);
+ var types = fork.use(types_1.default);
+ var Type = types.Type;
+ var def = types.Type.def;
+ var or = Type.or;
+ var shared = fork.use(shared_1.default);
+ var defaults = shared.defaults;
+ // https://github.com/tc39/proposal-optional-chaining
+ // `a?.b` as per https://github.com/estree/estree/issues/146
+ def("OptionalMemberExpression")
+ .bases("MemberExpression")
+ .build("object", "property", "computed", "optional")
+ .field("optional", Boolean, defaults["true"]);
+ // a?.b()
+ def("OptionalCallExpression")
+ .bases("CallExpression")
+ .build("callee", "arguments", "optional")
+ .field("optional", Boolean, defaults["true"]);
+ // https://github.com/tc39/proposal-nullish-coalescing
+ // `a ?? b` as per https://github.com/babel/babylon/pull/761/files
+ var LogicalOperator = or("||", "&&", "??");
+ def("LogicalExpression")
+ .field("operator", LogicalOperator);
+}
+exports["default"] = default_1;
+module.exports = exports["default"];
+
+
+/***/ }),
+
+/***/ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/es2020.js":
+/*!*************************************************************************************************************!*\
+ !*** ../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/es2020.js ***!
+ \*************************************************************************************************************/
+/***/ ((module, exports, __webpack_require__) => {
+
+"use strict";
+;
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var tslib_1 = __webpack_require__(/*! tslib */ "../../../.yarn/berry/cache/tslib-npm-2.4.0-9cb6dc5030-9.zip/node_modules/tslib/tslib.es6.js");
+var es7_1 = tslib_1.__importDefault(__webpack_require__(/*! ./es7 */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/es7.js"));
+var types_1 = tslib_1.__importDefault(__webpack_require__(/*! ../lib/types */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/types.js"));
+function default_1(fork) {
+ fork.use(es7_1.default);
+ var types = fork.use(types_1.default);
+ var def = types.Type.def;
+ def("ImportExpression")
+ .bases("Expression")
+ .build("source")
+ .field("source", def("Expression"));
+}
+exports["default"] = default_1;
+module.exports = exports["default"];
+
+
+/***/ }),
+
+/***/ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/es6.js":
+/*!**********************************************************************************************************!*\
+ !*** ../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/es6.js ***!
+ \**********************************************************************************************************/
+/***/ ((module, exports, __webpack_require__) => {
+
+"use strict";
+;
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var tslib_1 = __webpack_require__(/*! tslib */ "../../../.yarn/berry/cache/tslib-npm-2.4.0-9cb6dc5030-9.zip/node_modules/tslib/tslib.es6.js");
+var core_1 = tslib_1.__importDefault(__webpack_require__(/*! ./core */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/core.js"));
+var types_1 = tslib_1.__importDefault(__webpack_require__(/*! ../lib/types */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/types.js"));
+var shared_1 = tslib_1.__importDefault(__webpack_require__(/*! ../lib/shared */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/shared.js"));
+function default_1(fork) {
+ fork.use(core_1.default);
+ var types = fork.use(types_1.default);
+ var def = types.Type.def;
+ var or = types.Type.or;
+ var defaults = fork.use(shared_1.default).defaults;
+ def("Function")
+ .field("generator", Boolean, defaults["false"])
+ .field("expression", Boolean, defaults["false"])
+ .field("defaults", [or(def("Expression"), null)], defaults.emptyArray)
+ // TODO This could be represented as a RestElement in .params.
+ .field("rest", or(def("Identifier"), null), defaults["null"]);
+ // The ESTree way of representing a ...rest parameter.
+ def("RestElement")
+ .bases("Pattern")
+ .build("argument")
+ .field("argument", def("Pattern"))
+ .field("typeAnnotation", // for Babylon. Flow parser puts it on the identifier
+ or(def("TypeAnnotation"), def("TSTypeAnnotation"), null), defaults["null"]);
+ def("SpreadElementPattern")
+ .bases("Pattern")
+ .build("argument")
+ .field("argument", def("Pattern"));
+ def("FunctionDeclaration")
+ .build("id", "params", "body", "generator", "expression");
+ def("FunctionExpression")
+ .build("id", "params", "body", "generator", "expression");
+ // The Parser API calls this ArrowExpression, but Esprima and all other
+ // actual parsers use ArrowFunctionExpression.
+ def("ArrowFunctionExpression")
+ .bases("Function", "Expression")
+ .build("params", "body", "expression")
+ // The forced null value here is compatible with the overridden
+ // definition of the "id" field in the Function interface.
+ .field("id", null, defaults["null"])
+ // Arrow function bodies are allowed to be expressions.
+ .field("body", or(def("BlockStatement"), def("Expression")))
+ // The current spec forbids arrow generators, so I have taken the
+ // liberty of enforcing that. TODO Report this.
+ .field("generator", false, defaults["false"]);
+ def("ForOfStatement")
+ .bases("Statement")
+ .build("left", "right", "body")
+ .field("left", or(def("VariableDeclaration"), def("Pattern")))
+ .field("right", def("Expression"))
+ .field("body", def("Statement"));
+ def("YieldExpression")
+ .bases("Expression")
+ .build("argument", "delegate")
+ .field("argument", or(def("Expression"), null))
+ .field("delegate", Boolean, defaults["false"]);
+ def("GeneratorExpression")
+ .bases("Expression")
+ .build("body", "blocks", "filter")
+ .field("body", def("Expression"))
+ .field("blocks", [def("ComprehensionBlock")])
+ .field("filter", or(def("Expression"), null));
+ def("ComprehensionExpression")
+ .bases("Expression")
+ .build("body", "blocks", "filter")
+ .field("body", def("Expression"))
+ .field("blocks", [def("ComprehensionBlock")])
+ .field("filter", or(def("Expression"), null));
+ def("ComprehensionBlock")
+ .bases("Node")
+ .build("left", "right", "each")
+ .field("left", def("Pattern"))
+ .field("right", def("Expression"))
+ .field("each", Boolean);
+ def("Property")
+ .field("key", or(def("Literal"), def("Identifier"), def("Expression")))
+ .field("value", or(def("Expression"), def("Pattern")))
+ .field("method", Boolean, defaults["false"])
+ .field("shorthand", Boolean, defaults["false"])
+ .field("computed", Boolean, defaults["false"]);
+ def("ObjectProperty")
+ .field("shorthand", Boolean, defaults["false"]);
+ def("PropertyPattern")
+ .bases("Pattern")
+ .build("key", "pattern")
+ .field("key", or(def("Literal"), def("Identifier"), def("Expression")))
+ .field("pattern", def("Pattern"))
+ .field("computed", Boolean, defaults["false"]);
+ def("ObjectPattern")
+ .bases("Pattern")
+ .build("properties")
+ .field("properties", [or(def("PropertyPattern"), def("Property"))]);
+ def("ArrayPattern")
+ .bases("Pattern")
+ .build("elements")
+ .field("elements", [or(def("Pattern"), null)]);
+ def("MethodDefinition")
+ .bases("Declaration")
+ .build("kind", "key", "value", "static")
+ .field("kind", or("constructor", "method", "get", "set"))
+ .field("key", def("Expression"))
+ .field("value", def("Function"))
+ .field("computed", Boolean, defaults["false"])
+ .field("static", Boolean, defaults["false"]);
+ def("SpreadElement")
+ .bases("Node")
+ .build("argument")
+ .field("argument", def("Expression"));
+ def("ArrayExpression")
+ .field("elements", [or(def("Expression"), def("SpreadElement"), def("RestElement"), null)]);
+ def("NewExpression")
+ .field("arguments", [or(def("Expression"), def("SpreadElement"))]);
+ def("CallExpression")
+ .field("arguments", [or(def("Expression"), def("SpreadElement"))]);
+ // Note: this node type is *not* an AssignmentExpression with a Pattern on
+ // the left-hand side! The existing AssignmentExpression type already
+ // supports destructuring assignments. AssignmentPattern nodes may appear
+ // wherever a Pattern is allowed, and the right-hand side represents a
+ // default value to be destructured against the left-hand side, if no
+ // value is otherwise provided. For example: default parameter values.
+ def("AssignmentPattern")
+ .bases("Pattern")
+ .build("left", "right")
+ .field("left", def("Pattern"))
+ .field("right", def("Expression"));
+ var ClassBodyElement = or(def("MethodDefinition"), def("VariableDeclarator"), def("ClassPropertyDefinition"), def("ClassProperty"));
+ def("ClassProperty")
+ .bases("Declaration")
+ .build("key")
+ .field("key", or(def("Literal"), def("Identifier"), def("Expression")))
+ .field("computed", Boolean, defaults["false"]);
+ def("ClassPropertyDefinition") // static property
+ .bases("Declaration")
+ .build("definition")
+ // Yes, Virginia, circular definitions are permitted.
+ .field("definition", ClassBodyElement);
+ def("ClassBody")
+ .bases("Declaration")
+ .build("body")
+ .field("body", [ClassBodyElement]);
+ def("ClassDeclaration")
+ .bases("Declaration")
+ .build("id", "body", "superClass")
+ .field("id", or(def("Identifier"), null))
+ .field("body", def("ClassBody"))
+ .field("superClass", or(def("Expression"), null), defaults["null"]);
+ def("ClassExpression")
+ .bases("Expression")
+ .build("id", "body", "superClass")
+ .field("id", or(def("Identifier"), null), defaults["null"])
+ .field("body", def("ClassBody"))
+ .field("superClass", or(def("Expression"), null), defaults["null"]);
+ // Specifier and ModuleSpecifier are abstract non-standard types
+ // introduced for definitional convenience.
+ def("Specifier").bases("Node");
+ // This supertype is shared/abused by both def/babel.js and
+ // def/esprima.js. In the future, it will be possible to load only one set
+ // of definitions appropriate for a given parser, but until then we must
+ // rely on default functions to reconcile the conflicting AST formats.
+ def("ModuleSpecifier")
+ .bases("Specifier")
+ // This local field is used by Babel/Acorn. It should not technically
+ // be optional in the Babel/Acorn AST format, but it must be optional
+ // in the Esprima AST format.
+ .field("local", or(def("Identifier"), null), defaults["null"])
+ // The id and name fields are used by Esprima. The id field should not
+ // technically be optional in the Esprima AST format, but it must be
+ // optional in the Babel/Acorn AST format.
+ .field("id", or(def("Identifier"), null), defaults["null"])
+ .field("name", or(def("Identifier"), null), defaults["null"]);
+ // Like ModuleSpecifier, except type:"ImportSpecifier" and buildable.
+ // import {} from ...;
+ def("ImportSpecifier")
+ .bases("ModuleSpecifier")
+ .build("id", "name");
+ // import <* as id> from ...;
+ def("ImportNamespaceSpecifier")
+ .bases("ModuleSpecifier")
+ .build("id");
+ // import from ...;
+ def("ImportDefaultSpecifier")
+ .bases("ModuleSpecifier")
+ .build("id");
+ def("ImportDeclaration")
+ .bases("Declaration")
+ .build("specifiers", "source", "importKind")
+ .field("specifiers", [or(def("ImportSpecifier"), def("ImportNamespaceSpecifier"), def("ImportDefaultSpecifier"))], defaults.emptyArray)
+ .field("source", def("Literal"))
+ .field("importKind", or("value", "type"), function () {
+ return "value";
+ });
+ def("TaggedTemplateExpression")
+ .bases("Expression")
+ .build("tag", "quasi")
+ .field("tag", def("Expression"))
+ .field("quasi", def("TemplateLiteral"));
+ def("TemplateLiteral")
+ .bases("Expression")
+ .build("quasis", "expressions")
+ .field("quasis", [def("TemplateElement")])
+ .field("expressions", [def("Expression")]);
+ def("TemplateElement")
+ .bases("Node")
+ .build("value", "tail")
+ .field("value", { "cooked": String, "raw": String })
+ .field("tail", Boolean);
+}
+exports["default"] = default_1;
+module.exports = exports["default"];
+
+
+/***/ }),
+
+/***/ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/es7.js":
+/*!**********************************************************************************************************!*\
+ !*** ../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/es7.js ***!
+ \**********************************************************************************************************/
+/***/ ((module, exports, __webpack_require__) => {
+
+"use strict";
+;
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var tslib_1 = __webpack_require__(/*! tslib */ "../../../.yarn/berry/cache/tslib-npm-2.4.0-9cb6dc5030-9.zip/node_modules/tslib/tslib.es6.js");
+var es6_1 = tslib_1.__importDefault(__webpack_require__(/*! ./es6 */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/es6.js"));
+var types_1 = tslib_1.__importDefault(__webpack_require__(/*! ../lib/types */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/types.js"));
+var shared_1 = tslib_1.__importDefault(__webpack_require__(/*! ../lib/shared */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/shared.js"));
+function default_1(fork) {
+ fork.use(es6_1.default);
+ var types = fork.use(types_1.default);
+ var def = types.Type.def;
+ var or = types.Type.or;
+ var defaults = fork.use(shared_1.default).defaults;
+ def("Function")
+ .field("async", Boolean, defaults["false"]);
+ def("SpreadProperty")
+ .bases("Node")
+ .build("argument")
+ .field("argument", def("Expression"));
+ def("ObjectExpression")
+ .field("properties", [or(def("Property"), def("SpreadProperty"), def("SpreadElement"))]);
+ def("SpreadPropertyPattern")
+ .bases("Pattern")
+ .build("argument")
+ .field("argument", def("Pattern"));
+ def("ObjectPattern")
+ .field("properties", [or(def("Property"), def("PropertyPattern"), def("SpreadPropertyPattern"))]);
+ def("AwaitExpression")
+ .bases("Expression")
+ .build("argument", "all")
+ .field("argument", or(def("Expression"), null))
+ .field("all", Boolean, defaults["false"]);
+}
+exports["default"] = default_1;
+module.exports = exports["default"];
+
+
+/***/ }),
+
+/***/ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/esprima.js":
+/*!**************************************************************************************************************!*\
+ !*** ../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/esprima.js ***!
+ \**************************************************************************************************************/
+/***/ ((module, exports, __webpack_require__) => {
+
+"use strict";
+;
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var tslib_1 = __webpack_require__(/*! tslib */ "../../../.yarn/berry/cache/tslib-npm-2.4.0-9cb6dc5030-9.zip/node_modules/tslib/tslib.es6.js");
+var es7_1 = tslib_1.__importDefault(__webpack_require__(/*! ./es7 */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/es7.js"));
+var types_1 = tslib_1.__importDefault(__webpack_require__(/*! ../lib/types */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/types.js"));
+var shared_1 = tslib_1.__importDefault(__webpack_require__(/*! ../lib/shared */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/shared.js"));
+function default_1(fork) {
+ fork.use(es7_1.default);
+ var types = fork.use(types_1.default);
+ var defaults = fork.use(shared_1.default).defaults;
+ var def = types.Type.def;
+ var or = types.Type.or;
+ def("VariableDeclaration")
+ .field("declarations", [or(def("VariableDeclarator"), def("Identifier") // Esprima deviation.
+ )]);
+ def("Property")
+ .field("value", or(def("Expression"), def("Pattern") // Esprima deviation.
+ ));
+ def("ArrayPattern")
+ .field("elements", [or(def("Pattern"), def("SpreadElement"), null)]);
+ def("ObjectPattern")
+ .field("properties", [or(def("Property"), def("PropertyPattern"), def("SpreadPropertyPattern"), def("SpreadProperty") // Used by Esprima.
+ )]);
+ // Like ModuleSpecifier, except type:"ExportSpecifier" and buildable.
+ // export {} [from ...];
+ def("ExportSpecifier")
+ .bases("ModuleSpecifier")
+ .build("id", "name");
+ // export <*> from ...;
+ def("ExportBatchSpecifier")
+ .bases("Specifier")
+ .build();
+ def("ExportDeclaration")
+ .bases("Declaration")
+ .build("default", "declaration", "specifiers", "source")
+ .field("default", Boolean)
+ .field("declaration", or(def("Declaration"), def("Expression"), // Implies default.
+ null))
+ .field("specifiers", [or(def("ExportSpecifier"), def("ExportBatchSpecifier"))], defaults.emptyArray)
+ .field("source", or(def("Literal"), null), defaults["null"]);
+ def("Block")
+ .bases("Comment")
+ .build("value", /*optional:*/ "leading", "trailing");
+ def("Line")
+ .bases("Comment")
+ .build("value", /*optional:*/ "leading", "trailing");
+}
+exports["default"] = default_1;
+module.exports = exports["default"];
+
+
+/***/ }),
+
+/***/ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/flow.js":
+/*!***********************************************************************************************************!*\
+ !*** ../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/flow.js ***!
+ \***********************************************************************************************************/
+/***/ ((module, exports, __webpack_require__) => {
+
+"use strict";
+;
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var tslib_1 = __webpack_require__(/*! tslib */ "../../../.yarn/berry/cache/tslib-npm-2.4.0-9cb6dc5030-9.zip/node_modules/tslib/tslib.es6.js");
+var es7_1 = tslib_1.__importDefault(__webpack_require__(/*! ./es7 */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/es7.js"));
+var type_annotations_1 = tslib_1.__importDefault(__webpack_require__(/*! ./type-annotations */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/type-annotations.js"));
+var types_1 = tslib_1.__importDefault(__webpack_require__(/*! ../lib/types */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/types.js"));
+var shared_1 = tslib_1.__importDefault(__webpack_require__(/*! ../lib/shared */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/shared.js"));
+function default_1(fork) {
+ fork.use(es7_1.default);
+ fork.use(type_annotations_1.default);
+ var types = fork.use(types_1.default);
+ var def = types.Type.def;
+ var or = types.Type.or;
+ var defaults = fork.use(shared_1.default).defaults;
+ // Base types
+ def("Flow").bases("Node");
+ def("FlowType").bases("Flow");
+ // Type annotations
+ def("AnyTypeAnnotation")
+ .bases("FlowType")
+ .build();
+ def("EmptyTypeAnnotation")
+ .bases("FlowType")
+ .build();
+ def("MixedTypeAnnotation")
+ .bases("FlowType")
+ .build();
+ def("VoidTypeAnnotation")
+ .bases("FlowType")
+ .build();
+ def("NumberTypeAnnotation")
+ .bases("FlowType")
+ .build();
+ def("NumberLiteralTypeAnnotation")
+ .bases("FlowType")
+ .build("value", "raw")
+ .field("value", Number)
+ .field("raw", String);
+ // Babylon 6 differs in AST from Flow
+ // same as NumberLiteralTypeAnnotation
+ def("NumericLiteralTypeAnnotation")
+ .bases("FlowType")
+ .build("value", "raw")
+ .field("value", Number)
+ .field("raw", String);
+ def("StringTypeAnnotation")
+ .bases("FlowType")
+ .build();
+ def("StringLiteralTypeAnnotation")
+ .bases("FlowType")
+ .build("value", "raw")
+ .field("value", String)
+ .field("raw", String);
+ def("BooleanTypeAnnotation")
+ .bases("FlowType")
+ .build();
+ def("BooleanLiteralTypeAnnotation")
+ .bases("FlowType")
+ .build("value", "raw")
+ .field("value", Boolean)
+ .field("raw", String);
+ def("TypeAnnotation")
+ .bases("Node")
+ .build("typeAnnotation")
+ .field("typeAnnotation", def("FlowType"));
+ def("NullableTypeAnnotation")
+ .bases("FlowType")
+ .build("typeAnnotation")
+ .field("typeAnnotation", def("FlowType"));
+ def("NullLiteralTypeAnnotation")
+ .bases("FlowType")
+ .build();
+ def("NullTypeAnnotation")
+ .bases("FlowType")
+ .build();
+ def("ThisTypeAnnotation")
+ .bases("FlowType")
+ .build();
+ def("ExistsTypeAnnotation")
+ .bases("FlowType")
+ .build();
+ def("ExistentialTypeParam")
+ .bases("FlowType")
+ .build();
+ def("FunctionTypeAnnotation")
+ .bases("FlowType")
+ .build("params", "returnType", "rest", "typeParameters")
+ .field("params", [def("FunctionTypeParam")])
+ .field("returnType", def("FlowType"))
+ .field("rest", or(def("FunctionTypeParam"), null))
+ .field("typeParameters", or(def("TypeParameterDeclaration"), null));
+ def("FunctionTypeParam")
+ .bases("Node")
+ .build("name", "typeAnnotation", "optional")
+ .field("name", def("Identifier"))
+ .field("typeAnnotation", def("FlowType"))
+ .field("optional", Boolean);
+ def("ArrayTypeAnnotation")
+ .bases("FlowType")
+ .build("elementType")
+ .field("elementType", def("FlowType"));
+ def("ObjectTypeAnnotation")
+ .bases("FlowType")
+ .build("properties", "indexers", "callProperties")
+ .field("properties", [
+ or(def("ObjectTypeProperty"), def("ObjectTypeSpreadProperty"))
+ ])
+ .field("indexers", [def("ObjectTypeIndexer")], defaults.emptyArray)
+ .field("callProperties", [def("ObjectTypeCallProperty")], defaults.emptyArray)
+ .field("inexact", or(Boolean, void 0), defaults["undefined"])
+ .field("exact", Boolean, defaults["false"])
+ .field("internalSlots", [def("ObjectTypeInternalSlot")], defaults.emptyArray);
+ def("Variance")
+ .bases("Node")
+ .build("kind")
+ .field("kind", or("plus", "minus"));
+ var LegacyVariance = or(def("Variance"), "plus", "minus", null);
+ def("ObjectTypeProperty")
+ .bases("Node")
+ .build("key", "value", "optional")
+ .field("key", or(def("Literal"), def("Identifier")))
+ .field("value", def("FlowType"))
+ .field("optional", Boolean)
+ .field("variance", LegacyVariance, defaults["null"]);
+ def("ObjectTypeIndexer")
+ .bases("Node")
+ .build("id", "key", "value")
+ .field("id", def("Identifier"))
+ .field("key", def("FlowType"))
+ .field("value", def("FlowType"))
+ .field("variance", LegacyVariance, defaults["null"]);
+ def("ObjectTypeCallProperty")
+ .bases("Node")
+ .build("value")
+ .field("value", def("FunctionTypeAnnotation"))
+ .field("static", Boolean, defaults["false"]);
+ def("QualifiedTypeIdentifier")
+ .bases("Node")
+ .build("qualification", "id")
+ .field("qualification", or(def("Identifier"), def("QualifiedTypeIdentifier")))
+ .field("id", def("Identifier"));
+ def("GenericTypeAnnotation")
+ .bases("FlowType")
+ .build("id", "typeParameters")
+ .field("id", or(def("Identifier"), def("QualifiedTypeIdentifier")))
+ .field("typeParameters", or(def("TypeParameterInstantiation"), null));
+ def("MemberTypeAnnotation")
+ .bases("FlowType")
+ .build("object", "property")
+ .field("object", def("Identifier"))
+ .field("property", or(def("MemberTypeAnnotation"), def("GenericTypeAnnotation")));
+ def("UnionTypeAnnotation")
+ .bases("FlowType")
+ .build("types")
+ .field("types", [def("FlowType")]);
+ def("IntersectionTypeAnnotation")
+ .bases("FlowType")
+ .build("types")
+ .field("types", [def("FlowType")]);
+ def("TypeofTypeAnnotation")
+ .bases("FlowType")
+ .build("argument")
+ .field("argument", def("FlowType"));
+ def("ObjectTypeSpreadProperty")
+ .bases("Node")
+ .build("argument")
+ .field("argument", def("FlowType"));
+ def("ObjectTypeInternalSlot")
+ .bases("Node")
+ .build("id", "value", "optional", "static", "method")
+ .field("id", def("Identifier"))
+ .field("value", def("FlowType"))
+ .field("optional", Boolean)
+ .field("static", Boolean)
+ .field("method", Boolean);
+ def("TypeParameterDeclaration")
+ .bases("Node")
+ .build("params")
+ .field("params", [def("TypeParameter")]);
+ def("TypeParameterInstantiation")
+ .bases("Node")
+ .build("params")
+ .field("params", [def("FlowType")]);
+ def("TypeParameter")
+ .bases("FlowType")
+ .build("name", "variance", "bound")
+ .field("name", String)
+ .field("variance", LegacyVariance, defaults["null"])
+ .field("bound", or(def("TypeAnnotation"), null), defaults["null"]);
+ def("ClassProperty")
+ .field("variance", LegacyVariance, defaults["null"]);
+ def("ClassImplements")
+ .bases("Node")
+ .build("id")
+ .field("id", def("Identifier"))
+ .field("superClass", or(def("Expression"), null), defaults["null"])
+ .field("typeParameters", or(def("TypeParameterInstantiation"), null), defaults["null"]);
+ def("InterfaceTypeAnnotation")
+ .bases("FlowType")
+ .build("body", "extends")
+ .field("body", def("ObjectTypeAnnotation"))
+ .field("extends", or([def("InterfaceExtends")], null), defaults["null"]);
+ def("InterfaceDeclaration")
+ .bases("Declaration")
+ .build("id", "body", "extends")
+ .field("id", def("Identifier"))
+ .field("typeParameters", or(def("TypeParameterDeclaration"), null), defaults["null"])
+ .field("body", def("ObjectTypeAnnotation"))
+ .field("extends", [def("InterfaceExtends")]);
+ def("DeclareInterface")
+ .bases("InterfaceDeclaration")
+ .build("id", "body", "extends");
+ def("InterfaceExtends")
+ .bases("Node")
+ .build("id")
+ .field("id", def("Identifier"))
+ .field("typeParameters", or(def("TypeParameterInstantiation"), null), defaults["null"]);
+ def("TypeAlias")
+ .bases("Declaration")
+ .build("id", "typeParameters", "right")
+ .field("id", def("Identifier"))
+ .field("typeParameters", or(def("TypeParameterDeclaration"), null))
+ .field("right", def("FlowType"));
+ def("OpaqueType")
+ .bases("Declaration")
+ .build("id", "typeParameters", "impltype", "supertype")
+ .field("id", def("Identifier"))
+ .field("typeParameters", or(def("TypeParameterDeclaration"), null))
+ .field("impltype", def("FlowType"))
+ .field("supertype", def("FlowType"));
+ def("DeclareTypeAlias")
+ .bases("TypeAlias")
+ .build("id", "typeParameters", "right");
+ def("DeclareOpaqueType")
+ .bases("TypeAlias")
+ .build("id", "typeParameters", "supertype");
+ def("TypeCastExpression")
+ .bases("Expression")
+ .build("expression", "typeAnnotation")
+ .field("expression", def("Expression"))
+ .field("typeAnnotation", def("TypeAnnotation"));
+ def("TupleTypeAnnotation")
+ .bases("FlowType")
+ .build("types")
+ .field("types", [def("FlowType")]);
+ def("DeclareVariable")
+ .bases("Statement")
+ .build("id")
+ .field("id", def("Identifier"));
+ def("DeclareFunction")
+ .bases("Statement")
+ .build("id")
+ .field("id", def("Identifier"));
+ def("DeclareClass")
+ .bases("InterfaceDeclaration")
+ .build("id");
+ def("DeclareModule")
+ .bases("Statement")
+ .build("id", "body")
+ .field("id", or(def("Identifier"), def("Literal")))
+ .field("body", def("BlockStatement"));
+ def("DeclareModuleExports")
+ .bases("Statement")
+ .build("typeAnnotation")
+ .field("typeAnnotation", def("TypeAnnotation"));
+ def("DeclareExportDeclaration")
+ .bases("Declaration")
+ .build("default", "declaration", "specifiers", "source")
+ .field("default", Boolean)
+ .field("declaration", or(def("DeclareVariable"), def("DeclareFunction"), def("DeclareClass"), def("FlowType"), // Implies default.
+ null))
+ .field("specifiers", [or(def("ExportSpecifier"), def("ExportBatchSpecifier"))], defaults.emptyArray)
+ .field("source", or(def("Literal"), null), defaults["null"]);
+ def("DeclareExportAllDeclaration")
+ .bases("Declaration")
+ .build("source")
+ .field("source", or(def("Literal"), null), defaults["null"]);
+ def("FlowPredicate").bases("Flow");
+ def("InferredPredicate")
+ .bases("FlowPredicate")
+ .build();
+ def("DeclaredPredicate")
+ .bases("FlowPredicate")
+ .build("value")
+ .field("value", def("Expression"));
+ def("CallExpression")
+ .field("typeArguments", or(null, def("TypeParameterInstantiation")), defaults["null"]);
+ def("NewExpression")
+ .field("typeArguments", or(null, def("TypeParameterInstantiation")), defaults["null"]);
+}
+exports["default"] = default_1;
+module.exports = exports["default"];
+
+
+/***/ }),
+
+/***/ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/jsx.js":
+/*!**********************************************************************************************************!*\
+ !*** ../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/jsx.js ***!
+ \**********************************************************************************************************/
+/***/ ((module, exports, __webpack_require__) => {
+
+"use strict";
+;
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var tslib_1 = __webpack_require__(/*! tslib */ "../../../.yarn/berry/cache/tslib-npm-2.4.0-9cb6dc5030-9.zip/node_modules/tslib/tslib.es6.js");
+var es7_1 = tslib_1.__importDefault(__webpack_require__(/*! ./es7 */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/es7.js"));
+var types_1 = tslib_1.__importDefault(__webpack_require__(/*! ../lib/types */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/types.js"));
+var shared_1 = tslib_1.__importDefault(__webpack_require__(/*! ../lib/shared */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/shared.js"));
+function default_1(fork) {
+ fork.use(es7_1.default);
+ var types = fork.use(types_1.default);
+ var def = types.Type.def;
+ var or = types.Type.or;
+ var defaults = fork.use(shared_1.default).defaults;
+ def("JSXAttribute")
+ .bases("Node")
+ .build("name", "value")
+ .field("name", or(def("JSXIdentifier"), def("JSXNamespacedName")))
+ .field("value", or(def("Literal"), // attr="value"
+ def("JSXExpressionContainer"), // attr={value}
+ null // attr= or just attr
+ ), defaults["null"]);
+ def("JSXIdentifier")
+ .bases("Identifier")
+ .build("name")
+ .field("name", String);
+ def("JSXNamespacedName")
+ .bases("Node")
+ .build("namespace", "name")
+ .field("namespace", def("JSXIdentifier"))
+ .field("name", def("JSXIdentifier"));
+ def("JSXMemberExpression")
+ .bases("MemberExpression")
+ .build("object", "property")
+ .field("object", or(def("JSXIdentifier"), def("JSXMemberExpression")))
+ .field("property", def("JSXIdentifier"))
+ .field("computed", Boolean, defaults.false);
+ var JSXElementName = or(def("JSXIdentifier"), def("JSXNamespacedName"), def("JSXMemberExpression"));
+ def("JSXSpreadAttribute")
+ .bases("Node")
+ .build("argument")
+ .field("argument", def("Expression"));
+ var JSXAttributes = [or(def("JSXAttribute"), def("JSXSpreadAttribute"))];
+ def("JSXExpressionContainer")
+ .bases("Expression")
+ .build("expression")
+ .field("expression", def("Expression"));
+ def("JSXElement")
+ .bases("Expression")
+ .build("openingElement", "closingElement", "children")
+ .field("openingElement", def("JSXOpeningElement"))
+ .field("closingElement", or(def("JSXClosingElement"), null), defaults["null"])
+ .field("children", [or(def("JSXElement"), def("JSXExpressionContainer"), def("JSXFragment"), def("JSXText"), def("Literal") // TODO Esprima should return JSXText instead.
+ )], defaults.emptyArray)
+ .field("name", JSXElementName, function () {
+ // Little-known fact: the `this` object inside a default function
+ // is none other than the partially-built object itself, and any
+ // fields initialized directly from builder function arguments
+ // (like openingElement, closingElement, and children) are
+ // guaranteed to be available.
+ return this.openingElement.name;
+ }, true) // hidden from traversal
+ .field("selfClosing", Boolean, function () {
+ return this.openingElement.selfClosing;
+ }, true) // hidden from traversal
+ .field("attributes", JSXAttributes, function () {
+ return this.openingElement.attributes;
+ }, true); // hidden from traversal
+ def("JSXOpeningElement")
+ .bases("Node") // TODO Does this make sense? Can't really be an JSXElement.
+ .build("name", "attributes", "selfClosing")
+ .field("name", JSXElementName)
+ .field("attributes", JSXAttributes, defaults.emptyArray)
+ .field("selfClosing", Boolean, defaults["false"]);
+ def("JSXClosingElement")
+ .bases("Node") // TODO Same concern.
+ .build("name")
+ .field("name", JSXElementName);
+ def("JSXFragment")
+ .bases("Expression")
+ .build("openingElement", "closingElement", "children")
+ .field("openingElement", def("JSXOpeningFragment"))
+ .field("closingElement", def("JSXClosingFragment"))
+ .field("children", [or(def("JSXElement"), def("JSXExpressionContainer"), def("JSXFragment"), def("JSXText"), def("Literal") // TODO Esprima should return JSXText instead.
+ )], defaults.emptyArray);
+ def("JSXOpeningFragment")
+ .bases("Node") // TODO Same concern.
+ .build();
+ def("JSXClosingFragment")
+ .bases("Node") // TODO Same concern.
+ .build();
+ def("JSXText")
+ .bases("Literal")
+ .build("value")
+ .field("value", String);
+ def("JSXEmptyExpression").bases("Expression").build();
+ // This PR has caused many people issues, but supporting it seems like a
+ // good idea anyway: https://github.com/babel/babel/pull/4988
+ def("JSXSpreadChild")
+ .bases("Expression")
+ .build("expression")
+ .field("expression", def("Expression"));
+}
+exports["default"] = default_1;
+module.exports = exports["default"];
+
+
+/***/ }),
+
+/***/ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/type-annotations.js":
+/*!***********************************************************************************************************************!*\
+ !*** ../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/type-annotations.js ***!
+ \***********************************************************************************************************************/
+/***/ ((module, exports, __webpack_require__) => {
+
+"use strict";
+;
+/**
+ * Type annotation defs shared between Flow and TypeScript.
+ * These defs could not be defined in ./flow.ts or ./typescript.ts directly
+ * because they use the same name.
+ */
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var tslib_1 = __webpack_require__(/*! tslib */ "../../../.yarn/berry/cache/tslib-npm-2.4.0-9cb6dc5030-9.zip/node_modules/tslib/tslib.es6.js");
+var types_1 = tslib_1.__importDefault(__webpack_require__(/*! ../lib/types */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/types.js"));
+var shared_1 = tslib_1.__importDefault(__webpack_require__(/*! ../lib/shared */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/shared.js"));
+function default_1(fork) {
+ var types = fork.use(types_1.default);
+ var def = types.Type.def;
+ var or = types.Type.or;
+ var defaults = fork.use(shared_1.default).defaults;
+ var TypeAnnotation = or(def("TypeAnnotation"), def("TSTypeAnnotation"), null);
+ var TypeParamDecl = or(def("TypeParameterDeclaration"), def("TSTypeParameterDeclaration"), null);
+ def("Identifier")
+ .field("typeAnnotation", TypeAnnotation, defaults["null"]);
+ def("ObjectPattern")
+ .field("typeAnnotation", TypeAnnotation, defaults["null"]);
+ def("Function")
+ .field("returnType", TypeAnnotation, defaults["null"])
+ .field("typeParameters", TypeParamDecl, defaults["null"]);
+ def("ClassProperty")
+ .build("key", "value", "typeAnnotation", "static")
+ .field("value", or(def("Expression"), null))
+ .field("static", Boolean, defaults["false"])
+ .field("typeAnnotation", TypeAnnotation, defaults["null"]);
+ ["ClassDeclaration",
+ "ClassExpression",
+ ].forEach(function (typeName) {
+ def(typeName)
+ .field("typeParameters", TypeParamDecl, defaults["null"])
+ .field("superTypeParameters", or(def("TypeParameterInstantiation"), def("TSTypeParameterInstantiation"), null), defaults["null"])
+ .field("implements", or([def("ClassImplements")], [def("TSExpressionWithTypeArguments")]), defaults.emptyArray);
+ });
+}
+exports["default"] = default_1;
+module.exports = exports["default"];
+
+
+/***/ }),
+
+/***/ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/typescript.js":
+/*!*****************************************************************************************************************!*\
+ !*** ../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/typescript.js ***!
+ \*****************************************************************************************************************/
+/***/ ((module, exports, __webpack_require__) => {
+
+"use strict";
+;
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var tslib_1 = __webpack_require__(/*! tslib */ "../../../.yarn/berry/cache/tslib-npm-2.4.0-9cb6dc5030-9.zip/node_modules/tslib/tslib.es6.js");
+var babel_core_1 = tslib_1.__importDefault(__webpack_require__(/*! ./babel-core */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/babel-core.js"));
+var type_annotations_1 = tslib_1.__importDefault(__webpack_require__(/*! ./type-annotations */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/type-annotations.js"));
+var types_1 = tslib_1.__importDefault(__webpack_require__(/*! ../lib/types */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/types.js"));
+var shared_1 = tslib_1.__importDefault(__webpack_require__(/*! ../lib/shared */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/shared.js"));
+function default_1(fork) {
+ // Since TypeScript is parsed by Babylon, include the core Babylon types
+ // but omit the Flow-related types.
+ fork.use(babel_core_1.default);
+ fork.use(type_annotations_1.default);
+ var types = fork.use(types_1.default);
+ var n = types.namedTypes;
+ var def = types.Type.def;
+ var or = types.Type.or;
+ var defaults = fork.use(shared_1.default).defaults;
+ var StringLiteral = types.Type.from(function (value, deep) {
+ if (n.StringLiteral &&
+ n.StringLiteral.check(value, deep)) {
+ return true;
+ }
+ if (n.Literal &&
+ n.Literal.check(value, deep) &&
+ typeof value.value === "string") {
+ return true;
+ }
+ return false;
+ }, "StringLiteral");
+ def("TSType")
+ .bases("Node");
+ var TSEntityName = or(def("Identifier"), def("TSQualifiedName"));
+ def("TSTypeReference")
+ .bases("TSType", "TSHasOptionalTypeParameterInstantiation")
+ .build("typeName", "typeParameters")
+ .field("typeName", TSEntityName);
+ // An abstract (non-buildable) base type that provide a commonly-needed
+ // optional .typeParameters field.
+ def("TSHasOptionalTypeParameterInstantiation")
+ .field("typeParameters", or(def("TSTypeParameterInstantiation"), null), defaults["null"]);
+ // An abstract (non-buildable) base type that provide a commonly-needed
+ // optional .typeParameters field.
+ def("TSHasOptionalTypeParameters")
+ .field("typeParameters", or(def("TSTypeParameterDeclaration"), null, void 0), defaults["null"]);
+ // An abstract (non-buildable) base type that provide a commonly-needed
+ // optional .typeAnnotation field.
+ def("TSHasOptionalTypeAnnotation")
+ .field("typeAnnotation", or(def("TSTypeAnnotation"), null), defaults["null"]);
+ def("TSQualifiedName")
+ .bases("Node")
+ .build("left", "right")
+ .field("left", TSEntityName)
+ .field("right", TSEntityName);
+ def("TSAsExpression")
+ .bases("Expression", "Pattern")
+ .build("expression", "typeAnnotation")
+ .field("expression", def("Expression"))
+ .field("typeAnnotation", def("TSType"))
+ .field("extra", or({ parenthesized: Boolean }, null), defaults["null"]);
+ def("TSNonNullExpression")
+ .bases("Expression", "Pattern")
+ .build("expression")
+ .field("expression", def("Expression"));
+ [
+ "TSAnyKeyword",
+ "TSBigIntKeyword",
+ "TSBooleanKeyword",
+ "TSNeverKeyword",
+ "TSNullKeyword",
+ "TSNumberKeyword",
+ "TSObjectKeyword",
+ "TSStringKeyword",
+ "TSSymbolKeyword",
+ "TSUndefinedKeyword",
+ "TSUnknownKeyword",
+ "TSVoidKeyword",
+ "TSThisType",
+ ].forEach(function (keywordType) {
+ def(keywordType)
+ .bases("TSType")
+ .build();
+ });
+ def("TSArrayType")
+ .bases("TSType")
+ .build("elementType")
+ .field("elementType", def("TSType"));
+ def("TSLiteralType")
+ .bases("TSType")
+ .build("literal")
+ .field("literal", or(def("NumericLiteral"), def("StringLiteral"), def("BooleanLiteral"), def("TemplateLiteral"), def("UnaryExpression")));
+ ["TSUnionType",
+ "TSIntersectionType",
+ ].forEach(function (typeName) {
+ def(typeName)
+ .bases("TSType")
+ .build("types")
+ .field("types", [def("TSType")]);
+ });
+ def("TSConditionalType")
+ .bases("TSType")
+ .build("checkType", "extendsType", "trueType", "falseType")
+ .field("checkType", def("TSType"))
+ .field("extendsType", def("TSType"))
+ .field("trueType", def("TSType"))
+ .field("falseType", def("TSType"));
+ def("TSInferType")
+ .bases("TSType")
+ .build("typeParameter")
+ .field("typeParameter", def("TSTypeParameter"));
+ def("TSParenthesizedType")
+ .bases("TSType")
+ .build("typeAnnotation")
+ .field("typeAnnotation", def("TSType"));
+ var ParametersType = [or(def("Identifier"), def("RestElement"), def("ArrayPattern"), def("ObjectPattern"))];
+ ["TSFunctionType",
+ "TSConstructorType",
+ ].forEach(function (typeName) {
+ def(typeName)
+ .bases("TSType", "TSHasOptionalTypeParameters", "TSHasOptionalTypeAnnotation")
+ .build("parameters")
+ .field("parameters", ParametersType);
+ });
+ def("TSDeclareFunction")
+ .bases("Declaration", "TSHasOptionalTypeParameters")
+ .build("id", "params", "returnType")
+ .field("declare", Boolean, defaults["false"])
+ .field("async", Boolean, defaults["false"])
+ .field("generator", Boolean, defaults["false"])
+ .field("id", or(def("Identifier"), null), defaults["null"])
+ .field("params", [def("Pattern")])
+ // tSFunctionTypeAnnotationCommon
+ .field("returnType", or(def("TSTypeAnnotation"), def("Noop"), // Still used?
+ null), defaults["null"]);
+ def("TSDeclareMethod")
+ .bases("Declaration", "TSHasOptionalTypeParameters")
+ .build("key", "params", "returnType")
+ .field("async", Boolean, defaults["false"])
+ .field("generator", Boolean, defaults["false"])
+ .field("params", [def("Pattern")])
+ // classMethodOrPropertyCommon
+ .field("abstract", Boolean, defaults["false"])
+ .field("accessibility", or("public", "private", "protected", void 0), defaults["undefined"])
+ .field("static", Boolean, defaults["false"])
+ .field("computed", Boolean, defaults["false"])
+ .field("optional", Boolean, defaults["false"])
+ .field("key", or(def("Identifier"), def("StringLiteral"), def("NumericLiteral"),
+ // Only allowed if .computed is true.
+ def("Expression")))
+ // classMethodOrDeclareMethodCommon
+ .field("kind", or("get", "set", "method", "constructor"), function getDefault() { return "method"; })
+ .field("access", // Not "accessibility"?
+ or("public", "private", "protected", void 0), defaults["undefined"])
+ .field("decorators", or([def("Decorator")], null), defaults["null"])
+ // tSFunctionTypeAnnotationCommon
+ .field("returnType", or(def("TSTypeAnnotation"), def("Noop"), // Still used?
+ null), defaults["null"]);
+ def("TSMappedType")
+ .bases("TSType")
+ .build("typeParameter", "typeAnnotation")
+ .field("readonly", or(Boolean, "+", "-"), defaults["false"])
+ .field("typeParameter", def("TSTypeParameter"))
+ .field("optional", or(Boolean, "+", "-"), defaults["false"])
+ .field("typeAnnotation", or(def("TSType"), null), defaults["null"]);
+ def("TSTupleType")
+ .bases("TSType")
+ .build("elementTypes")
+ .field("elementTypes", [or(def("TSType"), def("TSNamedTupleMember"))]);
+ def("TSNamedTupleMember")
+ .bases("TSType")
+ .build("label", "elementType", "optional")
+ .field("label", def("Identifier"))
+ .field("optional", Boolean, defaults["false"])
+ .field("elementType", def("TSType"));
+ def("TSRestType")
+ .bases("TSType")
+ .build("typeAnnotation")
+ .field("typeAnnotation", def("TSType"));
+ def("TSOptionalType")
+ .bases("TSType")
+ .build("typeAnnotation")
+ .field("typeAnnotation", def("TSType"));
+ def("TSIndexedAccessType")
+ .bases("TSType")
+ .build("objectType", "indexType")
+ .field("objectType", def("TSType"))
+ .field("indexType", def("TSType"));
+ def("TSTypeOperator")
+ .bases("TSType")
+ .build("operator")
+ .field("operator", String)
+ .field("typeAnnotation", def("TSType"));
+ def("TSTypeAnnotation")
+ .bases("Node")
+ .build("typeAnnotation")
+ .field("typeAnnotation", or(def("TSType"), def("TSTypeAnnotation")));
+ def("TSIndexSignature")
+ .bases("Declaration", "TSHasOptionalTypeAnnotation")
+ .build("parameters", "typeAnnotation")
+ .field("parameters", [def("Identifier")]) // Length === 1
+ .field("readonly", Boolean, defaults["false"]);
+ def("TSPropertySignature")
+ .bases("Declaration", "TSHasOptionalTypeAnnotation")
+ .build("key", "typeAnnotation", "optional")
+ .field("key", def("Expression"))
+ .field("computed", Boolean, defaults["false"])
+ .field("readonly", Boolean, defaults["false"])
+ .field("optional", Boolean, defaults["false"])
+ .field("initializer", or(def("Expression"), null), defaults["null"]);
+ def("TSMethodSignature")
+ .bases("Declaration", "TSHasOptionalTypeParameters", "TSHasOptionalTypeAnnotation")
+ .build("key", "parameters", "typeAnnotation")
+ .field("key", def("Expression"))
+ .field("computed", Boolean, defaults["false"])
+ .field("optional", Boolean, defaults["false"])
+ .field("parameters", ParametersType);
+ def("TSTypePredicate")
+ .bases("TSTypeAnnotation", "TSType")
+ .build("parameterName", "typeAnnotation", "asserts")
+ .field("parameterName", or(def("Identifier"), def("TSThisType")))
+ .field("typeAnnotation", or(def("TSTypeAnnotation"), null), defaults["null"])
+ .field("asserts", Boolean, defaults["false"]);
+ ["TSCallSignatureDeclaration",
+ "TSConstructSignatureDeclaration",
+ ].forEach(function (typeName) {
+ def(typeName)
+ .bases("Declaration", "TSHasOptionalTypeParameters", "TSHasOptionalTypeAnnotation")
+ .build("parameters", "typeAnnotation")
+ .field("parameters", ParametersType);
+ });
+ def("TSEnumMember")
+ .bases("Node")
+ .build("id", "initializer")
+ .field("id", or(def("Identifier"), StringLiteral))
+ .field("initializer", or(def("Expression"), null), defaults["null"]);
+ def("TSTypeQuery")
+ .bases("TSType")
+ .build("exprName")
+ .field("exprName", or(TSEntityName, def("TSImportType")));
+ // Inferred from Babylon's tsParseTypeMember method.
+ var TSTypeMember = or(def("TSCallSignatureDeclaration"), def("TSConstructSignatureDeclaration"), def("TSIndexSignature"), def("TSMethodSignature"), def("TSPropertySignature"));
+ def("TSTypeLiteral")
+ .bases("TSType")
+ .build("members")
+ .field("members", [TSTypeMember]);
+ def("TSTypeParameter")
+ .bases("Identifier")
+ .build("name", "constraint", "default")
+ .field("name", String)
+ .field("constraint", or(def("TSType"), void 0), defaults["undefined"])
+ .field("default", or(def("TSType"), void 0), defaults["undefined"]);
+ def("TSTypeAssertion")
+ .bases("Expression", "Pattern")
+ .build("typeAnnotation", "expression")
+ .field("typeAnnotation", def("TSType"))
+ .field("expression", def("Expression"))
+ .field("extra", or({ parenthesized: Boolean }, null), defaults["null"]);
+ def("TSTypeParameterDeclaration")
+ .bases("Declaration")
+ .build("params")
+ .field("params", [def("TSTypeParameter")]);
+ def("TSTypeParameterInstantiation")
+ .bases("Node")
+ .build("params")
+ .field("params", [def("TSType")]);
+ def("TSEnumDeclaration")
+ .bases("Declaration")
+ .build("id", "members")
+ .field("id", def("Identifier"))
+ .field("const", Boolean, defaults["false"])
+ .field("declare", Boolean, defaults["false"])
+ .field("members", [def("TSEnumMember")])
+ .field("initializer", or(def("Expression"), null), defaults["null"]);
+ def("TSTypeAliasDeclaration")
+ .bases("Declaration", "TSHasOptionalTypeParameters")
+ .build("id", "typeAnnotation")
+ .field("id", def("Identifier"))
+ .field("declare", Boolean, defaults["false"])
+ .field("typeAnnotation", def("TSType"));
+ def("TSModuleBlock")
+ .bases("Node")
+ .build("body")
+ .field("body", [def("Statement")]);
+ def("TSModuleDeclaration")
+ .bases("Declaration")
+ .build("id", "body")
+ .field("id", or(StringLiteral, TSEntityName))
+ .field("declare", Boolean, defaults["false"])
+ .field("global", Boolean, defaults["false"])
+ .field("body", or(def("TSModuleBlock"), def("TSModuleDeclaration"), null), defaults["null"]);
+ def("TSImportType")
+ .bases("TSType", "TSHasOptionalTypeParameterInstantiation")
+ .build("argument", "qualifier", "typeParameters")
+ .field("argument", StringLiteral)
+ .field("qualifier", or(TSEntityName, void 0), defaults["undefined"]);
+ def("TSImportEqualsDeclaration")
+ .bases("Declaration")
+ .build("id", "moduleReference")
+ .field("id", def("Identifier"))
+ .field("isExport", Boolean, defaults["false"])
+ .field("moduleReference", or(TSEntityName, def("TSExternalModuleReference")));
+ def("TSExternalModuleReference")
+ .bases("Declaration")
+ .build("expression")
+ .field("expression", StringLiteral);
+ def("TSExportAssignment")
+ .bases("Statement")
+ .build("expression")
+ .field("expression", def("Expression"));
+ def("TSNamespaceExportDeclaration")
+ .bases("Declaration")
+ .build("id")
+ .field("id", def("Identifier"));
+ def("TSInterfaceBody")
+ .bases("Node")
+ .build("body")
+ .field("body", [TSTypeMember]);
+ def("TSExpressionWithTypeArguments")
+ .bases("TSType", "TSHasOptionalTypeParameterInstantiation")
+ .build("expression", "typeParameters")
+ .field("expression", TSEntityName);
+ def("TSInterfaceDeclaration")
+ .bases("Declaration", "TSHasOptionalTypeParameters")
+ .build("id", "body")
+ .field("id", TSEntityName)
+ .field("declare", Boolean, defaults["false"])
+ .field("extends", or([def("TSExpressionWithTypeArguments")], null), defaults["null"])
+ .field("body", def("TSInterfaceBody"));
+ def("TSParameterProperty")
+ .bases("Pattern")
+ .build("parameter")
+ .field("accessibility", or("public", "private", "protected", void 0), defaults["undefined"])
+ .field("readonly", Boolean, defaults["false"])
+ .field("parameter", or(def("Identifier"), def("AssignmentPattern")));
+ def("ClassProperty")
+ .field("access", // Not "accessibility"?
+ or("public", "private", "protected", void 0), defaults["undefined"]);
+ // Defined already in es6 and babel-core.
+ def("ClassBody")
+ .field("body", [or(def("MethodDefinition"), def("VariableDeclarator"), def("ClassPropertyDefinition"), def("ClassProperty"), def("ClassPrivateProperty"), def("ClassMethod"), def("ClassPrivateMethod"),
+ // Just need to add these types:
+ def("TSDeclareMethod"), TSTypeMember)]);
+}
+exports["default"] = default_1;
+module.exports = exports["default"];
+
+
+/***/ }),
+
+/***/ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/fork.js":
+/*!*******************************************************************************************************!*\
+ !*** ../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/fork.js ***!
+ \*******************************************************************************************************/
+/***/ ((module, exports, __webpack_require__) => {
+
+"use strict";
+;
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var tslib_1 = __webpack_require__(/*! tslib */ "../../../.yarn/berry/cache/tslib-npm-2.4.0-9cb6dc5030-9.zip/node_modules/tslib/tslib.es6.js");
+var types_1 = tslib_1.__importDefault(__webpack_require__(/*! ./lib/types */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/types.js"));
+var path_visitor_1 = tslib_1.__importDefault(__webpack_require__(/*! ./lib/path-visitor */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/path-visitor.js"));
+var equiv_1 = tslib_1.__importDefault(__webpack_require__(/*! ./lib/equiv */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/equiv.js"));
+var path_1 = tslib_1.__importDefault(__webpack_require__(/*! ./lib/path */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/path.js"));
+var node_path_1 = tslib_1.__importDefault(__webpack_require__(/*! ./lib/node-path */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/node-path.js"));
+function default_1(defs) {
+ var fork = createFork();
+ var types = fork.use(types_1.default);
+ defs.forEach(fork.use);
+ types.finalize();
+ var PathVisitor = fork.use(path_visitor_1.default);
+ return {
+ Type: types.Type,
+ builtInTypes: types.builtInTypes,
+ namedTypes: types.namedTypes,
+ builders: types.builders,
+ defineMethod: types.defineMethod,
+ getFieldNames: types.getFieldNames,
+ getFieldValue: types.getFieldValue,
+ eachField: types.eachField,
+ someField: types.someField,
+ getSupertypeNames: types.getSupertypeNames,
+ getBuilderName: types.getBuilderName,
+ astNodesAreEquivalent: fork.use(equiv_1.default),
+ finalize: types.finalize,
+ Path: fork.use(path_1.default),
+ NodePath: fork.use(node_path_1.default),
+ PathVisitor: PathVisitor,
+ use: fork.use,
+ visit: PathVisitor.visit,
+ };
+}
+exports["default"] = default_1;
+function createFork() {
+ var used = [];
+ var usedResult = [];
+ function use(plugin) {
+ var idx = used.indexOf(plugin);
+ if (idx === -1) {
+ idx = used.length;
+ used.push(plugin);
+ usedResult[idx] = plugin(fork);
+ }
+ return usedResult[idx];
+ }
+ var fork = { use: use };
+ return fork;
+}
+module.exports = exports["default"];
+
+
+/***/ }),
+
+/***/ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/gen/namedTypes.js":
+/*!*****************************************************************************************************************!*\
+ !*** ../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/gen/namedTypes.js ***!
+ \*****************************************************************************************************************/
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.namedTypes = void 0;
+var namedTypes;
+(function (namedTypes) {
+})(namedTypes = exports.namedTypes || (exports.namedTypes = {}));
+
+
+/***/ }),
+
+/***/ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/equiv.js":
+/*!************************************************************************************************************!*\
+ !*** ../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/equiv.js ***!
+ \************************************************************************************************************/
+/***/ ((module, exports, __webpack_require__) => {
+
+"use strict";
+;
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var tslib_1 = __webpack_require__(/*! tslib */ "../../../.yarn/berry/cache/tslib-npm-2.4.0-9cb6dc5030-9.zip/node_modules/tslib/tslib.es6.js");
+var types_1 = tslib_1.__importDefault(__webpack_require__(/*! ./types */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/types.js"));
+function default_1(fork) {
+ var types = fork.use(types_1.default);
+ var getFieldNames = types.getFieldNames;
+ var getFieldValue = types.getFieldValue;
+ var isArray = types.builtInTypes.array;
+ var isObject = types.builtInTypes.object;
+ var isDate = types.builtInTypes.Date;
+ var isRegExp = types.builtInTypes.RegExp;
+ var hasOwn = Object.prototype.hasOwnProperty;
+ function astNodesAreEquivalent(a, b, problemPath) {
+ if (isArray.check(problemPath)) {
+ problemPath.length = 0;
+ }
+ else {
+ problemPath = null;
+ }
+ return areEquivalent(a, b, problemPath);
+ }
+ astNodesAreEquivalent.assert = function (a, b) {
+ var problemPath = [];
+ if (!astNodesAreEquivalent(a, b, problemPath)) {
+ if (problemPath.length === 0) {
+ if (a !== b) {
+ throw new Error("Nodes must be equal");
+ }
+ }
+ else {
+ throw new Error("Nodes differ in the following path: " +
+ problemPath.map(subscriptForProperty).join(""));
+ }
+ }
+ };
+ function subscriptForProperty(property) {
+ if (/[_$a-z][_$a-z0-9]*/i.test(property)) {
+ return "." + property;
+ }
+ return "[" + JSON.stringify(property) + "]";
+ }
+ function areEquivalent(a, b, problemPath) {
+ if (a === b) {
+ return true;
+ }
+ if (isArray.check(a)) {
+ return arraysAreEquivalent(a, b, problemPath);
+ }
+ if (isObject.check(a)) {
+ return objectsAreEquivalent(a, b, problemPath);
+ }
+ if (isDate.check(a)) {
+ return isDate.check(b) && (+a === +b);
+ }
+ if (isRegExp.check(a)) {
+ return isRegExp.check(b) && (a.source === b.source &&
+ a.global === b.global &&
+ a.multiline === b.multiline &&
+ a.ignoreCase === b.ignoreCase);
+ }
+ return a == b;
+ }
+ function arraysAreEquivalent(a, b, problemPath) {
+ isArray.assert(a);
+ var aLength = a.length;
+ if (!isArray.check(b) || b.length !== aLength) {
+ if (problemPath) {
+ problemPath.push("length");
+ }
+ return false;
+ }
+ for (var i = 0; i < aLength; ++i) {
+ if (problemPath) {
+ problemPath.push(i);
+ }
+ if (i in a !== i in b) {
+ return false;
+ }
+ if (!areEquivalent(a[i], b[i], problemPath)) {
+ return false;
+ }
+ if (problemPath) {
+ var problemPathTail = problemPath.pop();
+ if (problemPathTail !== i) {
+ throw new Error("" + problemPathTail);
+ }
+ }
+ }
+ return true;
+ }
+ function objectsAreEquivalent(a, b, problemPath) {
+ isObject.assert(a);
+ if (!isObject.check(b)) {
+ return false;
+ }
+ // Fast path for a common property of AST nodes.
+ if (a.type !== b.type) {
+ if (problemPath) {
+ problemPath.push("type");
+ }
+ return false;
+ }
+ var aNames = getFieldNames(a);
+ var aNameCount = aNames.length;
+ var bNames = getFieldNames(b);
+ var bNameCount = bNames.length;
+ if (aNameCount === bNameCount) {
+ for (var i = 0; i < aNameCount; ++i) {
+ var name = aNames[i];
+ var aChild = getFieldValue(a, name);
+ var bChild = getFieldValue(b, name);
+ if (problemPath) {
+ problemPath.push(name);
+ }
+ if (!areEquivalent(aChild, bChild, problemPath)) {
+ return false;
+ }
+ if (problemPath) {
+ var problemPathTail = problemPath.pop();
+ if (problemPathTail !== name) {
+ throw new Error("" + problemPathTail);
+ }
+ }
+ }
+ return true;
+ }
+ if (!problemPath) {
+ return false;
+ }
+ // Since aNameCount !== bNameCount, we need to find some name that's
+ // missing in aNames but present in bNames, or vice-versa.
+ var seenNames = Object.create(null);
+ for (i = 0; i < aNameCount; ++i) {
+ seenNames[aNames[i]] = true;
+ }
+ for (i = 0; i < bNameCount; ++i) {
+ name = bNames[i];
+ if (!hasOwn.call(seenNames, name)) {
+ problemPath.push(name);
+ return false;
+ }
+ delete seenNames[name];
+ }
+ for (name in seenNames) {
+ problemPath.push(name);
+ break;
+ }
+ return false;
+ }
+ return astNodesAreEquivalent;
+}
+exports["default"] = default_1;
+module.exports = exports["default"];
+
+
+/***/ }),
+
+/***/ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/node-path.js":
+/*!****************************************************************************************************************!*\
+ !*** ../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/node-path.js ***!
+ \****************************************************************************************************************/
+/***/ ((module, exports, __webpack_require__) => {
+
+"use strict";
+;
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var tslib_1 = __webpack_require__(/*! tslib */ "../../../.yarn/berry/cache/tslib-npm-2.4.0-9cb6dc5030-9.zip/node_modules/tslib/tslib.es6.js");
+var types_1 = tslib_1.__importDefault(__webpack_require__(/*! ./types */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/types.js"));
+var path_1 = tslib_1.__importDefault(__webpack_require__(/*! ./path */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/path.js"));
+var scope_1 = tslib_1.__importDefault(__webpack_require__(/*! ./scope */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/scope.js"));
+function nodePathPlugin(fork) {
+ var types = fork.use(types_1.default);
+ var n = types.namedTypes;
+ var b = types.builders;
+ var isNumber = types.builtInTypes.number;
+ var isArray = types.builtInTypes.array;
+ var Path = fork.use(path_1.default);
+ var Scope = fork.use(scope_1.default);
+ var NodePath = function NodePath(value, parentPath, name) {
+ if (!(this instanceof NodePath)) {
+ throw new Error("NodePath constructor cannot be invoked without 'new'");
+ }
+ Path.call(this, value, parentPath, name);
+ };
+ var NPp = NodePath.prototype = Object.create(Path.prototype, {
+ constructor: {
+ value: NodePath,
+ enumerable: false,
+ writable: true,
+ configurable: true
+ }
+ });
+ Object.defineProperties(NPp, {
+ node: {
+ get: function () {
+ Object.defineProperty(this, "node", {
+ configurable: true,
+ value: this._computeNode()
+ });
+ return this.node;
+ }
+ },
+ parent: {
+ get: function () {
+ Object.defineProperty(this, "parent", {
+ configurable: true,
+ value: this._computeParent()
+ });
+ return this.parent;
+ }
+ },
+ scope: {
+ get: function () {
+ Object.defineProperty(this, "scope", {
+ configurable: true,
+ value: this._computeScope()
+ });
+ return this.scope;
+ }
+ }
+ });
+ NPp.replace = function () {
+ delete this.node;
+ delete this.parent;
+ delete this.scope;
+ return Path.prototype.replace.apply(this, arguments);
+ };
+ NPp.prune = function () {
+ var remainingNodePath = this.parent;
+ this.replace();
+ return cleanUpNodesAfterPrune(remainingNodePath);
+ };
+ // The value of the first ancestor Path whose value is a Node.
+ NPp._computeNode = function () {
+ var value = this.value;
+ if (n.Node.check(value)) {
+ return value;
+ }
+ var pp = this.parentPath;
+ return pp && pp.node || null;
+ };
+ // The first ancestor Path whose value is a Node distinct from this.node.
+ NPp._computeParent = function () {
+ var value = this.value;
+ var pp = this.parentPath;
+ if (!n.Node.check(value)) {
+ while (pp && !n.Node.check(pp.value)) {
+ pp = pp.parentPath;
+ }
+ if (pp) {
+ pp = pp.parentPath;
+ }
+ }
+ while (pp && !n.Node.check(pp.value)) {
+ pp = pp.parentPath;
+ }
+ return pp || null;
+ };
+ // The closest enclosing scope that governs this node.
+ NPp._computeScope = function () {
+ var value = this.value;
+ var pp = this.parentPath;
+ var scope = pp && pp.scope;
+ if (n.Node.check(value) &&
+ Scope.isEstablishedBy(value)) {
+ scope = new Scope(this, scope);
+ }
+ return scope || null;
+ };
+ NPp.getValueProperty = function (name) {
+ return types.getFieldValue(this.value, name);
+ };
+ /**
+ * Determine whether this.node needs to be wrapped in parentheses in order
+ * for a parser to reproduce the same local AST structure.
+ *
+ * For instance, in the expression `(1 + 2) * 3`, the BinaryExpression
+ * whose operator is "+" needs parentheses, because `1 + 2 * 3` would
+ * parse differently.
+ *
+ * If assumeExpressionContext === true, we don't worry about edge cases
+ * like an anonymous FunctionExpression appearing lexically first in its
+ * enclosing statement and thus needing parentheses to avoid being parsed
+ * as a FunctionDeclaration with a missing name.
+ */
+ NPp.needsParens = function (assumeExpressionContext) {
+ var pp = this.parentPath;
+ if (!pp) {
+ return false;
+ }
+ var node = this.value;
+ // Only expressions need parentheses.
+ if (!n.Expression.check(node)) {
+ return false;
+ }
+ // Identifiers never need parentheses.
+ if (node.type === "Identifier") {
+ return false;
+ }
+ while (!n.Node.check(pp.value)) {
+ pp = pp.parentPath;
+ if (!pp) {
+ return false;
+ }
+ }
+ var parent = pp.value;
+ switch (node.type) {
+ case "UnaryExpression":
+ case "SpreadElement":
+ case "SpreadProperty":
+ return parent.type === "MemberExpression"
+ && this.name === "object"
+ && parent.object === node;
+ case "BinaryExpression":
+ case "LogicalExpression":
+ switch (parent.type) {
+ case "CallExpression":
+ return this.name === "callee"
+ && parent.callee === node;
+ case "UnaryExpression":
+ case "SpreadElement":
+ case "SpreadProperty":
+ return true;
+ case "MemberExpression":
+ return this.name === "object"
+ && parent.object === node;
+ case "BinaryExpression":
+ case "LogicalExpression": {
+ var n_1 = node;
+ var po = parent.operator;
+ var pp_1 = PRECEDENCE[po];
+ var no = n_1.operator;
+ var np = PRECEDENCE[no];
+ if (pp_1 > np) {
+ return true;
+ }
+ if (pp_1 === np && this.name === "right") {
+ if (parent.right !== n_1) {
+ throw new Error("Nodes must be equal");
+ }
+ return true;
+ }
+ }
+ default:
+ return false;
+ }
+ case "SequenceExpression":
+ switch (parent.type) {
+ case "ForStatement":
+ // Although parentheses wouldn't hurt around sequence
+ // expressions in the head of for loops, traditional style
+ // dictates that e.g. i++, j++ should not be wrapped with
+ // parentheses.
+ return false;
+ case "ExpressionStatement":
+ return this.name !== "expression";
+ default:
+ // Otherwise err on the side of overparenthesization, adding
+ // explicit exceptions above if this proves overzealous.
+ return true;
+ }
+ case "YieldExpression":
+ switch (parent.type) {
+ case "BinaryExpression":
+ case "LogicalExpression":
+ case "UnaryExpression":
+ case "SpreadElement":
+ case "SpreadProperty":
+ case "CallExpression":
+ case "MemberExpression":
+ case "NewExpression":
+ case "ConditionalExpression":
+ case "YieldExpression":
+ return true;
+ default:
+ return false;
+ }
+ case "Literal":
+ return parent.type === "MemberExpression"
+ && isNumber.check(node.value)
+ && this.name === "object"
+ && parent.object === node;
+ case "AssignmentExpression":
+ case "ConditionalExpression":
+ switch (parent.type) {
+ case "UnaryExpression":
+ case "SpreadElement":
+ case "SpreadProperty":
+ case "BinaryExpression":
+ case "LogicalExpression":
+ return true;
+ case "CallExpression":
+ return this.name === "callee"
+ && parent.callee === node;
+ case "ConditionalExpression":
+ return this.name === "test"
+ && parent.test === node;
+ case "MemberExpression":
+ return this.name === "object"
+ && parent.object === node;
+ default:
+ return false;
+ }
+ default:
+ if (parent.type === "NewExpression" &&
+ this.name === "callee" &&
+ parent.callee === node) {
+ return containsCallExpression(node);
+ }
+ }
+ if (assumeExpressionContext !== true &&
+ !this.canBeFirstInStatement() &&
+ this.firstInStatement())
+ return true;
+ return false;
+ };
+ function isBinary(node) {
+ return n.BinaryExpression.check(node)
+ || n.LogicalExpression.check(node);
+ }
+ // @ts-ignore 'isUnaryLike' is declared but its value is never read. [6133]
+ function isUnaryLike(node) {
+ return n.UnaryExpression.check(node)
+ // I considered making SpreadElement and SpreadProperty subtypes
+ // of UnaryExpression, but they're not really Expression nodes.
+ || (n.SpreadElement && n.SpreadElement.check(node))
+ || (n.SpreadProperty && n.SpreadProperty.check(node));
+ }
+ var PRECEDENCE = {};
+ [["||"],
+ ["&&"],
+ ["|"],
+ ["^"],
+ ["&"],
+ ["==", "===", "!=", "!=="],
+ ["<", ">", "<=", ">=", "in", "instanceof"],
+ [">>", "<<", ">>>"],
+ ["+", "-"],
+ ["*", "/", "%"]
+ ].forEach(function (tier, i) {
+ tier.forEach(function (op) {
+ PRECEDENCE[op] = i;
+ });
+ });
+ function containsCallExpression(node) {
+ if (n.CallExpression.check(node)) {
+ return true;
+ }
+ if (isArray.check(node)) {
+ return node.some(containsCallExpression);
+ }
+ if (n.Node.check(node)) {
+ return types.someField(node, function (_name, child) {
+ return containsCallExpression(child);
+ });
+ }
+ return false;
+ }
+ NPp.canBeFirstInStatement = function () {
+ var node = this.node;
+ return !n.FunctionExpression.check(node)
+ && !n.ObjectExpression.check(node);
+ };
+ NPp.firstInStatement = function () {
+ return firstInStatement(this);
+ };
+ function firstInStatement(path) {
+ for (var node, parent; path.parent; path = path.parent) {
+ node = path.node;
+ parent = path.parent.node;
+ if (n.BlockStatement.check(parent) &&
+ path.parent.name === "body" &&
+ path.name === 0) {
+ if (parent.body[0] !== node) {
+ throw new Error("Nodes must be equal");
+ }
+ return true;
+ }
+ if (n.ExpressionStatement.check(parent) &&
+ path.name === "expression") {
+ if (parent.expression !== node) {
+ throw new Error("Nodes must be equal");
+ }
+ return true;
+ }
+ if (n.SequenceExpression.check(parent) &&
+ path.parent.name === "expressions" &&
+ path.name === 0) {
+ if (parent.expressions[0] !== node) {
+ throw new Error("Nodes must be equal");
+ }
+ continue;
+ }
+ if (n.CallExpression.check(parent) &&
+ path.name === "callee") {
+ if (parent.callee !== node) {
+ throw new Error("Nodes must be equal");
+ }
+ continue;
+ }
+ if (n.MemberExpression.check(parent) &&
+ path.name === "object") {
+ if (parent.object !== node) {
+ throw new Error("Nodes must be equal");
+ }
+ continue;
+ }
+ if (n.ConditionalExpression.check(parent) &&
+ path.name === "test") {
+ if (parent.test !== node) {
+ throw new Error("Nodes must be equal");
+ }
+ continue;
+ }
+ if (isBinary(parent) &&
+ path.name === "left") {
+ if (parent.left !== node) {
+ throw new Error("Nodes must be equal");
+ }
+ continue;
+ }
+ if (n.UnaryExpression.check(parent) &&
+ !parent.prefix &&
+ path.name === "argument") {
+ if (parent.argument !== node) {
+ throw new Error("Nodes must be equal");
+ }
+ continue;
+ }
+ return false;
+ }
+ return true;
+ }
+ /**
+ * Pruning certain nodes will result in empty or incomplete nodes, here we clean those nodes up.
+ */
+ function cleanUpNodesAfterPrune(remainingNodePath) {
+ if (n.VariableDeclaration.check(remainingNodePath.node)) {
+ var declarations = remainingNodePath.get('declarations').value;
+ if (!declarations || declarations.length === 0) {
+ return remainingNodePath.prune();
+ }
+ }
+ else if (n.ExpressionStatement.check(remainingNodePath.node)) {
+ if (!remainingNodePath.get('expression').value) {
+ return remainingNodePath.prune();
+ }
+ }
+ else if (n.IfStatement.check(remainingNodePath.node)) {
+ cleanUpIfStatementAfterPrune(remainingNodePath);
+ }
+ return remainingNodePath;
+ }
+ function cleanUpIfStatementAfterPrune(ifStatement) {
+ var testExpression = ifStatement.get('test').value;
+ var alternate = ifStatement.get('alternate').value;
+ var consequent = ifStatement.get('consequent').value;
+ if (!consequent && !alternate) {
+ var testExpressionStatement = b.expressionStatement(testExpression);
+ ifStatement.replace(testExpressionStatement);
+ }
+ else if (!consequent && alternate) {
+ var negatedTestExpression = b.unaryExpression('!', testExpression, true);
+ if (n.UnaryExpression.check(testExpression) && testExpression.operator === '!') {
+ negatedTestExpression = testExpression.argument;
+ }
+ ifStatement.get("test").replace(negatedTestExpression);
+ ifStatement.get("consequent").replace(alternate);
+ ifStatement.get("alternate").replace();
+ }
+ }
+ return NodePath;
+}
+exports["default"] = nodePathPlugin;
+module.exports = exports["default"];
+
+
+/***/ }),
+
+/***/ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/path-visitor.js":
+/*!*******************************************************************************************************************!*\
+ !*** ../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/path-visitor.js ***!
+ \*******************************************************************************************************************/
+/***/ ((module, exports, __webpack_require__) => {
+
+"use strict";
+;
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var tslib_1 = __webpack_require__(/*! tslib */ "../../../.yarn/berry/cache/tslib-npm-2.4.0-9cb6dc5030-9.zip/node_modules/tslib/tslib.es6.js");
+var types_1 = tslib_1.__importDefault(__webpack_require__(/*! ./types */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/types.js"));
+var node_path_1 = tslib_1.__importDefault(__webpack_require__(/*! ./node-path */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/node-path.js"));
+var hasOwn = Object.prototype.hasOwnProperty;
+function pathVisitorPlugin(fork) {
+ var types = fork.use(types_1.default);
+ var NodePath = fork.use(node_path_1.default);
+ var isArray = types.builtInTypes.array;
+ var isObject = types.builtInTypes.object;
+ var isFunction = types.builtInTypes.function;
+ var undefined;
+ var PathVisitor = function PathVisitor() {
+ if (!(this instanceof PathVisitor)) {
+ throw new Error("PathVisitor constructor cannot be invoked without 'new'");
+ }
+ // Permanent state.
+ this._reusableContextStack = [];
+ this._methodNameTable = computeMethodNameTable(this);
+ this._shouldVisitComments =
+ hasOwn.call(this._methodNameTable, "Block") ||
+ hasOwn.call(this._methodNameTable, "Line");
+ this.Context = makeContextConstructor(this);
+ // State reset every time PathVisitor.prototype.visit is called.
+ this._visiting = false;
+ this._changeReported = false;
+ };
+ function computeMethodNameTable(visitor) {
+ var typeNames = Object.create(null);
+ for (var methodName in visitor) {
+ if (/^visit[A-Z]/.test(methodName)) {
+ typeNames[methodName.slice("visit".length)] = true;
+ }
+ }
+ var supertypeTable = types.computeSupertypeLookupTable(typeNames);
+ var methodNameTable = Object.create(null);
+ var typeNameKeys = Object.keys(supertypeTable);
+ var typeNameCount = typeNameKeys.length;
+ for (var i = 0; i < typeNameCount; ++i) {
+ var typeName = typeNameKeys[i];
+ methodName = "visit" + supertypeTable[typeName];
+ if (isFunction.check(visitor[methodName])) {
+ methodNameTable[typeName] = methodName;
+ }
+ }
+ return methodNameTable;
+ }
+ PathVisitor.fromMethodsObject = function fromMethodsObject(methods) {
+ if (methods instanceof PathVisitor) {
+ return methods;
+ }
+ if (!isObject.check(methods)) {
+ // An empty visitor?
+ return new PathVisitor;
+ }
+ var Visitor = function Visitor() {
+ if (!(this instanceof Visitor)) {
+ throw new Error("Visitor constructor cannot be invoked without 'new'");
+ }
+ PathVisitor.call(this);
+ };
+ var Vp = Visitor.prototype = Object.create(PVp);
+ Vp.constructor = Visitor;
+ extend(Vp, methods);
+ extend(Visitor, PathVisitor);
+ isFunction.assert(Visitor.fromMethodsObject);
+ isFunction.assert(Visitor.visit);
+ return new Visitor;
+ };
+ function extend(target, source) {
+ for (var property in source) {
+ if (hasOwn.call(source, property)) {
+ target[property] = source[property];
+ }
+ }
+ return target;
+ }
+ PathVisitor.visit = function visit(node, methods) {
+ return PathVisitor.fromMethodsObject(methods).visit(node);
+ };
+ var PVp = PathVisitor.prototype;
+ PVp.visit = function () {
+ if (this._visiting) {
+ throw new Error("Recursively calling visitor.visit(path) resets visitor state. " +
+ "Try this.visit(path) or this.traverse(path) instead.");
+ }
+ // Private state that needs to be reset before every traversal.
+ this._visiting = true;
+ this._changeReported = false;
+ this._abortRequested = false;
+ var argc = arguments.length;
+ var args = new Array(argc);
+ for (var i = 0; i < argc; ++i) {
+ args[i] = arguments[i];
+ }
+ if (!(args[0] instanceof NodePath)) {
+ args[0] = new NodePath({ root: args[0] }).get("root");
+ }
+ // Called with the same arguments as .visit.
+ this.reset.apply(this, args);
+ var didNotThrow;
+ try {
+ var root = this.visitWithoutReset(args[0]);
+ didNotThrow = true;
+ }
+ finally {
+ this._visiting = false;
+ if (!didNotThrow && this._abortRequested) {
+ // If this.visitWithoutReset threw an exception and
+ // this._abortRequested was set to true, return the root of
+ // the AST instead of letting the exception propagate, so that
+ // client code does not have to provide a try-catch block to
+ // intercept the AbortRequest exception. Other kinds of
+ // exceptions will propagate without being intercepted and
+ // rethrown by a catch block, so their stacks will accurately
+ // reflect the original throwing context.
+ return args[0].value;
+ }
+ }
+ return root;
+ };
+ PVp.AbortRequest = function AbortRequest() { };
+ PVp.abort = function () {
+ var visitor = this;
+ visitor._abortRequested = true;
+ var request = new visitor.AbortRequest();
+ // If you decide to catch this exception and stop it from propagating,
+ // make sure to call its cancel method to avoid silencing other
+ // exceptions that might be thrown later in the traversal.
+ request.cancel = function () {
+ visitor._abortRequested = false;
+ };
+ throw request;
+ };
+ PVp.reset = function (_path /*, additional arguments */) {
+ // Empty stub; may be reassigned or overridden by subclasses.
+ };
+ PVp.visitWithoutReset = function (path) {
+ if (this instanceof this.Context) {
+ // Since this.Context.prototype === this, there's a chance we
+ // might accidentally call context.visitWithoutReset. If that
+ // happens, re-invoke the method against context.visitor.
+ return this.visitor.visitWithoutReset(path);
+ }
+ if (!(path instanceof NodePath)) {
+ throw new Error("");
+ }
+ var value = path.value;
+ var methodName = value &&
+ typeof value === "object" &&
+ typeof value.type === "string" &&
+ this._methodNameTable[value.type];
+ if (methodName) {
+ var context = this.acquireContext(path);
+ try {
+ return context.invokeVisitorMethod(methodName);
+ }
+ finally {
+ this.releaseContext(context);
+ }
+ }
+ else {
+ // If there was no visitor method to call, visit the children of
+ // this node generically.
+ return visitChildren(path, this);
+ }
+ };
+ function visitChildren(path, visitor) {
+ if (!(path instanceof NodePath)) {
+ throw new Error("");
+ }
+ if (!(visitor instanceof PathVisitor)) {
+ throw new Error("");
+ }
+ var value = path.value;
+ if (isArray.check(value)) {
+ path.each(visitor.visitWithoutReset, visitor);
+ }
+ else if (!isObject.check(value)) {
+ // No children to visit.
+ }
+ else {
+ var childNames = types.getFieldNames(value);
+ // The .comments field of the Node type is hidden, so we only
+ // visit it if the visitor defines visitBlock or visitLine, and
+ // value.comments is defined.
+ if (visitor._shouldVisitComments &&
+ value.comments &&
+ childNames.indexOf("comments") < 0) {
+ childNames.push("comments");
+ }
+ var childCount = childNames.length;
+ var childPaths = [];
+ for (var i = 0; i < childCount; ++i) {
+ var childName = childNames[i];
+ if (!hasOwn.call(value, childName)) {
+ value[childName] = types.getFieldValue(value, childName);
+ }
+ childPaths.push(path.get(childName));
+ }
+ for (var i = 0; i < childCount; ++i) {
+ visitor.visitWithoutReset(childPaths[i]);
+ }
+ }
+ return path.value;
+ }
+ PVp.acquireContext = function (path) {
+ if (this._reusableContextStack.length === 0) {
+ return new this.Context(path);
+ }
+ return this._reusableContextStack.pop().reset(path);
+ };
+ PVp.releaseContext = function (context) {
+ if (!(context instanceof this.Context)) {
+ throw new Error("");
+ }
+ this._reusableContextStack.push(context);
+ context.currentPath = null;
+ };
+ PVp.reportChanged = function () {
+ this._changeReported = true;
+ };
+ PVp.wasChangeReported = function () {
+ return this._changeReported;
+ };
+ function makeContextConstructor(visitor) {
+ function Context(path) {
+ if (!(this instanceof Context)) {
+ throw new Error("");
+ }
+ if (!(this instanceof PathVisitor)) {
+ throw new Error("");
+ }
+ if (!(path instanceof NodePath)) {
+ throw new Error("");
+ }
+ Object.defineProperty(this, "visitor", {
+ value: visitor,
+ writable: false,
+ enumerable: true,
+ configurable: false
+ });
+ this.currentPath = path;
+ this.needToCallTraverse = true;
+ Object.seal(this);
+ }
+ if (!(visitor instanceof PathVisitor)) {
+ throw new Error("");
+ }
+ // Note that the visitor object is the prototype of Context.prototype,
+ // so all visitor methods are inherited by context objects.
+ var Cp = Context.prototype = Object.create(visitor);
+ Cp.constructor = Context;
+ extend(Cp, sharedContextProtoMethods);
+ return Context;
+ }
+ // Every PathVisitor has a different this.Context constructor and
+ // this.Context.prototype object, but those prototypes can all use the
+ // same reset, invokeVisitorMethod, and traverse function objects.
+ var sharedContextProtoMethods = Object.create(null);
+ sharedContextProtoMethods.reset =
+ function reset(path) {
+ if (!(this instanceof this.Context)) {
+ throw new Error("");
+ }
+ if (!(path instanceof NodePath)) {
+ throw new Error("");
+ }
+ this.currentPath = path;
+ this.needToCallTraverse = true;
+ return this;
+ };
+ sharedContextProtoMethods.invokeVisitorMethod =
+ function invokeVisitorMethod(methodName) {
+ if (!(this instanceof this.Context)) {
+ throw new Error("");
+ }
+ if (!(this.currentPath instanceof NodePath)) {
+ throw new Error("");
+ }
+ var result = this.visitor[methodName].call(this, this.currentPath);
+ if (result === false) {
+ // Visitor methods return false to indicate that they have handled
+ // their own traversal needs, and we should not complain if
+ // this.needToCallTraverse is still true.
+ this.needToCallTraverse = false;
+ }
+ else if (result !== undefined) {
+ // Any other non-undefined value returned from the visitor method
+ // is interpreted as a replacement value.
+ this.currentPath = this.currentPath.replace(result)[0];
+ if (this.needToCallTraverse) {
+ // If this.traverse still hasn't been called, visit the
+ // children of the replacement node.
+ this.traverse(this.currentPath);
+ }
+ }
+ if (this.needToCallTraverse !== false) {
+ throw new Error("Must either call this.traverse or return false in " + methodName);
+ }
+ var path = this.currentPath;
+ return path && path.value;
+ };
+ sharedContextProtoMethods.traverse =
+ function traverse(path, newVisitor) {
+ if (!(this instanceof this.Context)) {
+ throw new Error("");
+ }
+ if (!(path instanceof NodePath)) {
+ throw new Error("");
+ }
+ if (!(this.currentPath instanceof NodePath)) {
+ throw new Error("");
+ }
+ this.needToCallTraverse = false;
+ return visitChildren(path, PathVisitor.fromMethodsObject(newVisitor || this.visitor));
+ };
+ sharedContextProtoMethods.visit =
+ function visit(path, newVisitor) {
+ if (!(this instanceof this.Context)) {
+ throw new Error("");
+ }
+ if (!(path instanceof NodePath)) {
+ throw new Error("");
+ }
+ if (!(this.currentPath instanceof NodePath)) {
+ throw new Error("");
+ }
+ this.needToCallTraverse = false;
+ return PathVisitor.fromMethodsObject(newVisitor || this.visitor).visitWithoutReset(path);
+ };
+ sharedContextProtoMethods.reportChanged = function reportChanged() {
+ this.visitor.reportChanged();
+ };
+ sharedContextProtoMethods.abort = function abort() {
+ this.needToCallTraverse = false;
+ this.visitor.abort();
+ };
+ return PathVisitor;
+}
+exports["default"] = pathVisitorPlugin;
+module.exports = exports["default"];
+
+
+/***/ }),
+
+/***/ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/path.js":
+/*!***********************************************************************************************************!*\
+ !*** ../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/path.js ***!
+ \***********************************************************************************************************/
+/***/ ((module, exports, __webpack_require__) => {
+
+"use strict";
+;
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var tslib_1 = __webpack_require__(/*! tslib */ "../../../.yarn/berry/cache/tslib-npm-2.4.0-9cb6dc5030-9.zip/node_modules/tslib/tslib.es6.js");
+var types_1 = tslib_1.__importDefault(__webpack_require__(/*! ./types */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/types.js"));
+var Op = Object.prototype;
+var hasOwn = Op.hasOwnProperty;
+function pathPlugin(fork) {
+ var types = fork.use(types_1.default);
+ var isArray = types.builtInTypes.array;
+ var isNumber = types.builtInTypes.number;
+ var Path = function Path(value, parentPath, name) {
+ if (!(this instanceof Path)) {
+ throw new Error("Path constructor cannot be invoked without 'new'");
+ }
+ if (parentPath) {
+ if (!(parentPath instanceof Path)) {
+ throw new Error("");
+ }
+ }
+ else {
+ parentPath = null;
+ name = null;
+ }
+ // The value encapsulated by this Path, generally equal to
+ // parentPath.value[name] if we have a parentPath.
+ this.value = value;
+ // The immediate parent Path of this Path.
+ this.parentPath = parentPath;
+ // The name of the property of parentPath.value through which this
+ // Path's value was reached.
+ this.name = name;
+ // Calling path.get("child") multiple times always returns the same
+ // child Path object, for both performance and consistency reasons.
+ this.__childCache = null;
+ };
+ var Pp = Path.prototype;
+ function getChildCache(path) {
+ // Lazily create the child cache. This also cheapens cache
+ // invalidation, since you can just reset path.__childCache to null.
+ return path.__childCache || (path.__childCache = Object.create(null));
+ }
+ function getChildPath(path, name) {
+ var cache = getChildCache(path);
+ var actualChildValue = path.getValueProperty(name);
+ var childPath = cache[name];
+ if (!hasOwn.call(cache, name) ||
+ // Ensure consistency between cache and reality.
+ childPath.value !== actualChildValue) {
+ childPath = cache[name] = new path.constructor(actualChildValue, path, name);
+ }
+ return childPath;
+ }
+ // This method is designed to be overridden by subclasses that need to
+ // handle missing properties, etc.
+ Pp.getValueProperty = function getValueProperty(name) {
+ return this.value[name];
+ };
+ Pp.get = function get() {
+ var names = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ names[_i] = arguments[_i];
+ }
+ var path = this;
+ var count = names.length;
+ for (var i = 0; i < count; ++i) {
+ path = getChildPath(path, names[i]);
+ }
+ return path;
+ };
+ Pp.each = function each(callback, context) {
+ var childPaths = [];
+ var len = this.value.length;
+ var i = 0;
+ // Collect all the original child paths before invoking the callback.
+ for (var i = 0; i < len; ++i) {
+ if (hasOwn.call(this.value, i)) {
+ childPaths[i] = this.get(i);
+ }
+ }
+ // Invoke the callback on just the original child paths, regardless of
+ // any modifications made to the array by the callback. I chose these
+ // semantics over cleverly invoking the callback on new elements because
+ // this way is much easier to reason about.
+ context = context || this;
+ for (i = 0; i < len; ++i) {
+ if (hasOwn.call(childPaths, i)) {
+ callback.call(context, childPaths[i]);
+ }
+ }
+ };
+ Pp.map = function map(callback, context) {
+ var result = [];
+ this.each(function (childPath) {
+ result.push(callback.call(this, childPath));
+ }, context);
+ return result;
+ };
+ Pp.filter = function filter(callback, context) {
+ var result = [];
+ this.each(function (childPath) {
+ if (callback.call(this, childPath)) {
+ result.push(childPath);
+ }
+ }, context);
+ return result;
+ };
+ function emptyMoves() { }
+ function getMoves(path, offset, start, end) {
+ isArray.assert(path.value);
+ if (offset === 0) {
+ return emptyMoves;
+ }
+ var length = path.value.length;
+ if (length < 1) {
+ return emptyMoves;
+ }
+ var argc = arguments.length;
+ if (argc === 2) {
+ start = 0;
+ end = length;
+ }
+ else if (argc === 3) {
+ start = Math.max(start, 0);
+ end = length;
+ }
+ else {
+ start = Math.max(start, 0);
+ end = Math.min(end, length);
+ }
+ isNumber.assert(start);
+ isNumber.assert(end);
+ var moves = Object.create(null);
+ var cache = getChildCache(path);
+ for (var i = start; i < end; ++i) {
+ if (hasOwn.call(path.value, i)) {
+ var childPath = path.get(i);
+ if (childPath.name !== i) {
+ throw new Error("");
+ }
+ var newIndex = i + offset;
+ childPath.name = newIndex;
+ moves[newIndex] = childPath;
+ delete cache[i];
+ }
+ }
+ delete cache.length;
+ return function () {
+ for (var newIndex in moves) {
+ var childPath = moves[newIndex];
+ if (childPath.name !== +newIndex) {
+ throw new Error("");
+ }
+ cache[newIndex] = childPath;
+ path.value[newIndex] = childPath.value;
+ }
+ };
+ }
+ Pp.shift = function shift() {
+ var move = getMoves(this, -1);
+ var result = this.value.shift();
+ move();
+ return result;
+ };
+ Pp.unshift = function unshift() {
+ var args = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ args[_i] = arguments[_i];
+ }
+ var move = getMoves(this, args.length);
+ var result = this.value.unshift.apply(this.value, args);
+ move();
+ return result;
+ };
+ Pp.push = function push() {
+ var args = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ args[_i] = arguments[_i];
+ }
+ isArray.assert(this.value);
+ delete getChildCache(this).length;
+ return this.value.push.apply(this.value, args);
+ };
+ Pp.pop = function pop() {
+ isArray.assert(this.value);
+ var cache = getChildCache(this);
+ delete cache[this.value.length - 1];
+ delete cache.length;
+ return this.value.pop();
+ };
+ Pp.insertAt = function insertAt(index) {
+ var argc = arguments.length;
+ var move = getMoves(this, argc - 1, index);
+ if (move === emptyMoves && argc <= 1) {
+ return this;
+ }
+ index = Math.max(index, 0);
+ for (var i = 1; i < argc; ++i) {
+ this.value[index + i - 1] = arguments[i];
+ }
+ move();
+ return this;
+ };
+ Pp.insertBefore = function insertBefore() {
+ var args = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ args[_i] = arguments[_i];
+ }
+ var pp = this.parentPath;
+ var argc = args.length;
+ var insertAtArgs = [this.name];
+ for (var i = 0; i < argc; ++i) {
+ insertAtArgs.push(args[i]);
+ }
+ return pp.insertAt.apply(pp, insertAtArgs);
+ };
+ Pp.insertAfter = function insertAfter() {
+ var args = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ args[_i] = arguments[_i];
+ }
+ var pp = this.parentPath;
+ var argc = args.length;
+ var insertAtArgs = [this.name + 1];
+ for (var i = 0; i < argc; ++i) {
+ insertAtArgs.push(args[i]);
+ }
+ return pp.insertAt.apply(pp, insertAtArgs);
+ };
+ function repairRelationshipWithParent(path) {
+ if (!(path instanceof Path)) {
+ throw new Error("");
+ }
+ var pp = path.parentPath;
+ if (!pp) {
+ // Orphan paths have no relationship to repair.
+ return path;
+ }
+ var parentValue = pp.value;
+ var parentCache = getChildCache(pp);
+ // Make sure parentCache[path.name] is populated.
+ if (parentValue[path.name] === path.value) {
+ parentCache[path.name] = path;
+ }
+ else if (isArray.check(parentValue)) {
+ // Something caused path.name to become out of date, so attempt to
+ // recover by searching for path.value in parentValue.
+ var i = parentValue.indexOf(path.value);
+ if (i >= 0) {
+ parentCache[path.name = i] = path;
+ }
+ }
+ else {
+ // If path.value disagrees with parentValue[path.name], and
+ // path.name is not an array index, let path.value become the new
+ // parentValue[path.name] and update parentCache accordingly.
+ parentValue[path.name] = path.value;
+ parentCache[path.name] = path;
+ }
+ if (parentValue[path.name] !== path.value) {
+ throw new Error("");
+ }
+ if (path.parentPath.get(path.name) !== path) {
+ throw new Error("");
+ }
+ return path;
+ }
+ Pp.replace = function replace(replacement) {
+ var results = [];
+ var parentValue = this.parentPath.value;
+ var parentCache = getChildCache(this.parentPath);
+ var count = arguments.length;
+ repairRelationshipWithParent(this);
+ if (isArray.check(parentValue)) {
+ var originalLength = parentValue.length;
+ var move = getMoves(this.parentPath, count - 1, this.name + 1);
+ var spliceArgs = [this.name, 1];
+ for (var i = 0; i < count; ++i) {
+ spliceArgs.push(arguments[i]);
+ }
+ var splicedOut = parentValue.splice.apply(parentValue, spliceArgs);
+ if (splicedOut[0] !== this.value) {
+ throw new Error("");
+ }
+ if (parentValue.length !== (originalLength - 1 + count)) {
+ throw new Error("");
+ }
+ move();
+ if (count === 0) {
+ delete this.value;
+ delete parentCache[this.name];
+ this.__childCache = null;
+ }
+ else {
+ if (parentValue[this.name] !== replacement) {
+ throw new Error("");
+ }
+ if (this.value !== replacement) {
+ this.value = replacement;
+ this.__childCache = null;
+ }
+ for (i = 0; i < count; ++i) {
+ results.push(this.parentPath.get(this.name + i));
+ }
+ if (results[0] !== this) {
+ throw new Error("");
+ }
+ }
+ }
+ else if (count === 1) {
+ if (this.value !== replacement) {
+ this.__childCache = null;
+ }
+ this.value = parentValue[this.name] = replacement;
+ results.push(this);
+ }
+ else if (count === 0) {
+ delete parentValue[this.name];
+ delete this.value;
+ this.__childCache = null;
+ // Leave this path cached as parentCache[this.name], even though
+ // it no longer has a value defined.
+ }
+ else {
+ throw new Error("Could not replace path");
+ }
+ return results;
+ };
+ return Path;
+}
+exports["default"] = pathPlugin;
+module.exports = exports["default"];
+
+
+/***/ }),
+
+/***/ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/scope.js":
+/*!************************************************************************************************************!*\
+ !*** ../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/scope.js ***!
+ \************************************************************************************************************/
+/***/ ((module, exports, __webpack_require__) => {
+
+"use strict";
+;
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var tslib_1 = __webpack_require__(/*! tslib */ "../../../.yarn/berry/cache/tslib-npm-2.4.0-9cb6dc5030-9.zip/node_modules/tslib/tslib.es6.js");
+var types_1 = tslib_1.__importDefault(__webpack_require__(/*! ./types */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/types.js"));
+var hasOwn = Object.prototype.hasOwnProperty;
+function scopePlugin(fork) {
+ var types = fork.use(types_1.default);
+ var Type = types.Type;
+ var namedTypes = types.namedTypes;
+ var Node = namedTypes.Node;
+ var Expression = namedTypes.Expression;
+ var isArray = types.builtInTypes.array;
+ var b = types.builders;
+ var Scope = function Scope(path, parentScope) {
+ if (!(this instanceof Scope)) {
+ throw new Error("Scope constructor cannot be invoked without 'new'");
+ }
+ ScopeType.assert(path.value);
+ var depth;
+ if (parentScope) {
+ if (!(parentScope instanceof Scope)) {
+ throw new Error("");
+ }
+ depth = parentScope.depth + 1;
+ }
+ else {
+ parentScope = null;
+ depth = 0;
+ }
+ Object.defineProperties(this, {
+ path: { value: path },
+ node: { value: path.value },
+ isGlobal: { value: !parentScope, enumerable: true },
+ depth: { value: depth },
+ parent: { value: parentScope },
+ bindings: { value: {} },
+ types: { value: {} },
+ });
+ };
+ var scopeTypes = [
+ // Program nodes introduce global scopes.
+ namedTypes.Program,
+ // Function is the supertype of FunctionExpression,
+ // FunctionDeclaration, ArrowExpression, etc.
+ namedTypes.Function,
+ // In case you didn't know, the caught parameter shadows any variable
+ // of the same name in an outer scope.
+ namedTypes.CatchClause
+ ];
+ var ScopeType = Type.or.apply(Type, scopeTypes);
+ Scope.isEstablishedBy = function (node) {
+ return ScopeType.check(node);
+ };
+ var Sp = Scope.prototype;
+ // Will be overridden after an instance lazily calls scanScope.
+ Sp.didScan = false;
+ Sp.declares = function (name) {
+ this.scan();
+ return hasOwn.call(this.bindings, name);
+ };
+ Sp.declaresType = function (name) {
+ this.scan();
+ return hasOwn.call(this.types, name);
+ };
+ Sp.declareTemporary = function (prefix) {
+ if (prefix) {
+ if (!/^[a-z$_]/i.test(prefix)) {
+ throw new Error("");
+ }
+ }
+ else {
+ prefix = "t$";
+ }
+ // Include this.depth in the name to make sure the name does not
+ // collide with any variables in nested/enclosing scopes.
+ prefix += this.depth.toString(36) + "$";
+ this.scan();
+ var index = 0;
+ while (this.declares(prefix + index)) {
+ ++index;
+ }
+ var name = prefix + index;
+ return this.bindings[name] = types.builders.identifier(name);
+ };
+ Sp.injectTemporary = function (identifier, init) {
+ identifier || (identifier = this.declareTemporary());
+ var bodyPath = this.path.get("body");
+ if (namedTypes.BlockStatement.check(bodyPath.value)) {
+ bodyPath = bodyPath.get("body");
+ }
+ bodyPath.unshift(b.variableDeclaration("var", [b.variableDeclarator(identifier, init || null)]));
+ return identifier;
+ };
+ Sp.scan = function (force) {
+ if (force || !this.didScan) {
+ for (var name in this.bindings) {
+ // Empty out this.bindings, just in cases.
+ delete this.bindings[name];
+ }
+ scanScope(this.path, this.bindings, this.types);
+ this.didScan = true;
+ }
+ };
+ Sp.getBindings = function () {
+ this.scan();
+ return this.bindings;
+ };
+ Sp.getTypes = function () {
+ this.scan();
+ return this.types;
+ };
+ function scanScope(path, bindings, scopeTypes) {
+ var node = path.value;
+ ScopeType.assert(node);
+ if (namedTypes.CatchClause.check(node)) {
+ // A catch clause establishes a new scope but the only variable
+ // bound in that scope is the catch parameter. Any other
+ // declarations create bindings in the outer scope.
+ var param = path.get("param");
+ if (param.value) {
+ addPattern(param, bindings);
+ }
+ }
+ else {
+ recursiveScanScope(path, bindings, scopeTypes);
+ }
+ }
+ function recursiveScanScope(path, bindings, scopeTypes) {
+ var node = path.value;
+ if (path.parent &&
+ namedTypes.FunctionExpression.check(path.parent.node) &&
+ path.parent.node.id) {
+ addPattern(path.parent.get("id"), bindings);
+ }
+ if (!node) {
+ // None of the remaining cases matter if node is falsy.
+ }
+ else if (isArray.check(node)) {
+ path.each(function (childPath) {
+ recursiveScanChild(childPath, bindings, scopeTypes);
+ });
+ }
+ else if (namedTypes.Function.check(node)) {
+ path.get("params").each(function (paramPath) {
+ addPattern(paramPath, bindings);
+ });
+ recursiveScanChild(path.get("body"), bindings, scopeTypes);
+ }
+ else if ((namedTypes.TypeAlias && namedTypes.TypeAlias.check(node)) ||
+ (namedTypes.InterfaceDeclaration && namedTypes.InterfaceDeclaration.check(node)) ||
+ (namedTypes.TSTypeAliasDeclaration && namedTypes.TSTypeAliasDeclaration.check(node)) ||
+ (namedTypes.TSInterfaceDeclaration && namedTypes.TSInterfaceDeclaration.check(node))) {
+ addTypePattern(path.get("id"), scopeTypes);
+ }
+ else if (namedTypes.VariableDeclarator.check(node)) {
+ addPattern(path.get("id"), bindings);
+ recursiveScanChild(path.get("init"), bindings, scopeTypes);
+ }
+ else if (node.type === "ImportSpecifier" ||
+ node.type === "ImportNamespaceSpecifier" ||
+ node.type === "ImportDefaultSpecifier") {
+ addPattern(
+ // Esprima used to use the .name field to refer to the local
+ // binding identifier for ImportSpecifier nodes, but .id for
+ // ImportNamespaceSpecifier and ImportDefaultSpecifier nodes.
+ // ESTree/Acorn/ESpree use .local for all three node types.
+ path.get(node.local ? "local" :
+ node.name ? "name" : "id"), bindings);
+ }
+ else if (Node.check(node) && !Expression.check(node)) {
+ types.eachField(node, function (name, child) {
+ var childPath = path.get(name);
+ if (!pathHasValue(childPath, child)) {
+ throw new Error("");
+ }
+ recursiveScanChild(childPath, bindings, scopeTypes);
+ });
+ }
+ }
+ function pathHasValue(path, value) {
+ if (path.value === value) {
+ return true;
+ }
+ // Empty arrays are probably produced by defaults.emptyArray, in which
+ // case is makes sense to regard them as equivalent, if not ===.
+ if (Array.isArray(path.value) &&
+ path.value.length === 0 &&
+ Array.isArray(value) &&
+ value.length === 0) {
+ return true;
+ }
+ return false;
+ }
+ function recursiveScanChild(path, bindings, scopeTypes) {
+ var node = path.value;
+ if (!node || Expression.check(node)) {
+ // Ignore falsy values and Expressions.
+ }
+ else if (namedTypes.FunctionDeclaration.check(node) &&
+ node.id !== null) {
+ addPattern(path.get("id"), bindings);
+ }
+ else if (namedTypes.ClassDeclaration &&
+ namedTypes.ClassDeclaration.check(node)) {
+ addPattern(path.get("id"), bindings);
+ }
+ else if (ScopeType.check(node)) {
+ if (namedTypes.CatchClause.check(node) &&
+ // TODO Broaden this to accept any pattern.
+ namedTypes.Identifier.check(node.param)) {
+ var catchParamName = node.param.name;
+ var hadBinding = hasOwn.call(bindings, catchParamName);
+ // Any declarations that occur inside the catch body that do
+ // not have the same name as the catch parameter should count
+ // as bindings in the outer scope.
+ recursiveScanScope(path.get("body"), bindings, scopeTypes);
+ // If a new binding matching the catch parameter name was
+ // created while scanning the catch body, ignore it because it
+ // actually refers to the catch parameter and not the outer
+ // scope that we're currently scanning.
+ if (!hadBinding) {
+ delete bindings[catchParamName];
+ }
+ }
+ }
+ else {
+ recursiveScanScope(path, bindings, scopeTypes);
+ }
+ }
+ function addPattern(patternPath, bindings) {
+ var pattern = patternPath.value;
+ namedTypes.Pattern.assert(pattern);
+ if (namedTypes.Identifier.check(pattern)) {
+ if (hasOwn.call(bindings, pattern.name)) {
+ bindings[pattern.name].push(patternPath);
+ }
+ else {
+ bindings[pattern.name] = [patternPath];
+ }
+ }
+ else if (namedTypes.AssignmentPattern &&
+ namedTypes.AssignmentPattern.check(pattern)) {
+ addPattern(patternPath.get('left'), bindings);
+ }
+ else if (namedTypes.ObjectPattern &&
+ namedTypes.ObjectPattern.check(pattern)) {
+ patternPath.get('properties').each(function (propertyPath) {
+ var property = propertyPath.value;
+ if (namedTypes.Pattern.check(property)) {
+ addPattern(propertyPath, bindings);
+ }
+ else if (namedTypes.Property.check(property)) {
+ addPattern(propertyPath.get('value'), bindings);
+ }
+ else if (namedTypes.SpreadProperty &&
+ namedTypes.SpreadProperty.check(property)) {
+ addPattern(propertyPath.get('argument'), bindings);
+ }
+ });
+ }
+ else if (namedTypes.ArrayPattern &&
+ namedTypes.ArrayPattern.check(pattern)) {
+ patternPath.get('elements').each(function (elementPath) {
+ var element = elementPath.value;
+ if (namedTypes.Pattern.check(element)) {
+ addPattern(elementPath, bindings);
+ }
+ else if (namedTypes.SpreadElement &&
+ namedTypes.SpreadElement.check(element)) {
+ addPattern(elementPath.get("argument"), bindings);
+ }
+ });
+ }
+ else if (namedTypes.PropertyPattern &&
+ namedTypes.PropertyPattern.check(pattern)) {
+ addPattern(patternPath.get('pattern'), bindings);
+ }
+ else if ((namedTypes.SpreadElementPattern &&
+ namedTypes.SpreadElementPattern.check(pattern)) ||
+ (namedTypes.SpreadPropertyPattern &&
+ namedTypes.SpreadPropertyPattern.check(pattern))) {
+ addPattern(patternPath.get('argument'), bindings);
+ }
+ }
+ function addTypePattern(patternPath, types) {
+ var pattern = patternPath.value;
+ namedTypes.Pattern.assert(pattern);
+ if (namedTypes.Identifier.check(pattern)) {
+ if (hasOwn.call(types, pattern.name)) {
+ types[pattern.name].push(patternPath);
+ }
+ else {
+ types[pattern.name] = [patternPath];
+ }
+ }
+ }
+ Sp.lookup = function (name) {
+ for (var scope = this; scope; scope = scope.parent)
+ if (scope.declares(name))
+ break;
+ return scope;
+ };
+ Sp.lookupType = function (name) {
+ for (var scope = this; scope; scope = scope.parent)
+ if (scope.declaresType(name))
+ break;
+ return scope;
+ };
+ Sp.getGlobalScope = function () {
+ var scope = this;
+ while (!scope.isGlobal)
+ scope = scope.parent;
+ return scope;
+ };
+ return Scope;
+}
+exports["default"] = scopePlugin;
+module.exports = exports["default"];
+
+
+/***/ }),
+
+/***/ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/shared.js":
+/*!*************************************************************************************************************!*\
+ !*** ../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/shared.js ***!
+ \*************************************************************************************************************/
+/***/ ((module, exports, __webpack_require__) => {
+
+"use strict";
+;
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var tslib_1 = __webpack_require__(/*! tslib */ "../../../.yarn/berry/cache/tslib-npm-2.4.0-9cb6dc5030-9.zip/node_modules/tslib/tslib.es6.js");
+var types_1 = tslib_1.__importDefault(__webpack_require__(/*! ./types */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/types.js"));
+function default_1(fork) {
+ var types = fork.use(types_1.default);
+ var Type = types.Type;
+ var builtin = types.builtInTypes;
+ var isNumber = builtin.number;
+ // An example of constructing a new type with arbitrary constraints from
+ // an existing type.
+ function geq(than) {
+ return Type.from(function (value) { return isNumber.check(value) && value >= than; }, isNumber + " >= " + than);
+ }
+ ;
+ // Default value-returning functions that may optionally be passed as a
+ // third argument to Def.prototype.field.
+ var defaults = {
+ // Functions were used because (among other reasons) that's the most
+ // elegant way to allow for the emptyArray one always to give a new
+ // array instance.
+ "null": function () { return null; },
+ "emptyArray": function () { return []; },
+ "false": function () { return false; },
+ "true": function () { return true; },
+ "undefined": function () { },
+ "use strict": function () { return "use strict"; }
+ };
+ var naiveIsPrimitive = Type.or(builtin.string, builtin.number, builtin.boolean, builtin.null, builtin.undefined);
+ var isPrimitive = Type.from(function (value) {
+ if (value === null)
+ return true;
+ var type = typeof value;
+ if (type === "object" ||
+ type === "function") {
+ return false;
+ }
+ return true;
+ }, naiveIsPrimitive.toString());
+ return {
+ geq: geq,
+ defaults: defaults,
+ isPrimitive: isPrimitive,
+ };
+}
+exports["default"] = default_1;
+module.exports = exports["default"];
+
+
+/***/ }),
+
+/***/ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/types.js":
+/*!************************************************************************************************************!*\
+ !*** ../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/lib/types.js ***!
+ \************************************************************************************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.Def = void 0;
+var tslib_1 = __webpack_require__(/*! tslib */ "../../../.yarn/berry/cache/tslib-npm-2.4.0-9cb6dc5030-9.zip/node_modules/tslib/tslib.es6.js");
+var Op = Object.prototype;
+var objToStr = Op.toString;
+var hasOwn = Op.hasOwnProperty;
+var BaseType = /** @class */ (function () {
+ function BaseType() {
+ }
+ BaseType.prototype.assert = function (value, deep) {
+ if (!this.check(value, deep)) {
+ var str = shallowStringify(value);
+ throw new Error(str + " does not match type " + this);
+ }
+ return true;
+ };
+ BaseType.prototype.arrayOf = function () {
+ var elemType = this;
+ return new ArrayType(elemType);
+ };
+ return BaseType;
+}());
+var ArrayType = /** @class */ (function (_super) {
+ tslib_1.__extends(ArrayType, _super);
+ function ArrayType(elemType) {
+ var _this = _super.call(this) || this;
+ _this.elemType = elemType;
+ _this.kind = "ArrayType";
+ return _this;
+ }
+ ArrayType.prototype.toString = function () {
+ return "[" + this.elemType + "]";
+ };
+ ArrayType.prototype.check = function (value, deep) {
+ var _this = this;
+ return Array.isArray(value) && value.every(function (elem) { return _this.elemType.check(elem, deep); });
+ };
+ return ArrayType;
+}(BaseType));
+var IdentityType = /** @class */ (function (_super) {
+ tslib_1.__extends(IdentityType, _super);
+ function IdentityType(value) {
+ var _this = _super.call(this) || this;
+ _this.value = value;
+ _this.kind = "IdentityType";
+ return _this;
+ }
+ IdentityType.prototype.toString = function () {
+ return String(this.value);
+ };
+ IdentityType.prototype.check = function (value, deep) {
+ var result = value === this.value;
+ if (!result && typeof deep === "function") {
+ deep(this, value);
+ }
+ return result;
+ };
+ return IdentityType;
+}(BaseType));
+var ObjectType = /** @class */ (function (_super) {
+ tslib_1.__extends(ObjectType, _super);
+ function ObjectType(fields) {
+ var _this = _super.call(this) || this;
+ _this.fields = fields;
+ _this.kind = "ObjectType";
+ return _this;
+ }
+ ObjectType.prototype.toString = function () {
+ return "{ " + this.fields.join(", ") + " }";
+ };
+ ObjectType.prototype.check = function (value, deep) {
+ return (objToStr.call(value) === objToStr.call({}) &&
+ this.fields.every(function (field) {
+ return field.type.check(value[field.name], deep);
+ }));
+ };
+ return ObjectType;
+}(BaseType));
+var OrType = /** @class */ (function (_super) {
+ tslib_1.__extends(OrType, _super);
+ function OrType(types) {
+ var _this = _super.call(this) || this;
+ _this.types = types;
+ _this.kind = "OrType";
+ return _this;
+ }
+ OrType.prototype.toString = function () {
+ return this.types.join(" | ");
+ };
+ OrType.prototype.check = function (value, deep) {
+ return this.types.some(function (type) {
+ return type.check(value, deep);
+ });
+ };
+ return OrType;
+}(BaseType));
+var PredicateType = /** @class */ (function (_super) {
+ tslib_1.__extends(PredicateType, _super);
+ function PredicateType(name, predicate) {
+ var _this = _super.call(this) || this;
+ _this.name = name;
+ _this.predicate = predicate;
+ _this.kind = "PredicateType";
+ return _this;
+ }
+ PredicateType.prototype.toString = function () {
+ return this.name;
+ };
+ PredicateType.prototype.check = function (value, deep) {
+ var result = this.predicate(value, deep);
+ if (!result && typeof deep === "function") {
+ deep(this, value);
+ }
+ return result;
+ };
+ return PredicateType;
+}(BaseType));
+var Def = /** @class */ (function () {
+ function Def(type, typeName) {
+ this.type = type;
+ this.typeName = typeName;
+ this.baseNames = [];
+ this.ownFields = Object.create(null);
+ // Includes own typeName. Populated during finalization.
+ this.allSupertypes = Object.create(null);
+ // Linear inheritance hierarchy. Populated during finalization.
+ this.supertypeList = [];
+ // Includes inherited fields.
+ this.allFields = Object.create(null);
+ // Non-hidden keys of allFields.
+ this.fieldNames = [];
+ // This property will be overridden as true by individual Def instances
+ // when they are finalized.
+ this.finalized = false;
+ // False by default until .build(...) is called on an instance.
+ this.buildable = false;
+ this.buildParams = [];
+ }
+ Def.prototype.isSupertypeOf = function (that) {
+ if (that instanceof Def) {
+ if (this.finalized !== true ||
+ that.finalized !== true) {
+ throw new Error("");
+ }
+ return hasOwn.call(that.allSupertypes, this.typeName);
+ }
+ else {
+ throw new Error(that + " is not a Def");
+ }
+ };
+ Def.prototype.checkAllFields = function (value, deep) {
+ var allFields = this.allFields;
+ if (this.finalized !== true) {
+ throw new Error("" + this.typeName);
+ }
+ function checkFieldByName(name) {
+ var field = allFields[name];
+ var type = field.type;
+ var child = field.getValue(value);
+ return type.check(child, deep);
+ }
+ return value !== null &&
+ typeof value === "object" &&
+ Object.keys(allFields).every(checkFieldByName);
+ };
+ Def.prototype.bases = function () {
+ var supertypeNames = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ supertypeNames[_i] = arguments[_i];
+ }
+ var bases = this.baseNames;
+ if (this.finalized) {
+ if (supertypeNames.length !== bases.length) {
+ throw new Error("");
+ }
+ for (var i = 0; i < supertypeNames.length; i++) {
+ if (supertypeNames[i] !== bases[i]) {
+ throw new Error("");
+ }
+ }
+ return this;
+ }
+ supertypeNames.forEach(function (baseName) {
+ // This indexOf lookup may be O(n), but the typical number of base
+ // names is very small, and indexOf is a native Array method.
+ if (bases.indexOf(baseName) < 0) {
+ bases.push(baseName);
+ }
+ });
+ return this; // For chaining.
+ };
+ return Def;
+}());
+exports.Def = Def;
+var Field = /** @class */ (function () {
+ function Field(name, type, defaultFn, hidden) {
+ this.name = name;
+ this.type = type;
+ this.defaultFn = defaultFn;
+ this.hidden = !!hidden;
+ }
+ Field.prototype.toString = function () {
+ return JSON.stringify(this.name) + ": " + this.type;
+ };
+ Field.prototype.getValue = function (obj) {
+ var value = obj[this.name];
+ if (typeof value !== "undefined") {
+ return value;
+ }
+ if (typeof this.defaultFn === "function") {
+ value = this.defaultFn.call(obj);
+ }
+ return value;
+ };
+ return Field;
+}());
+function shallowStringify(value) {
+ if (Array.isArray(value)) {
+ return "[" + value.map(shallowStringify).join(", ") + "]";
+ }
+ if (value && typeof value === "object") {
+ return "{ " + Object.keys(value).map(function (key) {
+ return key + ": " + value[key];
+ }).join(", ") + " }";
+ }
+ return JSON.stringify(value);
+}
+function typesPlugin(_fork) {
+ var Type = {
+ or: function () {
+ var types = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ types[_i] = arguments[_i];
+ }
+ return new OrType(types.map(function (type) { return Type.from(type); }));
+ },
+ from: function (value, name) {
+ if (value instanceof ArrayType ||
+ value instanceof IdentityType ||
+ value instanceof ObjectType ||
+ value instanceof OrType ||
+ value instanceof PredicateType) {
+ return value;
+ }
+ // The Def type is used as a helper for constructing compound
+ // interface types for AST nodes.
+ if (value instanceof Def) {
+ return value.type;
+ }
+ // Support [ElemType] syntax.
+ if (isArray.check(value)) {
+ if (value.length !== 1) {
+ throw new Error("only one element type is permitted for typed arrays");
+ }
+ return new ArrayType(Type.from(value[0]));
+ }
+ // Support { someField: FieldType, ... } syntax.
+ if (isObject.check(value)) {
+ return new ObjectType(Object.keys(value).map(function (name) {
+ return new Field(name, Type.from(value[name], name));
+ }));
+ }
+ if (typeof value === "function") {
+ var bicfIndex = builtInCtorFns.indexOf(value);
+ if (bicfIndex >= 0) {
+ return builtInCtorTypes[bicfIndex];
+ }
+ if (typeof name !== "string") {
+ throw new Error("missing name");
+ }
+ return new PredicateType(name, value);
+ }
+ // As a last resort, toType returns a type that matches any value that
+ // is === from. This is primarily useful for literal values like
+ // toType(null), but it has the additional advantage of allowing
+ // toType to be a total function.
+ return new IdentityType(value);
+ },
+ // Define a type whose name is registered in a namespace (the defCache) so
+ // that future definitions will return the same type given the same name.
+ // In particular, this system allows for circular and forward definitions.
+ // The Def object d returned from Type.def may be used to configure the
+ // type d.type by calling methods such as d.bases, d.build, and d.field.
+ def: function (typeName) {
+ return hasOwn.call(defCache, typeName)
+ ? defCache[typeName]
+ : defCache[typeName] = new DefImpl(typeName);
+ },
+ hasDef: function (typeName) {
+ return hasOwn.call(defCache, typeName);
+ }
+ };
+ var builtInCtorFns = [];
+ var builtInCtorTypes = [];
+ function defBuiltInType(name, example) {
+ var objStr = objToStr.call(example);
+ var type = new PredicateType(name, function (value) { return objToStr.call(value) === objStr; });
+ if (example && typeof example.constructor === "function") {
+ builtInCtorFns.push(example.constructor);
+ builtInCtorTypes.push(type);
+ }
+ return type;
+ }
+ // These types check the underlying [[Class]] attribute of the given
+ // value, rather than using the problematic typeof operator. Note however
+ // that no subtyping is considered; so, for instance, isObject.check
+ // returns false for [], /./, new Date, and null.
+ var isString = defBuiltInType("string", "truthy");
+ var isFunction = defBuiltInType("function", function () { });
+ var isArray = defBuiltInType("array", []);
+ var isObject = defBuiltInType("object", {});
+ var isRegExp = defBuiltInType("RegExp", /./);
+ var isDate = defBuiltInType("Date", new Date());
+ var isNumber = defBuiltInType("number", 3);
+ var isBoolean = defBuiltInType("boolean", true);
+ var isNull = defBuiltInType("null", null);
+ var isUndefined = defBuiltInType("undefined", undefined);
+ var builtInTypes = {
+ string: isString,
+ function: isFunction,
+ array: isArray,
+ object: isObject,
+ RegExp: isRegExp,
+ Date: isDate,
+ number: isNumber,
+ boolean: isBoolean,
+ null: isNull,
+ undefined: isUndefined,
+ };
+ // In order to return the same Def instance every time Type.def is called
+ // with a particular name, those instances need to be stored in a cache.
+ var defCache = Object.create(null);
+ function defFromValue(value) {
+ if (value && typeof value === "object") {
+ var type = value.type;
+ if (typeof type === "string" &&
+ hasOwn.call(defCache, type)) {
+ var d = defCache[type];
+ if (d.finalized) {
+ return d;
+ }
+ }
+ }
+ return null;
+ }
+ var DefImpl = /** @class */ (function (_super) {
+ tslib_1.__extends(DefImpl, _super);
+ function DefImpl(typeName) {
+ var _this = _super.call(this, new PredicateType(typeName, function (value, deep) { return _this.check(value, deep); }), typeName) || this;
+ return _this;
+ }
+ DefImpl.prototype.check = function (value, deep) {
+ if (this.finalized !== true) {
+ throw new Error("prematurely checking unfinalized type " + this.typeName);
+ }
+ // A Def type can only match an object value.
+ if (value === null || typeof value !== "object") {
+ return false;
+ }
+ var vDef = defFromValue(value);
+ if (!vDef) {
+ // If we couldn't infer the Def associated with the given value,
+ // and we expected it to be a SourceLocation or a Position, it was
+ // probably just missing a "type" field (because Esprima does not
+ // assign a type property to such nodes). Be optimistic and let
+ // this.checkAllFields make the final decision.
+ if (this.typeName === "SourceLocation" ||
+ this.typeName === "Position") {
+ return this.checkAllFields(value, deep);
+ }
+ // Calling this.checkAllFields for any other type of node is both
+ // bad for performance and way too forgiving.
+ return false;
+ }
+ // If checking deeply and vDef === this, then we only need to call
+ // checkAllFields once. Calling checkAllFields is too strict when deep
+ // is false, because then we only care about this.isSupertypeOf(vDef).
+ if (deep && vDef === this) {
+ return this.checkAllFields(value, deep);
+ }
+ // In most cases we rely exclusively on isSupertypeOf to make O(1)
+ // subtyping determinations. This suffices in most situations outside
+ // of unit tests, since interface conformance is checked whenever new
+ // instances are created using builder functions.
+ if (!this.isSupertypeOf(vDef)) {
+ return false;
+ }
+ // The exception is when deep is true; then, we recursively check all
+ // fields.
+ if (!deep) {
+ return true;
+ }
+ // Use the more specific Def (vDef) to perform the deep check, but
+ // shallow-check fields defined by the less specific Def (this).
+ return vDef.checkAllFields(value, deep)
+ && this.checkAllFields(value, false);
+ };
+ DefImpl.prototype.build = function () {
+ var _this = this;
+ var buildParams = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ buildParams[_i] = arguments[_i];
+ }
+ // Calling Def.prototype.build multiple times has the effect of merely
+ // redefining this property.
+ this.buildParams = buildParams;
+ if (this.buildable) {
+ // If this Def is already buildable, update self.buildParams and
+ // continue using the old builder function.
+ return this;
+ }
+ // Every buildable type will have its "type" field filled in
+ // automatically. This includes types that are not subtypes of Node,
+ // like SourceLocation, but that seems harmless (TODO?).
+ this.field("type", String, function () { return _this.typeName; });
+ // Override Dp.buildable for this Def instance.
+ this.buildable = true;
+ var addParam = function (built, param, arg, isArgAvailable) {
+ if (hasOwn.call(built, param))
+ return;
+ var all = _this.allFields;
+ if (!hasOwn.call(all, param)) {
+ throw new Error("" + param);
+ }
+ var field = all[param];
+ var type = field.type;
+ var value;
+ if (isArgAvailable) {
+ value = arg;
+ }
+ else if (field.defaultFn) {
+ // Expose the partially-built object to the default
+ // function as its `this` object.
+ value = field.defaultFn.call(built);
+ }
+ else {
+ var message = "no value or default function given for field " +
+ JSON.stringify(param) + " of " + _this.typeName + "(" +
+ _this.buildParams.map(function (name) {
+ return all[name];
+ }).join(", ") + ")";
+ throw new Error(message);
+ }
+ if (!type.check(value)) {
+ throw new Error(shallowStringify(value) +
+ " does not match field " + field +
+ " of type " + _this.typeName);
+ }
+ built[param] = value;
+ };
+ // Calling the builder function will construct an instance of the Def,
+ // with positional arguments mapped to the fields original passed to .build.
+ // If not enough arguments are provided, the default value for the remaining fields
+ // will be used.
+ var builder = function () {
+ var args = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ args[_i] = arguments[_i];
+ }
+ var argc = args.length;
+ if (!_this.finalized) {
+ throw new Error("attempting to instantiate unfinalized type " +
+ _this.typeName);
+ }
+ var built = Object.create(nodePrototype);
+ _this.buildParams.forEach(function (param, i) {
+ if (i < argc) {
+ addParam(built, param, args[i], true);
+ }
+ else {
+ addParam(built, param, null, false);
+ }
+ });
+ Object.keys(_this.allFields).forEach(function (param) {
+ // Use the default value.
+ addParam(built, param, null, false);
+ });
+ // Make sure that the "type" field was filled automatically.
+ if (built.type !== _this.typeName) {
+ throw new Error("");
+ }
+ return built;
+ };
+ // Calling .from on the builder function will construct an instance of the Def,
+ // using field values from the passed object. For fields missing from the passed object,
+ // their default value will be used.
+ builder.from = function (obj) {
+ if (!_this.finalized) {
+ throw new Error("attempting to instantiate unfinalized type " +
+ _this.typeName);
+ }
+ var built = Object.create(nodePrototype);
+ Object.keys(_this.allFields).forEach(function (param) {
+ if (hasOwn.call(obj, param)) {
+ addParam(built, param, obj[param], true);
+ }
+ else {
+ addParam(built, param, null, false);
+ }
+ });
+ // Make sure that the "type" field was filled automatically.
+ if (built.type !== _this.typeName) {
+ throw new Error("");
+ }
+ return built;
+ };
+ Object.defineProperty(builders, getBuilderName(this.typeName), {
+ enumerable: true,
+ value: builder
+ });
+ return this;
+ };
+ // The reason fields are specified using .field(...) instead of an object
+ // literal syntax is somewhat subtle: the object literal syntax would
+ // support only one key and one value, but with .field(...) we can pass
+ // any number of arguments to specify the field.
+ DefImpl.prototype.field = function (name, type, defaultFn, hidden) {
+ if (this.finalized) {
+ console.error("Ignoring attempt to redefine field " +
+ JSON.stringify(name) + " of finalized type " +
+ JSON.stringify(this.typeName));
+ return this;
+ }
+ this.ownFields[name] = new Field(name, Type.from(type), defaultFn, hidden);
+ return this; // For chaining.
+ };
+ DefImpl.prototype.finalize = function () {
+ var _this = this;
+ // It's not an error to finalize a type more than once, but only the
+ // first call to .finalize does anything.
+ if (!this.finalized) {
+ var allFields = this.allFields;
+ var allSupertypes = this.allSupertypes;
+ this.baseNames.forEach(function (name) {
+ var def = defCache[name];
+ if (def instanceof Def) {
+ def.finalize();
+ extend(allFields, def.allFields);
+ extend(allSupertypes, def.allSupertypes);
+ }
+ else {
+ var message = "unknown supertype name " +
+ JSON.stringify(name) +
+ " for subtype " +
+ JSON.stringify(_this.typeName);
+ throw new Error(message);
+ }
+ });
+ // TODO Warn if fields are overridden with incompatible types.
+ extend(allFields, this.ownFields);
+ allSupertypes[this.typeName] = this;
+ this.fieldNames.length = 0;
+ for (var fieldName in allFields) {
+ if (hasOwn.call(allFields, fieldName) &&
+ !allFields[fieldName].hidden) {
+ this.fieldNames.push(fieldName);
+ }
+ }
+ // Types are exported only once they have been finalized.
+ Object.defineProperty(namedTypes, this.typeName, {
+ enumerable: true,
+ value: this.type
+ });
+ this.finalized = true;
+ // A linearization of the inheritance hierarchy.
+ populateSupertypeList(this.typeName, this.supertypeList);
+ if (this.buildable &&
+ this.supertypeList.lastIndexOf("Expression") >= 0) {
+ wrapExpressionBuilderWithStatement(this.typeName);
+ }
+ }
+ };
+ return DefImpl;
+ }(Def));
+ // Note that the list returned by this function is a copy of the internal
+ // supertypeList, *without* the typeName itself as the first element.
+ function getSupertypeNames(typeName) {
+ if (!hasOwn.call(defCache, typeName)) {
+ throw new Error("");
+ }
+ var d = defCache[typeName];
+ if (d.finalized !== true) {
+ throw new Error("");
+ }
+ return d.supertypeList.slice(1);
+ }
+ // Returns an object mapping from every known type in the defCache to the
+ // most specific supertype whose name is an own property of the candidates
+ // object.
+ function computeSupertypeLookupTable(candidates) {
+ var table = {};
+ var typeNames = Object.keys(defCache);
+ var typeNameCount = typeNames.length;
+ for (var i = 0; i < typeNameCount; ++i) {
+ var typeName = typeNames[i];
+ var d = defCache[typeName];
+ if (d.finalized !== true) {
+ throw new Error("" + typeName);
+ }
+ for (var j = 0; j < d.supertypeList.length; ++j) {
+ var superTypeName = d.supertypeList[j];
+ if (hasOwn.call(candidates, superTypeName)) {
+ table[typeName] = superTypeName;
+ break;
+ }
+ }
+ }
+ return table;
+ }
+ var builders = Object.create(null);
+ // This object is used as prototype for any node created by a builder.
+ var nodePrototype = {};
+ // Call this function to define a new method to be shared by all AST
+ // nodes. The replaced method (if any) is returned for easy wrapping.
+ function defineMethod(name, func) {
+ var old = nodePrototype[name];
+ // Pass undefined as func to delete nodePrototype[name].
+ if (isUndefined.check(func)) {
+ delete nodePrototype[name];
+ }
+ else {
+ isFunction.assert(func);
+ Object.defineProperty(nodePrototype, name, {
+ enumerable: true,
+ configurable: true,
+ value: func
+ });
+ }
+ return old;
+ }
+ function getBuilderName(typeName) {
+ return typeName.replace(/^[A-Z]+/, function (upperCasePrefix) {
+ var len = upperCasePrefix.length;
+ switch (len) {
+ case 0: return "";
+ // If there's only one initial capital letter, just lower-case it.
+ case 1: return upperCasePrefix.toLowerCase();
+ default:
+ // If there's more than one initial capital letter, lower-case
+ // all but the last one, so that XMLDefaultDeclaration (for
+ // example) becomes xmlDefaultDeclaration.
+ return upperCasePrefix.slice(0, len - 1).toLowerCase() +
+ upperCasePrefix.charAt(len - 1);
+ }
+ });
+ }
+ function getStatementBuilderName(typeName) {
+ typeName = getBuilderName(typeName);
+ return typeName.replace(/(Expression)?$/, "Statement");
+ }
+ var namedTypes = {};
+ // Like Object.keys, but aware of what fields each AST type should have.
+ function getFieldNames(object) {
+ var d = defFromValue(object);
+ if (d) {
+ return d.fieldNames.slice(0);
+ }
+ if ("type" in object) {
+ throw new Error("did not recognize object of type " +
+ JSON.stringify(object.type));
+ }
+ return Object.keys(object);
+ }
+ // Get the value of an object property, taking object.type and default
+ // functions into account.
+ function getFieldValue(object, fieldName) {
+ var d = defFromValue(object);
+ if (d) {
+ var field = d.allFields[fieldName];
+ if (field) {
+ return field.getValue(object);
+ }
+ }
+ return object && object[fieldName];
+ }
+ // Iterate over all defined fields of an object, including those missing
+ // or undefined, passing each field name and effective value (as returned
+ // by getFieldValue) to the callback. If the object has no corresponding
+ // Def, the callback will never be called.
+ function eachField(object, callback, context) {
+ getFieldNames(object).forEach(function (name) {
+ callback.call(this, name, getFieldValue(object, name));
+ }, context);
+ }
+ // Similar to eachField, except that iteration stops as soon as the
+ // callback returns a truthy value. Like Array.prototype.some, the final
+ // result is either true or false to indicates whether the callback
+ // returned true for any element or not.
+ function someField(object, callback, context) {
+ return getFieldNames(object).some(function (name) {
+ return callback.call(this, name, getFieldValue(object, name));
+ }, context);
+ }
+ // Adds an additional builder for Expression subtypes
+ // that wraps the built Expression in an ExpressionStatements.
+ function wrapExpressionBuilderWithStatement(typeName) {
+ var wrapperName = getStatementBuilderName(typeName);
+ // skip if the builder already exists
+ if (builders[wrapperName])
+ return;
+ // the builder function to wrap with builders.ExpressionStatement
+ var wrapped = builders[getBuilderName(typeName)];
+ // skip if there is nothing to wrap
+ if (!wrapped)
+ return;
+ var builder = function () {
+ var args = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ args[_i] = arguments[_i];
+ }
+ return builders.expressionStatement(wrapped.apply(builders, args));
+ };
+ builder.from = function () {
+ var args = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ args[_i] = arguments[_i];
+ }
+ return builders.expressionStatement(wrapped.from.apply(builders, args));
+ };
+ builders[wrapperName] = builder;
+ }
+ function populateSupertypeList(typeName, list) {
+ list.length = 0;
+ list.push(typeName);
+ var lastSeen = Object.create(null);
+ for (var pos = 0; pos < list.length; ++pos) {
+ typeName = list[pos];
+ var d = defCache[typeName];
+ if (d.finalized !== true) {
+ throw new Error("");
+ }
+ // If we saw typeName earlier in the breadth-first traversal,
+ // delete the last-seen occurrence.
+ if (hasOwn.call(lastSeen, typeName)) {
+ delete list[lastSeen[typeName]];
+ }
+ // Record the new index of the last-seen occurrence of typeName.
+ lastSeen[typeName] = pos;
+ // Enqueue the base names of this type.
+ list.push.apply(list, d.baseNames);
+ }
+ // Compaction loop to remove array holes.
+ for (var to = 0, from = to, len = list.length; from < len; ++from) {
+ if (hasOwn.call(list, from)) {
+ list[to++] = list[from];
+ }
+ }
+ list.length = to;
+ }
+ function extend(into, from) {
+ Object.keys(from).forEach(function (name) {
+ into[name] = from[name];
+ });
+ return into;
+ }
+ function finalize() {
+ Object.keys(defCache).forEach(function (name) {
+ defCache[name].finalize();
+ });
+ }
+ return {
+ Type: Type,
+ builtInTypes: builtInTypes,
+ getSupertypeNames: getSupertypeNames,
+ computeSupertypeLookupTable: computeSupertypeLookupTable,
+ builders: builders,
+ defineMethod: defineMethod,
+ getBuilderName: getBuilderName,
+ getStatementBuilderName: getStatementBuilderName,
+ namedTypes: namedTypes,
+ getFieldNames: getFieldNames,
+ getFieldValue: getFieldValue,
+ eachField: eachField,
+ someField: someField,
+ finalize: finalize,
+ };
+}
+exports["default"] = typesPlugin;
+;
+
+
+/***/ }),
+
+/***/ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/main.js":
+/*!*******************************************************************************************************!*\
+ !*** ../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/main.js ***!
+ \*******************************************************************************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.visit = exports.use = exports.Type = exports.someField = exports.PathVisitor = exports.Path = exports.NodePath = exports.namedTypes = exports.getSupertypeNames = exports.getFieldValue = exports.getFieldNames = exports.getBuilderName = exports.finalize = exports.eachField = exports.defineMethod = exports.builtInTypes = exports.builders = exports.astNodesAreEquivalent = void 0;
+var tslib_1 = __webpack_require__(/*! tslib */ "../../../.yarn/berry/cache/tslib-npm-2.4.0-9cb6dc5030-9.zip/node_modules/tslib/tslib.es6.js");
+var fork_1 = tslib_1.__importDefault(__webpack_require__(/*! ./fork */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/fork.js"));
+var core_1 = tslib_1.__importDefault(__webpack_require__(/*! ./def/core */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/core.js"));
+var es6_1 = tslib_1.__importDefault(__webpack_require__(/*! ./def/es6 */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/es6.js"));
+var es7_1 = tslib_1.__importDefault(__webpack_require__(/*! ./def/es7 */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/es7.js"));
+var es2020_1 = tslib_1.__importDefault(__webpack_require__(/*! ./def/es2020 */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/es2020.js"));
+var jsx_1 = tslib_1.__importDefault(__webpack_require__(/*! ./def/jsx */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/jsx.js"));
+var flow_1 = tslib_1.__importDefault(__webpack_require__(/*! ./def/flow */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/flow.js"));
+var esprima_1 = tslib_1.__importDefault(__webpack_require__(/*! ./def/esprima */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/esprima.js"));
+var babel_1 = tslib_1.__importDefault(__webpack_require__(/*! ./def/babel */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/babel.js"));
+var typescript_1 = tslib_1.__importDefault(__webpack_require__(/*! ./def/typescript */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/typescript.js"));
+var es_proposals_1 = tslib_1.__importDefault(__webpack_require__(/*! ./def/es-proposals */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/def/es-proposals.js"));
+var namedTypes_1 = __webpack_require__(/*! ./gen/namedTypes */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/gen/namedTypes.js");
+Object.defineProperty(exports, "namedTypes", ({ enumerable: true, get: function () { return namedTypes_1.namedTypes; } }));
+var _a = fork_1.default([
+ // This core module of AST types captures ES5 as it is parsed today by
+ // git://github.com/ariya/esprima.git#master.
+ core_1.default,
+ // Feel free to add to or remove from this list of extension modules to
+ // configure the precise type hierarchy that you need.
+ es6_1.default,
+ es7_1.default,
+ es2020_1.default,
+ jsx_1.default,
+ flow_1.default,
+ esprima_1.default,
+ babel_1.default,
+ typescript_1.default,
+ es_proposals_1.default,
+]), astNodesAreEquivalent = _a.astNodesAreEquivalent, builders = _a.builders, builtInTypes = _a.builtInTypes, defineMethod = _a.defineMethod, eachField = _a.eachField, finalize = _a.finalize, getBuilderName = _a.getBuilderName, getFieldNames = _a.getFieldNames, getFieldValue = _a.getFieldValue, getSupertypeNames = _a.getSupertypeNames, n = _a.namedTypes, NodePath = _a.NodePath, Path = _a.Path, PathVisitor = _a.PathVisitor, someField = _a.someField, Type = _a.Type, use = _a.use, visit = _a.visit;
+exports.astNodesAreEquivalent = astNodesAreEquivalent;
+exports.builders = builders;
+exports.builtInTypes = builtInTypes;
+exports.defineMethod = defineMethod;
+exports.eachField = eachField;
+exports.finalize = finalize;
+exports.getBuilderName = getBuilderName;
+exports.getFieldNames = getFieldNames;
+exports.getFieldValue = getFieldValue;
+exports.getSupertypeNames = getSupertypeNames;
+exports.NodePath = NodePath;
+exports.Path = Path;
+exports.PathVisitor = PathVisitor;
+exports.someField = someField;
+exports.Type = Type;
+exports.use = use;
+exports.visit = visit;
+// Populate the exported fields of the namedTypes namespace, while still
+// retaining its member types.
+Object.assign(namedTypes_1.namedTypes, n);
+
+
+/***/ }),
+
+/***/ "../../../.yarn/berry/cache/bytes-npm-3.1.2-28b8643004-9.zip/node_modules/bytes/index.js":
+/*!***********************************************************************************************!*\
+ !*** ../../../.yarn/berry/cache/bytes-npm-3.1.2-28b8643004-9.zip/node_modules/bytes/index.js ***!
+ \***********************************************************************************************/
+/***/ ((module) => {
+
+"use strict";
+/*!
+ * bytes
+ * Copyright(c) 2012-2014 TJ Holowaychuk
+ * Copyright(c) 2015 Jed Watson
+ * MIT Licensed
+ */
+
+
+
+/**
+ * Module exports.
+ * @public
+ */
+
+module.exports = bytes;
+module.exports.format = format;
+module.exports.parse = parse;
+
+/**
+ * Module variables.
+ * @private
+ */
+
+var formatThousandsRegExp = /\B(?=(\d{3})+(?!\d))/g;
+
+var formatDecimalsRegExp = /(?:\.0*|(\.[^0]+)0+)$/;
+
+var map = {
+ b: 1,
+ kb: 1 << 10,
+ mb: 1 << 20,
+ gb: 1 << 30,
+ tb: Math.pow(1024, 4),
+ pb: Math.pow(1024, 5),
+};
+
+var parseRegExp = /^((-|\+)?(\d+(?:\.\d+)?)) *(kb|mb|gb|tb|pb)$/i;
+
+/**
+ * Convert the given value in bytes into a string or parse to string to an integer in bytes.
+ *
+ * @param {string|number} value
+ * @param {{
+ * case: [string],
+ * decimalPlaces: [number]
+ * fixedDecimals: [boolean]
+ * thousandsSeparator: [string]
+ * unitSeparator: [string]
+ * }} [options] bytes options.
+ *
+ * @returns {string|number|null}
+ */
+
+function bytes(value, options) {
+ if (typeof value === 'string') {
+ return parse(value);
+ }
+
+ if (typeof value === 'number') {
+ return format(value, options);
+ }
+
+ return null;
+}
+
+/**
+ * Format the given value in bytes into a string.
+ *
+ * If the value is negative, it is kept as such. If it is a float,
+ * it is rounded.
+ *
+ * @param {number} value
+ * @param {object} [options]
+ * @param {number} [options.decimalPlaces=2]
+ * @param {number} [options.fixedDecimals=false]
+ * @param {string} [options.thousandsSeparator=]
+ * @param {string} [options.unit=]
+ * @param {string} [options.unitSeparator=]
+ *
+ * @returns {string|null}
+ * @public
+ */
+
+function format(value, options) {
+ if (!Number.isFinite(value)) {
+ return null;
+ }
+
+ var mag = Math.abs(value);
+ var thousandsSeparator = (options && options.thousandsSeparator) || '';
+ var unitSeparator = (options && options.unitSeparator) || '';
+ var decimalPlaces = (options && options.decimalPlaces !== undefined) ? options.decimalPlaces : 2;
+ var fixedDecimals = Boolean(options && options.fixedDecimals);
+ var unit = (options && options.unit) || '';
+
+ if (!unit || !map[unit.toLowerCase()]) {
+ if (mag >= map.pb) {
+ unit = 'PB';
+ } else if (mag >= map.tb) {
+ unit = 'TB';
+ } else if (mag >= map.gb) {
+ unit = 'GB';
+ } else if (mag >= map.mb) {
+ unit = 'MB';
+ } else if (mag >= map.kb) {
+ unit = 'KB';
+ } else {
+ unit = 'B';
+ }
+ }
+
+ var val = value / map[unit.toLowerCase()];
+ var str = val.toFixed(decimalPlaces);
+
+ if (!fixedDecimals) {
+ str = str.replace(formatDecimalsRegExp, '$1');
+ }
+
+ if (thousandsSeparator) {
+ str = str.split('.').map(function (s, i) {
+ return i === 0
+ ? s.replace(formatThousandsRegExp, thousandsSeparator)
+ : s
+ }).join('.');
+ }
+
+ return str + unitSeparator + unit;
+}
+
+/**
+ * Parse the string value into an integer in bytes.
+ *
+ * If no unit is given, it is assumed the value is in bytes.
+ *
+ * @param {number|string} val
+ *
+ * @returns {number|null}
+ * @public
+ */
+
+function parse(val) {
+ if (typeof val === 'number' && !isNaN(val)) {
+ return val;
+ }
+
+ if (typeof val !== 'string') {
+ return null;
+ }
+
+ // Test if the string passed is valid
+ var results = parseRegExp.exec(val);
+ var floatValue;
+ var unit = 'b';
+
+ if (!results) {
+ // Nothing could be extracted from the given string
+ floatValue = parseInt(val, 10);
+ unit = 'b'
+ } else {
+ // Retrieve the value and the unit
+ floatValue = parseFloat(results[1]);
+ unit = results[4].toLowerCase();
+ }
+
+ if (isNaN(floatValue)) {
+ return null;
+ }
+
+ return Math.floor(map[unit] * floatValue);
+}
+
+
+/***/ }),
+
+/***/ "../../../.yarn/berry/cache/core-util-is-npm-1.0.3-ca74b76c90-9.zip/node_modules/core-util-is/lib/util.js":
+/*!****************************************************************************************************************!*\
+ !*** ../../../.yarn/berry/cache/core-util-is-npm-1.0.3-ca74b76c90-9.zip/node_modules/core-util-is/lib/util.js ***!
+ \****************************************************************************************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+// 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.
+
+// NOTE: These type checking functions intentionally don't use `instanceof`
+// because it is fragile and can be easily faked with `Object.create()`.
+
+function isArray(arg) {
+ if (Array.isArray) {
+ return Array.isArray(arg);
+ }
+ return objectToString(arg) === '[object Array]';
+}
+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 objectToString(re) === '[object RegExp]';
+}
+exports.isRegExp = isRegExp;
+
+function isObject(arg) {
+ return typeof arg === 'object' && arg !== null;
+}
+exports.isObject = isObject;
+
+function isDate(d) {
+ return objectToString(d) === '[object Date]';
+}
+exports.isDate = isDate;
+
+function isError(e) {
+ return (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 = __webpack_require__(/*! buffer */ "buffer").Buffer.isBuffer;
+
+function objectToString(o) {
+ return Object.prototype.toString.call(o);
+}
+
+
+/***/ }),
+
+/***/ "../../../.yarn/berry/cache/data-uri-to-buffer-npm-3.0.1-830646f9ee-9.zip/node_modules/data-uri-to-buffer/dist/src/index.js":
+/*!**********************************************************************************************************************************!*\
+ !*** ../../../.yarn/berry/cache/data-uri-to-buffer-npm-3.0.1-830646f9ee-9.zip/node_modules/data-uri-to-buffer/dist/src/index.js ***!
+ \**********************************************************************************************************************************/
+/***/ ((module) => {
+
+"use strict";
+
+/**
+ * Returns a `Buffer` instance from the given data URI `uri`.
+ *
+ * @param {String} uri Data URI to turn into a Buffer instance
+ * @return {Buffer} Buffer instance from Data URI
+ * @api public
+ */
+function dataUriToBuffer(uri) {
+ if (!/^data:/i.test(uri)) {
+ throw new TypeError('`uri` does not appear to be a Data URI (must begin with "data:")');
+ }
+ // strip newlines
+ uri = uri.replace(/\r?\n/g, '');
+ // split the URI up into the "metadata" and the "data" portions
+ const firstComma = uri.indexOf(',');
+ if (firstComma === -1 || firstComma <= 4) {
+ throw new TypeError('malformed data: URI');
+ }
+ // remove the "data:" scheme and parse the metadata
+ const meta = uri.substring(5, firstComma).split(';');
+ let charset = '';
+ let base64 = false;
+ const type = meta[0] || 'text/plain';
+ let typeFull = type;
+ for (let i = 1; i < meta.length; i++) {
+ if (meta[i] === 'base64') {
+ base64 = true;
+ }
+ else {
+ typeFull += `;${meta[i]}`;
+ if (meta[i].indexOf('charset=') === 0) {
+ charset = meta[i].substring(8);
+ }
+ }
+ }
+ // defaults to US-ASCII only if type is not provided
+ if (!meta[0] && !charset.length) {
+ typeFull += ';charset=US-ASCII';
+ charset = 'US-ASCII';
+ }
+ // get the encoded data portion and decode URI-encoded chars
+ const encoding = base64 ? 'base64' : 'ascii';
+ const data = unescape(uri.substring(firstComma + 1));
+ const buffer = Buffer.from(data, encoding);
+ // set `.type` and `.typeFull` properties to MIME type
+ buffer.type = type;
+ buffer.typeFull = typeFull;
+ // set the `.charset` property
+ buffer.charset = charset;
+ return buffer;
+}
+module.exports = dataUriToBuffer;
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+
+/***/ "../../../.yarn/berry/cache/degenerator-npm-3.0.2-3b38df9d12-9.zip/node_modules/degenerator/dist/src/index.js":
+/*!********************************************************************************************************************!*\
+ !*** ../../../.yarn/berry/cache/degenerator-npm-3.0.2-3b38df9d12-9.zip/node_modules/degenerator/dist/src/index.js ***!
+ \********************************************************************************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+const util_1 = __webpack_require__(/*! util */ "util");
+const escodegen_1 = __webpack_require__(/*! escodegen */ "../../../.yarn/berry/cache/escodegen-npm-1.14.3-a4dedc6eeb-9.zip/node_modules/escodegen/escodegen.js");
+const esprima_1 = __webpack_require__(/*! esprima */ "../../../.yarn/berry/cache/esprima-npm-4.0.1-1084e98778-9.zip/node_modules/esprima/dist/esprima.js");
+const ast_types_1 = __webpack_require__(/*! ast-types */ "../../../.yarn/berry/cache/ast-types-npm-0.13.4-69f7e68df8-9.zip/node_modules/ast-types/main.js");
+const vm2_1 = __webpack_require__(/*! vm2 */ "../../../.yarn/berry/cache/vm2-patch-b52c0bba95-9.zip/node_modules/vm2/index.js");
+/**
+ * Compiles sync JavaScript code into JavaScript with async Functions.
+ *
+ * @param {String} code JavaScript string to convert
+ * @param {Array} names Array of function names to add `await` operators to
+ * @return {String} Converted JavaScript string with async/await injected
+ * @api public
+ */
+function degenerator(code, _names) {
+ if (!Array.isArray(_names)) {
+ throw new TypeError('an array of async function "names" is required');
+ }
+ // Duplicate the `names` array since it's rude to augment the user args
+ const names = _names.slice(0);
+ const ast = esprima_1.parseScript(code);
+ // First pass is to find the `function` nodes and turn them into async or
+ // generator functions only if their body includes `CallExpressions` to
+ // function in `names`. We also add the names of the functions to the `names`
+ // array. We'll iterate several time, as every iteration might add new items
+ // to the `names` array, until no new names were added in the iteration.
+ let lastNamesLength = 0;
+ do {
+ lastNamesLength = names.length;
+ ast_types_1.visit(ast, {
+ visitVariableDeclaration(path) {
+ if (path.node.declarations) {
+ for (let i = 0; i < path.node.declarations.length; i++) {
+ const declaration = path.node.declarations[i];
+ if (ast_types_1.namedTypes.VariableDeclarator.check(declaration) &&
+ ast_types_1.namedTypes.Identifier.check(declaration.init) &&
+ ast_types_1.namedTypes.Identifier.check(declaration.id) &&
+ checkName(declaration.init.name, names) &&
+ !checkName(declaration.id.name, names)) {
+ names.push(declaration.id.name);
+ }
+ }
+ }
+ return false;
+ },
+ visitAssignmentExpression(path) {
+ if (ast_types_1.namedTypes.Identifier.check(path.node.left) &&
+ ast_types_1.namedTypes.Identifier.check(path.node.right) &&
+ checkName(path.node.right.name, names) &&
+ !checkName(path.node.left.name, names)) {
+ names.push(path.node.left.name);
+ }
+ return false;
+ },
+ visitFunction(path) {
+ if (path.node.id) {
+ let shouldDegenerate = false;
+ ast_types_1.visit(path.node, {
+ visitCallExpression(path) {
+ if (checkNames(path.node, names)) {
+ shouldDegenerate = true;
+ }
+ return false;
+ },
+ });
+ if (!shouldDegenerate) {
+ return false;
+ }
+ // Got a "function" expression/statement,
+ // convert it into an async function
+ path.node.async = true;
+ // Add function name to `names` array
+ if (!checkName(path.node.id.name, names)) {
+ names.push(path.node.id.name);
+ }
+ }
+ this.traverse(path);
+ },
+ });
+ } while (lastNamesLength !== names.length);
+ // Second pass is for adding `await`/`yield` statements to any function
+ // invocations that match the given `names` array.
+ ast_types_1.visit(ast, {
+ visitCallExpression(path) {
+ if (checkNames(path.node, names)) {
+ // A "function invocation" expression,
+ // we need to inject a `AwaitExpression`/`YieldExpression`
+ const delegate = false;
+ const { name, parent: { node: pNode }, } = path;
+ const expr = ast_types_1.builders.awaitExpression(path.node, delegate);
+ if (ast_types_1.namedTypes.CallExpression.check(pNode)) {
+ pNode.arguments[name] = expr;
+ }
+ else {
+ pNode[name] = expr;
+ }
+ }
+ this.traverse(path);
+ },
+ });
+ return escodegen_1.generate(ast);
+}
+(function (degenerator) {
+ function compile(code, returnName, names, options = {}) {
+ const compiled = degenerator(code, names);
+ const vm = new vm2_1.VM(options);
+ const script = new vm2_1.VMScript(`${compiled};${returnName}`, {
+ filename: options.filename,
+ });
+ const fn = vm.run(script);
+ if (typeof fn !== 'function') {
+ throw new Error(`Expected a "function" to be returned for \`${returnName}\`, but got "${typeof fn}"`);
+ }
+ const r = function (...args) {
+ try {
+ const p = fn.apply(this, args);
+ if (typeof (p === null || p === void 0 ? void 0 : p.then) === 'function') {
+ return p;
+ }
+ return Promise.resolve(p);
+ }
+ catch (err) {
+ return Promise.reject(err);
+ }
+ };
+ Object.defineProperty(r, 'toString', {
+ value: fn.toString.bind(fn),
+ enumerable: false,
+ });
+ return r;
+ }
+ degenerator.compile = compile;
+})(degenerator || (degenerator = {}));
+/**
+ * Returns `true` if `node` has a matching name to one of the entries in the
+ * `names` array.
+ *
+ * @param {types.Node} node
+ * @param {Array} names Array of function names to return true for
+ * @return {Boolean}
+ * @api private
+ */
+function checkNames({ callee }, names) {
+ let name;
+ if (ast_types_1.namedTypes.Identifier.check(callee)) {
+ name = callee.name;
+ }
+ else if (ast_types_1.namedTypes.MemberExpression.check(callee)) {
+ if (ast_types_1.namedTypes.Identifier.check(callee.object) &&
+ ast_types_1.namedTypes.Identifier.check(callee.property)) {
+ name = `${callee.object.name}.${callee.property.name}`;
+ }
+ else {
+ return false;
+ }
+ }
+ else if (ast_types_1.namedTypes.FunctionExpression.check(callee)) {
+ if (callee.id) {
+ name = callee.id.name;
+ }
+ else {
+ return false;
+ }
+ }
+ else {
+ throw new Error(`Don't know how to get name for: ${callee.type}`);
+ }
+ return checkName(name, names);
+}
+function checkName(name, names) {
+ // now that we have the `name`, check if any entries match in the `names` array
+ for (let i = 0; i < names.length; i++) {
+ const n = names[i];
+ if (util_1.isRegExp(n)) {
+ if (n.test(name)) {
+ return true;
+ }
+ }
+ else if (name === n) {
+ return true;
+ }
+ }
+ return false;
+}
+module.exports = degenerator;
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+
+/***/ "../../../.yarn/berry/cache/depd-npm-2.0.0-b6c51a4b43-9.zip/node_modules/depd/index.js":
+/*!*********************************************************************************************!*\
+ !*** ../../../.yarn/berry/cache/depd-npm-2.0.0-b6c51a4b43-9.zip/node_modules/depd/index.js ***!
+ \*********************************************************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+/*!
+ * depd
+ * Copyright(c) 2014-2018 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var relative = (__webpack_require__(/*! path */ "path").relative)
+
+/**
+ * Module exports.
+ */
+
+module.exports = depd
+
+/**
+ * Get the path to base files on.
+ */
+
+var basePath = process.cwd()
+
+/**
+ * Determine if namespace is contained in the string.
+ */
+
+function containsNamespace (str, namespace) {
+ var vals = str.split(/[ ,]+/)
+ var ns = String(namespace).toLowerCase()
+
+ for (var i = 0; i < vals.length; i++) {
+ var val = vals[i]
+
+ // namespace contained
+ if (val && (val === '*' || val.toLowerCase() === ns)) {
+ return true
+ }
+ }
+
+ return false
+}
+
+/**
+ * Convert a data descriptor to accessor descriptor.
+ */
+
+function convertDataDescriptorToAccessor (obj, prop, message) {
+ var descriptor = Object.getOwnPropertyDescriptor(obj, prop)
+ var value = descriptor.value
+
+ descriptor.get = function getter () { return value }
+
+ if (descriptor.writable) {
+ descriptor.set = function setter (val) { return (value = val) }
+ }
+
+ delete descriptor.value
+ delete descriptor.writable
+
+ Object.defineProperty(obj, prop, descriptor)
+
+ return descriptor
+}
+
+/**
+ * Create arguments string to keep arity.
+ */
+
+function createArgumentsString (arity) {
+ var str = ''
+
+ for (var i = 0; i < arity; i++) {
+ str += ', arg' + i
+ }
+
+ return str.substr(2)
+}
+
+/**
+ * Create stack string from stack.
+ */
+
+function createStackString (stack) {
+ var str = this.name + ': ' + this.namespace
+
+ if (this.message) {
+ str += ' deprecated ' + this.message
+ }
+
+ for (var i = 0; i < stack.length; i++) {
+ str += '\n at ' + stack[i].toString()
+ }
+
+ return str
+}
+
+/**
+ * Create deprecate for namespace in caller.
+ */
+
+function depd (namespace) {
+ if (!namespace) {
+ throw new TypeError('argument namespace is required')
+ }
+
+ var stack = getStack()
+ var site = callSiteLocation(stack[1])
+ var file = site[0]
+
+ function deprecate (message) {
+ // call to self as log
+ log.call(deprecate, message)
+ }
+
+ deprecate._file = file
+ deprecate._ignored = isignored(namespace)
+ deprecate._namespace = namespace
+ deprecate._traced = istraced(namespace)
+ deprecate._warned = Object.create(null)
+
+ deprecate.function = wrapfunction
+ deprecate.property = wrapproperty
+
+ return deprecate
+}
+
+/**
+ * Determine if event emitter has listeners of a given type.
+ *
+ * The way to do this check is done three different ways in Node.js >= 0.8
+ * so this consolidates them into a minimal set using instance methods.
+ *
+ * @param {EventEmitter} emitter
+ * @param {string} type
+ * @returns {boolean}
+ * @private
+ */
+
+function eehaslisteners (emitter, type) {
+ var count = typeof emitter.listenerCount !== 'function'
+ ? emitter.listeners(type).length
+ : emitter.listenerCount(type)
+
+ return count > 0
+}
+
+/**
+ * Determine if namespace is ignored.
+ */
+
+function isignored (namespace) {
+ if (process.noDeprecation) {
+ // --no-deprecation support
+ return true
+ }
+
+ var str = process.env.NO_DEPRECATION || ''
+
+ // namespace ignored
+ return containsNamespace(str, namespace)
+}
+
+/**
+ * Determine if namespace is traced.
+ */
+
+function istraced (namespace) {
+ if (process.traceDeprecation) {
+ // --trace-deprecation support
+ return true
+ }
+
+ var str = process.env.TRACE_DEPRECATION || ''
+
+ // namespace traced
+ return containsNamespace(str, namespace)
+}
+
+/**
+ * Display deprecation message.
+ */
+
+function log (message, site) {
+ var haslisteners = eehaslisteners(process, 'deprecation')
+
+ // abort early if no destination
+ if (!haslisteners && this._ignored) {
+ return
+ }
+
+ var caller
+ var callFile
+ var callSite
+ var depSite
+ var i = 0
+ var seen = false
+ var stack = getStack()
+ var file = this._file
+
+ if (site) {
+ // provided site
+ depSite = site
+ callSite = callSiteLocation(stack[1])
+ callSite.name = depSite.name
+ file = callSite[0]
+ } else {
+ // get call site
+ i = 2
+ depSite = callSiteLocation(stack[i])
+ callSite = depSite
+ }
+
+ // get caller of deprecated thing in relation to file
+ for (; i < stack.length; i++) {
+ caller = callSiteLocation(stack[i])
+ callFile = caller[0]
+
+ if (callFile === file) {
+ seen = true
+ } else if (callFile === this._file) {
+ file = this._file
+ } else if (seen) {
+ break
+ }
+ }
+
+ var key = caller
+ ? depSite.join(':') + '__' + caller.join(':')
+ : undefined
+
+ if (key !== undefined && key in this._warned) {
+ // already warned
+ return
+ }
+
+ this._warned[key] = true
+
+ // generate automatic message from call site
+ var msg = message
+ if (!msg) {
+ msg = callSite === depSite || !callSite.name
+ ? defaultMessage(depSite)
+ : defaultMessage(callSite)
+ }
+
+ // emit deprecation if listeners exist
+ if (haslisteners) {
+ var err = DeprecationError(this._namespace, msg, stack.slice(i))
+ process.emit('deprecation', err)
+ return
+ }
+
+ // format and write message
+ var format = process.stderr.isTTY
+ ? formatColor
+ : formatPlain
+ var output = format.call(this, msg, caller, stack.slice(i))
+ process.stderr.write(output + '\n', 'utf8')
+}
+
+/**
+ * Get call site location as array.
+ */
+
+function callSiteLocation (callSite) {
+ var file = callSite.getFileName() || ''
+ var line = callSite.getLineNumber()
+ var colm = callSite.getColumnNumber()
+
+ if (callSite.isEval()) {
+ file = callSite.getEvalOrigin() + ', ' + file
+ }
+
+ var site = [file, line, colm]
+
+ site.callSite = callSite
+ site.name = callSite.getFunctionName()
+
+ return site
+}
+
+/**
+ * Generate a default message from the site.
+ */
+
+function defaultMessage (site) {
+ var callSite = site.callSite
+ var funcName = site.name
+
+ // make useful anonymous name
+ if (!funcName) {
+ funcName = ''
+ }
+
+ var context = callSite.getThis()
+ var typeName = context && callSite.getTypeName()
+
+ // ignore useless type name
+ if (typeName === 'Object') {
+ typeName = undefined
+ }
+
+ // make useful type name
+ if (typeName === 'Function') {
+ typeName = context.name || typeName
+ }
+
+ return typeName && callSite.getMethodName()
+ ? typeName + '.' + funcName
+ : funcName
+}
+
+/**
+ * Format deprecation message without color.
+ */
+
+function formatPlain (msg, caller, stack) {
+ var timestamp = new Date().toUTCString()
+
+ var formatted = timestamp +
+ ' ' + this._namespace +
+ ' deprecated ' + msg
+
+ // add stack trace
+ if (this._traced) {
+ for (var i = 0; i < stack.length; i++) {
+ formatted += '\n at ' + stack[i].toString()
+ }
+
+ return formatted
+ }
+
+ if (caller) {
+ formatted += ' at ' + formatLocation(caller)
+ }
+
+ return formatted
+}
+
+/**
+ * Format deprecation message with color.
+ */
+
+function formatColor (msg, caller, stack) {
+ var formatted = '\x1b[36;1m' + this._namespace + '\x1b[22;39m' + // bold cyan
+ ' \x1b[33;1mdeprecated\x1b[22;39m' + // bold yellow
+ ' \x1b[0m' + msg + '\x1b[39m' // reset
+
+ // add stack trace
+ if (this._traced) {
+ for (var i = 0; i < stack.length; i++) {
+ formatted += '\n \x1b[36mat ' + stack[i].toString() + '\x1b[39m' // cyan
+ }
+
+ return formatted
+ }
+
+ if (caller) {
+ formatted += ' \x1b[36m' + formatLocation(caller) + '\x1b[39m' // cyan
+ }
+
+ return formatted
+}
+
+/**
+ * Format call site location.
+ */
+
+function formatLocation (callSite) {
+ return relative(basePath, callSite[0]) +
+ ':' + callSite[1] +
+ ':' + callSite[2]
+}
+
+/**
+ * Get the stack as array of call sites.
+ */
+
+function getStack () {
+ var limit = Error.stackTraceLimit
+ var obj = {}
+ var prep = Error.prepareStackTrace
+
+ Error.prepareStackTrace = prepareObjectStackTrace
+ Error.stackTraceLimit = Math.max(10, limit)
+
+ // capture the stack
+ Error.captureStackTrace(obj)
+
+ // slice this function off the top
+ var stack = obj.stack.slice(1)
+
+ Error.prepareStackTrace = prep
+ Error.stackTraceLimit = limit
+
+ return stack
+}
+
+/**
+ * Capture call site stack from v8.
+ */
+
+function prepareObjectStackTrace (obj, stack) {
+ return stack
+}
+
+/**
+ * Return a wrapped function in a deprecation message.
+ */
+
+function wrapfunction (fn, message) {
+ if (typeof fn !== 'function') {
+ throw new TypeError('argument fn must be a function')
+ }
+
+ var args = createArgumentsString(fn.length)
+ var stack = getStack()
+ var site = callSiteLocation(stack[1])
+
+ site.name = fn.name
+
+ // eslint-disable-next-line no-new-func
+ var deprecatedfn = new Function('fn', 'log', 'deprecate', 'message', 'site',
+ '"use strict"\n' +
+ 'return function (' + args + ') {' +
+ 'log.call(deprecate, message, site)\n' +
+ 'return fn.apply(this, arguments)\n' +
+ '}')(fn, log, this, message, site)
+
+ return deprecatedfn
+}
+
+/**
+ * Wrap property in a deprecation message.
+ */
+
+function wrapproperty (obj, prop, message) {
+ if (!obj || (typeof obj !== 'object' && typeof obj !== 'function')) {
+ throw new TypeError('argument obj must be object')
+ }
+
+ var descriptor = Object.getOwnPropertyDescriptor(obj, prop)
+
+ if (!descriptor) {
+ throw new TypeError('must call property on owner object')
+ }
+
+ if (!descriptor.configurable) {
+ throw new TypeError('property must be configurable')
+ }
+
+ var deprecate = this
+ var stack = getStack()
+ var site = callSiteLocation(stack[1])
+
+ // set site name
+ site.name = prop
+
+ // convert data descriptor
+ if ('value' in descriptor) {
+ descriptor = convertDataDescriptorToAccessor(obj, prop, message)
+ }
+
+ var get = descriptor.get
+ var set = descriptor.set
+
+ // wrap getter
+ if (typeof get === 'function') {
+ descriptor.get = function getter () {
+ log.call(deprecate, message, site)
+ return get.apply(this, arguments)
+ }
+ }
+
+ // wrap setter
+ if (typeof set === 'function') {
+ descriptor.set = function setter () {
+ log.call(deprecate, message, site)
+ return set.apply(this, arguments)
+ }
+ }
+
+ Object.defineProperty(obj, prop, descriptor)
+}
+
+/**
+ * Create DeprecationError for deprecation
+ */
+
+function DeprecationError (namespace, message, stack) {
+ var error = new Error()
+ var stackString
+
+ Object.defineProperty(error, 'constructor', {
+ value: DeprecationError
+ })
+
+ Object.defineProperty(error, 'message', {
+ configurable: true,
+ enumerable: false,
+ value: message,
+ writable: true
+ })
+
+ Object.defineProperty(error, 'name', {
+ enumerable: false,
+ configurable: true,
+ value: 'DeprecationError',
+ writable: true
+ })
+
+ Object.defineProperty(error, 'namespace', {
+ configurable: true,
+ enumerable: false,
+ value: namespace,
+ writable: true
+ })
+
+ Object.defineProperty(error, 'stack', {
+ configurable: true,
+ enumerable: false,
+ get: function () {
+ if (stackString !== undefined) {
+ return stackString
+ }
+
+ // prepare stack trace
+ return (stackString = createStackString.call(this, stack))
+ },
+ set: function setter (val) {
+ stackString = val
+ }
+ })
+
+ return error
+}
+
+
+/***/ }),
+
+/***/ "../../../.yarn/berry/cache/escodegen-npm-1.14.3-a4dedc6eeb-9.zip/node_modules/escodegen/escodegen.js":
+/*!************************************************************************************************************!*\
+ !*** ../../../.yarn/berry/cache/escodegen-npm-1.14.3-a4dedc6eeb-9.zip/node_modules/escodegen/escodegen.js ***!
+ \************************************************************************************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+/*
+ Copyright (C) 2012-2014 Yusuke Suzuki
+ Copyright (C) 2015 Ingvar Stepanyan
+ Copyright (C) 2014 Ivan Nikulin
+ Copyright (C) 2012-2013 Michael Ficarra
+ Copyright (C) 2012-2013 Mathias Bynens
+ Copyright (C) 2013 Irakli Gozalishvili
+ Copyright (C) 2012 Robert Gust-Bardon
+ Copyright (C) 2012 John Freeman
+ Copyright (C) 2011-2012 Ariya Hidayat
+ Copyright (C) 2012 Joost-Wim Boekesteijn
+ Copyright (C) 2012 Kris Kowal
+ Copyright (C) 2012 Arpad Borsos
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/*global exports:true, require:true, global:true*/
+(function () {
+ 'use strict';
+
+ var Syntax,
+ Precedence,
+ BinaryPrecedence,
+ SourceNode,
+ estraverse,
+ esutils,
+ base,
+ indent,
+ json,
+ renumber,
+ hexadecimal,
+ quotes,
+ escapeless,
+ newline,
+ space,
+ parentheses,
+ semicolons,
+ safeConcatenation,
+ directive,
+ extra,
+ parse,
+ sourceMap,
+ sourceCode,
+ preserveBlankLines,
+ FORMAT_MINIFY,
+ FORMAT_DEFAULTS;
+
+ estraverse = __webpack_require__(/*! estraverse */ "../../../.yarn/berry/cache/estraverse-npm-4.3.0-920a32f3c6-9.zip/node_modules/estraverse/estraverse.js");
+ esutils = __webpack_require__(/*! esutils */ "../../../.yarn/berry/cache/esutils-npm-2.0.3-f865beafd5-9.zip/node_modules/esutils/lib/utils.js");
+
+ Syntax = estraverse.Syntax;
+
+ // Generation is done by generateExpression.
+ function isExpression(node) {
+ return CodeGenerator.Expression.hasOwnProperty(node.type);
+ }
+
+ // Generation is done by generateStatement.
+ function isStatement(node) {
+ return CodeGenerator.Statement.hasOwnProperty(node.type);
+ }
+
+ Precedence = {
+ Sequence: 0,
+ Yield: 1,
+ Assignment: 1,
+ Conditional: 2,
+ ArrowFunction: 2,
+ LogicalOR: 3,
+ LogicalAND: 4,
+ BitwiseOR: 5,
+ BitwiseXOR: 6,
+ BitwiseAND: 7,
+ Equality: 8,
+ Relational: 9,
+ BitwiseSHIFT: 10,
+ Additive: 11,
+ Multiplicative: 12,
+ Exponentiation: 13,
+ Await: 14,
+ Unary: 14,
+ Postfix: 15,
+ Call: 16,
+ New: 17,
+ TaggedTemplate: 18,
+ Member: 19,
+ Primary: 20
+ };
+
+ BinaryPrecedence = {
+ '||': Precedence.LogicalOR,
+ '&&': Precedence.LogicalAND,
+ '|': Precedence.BitwiseOR,
+ '^': Precedence.BitwiseXOR,
+ '&': Precedence.BitwiseAND,
+ '==': Precedence.Equality,
+ '!=': Precedence.Equality,
+ '===': Precedence.Equality,
+ '!==': Precedence.Equality,
+ 'is': Precedence.Equality,
+ 'isnt': Precedence.Equality,
+ '<': Precedence.Relational,
+ '>': Precedence.Relational,
+ '<=': Precedence.Relational,
+ '>=': Precedence.Relational,
+ 'in': Precedence.Relational,
+ 'instanceof': Precedence.Relational,
+ '<<': Precedence.BitwiseSHIFT,
+ '>>': Precedence.BitwiseSHIFT,
+ '>>>': Precedence.BitwiseSHIFT,
+ '+': Precedence.Additive,
+ '-': Precedence.Additive,
+ '*': Precedence.Multiplicative,
+ '%': Precedence.Multiplicative,
+ '/': Precedence.Multiplicative,
+ '**': Precedence.Exponentiation
+ };
+
+ //Flags
+ var F_ALLOW_IN = 1,
+ F_ALLOW_CALL = 1 << 1,
+ F_ALLOW_UNPARATH_NEW = 1 << 2,
+ F_FUNC_BODY = 1 << 3,
+ F_DIRECTIVE_CTX = 1 << 4,
+ F_SEMICOLON_OPT = 1 << 5;
+
+ //Expression flag sets
+ //NOTE: Flag order:
+ // F_ALLOW_IN
+ // F_ALLOW_CALL
+ // F_ALLOW_UNPARATH_NEW
+ var E_FTT = F_ALLOW_CALL | F_ALLOW_UNPARATH_NEW,
+ E_TTF = F_ALLOW_IN | F_ALLOW_CALL,
+ E_TTT = F_ALLOW_IN | F_ALLOW_CALL | F_ALLOW_UNPARATH_NEW,
+ E_TFF = F_ALLOW_IN,
+ E_FFT = F_ALLOW_UNPARATH_NEW,
+ E_TFT = F_ALLOW_IN | F_ALLOW_UNPARATH_NEW;
+
+ //Statement flag sets
+ //NOTE: Flag order:
+ // F_ALLOW_IN
+ // F_FUNC_BODY
+ // F_DIRECTIVE_CTX
+ // F_SEMICOLON_OPT
+ var S_TFFF = F_ALLOW_IN,
+ S_TFFT = F_ALLOW_IN | F_SEMICOLON_OPT,
+ S_FFFF = 0x00,
+ S_TFTF = F_ALLOW_IN | F_DIRECTIVE_CTX,
+ S_TTFF = F_ALLOW_IN | F_FUNC_BODY;
+
+ function getDefaultOptions() {
+ // default options
+ return {
+ indent: null,
+ base: null,
+ parse: null,
+ comment: false,
+ format: {
+ indent: {
+ style: ' ',
+ base: 0,
+ adjustMultilineComment: false
+ },
+ newline: '\n',
+ space: ' ',
+ json: false,
+ renumber: false,
+ hexadecimal: false,
+ quotes: 'single',
+ escapeless: false,
+ compact: false,
+ parentheses: true,
+ semicolons: true,
+ safeConcatenation: false,
+ preserveBlankLines: false
+ },
+ moz: {
+ comprehensionExpressionStartsWithAssignment: false,
+ starlessGenerator: false
+ },
+ sourceMap: null,
+ sourceMapRoot: null,
+ sourceMapWithCode: false,
+ directive: false,
+ raw: true,
+ verbatim: null,
+ sourceCode: null
+ };
+ }
+
+ function stringRepeat(str, num) {
+ var result = '';
+
+ for (num |= 0; num > 0; num >>>= 1, str += str) {
+ if (num & 1) {
+ result += str;
+ }
+ }
+
+ return result;
+ }
+
+ function hasLineTerminator(str) {
+ return (/[\r\n]/g).test(str);
+ }
+
+ function endsWithLineTerminator(str) {
+ var len = str.length;
+ return len && esutils.code.isLineTerminator(str.charCodeAt(len - 1));
+ }
+
+ function merge(target, override) {
+ var key;
+ for (key in override) {
+ if (override.hasOwnProperty(key)) {
+ target[key] = override[key];
+ }
+ }
+ return target;
+ }
+
+ function updateDeeply(target, override) {
+ var key, val;
+
+ function isHashObject(target) {
+ return typeof target === 'object' && target instanceof Object && !(target instanceof RegExp);
+ }
+
+ for (key in override) {
+ if (override.hasOwnProperty(key)) {
+ val = override[key];
+ if (isHashObject(val)) {
+ if (isHashObject(target[key])) {
+ updateDeeply(target[key], val);
+ } else {
+ target[key] = updateDeeply({}, val);
+ }
+ } else {
+ target[key] = val;
+ }
+ }
+ }
+ return target;
+ }
+
+ function generateNumber(value) {
+ var result, point, temp, exponent, pos;
+
+ if (value !== value) {
+ throw new Error('Numeric literal whose value is NaN');
+ }
+ if (value < 0 || (value === 0 && 1 / value < 0)) {
+ throw new Error('Numeric literal whose value is negative');
+ }
+
+ if (value === 1 / 0) {
+ return json ? 'null' : renumber ? '1e400' : '1e+400';
+ }
+
+ result = '' + value;
+ if (!renumber || result.length < 3) {
+ return result;
+ }
+
+ point = result.indexOf('.');
+ if (!json && result.charCodeAt(0) === 0x30 /* 0 */ && point === 1) {
+ point = 0;
+ result = result.slice(1);
+ }
+ temp = result;
+ result = result.replace('e+', 'e');
+ exponent = 0;
+ if ((pos = temp.indexOf('e')) > 0) {
+ exponent = +temp.slice(pos + 1);
+ temp = temp.slice(0, pos);
+ }
+ if (point >= 0) {
+ exponent -= temp.length - point - 1;
+ temp = +(temp.slice(0, point) + temp.slice(point + 1)) + '';
+ }
+ pos = 0;
+ while (temp.charCodeAt(temp.length + pos - 1) === 0x30 /* 0 */) {
+ --pos;
+ }
+ if (pos !== 0) {
+ exponent -= pos;
+ temp = temp.slice(0, pos);
+ }
+ if (exponent !== 0) {
+ temp += 'e' + exponent;
+ }
+ if ((temp.length < result.length ||
+ (hexadecimal && value > 1e12 && Math.floor(value) === value && (temp = '0x' + value.toString(16)).length < result.length)) &&
+ +temp === value) {
+ result = temp;
+ }
+
+ return result;
+ }
+
+ // Generate valid RegExp expression.
+ // This function is based on https://github.com/Constellation/iv Engine
+
+ function escapeRegExpCharacter(ch, previousIsBackslash) {
+ // not handling '\' and handling \u2028 or \u2029 to unicode escape sequence
+ if ((ch & ~1) === 0x2028) {
+ return (previousIsBackslash ? 'u' : '\\u') + ((ch === 0x2028) ? '2028' : '2029');
+ } else if (ch === 10 || ch === 13) { // \n, \r
+ return (previousIsBackslash ? '' : '\\') + ((ch === 10) ? 'n' : 'r');
+ }
+ return String.fromCharCode(ch);
+ }
+
+ function generateRegExp(reg) {
+ var match, result, flags, i, iz, ch, characterInBrack, previousIsBackslash;
+
+ result = reg.toString();
+
+ if (reg.source) {
+ // extract flag from toString result
+ match = result.match(/\/([^/]*)$/);
+ if (!match) {
+ return result;
+ }
+
+ flags = match[1];
+ result = '';
+
+ characterInBrack = false;
+ previousIsBackslash = false;
+ for (i = 0, iz = reg.source.length; i < iz; ++i) {
+ ch = reg.source.charCodeAt(i);
+
+ if (!previousIsBackslash) {
+ if (characterInBrack) {
+ if (ch === 93) { // ]
+ characterInBrack = false;
+ }
+ } else {
+ if (ch === 47) { // /
+ result += '\\';
+ } else if (ch === 91) { // [
+ characterInBrack = true;
+ }
+ }
+ result += escapeRegExpCharacter(ch, previousIsBackslash);
+ previousIsBackslash = ch === 92; // \
+ } else {
+ // if new RegExp("\\\n') is provided, create /\n/
+ result += escapeRegExpCharacter(ch, previousIsBackslash);
+ // prevent like /\\[/]/
+ previousIsBackslash = false;
+ }
+ }
+
+ return '/' + result + '/' + flags;
+ }
+
+ return result;
+ }
+
+ function escapeAllowedCharacter(code, next) {
+ var hex;
+
+ if (code === 0x08 /* \b */) {
+ return '\\b';
+ }
+
+ if (code === 0x0C /* \f */) {
+ return '\\f';
+ }
+
+ if (code === 0x09 /* \t */) {
+ return '\\t';
+ }
+
+ hex = code.toString(16).toUpperCase();
+ if (json || code > 0xFF) {
+ return '\\u' + '0000'.slice(hex.length) + hex;
+ } else if (code === 0x0000 && !esutils.code.isDecimalDigit(next)) {
+ return '\\0';
+ } else if (code === 0x000B /* \v */) { // '\v'
+ return '\\x0B';
+ } else {
+ return '\\x' + '00'.slice(hex.length) + hex;
+ }
+ }
+
+ function escapeDisallowedCharacter(code) {
+ if (code === 0x5C /* \ */) {
+ return '\\\\';
+ }
+
+ if (code === 0x0A /* \n */) {
+ return '\\n';
+ }
+
+ if (code === 0x0D /* \r */) {
+ return '\\r';
+ }
+
+ if (code === 0x2028) {
+ return '\\u2028';
+ }
+
+ if (code === 0x2029) {
+ return '\\u2029';
+ }
+
+ throw new Error('Incorrectly classified character');
+ }
+
+ function escapeDirective(str) {
+ var i, iz, code, quote;
+
+ quote = quotes === 'double' ? '"' : '\'';
+ for (i = 0, iz = str.length; i < iz; ++i) {
+ code = str.charCodeAt(i);
+ if (code === 0x27 /* ' */) {
+ quote = '"';
+ break;
+ } else if (code === 0x22 /* " */) {
+ quote = '\'';
+ break;
+ } else if (code === 0x5C /* \ */) {
+ ++i;
+ }
+ }
+
+ return quote + str + quote;
+ }
+
+ function escapeString(str) {
+ var result = '', i, len, code, singleQuotes = 0, doubleQuotes = 0, single, quote;
+
+ for (i = 0, len = str.length; i < len; ++i) {
+ code = str.charCodeAt(i);
+ if (code === 0x27 /* ' */) {
+ ++singleQuotes;
+ } else if (code === 0x22 /* " */) {
+ ++doubleQuotes;
+ } else if (code === 0x2F /* / */ && json) {
+ result += '\\';
+ } else if (esutils.code.isLineTerminator(code) || code === 0x5C /* \ */) {
+ result += escapeDisallowedCharacter(code);
+ continue;
+ } else if (!esutils.code.isIdentifierPartES5(code) && (json && code < 0x20 /* SP */ || !json && !escapeless && (code < 0x20 /* SP */ || code > 0x7E /* ~ */))) {
+ result += escapeAllowedCharacter(code, str.charCodeAt(i + 1));
+ continue;
+ }
+ result += String.fromCharCode(code);
+ }
+
+ single = !(quotes === 'double' || (quotes === 'auto' && doubleQuotes < singleQuotes));
+ quote = single ? '\'' : '"';
+
+ if (!(single ? singleQuotes : doubleQuotes)) {
+ return quote + result + quote;
+ }
+
+ str = result;
+ result = quote;
+
+ for (i = 0, len = str.length; i < len; ++i) {
+ code = str.charCodeAt(i);
+ if ((code === 0x27 /* ' */ && single) || (code === 0x22 /* " */ && !single)) {
+ result += '\\';
+ }
+ result += String.fromCharCode(code);
+ }
+
+ return result + quote;
+ }
+
+ /**
+ * flatten an array to a string, where the array can contain
+ * either strings or nested arrays
+ */
+ function flattenToString(arr) {
+ var i, iz, elem, result = '';
+ for (i = 0, iz = arr.length; i < iz; ++i) {
+ elem = arr[i];
+ result += Array.isArray(elem) ? flattenToString(elem) : elem;
+ }
+ return result;
+ }
+
+ /**
+ * convert generated to a SourceNode when source maps are enabled.
+ */
+ function toSourceNodeWhenNeeded(generated, node) {
+ if (!sourceMap) {
+ // with no source maps, generated is either an
+ // array or a string. if an array, flatten it.
+ // if a string, just return it
+ if (Array.isArray(generated)) {
+ return flattenToString(generated);
+ } else {
+ return generated;
+ }
+ }
+ if (node == null) {
+ if (generated instanceof SourceNode) {
+ return generated;
+ } else {
+ node = {};
+ }
+ }
+ if (node.loc == null) {
+ return new SourceNode(null, null, sourceMap, generated, node.name || null);
+ }
+ return new SourceNode(node.loc.start.line, node.loc.start.column, (sourceMap === true ? node.loc.source || null : sourceMap), generated, node.name || null);
+ }
+
+ function noEmptySpace() {
+ return (space) ? space : ' ';
+ }
+
+ function join(left, right) {
+ var leftSource,
+ rightSource,
+ leftCharCode,
+ rightCharCode;
+
+ leftSource = toSourceNodeWhenNeeded(left).toString();
+ if (leftSource.length === 0) {
+ return [right];
+ }
+
+ rightSource = toSourceNodeWhenNeeded(right).toString();
+ if (rightSource.length === 0) {
+ return [left];
+ }
+
+ leftCharCode = leftSource.charCodeAt(leftSource.length - 1);
+ rightCharCode = rightSource.charCodeAt(0);
+
+ if ((leftCharCode === 0x2B /* + */ || leftCharCode === 0x2D /* - */) && leftCharCode === rightCharCode ||
+ esutils.code.isIdentifierPartES5(leftCharCode) && esutils.code.isIdentifierPartES5(rightCharCode) ||
+ leftCharCode === 0x2F /* / */ && rightCharCode === 0x69 /* i */) { // infix word operators all start with `i`
+ return [left, noEmptySpace(), right];
+ } else if (esutils.code.isWhiteSpace(leftCharCode) || esutils.code.isLineTerminator(leftCharCode) ||
+ esutils.code.isWhiteSpace(rightCharCode) || esutils.code.isLineTerminator(rightCharCode)) {
+ return [left, right];
+ }
+ return [left, space, right];
+ }
+
+ function addIndent(stmt) {
+ return [base, stmt];
+ }
+
+ function withIndent(fn) {
+ var previousBase;
+ previousBase = base;
+ base += indent;
+ fn(base);
+ base = previousBase;
+ }
+
+ function calculateSpaces(str) {
+ var i;
+ for (i = str.length - 1; i >= 0; --i) {
+ if (esutils.code.isLineTerminator(str.charCodeAt(i))) {
+ break;
+ }
+ }
+ return (str.length - 1) - i;
+ }
+
+ function adjustMultilineComment(value, specialBase) {
+ var array, i, len, line, j, spaces, previousBase, sn;
+
+ array = value.split(/\r\n|[\r\n]/);
+ spaces = Number.MAX_VALUE;
+
+ // first line doesn't have indentation
+ for (i = 1, len = array.length; i < len; ++i) {
+ line = array[i];
+ j = 0;
+ while (j < line.length && esutils.code.isWhiteSpace(line.charCodeAt(j))) {
+ ++j;
+ }
+ if (spaces > j) {
+ spaces = j;
+ }
+ }
+
+ if (typeof specialBase !== 'undefined') {
+ // pattern like
+ // {
+ // var t = 20; /*
+ // * this is comment
+ // */
+ // }
+ previousBase = base;
+ if (array[1][spaces] === '*') {
+ specialBase += ' ';
+ }
+ base = specialBase;
+ } else {
+ if (spaces & 1) {
+ // /*
+ // *
+ // */
+ // If spaces are odd number, above pattern is considered.
+ // We waste 1 space.
+ --spaces;
+ }
+ previousBase = base;
+ }
+
+ for (i = 1, len = array.length; i < len; ++i) {
+ sn = toSourceNodeWhenNeeded(addIndent(array[i].slice(spaces)));
+ array[i] = sourceMap ? sn.join('') : sn;
+ }
+
+ base = previousBase;
+
+ return array.join('\n');
+ }
+
+ function generateComment(comment, specialBase) {
+ if (comment.type === 'Line') {
+ if (endsWithLineTerminator(comment.value)) {
+ return '//' + comment.value;
+ } else {
+ // Always use LineTerminator
+ var result = '//' + comment.value;
+ if (!preserveBlankLines) {
+ result += '\n';
+ }
+ return result;
+ }
+ }
+ if (extra.format.indent.adjustMultilineComment && /[\n\r]/.test(comment.value)) {
+ return adjustMultilineComment('/*' + comment.value + '*/', specialBase);
+ }
+ return '/*' + comment.value + '*/';
+ }
+
+ function addComments(stmt, result) {
+ var i, len, comment, save, tailingToStatement, specialBase, fragment,
+ extRange, range, prevRange, prefix, infix, suffix, count;
+
+ if (stmt.leadingComments && stmt.leadingComments.length > 0) {
+ save = result;
+
+ if (preserveBlankLines) {
+ comment = stmt.leadingComments[0];
+ result = [];
+
+ extRange = comment.extendedRange;
+ range = comment.range;
+
+ prefix = sourceCode.substring(extRange[0], range[0]);
+ count = (prefix.match(/\n/g) || []).length;
+ if (count > 0) {
+ result.push(stringRepeat('\n', count));
+ result.push(addIndent(generateComment(comment)));
+ } else {
+ result.push(prefix);
+ result.push(generateComment(comment));
+ }
+
+ prevRange = range;
+
+ for (i = 1, len = stmt.leadingComments.length; i < len; i++) {
+ comment = stmt.leadingComments[i];
+ range = comment.range;
+
+ infix = sourceCode.substring(prevRange[1], range[0]);
+ count = (infix.match(/\n/g) || []).length;
+ result.push(stringRepeat('\n', count));
+ result.push(addIndent(generateComment(comment)));
+
+ prevRange = range;
+ }
+
+ suffix = sourceCode.substring(range[1], extRange[1]);
+ count = (suffix.match(/\n/g) || []).length;
+ result.push(stringRepeat('\n', count));
+ } else {
+ comment = stmt.leadingComments[0];
+ result = [];
+ if (safeConcatenation && stmt.type === Syntax.Program && stmt.body.length === 0) {
+ result.push('\n');
+ }
+ result.push(generateComment(comment));
+ if (!endsWithLineTerminator(toSourceNodeWhenNeeded(result).toString())) {
+ result.push('\n');
+ }
+
+ for (i = 1, len = stmt.leadingComments.length; i < len; ++i) {
+ comment = stmt.leadingComments[i];
+ fragment = [generateComment(comment)];
+ if (!endsWithLineTerminator(toSourceNodeWhenNeeded(fragment).toString())) {
+ fragment.push('\n');
+ }
+ result.push(addIndent(fragment));
+ }
+ }
+
+ result.push(addIndent(save));
+ }
+
+ if (stmt.trailingComments) {
+
+ if (preserveBlankLines) {
+ comment = stmt.trailingComments[0];
+ extRange = comment.extendedRange;
+ range = comment.range;
+
+ prefix = sourceCode.substring(extRange[0], range[0]);
+ count = (prefix.match(/\n/g) || []).length;
+
+ if (count > 0) {
+ result.push(stringRepeat('\n', count));
+ result.push(addIndent(generateComment(comment)));
+ } else {
+ result.push(prefix);
+ result.push(generateComment(comment));
+ }
+ } else {
+ tailingToStatement = !endsWithLineTerminator(toSourceNodeWhenNeeded(result).toString());
+ specialBase = stringRepeat(' ', calculateSpaces(toSourceNodeWhenNeeded([base, result, indent]).toString()));
+ for (i = 0, len = stmt.trailingComments.length; i < len; ++i) {
+ comment = stmt.trailingComments[i];
+ if (tailingToStatement) {
+ // We assume target like following script
+ //
+ // var t = 20; /**
+ // * This is comment of t
+ // */
+ if (i === 0) {
+ // first case
+ result = [result, indent];
+ } else {
+ result = [result, specialBase];
+ }
+ result.push(generateComment(comment, specialBase));
+ } else {
+ result = [result, addIndent(generateComment(comment))];
+ }
+ if (i !== len - 1 && !endsWithLineTerminator(toSourceNodeWhenNeeded(result).toString())) {
+ result = [result, '\n'];
+ }
+ }
+ }
+ }
+
+ return result;
+ }
+
+ function generateBlankLines(start, end, result) {
+ var j, newlineCount = 0;
+
+ for (j = start; j < end; j++) {
+ if (sourceCode[j] === '\n') {
+ newlineCount++;
+ }
+ }
+
+ for (j = 1; j < newlineCount; j++) {
+ result.push(newline);
+ }
+ }
+
+ function parenthesize(text, current, should) {
+ if (current < should) {
+ return ['(', text, ')'];
+ }
+ return text;
+ }
+
+ function generateVerbatimString(string) {
+ var i, iz, result;
+ result = string.split(/\r\n|\n/);
+ for (i = 1, iz = result.length; i < iz; i++) {
+ result[i] = newline + base + result[i];
+ }
+ return result;
+ }
+
+ function generateVerbatim(expr, precedence) {
+ var verbatim, result, prec;
+ verbatim = expr[extra.verbatim];
+
+ if (typeof verbatim === 'string') {
+ result = parenthesize(generateVerbatimString(verbatim), Precedence.Sequence, precedence);
+ } else {
+ // verbatim is object
+ result = generateVerbatimString(verbatim.content);
+ prec = (verbatim.precedence != null) ? verbatim.precedence : Precedence.Sequence;
+ result = parenthesize(result, prec, precedence);
+ }
+
+ return toSourceNodeWhenNeeded(result, expr);
+ }
+
+ function CodeGenerator() {
+ }
+
+ // Helpers.
+
+ CodeGenerator.prototype.maybeBlock = function(stmt, flags) {
+ var result, noLeadingComment, that = this;
+
+ noLeadingComment = !extra.comment || !stmt.leadingComments;
+
+ if (stmt.type === Syntax.BlockStatement && noLeadingComment) {
+ return [space, this.generateStatement(stmt, flags)];
+ }
+
+ if (stmt.type === Syntax.EmptyStatement && noLeadingComment) {
+ return ';';
+ }
+
+ withIndent(function () {
+ result = [
+ newline,
+ addIndent(that.generateStatement(stmt, flags))
+ ];
+ });
+
+ return result;
+ };
+
+ CodeGenerator.prototype.maybeBlockSuffix = function (stmt, result) {
+ var ends = endsWithLineTerminator(toSourceNodeWhenNeeded(result).toString());
+ if (stmt.type === Syntax.BlockStatement && (!extra.comment || !stmt.leadingComments) && !ends) {
+ return [result, space];
+ }
+ if (ends) {
+ return [result, base];
+ }
+ return [result, newline, base];
+ };
+
+ function generateIdentifier(node) {
+ return toSourceNodeWhenNeeded(node.name, node);
+ }
+
+ function generateAsyncPrefix(node, spaceRequired) {
+ return node.async ? 'async' + (spaceRequired ? noEmptySpace() : space) : '';
+ }
+
+ function generateStarSuffix(node) {
+ var isGenerator = node.generator && !extra.moz.starlessGenerator;
+ return isGenerator ? '*' + space : '';
+ }
+
+ function generateMethodPrefix(prop) {
+ var func = prop.value, prefix = '';
+ if (func.async) {
+ prefix += generateAsyncPrefix(func, !prop.computed);
+ }
+ if (func.generator) {
+ // avoid space before method name
+ prefix += generateStarSuffix(func) ? '*' : '';
+ }
+ return prefix;
+ }
+
+ CodeGenerator.prototype.generatePattern = function (node, precedence, flags) {
+ if (node.type === Syntax.Identifier) {
+ return generateIdentifier(node);
+ }
+ return this.generateExpression(node, precedence, flags);
+ };
+
+ CodeGenerator.prototype.generateFunctionParams = function (node) {
+ var i, iz, result, hasDefault;
+
+ hasDefault = false;
+
+ if (node.type === Syntax.ArrowFunctionExpression &&
+ !node.rest && (!node.defaults || node.defaults.length === 0) &&
+ node.params.length === 1 && node.params[0].type === Syntax.Identifier) {
+ // arg => { } case
+ result = [generateAsyncPrefix(node, true), generateIdentifier(node.params[0])];
+ } else {
+ result = node.type === Syntax.ArrowFunctionExpression ? [generateAsyncPrefix(node, false)] : [];
+ result.push('(');
+ if (node.defaults) {
+ hasDefault = true;
+ }
+ for (i = 0, iz = node.params.length; i < iz; ++i) {
+ if (hasDefault && node.defaults[i]) {
+ // Handle default values.
+ result.push(this.generateAssignment(node.params[i], node.defaults[i], '=', Precedence.Assignment, E_TTT));
+ } else {
+ result.push(this.generatePattern(node.params[i], Precedence.Assignment, E_TTT));
+ }
+ if (i + 1 < iz) {
+ result.push(',' + space);
+ }
+ }
+
+ if (node.rest) {
+ if (node.params.length) {
+ result.push(',' + space);
+ }
+ result.push('...');
+ result.push(generateIdentifier(node.rest));
+ }
+
+ result.push(')');
+ }
+
+ return result;
+ };
+
+ CodeGenerator.prototype.generateFunctionBody = function (node) {
+ var result, expr;
+
+ result = this.generateFunctionParams(node);
+
+ if (node.type === Syntax.ArrowFunctionExpression) {
+ result.push(space);
+ result.push('=>');
+ }
+
+ if (node.expression) {
+ result.push(space);
+ expr = this.generateExpression(node.body, Precedence.Assignment, E_TTT);
+ if (expr.toString().charAt(0) === '{') {
+ expr = ['(', expr, ')'];
+ }
+ result.push(expr);
+ } else {
+ result.push(this.maybeBlock(node.body, S_TTFF));
+ }
+
+ return result;
+ };
+
+ CodeGenerator.prototype.generateIterationForStatement = function (operator, stmt, flags) {
+ var result = ['for' + (stmt.await ? noEmptySpace() + 'await' : '') + space + '('], that = this;
+ withIndent(function () {
+ if (stmt.left.type === Syntax.VariableDeclaration) {
+ withIndent(function () {
+ result.push(stmt.left.kind + noEmptySpace());
+ result.push(that.generateStatement(stmt.left.declarations[0], S_FFFF));
+ });
+ } else {
+ result.push(that.generateExpression(stmt.left, Precedence.Call, E_TTT));
+ }
+
+ result = join(result, operator);
+ result = [join(
+ result,
+ that.generateExpression(stmt.right, Precedence.Assignment, E_TTT)
+ ), ')'];
+ });
+ result.push(this.maybeBlock(stmt.body, flags));
+ return result;
+ };
+
+ CodeGenerator.prototype.generatePropertyKey = function (expr, computed) {
+ var result = [];
+
+ if (computed) {
+ result.push('[');
+ }
+
+ result.push(this.generateExpression(expr, Precedence.Assignment, E_TTT));
+
+ if (computed) {
+ result.push(']');
+ }
+
+ return result;
+ };
+
+ CodeGenerator.prototype.generateAssignment = function (left, right, operator, precedence, flags) {
+ if (Precedence.Assignment < precedence) {
+ flags |= F_ALLOW_IN;
+ }
+
+ return parenthesize(
+ [
+ this.generateExpression(left, Precedence.Call, flags),
+ space + operator + space,
+ this.generateExpression(right, Precedence.Assignment, flags)
+ ],
+ Precedence.Assignment,
+ precedence
+ );
+ };
+
+ CodeGenerator.prototype.semicolon = function (flags) {
+ if (!semicolons && flags & F_SEMICOLON_OPT) {
+ return '';
+ }
+ return ';';
+ };
+
+ // Statements.
+
+ CodeGenerator.Statement = {
+
+ BlockStatement: function (stmt, flags) {
+ var range, content, result = ['{', newline], that = this;
+
+ withIndent(function () {
+ // handle functions without any code
+ if (stmt.body.length === 0 && preserveBlankLines) {
+ range = stmt.range;
+ if (range[1] - range[0] > 2) {
+ content = sourceCode.substring(range[0] + 1, range[1] - 1);
+ if (content[0] === '\n') {
+ result = ['{'];
+ }
+ result.push(content);
+ }
+ }
+
+ var i, iz, fragment, bodyFlags;
+ bodyFlags = S_TFFF;
+ if (flags & F_FUNC_BODY) {
+ bodyFlags |= F_DIRECTIVE_CTX;
+ }
+
+ for (i = 0, iz = stmt.body.length; i < iz; ++i) {
+ if (preserveBlankLines) {
+ // handle spaces before the first line
+ if (i === 0) {
+ if (stmt.body[0].leadingComments) {
+ range = stmt.body[0].leadingComments[0].extendedRange;
+ content = sourceCode.substring(range[0], range[1]);
+ if (content[0] === '\n') {
+ result = ['{'];
+ }
+ }
+ if (!stmt.body[0].leadingComments) {
+ generateBlankLines(stmt.range[0], stmt.body[0].range[0], result);
+ }
+ }
+
+ // handle spaces between lines
+ if (i > 0) {
+ if (!stmt.body[i - 1].trailingComments && !stmt.body[i].leadingComments) {
+ generateBlankLines(stmt.body[i - 1].range[1], stmt.body[i].range[0], result);
+ }
+ }
+ }
+
+ if (i === iz - 1) {
+ bodyFlags |= F_SEMICOLON_OPT;
+ }
+
+ if (stmt.body[i].leadingComments && preserveBlankLines) {
+ fragment = that.generateStatement(stmt.body[i], bodyFlags);
+ } else {
+ fragment = addIndent(that.generateStatement(stmt.body[i], bodyFlags));
+ }
+
+ result.push(fragment);
+ if (!endsWithLineTerminator(toSourceNodeWhenNeeded(fragment).toString())) {
+ if (preserveBlankLines && i < iz - 1) {
+ // don't add a new line if there are leading coments
+ // in the next statement
+ if (!stmt.body[i + 1].leadingComments) {
+ result.push(newline);
+ }
+ } else {
+ result.push(newline);
+ }
+ }
+
+ if (preserveBlankLines) {
+ // handle spaces after the last line
+ if (i === iz - 1) {
+ if (!stmt.body[i].trailingComments) {
+ generateBlankLines(stmt.body[i].range[1], stmt.range[1], result);
+ }
+ }
+ }
+ }
+ });
+
+ result.push(addIndent('}'));
+ return result;
+ },
+
+ BreakStatement: function (stmt, flags) {
+ if (stmt.label) {
+ return 'break ' + stmt.label.name + this.semicolon(flags);
+ }
+ return 'break' + this.semicolon(flags);
+ },
+
+ ContinueStatement: function (stmt, flags) {
+ if (stmt.label) {
+ return 'continue ' + stmt.label.name + this.semicolon(flags);
+ }
+ return 'continue' + this.semicolon(flags);
+ },
+
+ ClassBody: function (stmt, flags) {
+ var result = [ '{', newline], that = this;
+
+ withIndent(function (indent) {
+ var i, iz;
+
+ for (i = 0, iz = stmt.body.length; i < iz; ++i) {
+ result.push(indent);
+ result.push(that.generateExpression(stmt.body[i], Precedence.Sequence, E_TTT));
+ if (i + 1 < iz) {
+ result.push(newline);
+ }
+ }
+ });
+
+ if (!endsWithLineTerminator(toSourceNodeWhenNeeded(result).toString())) {
+ result.push(newline);
+ }
+ result.push(base);
+ result.push('}');
+ return result;
+ },
+
+ ClassDeclaration: function (stmt, flags) {
+ var result, fragment;
+ result = ['class'];
+ if (stmt.id) {
+ result = join(result, this.generateExpression(stmt.id, Precedence.Sequence, E_TTT));
+ }
+ if (stmt.superClass) {
+ fragment = join('extends', this.generateExpression(stmt.superClass, Precedence.Unary, E_TTT));
+ result = join(result, fragment);
+ }
+ result.push(space);
+ result.push(this.generateStatement(stmt.body, S_TFFT));
+ return result;
+ },
+
+ DirectiveStatement: function (stmt, flags) {
+ if (extra.raw && stmt.raw) {
+ return stmt.raw + this.semicolon(flags);
+ }
+ return escapeDirective(stmt.directive) + this.semicolon(flags);
+ },
+
+ DoWhileStatement: function (stmt, flags) {
+ // Because `do 42 while (cond)` is Syntax Error. We need semicolon.
+ var result = join('do', this.maybeBlock(stmt.body, S_TFFF));
+ result = this.maybeBlockSuffix(stmt.body, result);
+ return join(result, [
+ 'while' + space + '(',
+ this.generateExpression(stmt.test, Precedence.Sequence, E_TTT),
+ ')' + this.semicolon(flags)
+ ]);
+ },
+
+ CatchClause: function (stmt, flags) {
+ var result, that = this;
+ withIndent(function () {
+ var guard;
+
+ if (stmt.param) {
+ result = [
+ 'catch' + space + '(',
+ that.generateExpression(stmt.param, Precedence.Sequence, E_TTT),
+ ')'
+ ];
+
+ if (stmt.guard) {
+ guard = that.generateExpression(stmt.guard, Precedence.Sequence, E_TTT);
+ result.splice(2, 0, ' if ', guard);
+ }
+ } else {
+ result = ['catch'];
+ }
+ });
+ result.push(this.maybeBlock(stmt.body, S_TFFF));
+ return result;
+ },
+
+ DebuggerStatement: function (stmt, flags) {
+ return 'debugger' + this.semicolon(flags);
+ },
+
+ EmptyStatement: function (stmt, flags) {
+ return ';';
+ },
+
+ ExportDefaultDeclaration: function (stmt, flags) {
+ var result = [ 'export' ], bodyFlags;
+
+ bodyFlags = (flags & F_SEMICOLON_OPT) ? S_TFFT : S_TFFF;
+
+ // export default HoistableDeclaration[Default]
+ // export default AssignmentExpression[In] ;
+ result = join(result, 'default');
+ if (isStatement(stmt.declaration)) {
+ result = join(result, this.generateStatement(stmt.declaration, bodyFlags));
+ } else {
+ result = join(result, this.generateExpression(stmt.declaration, Precedence.Assignment, E_TTT) + this.semicolon(flags));
+ }
+ return result;
+ },
+
+ ExportNamedDeclaration: function (stmt, flags) {
+ var result = [ 'export' ], bodyFlags, that = this;
+
+ bodyFlags = (flags & F_SEMICOLON_OPT) ? S_TFFT : S_TFFF;
+
+ // export VariableStatement
+ // export Declaration[Default]
+ if (stmt.declaration) {
+ return join(result, this.generateStatement(stmt.declaration, bodyFlags));
+ }
+
+ // export ExportClause[NoReference] FromClause ;
+ // export ExportClause ;
+ if (stmt.specifiers) {
+ if (stmt.specifiers.length === 0) {
+ result = join(result, '{' + space + '}');
+ } else if (stmt.specifiers[0].type === Syntax.ExportBatchSpecifier) {
+ result = join(result, this.generateExpression(stmt.specifiers[0], Precedence.Sequence, E_TTT));
+ } else {
+ result = join(result, '{');
+ withIndent(function (indent) {
+ var i, iz;
+ result.push(newline);
+ for (i = 0, iz = stmt.specifiers.length; i < iz; ++i) {
+ result.push(indent);
+ result.push(that.generateExpression(stmt.specifiers[i], Precedence.Sequence, E_TTT));
+ if (i + 1 < iz) {
+ result.push(',' + newline);
+ }
+ }
+ });
+ if (!endsWithLineTerminator(toSourceNodeWhenNeeded(result).toString())) {
+ result.push(newline);
+ }
+ result.push(base + '}');
+ }
+
+ if (stmt.source) {
+ result = join(result, [
+ 'from' + space,
+ // ModuleSpecifier
+ this.generateExpression(stmt.source, Precedence.Sequence, E_TTT),
+ this.semicolon(flags)
+ ]);
+ } else {
+ result.push(this.semicolon(flags));
+ }
+ }
+ return result;
+ },
+
+ ExportAllDeclaration: function (stmt, flags) {
+ // export * FromClause ;
+ return [
+ 'export' + space,
+ '*' + space,
+ 'from' + space,
+ // ModuleSpecifier
+ this.generateExpression(stmt.source, Precedence.Sequence, E_TTT),
+ this.semicolon(flags)
+ ];
+ },
+
+ ExpressionStatement: function (stmt, flags) {
+ var result, fragment;
+
+ function isClassPrefixed(fragment) {
+ var code;
+ if (fragment.slice(0, 5) !== 'class') {
+ return false;
+ }
+ code = fragment.charCodeAt(5);
+ return code === 0x7B /* '{' */ || esutils.code.isWhiteSpace(code) || esutils.code.isLineTerminator(code);
+ }
+
+ function isFunctionPrefixed(fragment) {
+ var code;
+ if (fragment.slice(0, 8) !== 'function') {
+ return false;
+ }
+ code = fragment.charCodeAt(8);
+ return code === 0x28 /* '(' */ || esutils.code.isWhiteSpace(code) || code === 0x2A /* '*' */ || esutils.code.isLineTerminator(code);
+ }
+
+ function isAsyncPrefixed(fragment) {
+ var code, i, iz;
+ if (fragment.slice(0, 5) !== 'async') {
+ return false;
+ }
+ if (!esutils.code.isWhiteSpace(fragment.charCodeAt(5))) {
+ return false;
+ }
+ for (i = 6, iz = fragment.length; i < iz; ++i) {
+ if (!esutils.code.isWhiteSpace(fragment.charCodeAt(i))) {
+ break;
+ }
+ }
+ if (i === iz) {
+ return false;
+ }
+ if (fragment.slice(i, i + 8) !== 'function') {
+ return false;
+ }
+ code = fragment.charCodeAt(i + 8);
+ return code === 0x28 /* '(' */ || esutils.code.isWhiteSpace(code) || code === 0x2A /* '*' */ || esutils.code.isLineTerminator(code);
+ }
+
+ result = [this.generateExpression(stmt.expression, Precedence.Sequence, E_TTT)];
+ // 12.4 '{', 'function', 'class' is not allowed in this position.
+ // wrap expression with parentheses
+ fragment = toSourceNodeWhenNeeded(result).toString();
+ if (fragment.charCodeAt(0) === 0x7B /* '{' */ || // ObjectExpression
+ isClassPrefixed(fragment) ||
+ isFunctionPrefixed(fragment) ||
+ isAsyncPrefixed(fragment) ||
+ (directive && (flags & F_DIRECTIVE_CTX) && stmt.expression.type === Syntax.Literal && typeof stmt.expression.value === 'string')) {
+ result = ['(', result, ')' + this.semicolon(flags)];
+ } else {
+ result.push(this.semicolon(flags));
+ }
+ return result;
+ },
+
+ ImportDeclaration: function (stmt, flags) {
+ // ES6: 15.2.1 valid import declarations:
+ // - import ImportClause FromClause ;
+ // - import ModuleSpecifier ;
+ var result, cursor, that = this;
+
+ // If no ImportClause is present,
+ // this should be `import ModuleSpecifier` so skip `from`
+ // ModuleSpecifier is StringLiteral.
+ if (stmt.specifiers.length === 0) {
+ // import ModuleSpecifier ;
+ return [
+ 'import',
+ space,
+ // ModuleSpecifier
+ this.generateExpression(stmt.source, Precedence.Sequence, E_TTT),
+ this.semicolon(flags)
+ ];
+ }
+
+ // import ImportClause FromClause ;
+ result = [
+ 'import'
+ ];
+ cursor = 0;
+
+ // ImportedBinding
+ if (stmt.specifiers[cursor].type === Syntax.ImportDefaultSpecifier) {
+ result = join(result, [
+ this.generateExpression(stmt.specifiers[cursor], Precedence.Sequence, E_TTT)
+ ]);
+ ++cursor;
+ }
+
+ if (stmt.specifiers[cursor]) {
+ if (cursor !== 0) {
+ result.push(',');
+ }
+
+ if (stmt.specifiers[cursor].type === Syntax.ImportNamespaceSpecifier) {
+ // NameSpaceImport
+ result = join(result, [
+ space,
+ this.generateExpression(stmt.specifiers[cursor], Precedence.Sequence, E_TTT)
+ ]);
+ } else {
+ // NamedImports
+ result.push(space + '{');
+
+ if ((stmt.specifiers.length - cursor) === 1) {
+ // import { ... } from "...";
+ result.push(space);
+ result.push(this.generateExpression(stmt.specifiers[cursor], Precedence.Sequence, E_TTT));
+ result.push(space + '}' + space);
+ } else {
+ // import {
+ // ...,
+ // ...,
+ // } from "...";
+ withIndent(function (indent) {
+ var i, iz;
+ result.push(newline);
+ for (i = cursor, iz = stmt.specifiers.length; i < iz; ++i) {
+ result.push(indent);
+ result.push(that.generateExpression(stmt.specifiers[i], Precedence.Sequence, E_TTT));
+ if (i + 1 < iz) {
+ result.push(',' + newline);
+ }
+ }
+ });
+ if (!endsWithLineTerminator(toSourceNodeWhenNeeded(result).toString())) {
+ result.push(newline);
+ }
+ result.push(base + '}' + space);
+ }
+ }
+ }
+
+ result = join(result, [
+ 'from' + space,
+ // ModuleSpecifier
+ this.generateExpression(stmt.source, Precedence.Sequence, E_TTT),
+ this.semicolon(flags)
+ ]);
+ return result;
+ },
+
+ VariableDeclarator: function (stmt, flags) {
+ var itemFlags = (flags & F_ALLOW_IN) ? E_TTT : E_FTT;
+ if (stmt.init) {
+ return [
+ this.generateExpression(stmt.id, Precedence.Assignment, itemFlags),
+ space,
+ '=',
+ space,
+ this.generateExpression(stmt.init, Precedence.Assignment, itemFlags)
+ ];
+ }
+ return this.generatePattern(stmt.id, Precedence.Assignment, itemFlags);
+ },
+
+ VariableDeclaration: function (stmt, flags) {
+ // VariableDeclarator is typed as Statement,
+ // but joined with comma (not LineTerminator).
+ // So if comment is attached to target node, we should specialize.
+ var result, i, iz, node, bodyFlags, that = this;
+
+ result = [ stmt.kind ];
+
+ bodyFlags = (flags & F_ALLOW_IN) ? S_TFFF : S_FFFF;
+
+ function block() {
+ node = stmt.declarations[0];
+ if (extra.comment && node.leadingComments) {
+ result.push('\n');
+ result.push(addIndent(that.generateStatement(node, bodyFlags)));
+ } else {
+ result.push(noEmptySpace());
+ result.push(that.generateStatement(node, bodyFlags));
+ }
+
+ for (i = 1, iz = stmt.declarations.length; i < iz; ++i) {
+ node = stmt.declarations[i];
+ if (extra.comment && node.leadingComments) {
+ result.push(',' + newline);
+ result.push(addIndent(that.generateStatement(node, bodyFlags)));
+ } else {
+ result.push(',' + space);
+ result.push(that.generateStatement(node, bodyFlags));
+ }
+ }
+ }
+
+ if (stmt.declarations.length > 1) {
+ withIndent(block);
+ } else {
+ block();
+ }
+
+ result.push(this.semicolon(flags));
+
+ return result;
+ },
+
+ ThrowStatement: function (stmt, flags) {
+ return [join(
+ 'throw',
+ this.generateExpression(stmt.argument, Precedence.Sequence, E_TTT)
+ ), this.semicolon(flags)];
+ },
+
+ TryStatement: function (stmt, flags) {
+ var result, i, iz, guardedHandlers;
+
+ result = ['try', this.maybeBlock(stmt.block, S_TFFF)];
+ result = this.maybeBlockSuffix(stmt.block, result);
+
+ if (stmt.handlers) {
+ // old interface
+ for (i = 0, iz = stmt.handlers.length; i < iz; ++i) {
+ result = join(result, this.generateStatement(stmt.handlers[i], S_TFFF));
+ if (stmt.finalizer || i + 1 !== iz) {
+ result = this.maybeBlockSuffix(stmt.handlers[i].body, result);
+ }
+ }
+ } else {
+ guardedHandlers = stmt.guardedHandlers || [];
+
+ for (i = 0, iz = guardedHandlers.length; i < iz; ++i) {
+ result = join(result, this.generateStatement(guardedHandlers[i], S_TFFF));
+ if (stmt.finalizer || i + 1 !== iz) {
+ result = this.maybeBlockSuffix(guardedHandlers[i].body, result);
+ }
+ }
+
+ // new interface
+ if (stmt.handler) {
+ if (Array.isArray(stmt.handler)) {
+ for (i = 0, iz = stmt.handler.length; i < iz; ++i) {
+ result = join(result, this.generateStatement(stmt.handler[i], S_TFFF));
+ if (stmt.finalizer || i + 1 !== iz) {
+ result = this.maybeBlockSuffix(stmt.handler[i].body, result);
+ }
+ }
+ } else {
+ result = join(result, this.generateStatement(stmt.handler, S_TFFF));
+ if (stmt.finalizer) {
+ result = this.maybeBlockSuffix(stmt.handler.body, result);
+ }
+ }
+ }
+ }
+ if (stmt.finalizer) {
+ result = join(result, ['finally', this.maybeBlock(stmt.finalizer, S_TFFF)]);
+ }
+ return result;
+ },
+
+ SwitchStatement: function (stmt, flags) {
+ var result, fragment, i, iz, bodyFlags, that = this;
+ withIndent(function () {
+ result = [
+ 'switch' + space + '(',
+ that.generateExpression(stmt.discriminant, Precedence.Sequence, E_TTT),
+ ')' + space + '{' + newline
+ ];
+ });
+ if (stmt.cases) {
+ bodyFlags = S_TFFF;
+ for (i = 0, iz = stmt.cases.length; i < iz; ++i) {
+ if (i === iz - 1) {
+ bodyFlags |= F_SEMICOLON_OPT;
+ }
+ fragment = addIndent(this.generateStatement(stmt.cases[i], bodyFlags));
+ result.push(fragment);
+ if (!endsWithLineTerminator(toSourceNodeWhenNeeded(fragment).toString())) {
+ result.push(newline);
+ }
+ }
+ }
+ result.push(addIndent('}'));
+ return result;
+ },
+
+ SwitchCase: function (stmt, flags) {
+ var result, fragment, i, iz, bodyFlags, that = this;
+ withIndent(function () {
+ if (stmt.test) {
+ result = [
+ join('case', that.generateExpression(stmt.test, Precedence.Sequence, E_TTT)),
+ ':'
+ ];
+ } else {
+ result = ['default:'];
+ }
+
+ i = 0;
+ iz = stmt.consequent.length;
+ if (iz && stmt.consequent[0].type === Syntax.BlockStatement) {
+ fragment = that.maybeBlock(stmt.consequent[0], S_TFFF);
+ result.push(fragment);
+ i = 1;
+ }
+
+ if (i !== iz && !endsWithLineTerminator(toSourceNodeWhenNeeded(result).toString())) {
+ result.push(newline);
+ }
+
+ bodyFlags = S_TFFF;
+ for (; i < iz; ++i) {
+ if (i === iz - 1 && flags & F_SEMICOLON_OPT) {
+ bodyFlags |= F_SEMICOLON_OPT;
+ }
+ fragment = addIndent(that.generateStatement(stmt.consequent[i], bodyFlags));
+ result.push(fragment);
+ if (i + 1 !== iz && !endsWithLineTerminator(toSourceNodeWhenNeeded(fragment).toString())) {
+ result.push(newline);
+ }
+ }
+ });
+ return result;
+ },
+
+ IfStatement: function (stmt, flags) {
+ var result, bodyFlags, semicolonOptional, that = this;
+ withIndent(function () {
+ result = [
+ 'if' + space + '(',
+ that.generateExpression(stmt.test, Precedence.Sequence, E_TTT),
+ ')'
+ ];
+ });
+ semicolonOptional = flags & F_SEMICOLON_OPT;
+ bodyFlags = S_TFFF;
+ if (semicolonOptional) {
+ bodyFlags |= F_SEMICOLON_OPT;
+ }
+ if (stmt.alternate) {
+ result.push(this.maybeBlock(stmt.consequent, S_TFFF));
+ result = this.maybeBlockSuffix(stmt.consequent, result);
+ if (stmt.alternate.type === Syntax.IfStatement) {
+ result = join(result, ['else ', this.generateStatement(stmt.alternate, bodyFlags)]);
+ } else {
+ result = join(result, join('else', this.maybeBlock(stmt.alternate, bodyFlags)));
+ }
+ } else {
+ result.push(this.maybeBlock(stmt.consequent, bodyFlags));
+ }
+ return result;
+ },
+
+ ForStatement: function (stmt, flags) {
+ var result, that = this;
+ withIndent(function () {
+ result = ['for' + space + '('];
+ if (stmt.init) {
+ if (stmt.init.type === Syntax.VariableDeclaration) {
+ result.push(that.generateStatement(stmt.init, S_FFFF));
+ } else {
+ // F_ALLOW_IN becomes false.
+ result.push(that.generateExpression(stmt.init, Precedence.Sequence, E_FTT));
+ result.push(';');
+ }
+ } else {
+ result.push(';');
+ }
+
+ if (stmt.test) {
+ result.push(space);
+ result.push(that.generateExpression(stmt.test, Precedence.Sequence, E_TTT));
+ result.push(';');
+ } else {
+ result.push(';');
+ }
+
+ if (stmt.update) {
+ result.push(space);
+ result.push(that.generateExpression(stmt.update, Precedence.Sequence, E_TTT));
+ result.push(')');
+ } else {
+ result.push(')');
+ }
+ });
+
+ result.push(this.maybeBlock(stmt.body, flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF));
+ return result;
+ },
+
+ ForInStatement: function (stmt, flags) {
+ return this.generateIterationForStatement('in', stmt, flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF);
+ },
+
+ ForOfStatement: function (stmt, flags) {
+ return this.generateIterationForStatement('of', stmt, flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF);
+ },
+
+ LabeledStatement: function (stmt, flags) {
+ return [stmt.label.name + ':', this.maybeBlock(stmt.body, flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF)];
+ },
+
+ Program: function (stmt, flags) {
+ var result, fragment, i, iz, bodyFlags;
+ iz = stmt.body.length;
+ result = [safeConcatenation && iz > 0 ? '\n' : ''];
+ bodyFlags = S_TFTF;
+ for (i = 0; i < iz; ++i) {
+ if (!safeConcatenation && i === iz - 1) {
+ bodyFlags |= F_SEMICOLON_OPT;
+ }
+
+ if (preserveBlankLines) {
+ // handle spaces before the first line
+ if (i === 0) {
+ if (!stmt.body[0].leadingComments) {
+ generateBlankLines(stmt.range[0], stmt.body[i].range[0], result);
+ }
+ }
+
+ // handle spaces between lines
+ if (i > 0) {
+ if (!stmt.body[i - 1].trailingComments && !stmt.body[i].leadingComments) {
+ generateBlankLines(stmt.body[i - 1].range[1], stmt.body[i].range[0], result);
+ }
+ }
+ }
+
+ fragment = addIndent(this.generateStatement(stmt.body[i], bodyFlags));
+ result.push(fragment);
+ if (i + 1 < iz && !endsWithLineTerminator(toSourceNodeWhenNeeded(fragment).toString())) {
+ if (preserveBlankLines) {
+ if (!stmt.body[i + 1].leadingComments) {
+ result.push(newline);
+ }
+ } else {
+ result.push(newline);
+ }
+ }
+
+ if (preserveBlankLines) {
+ // handle spaces after the last line
+ if (i === iz - 1) {
+ if (!stmt.body[i].trailingComments) {
+ generateBlankLines(stmt.body[i].range[1], stmt.range[1], result);
+ }
+ }
+ }
+ }
+ return result;
+ },
+
+ FunctionDeclaration: function (stmt, flags) {
+ return [
+ generateAsyncPrefix(stmt, true),
+ 'function',
+ generateStarSuffix(stmt) || noEmptySpace(),
+ stmt.id ? generateIdentifier(stmt.id) : '',
+ this.generateFunctionBody(stmt)
+ ];
+ },
+
+ ReturnStatement: function (stmt, flags) {
+ if (stmt.argument) {
+ return [join(
+ 'return',
+ this.generateExpression(stmt.argument, Precedence.Sequence, E_TTT)
+ ), this.semicolon(flags)];
+ }
+ return ['return' + this.semicolon(flags)];
+ },
+
+ WhileStatement: function (stmt, flags) {
+ var result, that = this;
+ withIndent(function () {
+ result = [
+ 'while' + space + '(',
+ that.generateExpression(stmt.test, Precedence.Sequence, E_TTT),
+ ')'
+ ];
+ });
+ result.push(this.maybeBlock(stmt.body, flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF));
+ return result;
+ },
+
+ WithStatement: function (stmt, flags) {
+ var result, that = this;
+ withIndent(function () {
+ result = [
+ 'with' + space + '(',
+ that.generateExpression(stmt.object, Precedence.Sequence, E_TTT),
+ ')'
+ ];
+ });
+ result.push(this.maybeBlock(stmt.body, flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF));
+ return result;
+ }
+
+ };
+
+ merge(CodeGenerator.prototype, CodeGenerator.Statement);
+
+ // Expressions.
+
+ CodeGenerator.Expression = {
+
+ SequenceExpression: function (expr, precedence, flags) {
+ var result, i, iz;
+ if (Precedence.Sequence < precedence) {
+ flags |= F_ALLOW_IN;
+ }
+ result = [];
+ for (i = 0, iz = expr.expressions.length; i < iz; ++i) {
+ result.push(this.generateExpression(expr.expressions[i], Precedence.Assignment, flags));
+ if (i + 1 < iz) {
+ result.push(',' + space);
+ }
+ }
+ return parenthesize(result, Precedence.Sequence, precedence);
+ },
+
+ AssignmentExpression: function (expr, precedence, flags) {
+ return this.generateAssignment(expr.left, expr.right, expr.operator, precedence, flags);
+ },
+
+ ArrowFunctionExpression: function (expr, precedence, flags) {
+ return parenthesize(this.generateFunctionBody(expr), Precedence.ArrowFunction, precedence);
+ },
+
+ ConditionalExpression: function (expr, precedence, flags) {
+ if (Precedence.Conditional < precedence) {
+ flags |= F_ALLOW_IN;
+ }
+ return parenthesize(
+ [
+ this.generateExpression(expr.test, Precedence.LogicalOR, flags),
+ space + '?' + space,
+ this.generateExpression(expr.consequent, Precedence.Assignment, flags),
+ space + ':' + space,
+ this.generateExpression(expr.alternate, Precedence.Assignment, flags)
+ ],
+ Precedence.Conditional,
+ precedence
+ );
+ },
+
+ LogicalExpression: function (expr, precedence, flags) {
+ return this.BinaryExpression(expr, precedence, flags);
+ },
+
+ BinaryExpression: function (expr, precedence, flags) {
+ var result, leftPrecedence, rightPrecedence, currentPrecedence, fragment, leftSource;
+ currentPrecedence = BinaryPrecedence[expr.operator];
+ leftPrecedence = expr.operator === '**' ? Precedence.Postfix : currentPrecedence;
+ rightPrecedence = expr.operator === '**' ? currentPrecedence : currentPrecedence + 1;
+
+ if (currentPrecedence < precedence) {
+ flags |= F_ALLOW_IN;
+ }
+
+ fragment = this.generateExpression(expr.left, leftPrecedence, flags);
+
+ leftSource = fragment.toString();
+
+ if (leftSource.charCodeAt(leftSource.length - 1) === 0x2F /* / */ && esutils.code.isIdentifierPartES5(expr.operator.charCodeAt(0))) {
+ result = [fragment, noEmptySpace(), expr.operator];
+ } else {
+ result = join(fragment, expr.operator);
+ }
+
+ fragment = this.generateExpression(expr.right, rightPrecedence, flags);
+
+ if (expr.operator === '/' && fragment.toString().charAt(0) === '/' ||
+ expr.operator.slice(-1) === '<' && fragment.toString().slice(0, 3) === '!--') {
+ // If '/' concats with '/' or `<` concats with `!--`, it is interpreted as comment start
+ result.push(noEmptySpace());
+ result.push(fragment);
+ } else {
+ result = join(result, fragment);
+ }
+
+ if (expr.operator === 'in' && !(flags & F_ALLOW_IN)) {
+ return ['(', result, ')'];
+ }
+ return parenthesize(result, currentPrecedence, precedence);
+ },
+
+ CallExpression: function (expr, precedence, flags) {
+ var result, i, iz;
+ // F_ALLOW_UNPARATH_NEW becomes false.
+ result = [this.generateExpression(expr.callee, Precedence.Call, E_TTF)];
+ result.push('(');
+ for (i = 0, iz = expr['arguments'].length; i < iz; ++i) {
+ result.push(this.generateExpression(expr['arguments'][i], Precedence.Assignment, E_TTT));
+ if (i + 1 < iz) {
+ result.push(',' + space);
+ }
+ }
+ result.push(')');
+
+ if (!(flags & F_ALLOW_CALL)) {
+ return ['(', result, ')'];
+ }
+ return parenthesize(result, Precedence.Call, precedence);
+ },
+
+ NewExpression: function (expr, precedence, flags) {
+ var result, length, i, iz, itemFlags;
+ length = expr['arguments'].length;
+
+ // F_ALLOW_CALL becomes false.
+ // F_ALLOW_UNPARATH_NEW may become false.
+ itemFlags = (flags & F_ALLOW_UNPARATH_NEW && !parentheses && length === 0) ? E_TFT : E_TFF;
+
+ result = join(
+ 'new',
+ this.generateExpression(expr.callee, Precedence.New, itemFlags)
+ );
+
+ if (!(flags & F_ALLOW_UNPARATH_NEW) || parentheses || length > 0) {
+ result.push('(');
+ for (i = 0, iz = length; i < iz; ++i) {
+ result.push(this.generateExpression(expr['arguments'][i], Precedence.Assignment, E_TTT));
+ if (i + 1 < iz) {
+ result.push(',' + space);
+ }
+ }
+ result.push(')');
+ }
+
+ return parenthesize(result, Precedence.New, precedence);
+ },
+
+ MemberExpression: function (expr, precedence, flags) {
+ var result, fragment;
+
+ // F_ALLOW_UNPARATH_NEW becomes false.
+ result = [this.generateExpression(expr.object, Precedence.Call, (flags & F_ALLOW_CALL) ? E_TTF : E_TFF)];
+
+ if (expr.computed) {
+ result.push('[');
+ result.push(this.generateExpression(expr.property, Precedence.Sequence, flags & F_ALLOW_CALL ? E_TTT : E_TFT));
+ result.push(']');
+ } else {
+ if (expr.object.type === Syntax.Literal && typeof expr.object.value === 'number') {
+ fragment = toSourceNodeWhenNeeded(result).toString();
+ // When the following conditions are all true,
+ // 1. No floating point
+ // 2. Don't have exponents
+ // 3. The last character is a decimal digit
+ // 4. Not hexadecimal OR octal number literal
+ // we should add a floating point.
+ if (
+ fragment.indexOf('.') < 0 &&
+ !/[eExX]/.test(fragment) &&
+ esutils.code.isDecimalDigit(fragment.charCodeAt(fragment.length - 1)) &&
+ !(fragment.length >= 2 && fragment.charCodeAt(0) === 48) // '0'
+ ) {
+ result.push(' ');
+ }
+ }
+ result.push('.');
+ result.push(generateIdentifier(expr.property));
+ }
+
+ return parenthesize(result, Precedence.Member, precedence);
+ },
+
+ MetaProperty: function (expr, precedence, flags) {
+ var result;
+ result = [];
+ result.push(typeof expr.meta === "string" ? expr.meta : generateIdentifier(expr.meta));
+ result.push('.');
+ result.push(typeof expr.property === "string" ? expr.property : generateIdentifier(expr.property));
+ return parenthesize(result, Precedence.Member, precedence);
+ },
+
+ UnaryExpression: function (expr, precedence, flags) {
+ var result, fragment, rightCharCode, leftSource, leftCharCode;
+ fragment = this.generateExpression(expr.argument, Precedence.Unary, E_TTT);
+
+ if (space === '') {
+ result = join(expr.operator, fragment);
+ } else {
+ result = [expr.operator];
+ if (expr.operator.length > 2) {
+ // delete, void, typeof
+ // get `typeof []`, not `typeof[]`
+ result = join(result, fragment);
+ } else {
+ // Prevent inserting spaces between operator and argument if it is unnecessary
+ // like, `!cond`
+ leftSource = toSourceNodeWhenNeeded(result).toString();
+ leftCharCode = leftSource.charCodeAt(leftSource.length - 1);
+ rightCharCode = fragment.toString().charCodeAt(0);
+
+ if (((leftCharCode === 0x2B /* + */ || leftCharCode === 0x2D /* - */) && leftCharCode === rightCharCode) ||
+ (esutils.code.isIdentifierPartES5(leftCharCode) && esutils.code.isIdentifierPartES5(rightCharCode))) {
+ result.push(noEmptySpace());
+ result.push(fragment);
+ } else {
+ result.push(fragment);
+ }
+ }
+ }
+ return parenthesize(result, Precedence.Unary, precedence);
+ },
+
+ YieldExpression: function (expr, precedence, flags) {
+ var result;
+ if (expr.delegate) {
+ result = 'yield*';
+ } else {
+ result = 'yield';
+ }
+ if (expr.argument) {
+ result = join(
+ result,
+ this.generateExpression(expr.argument, Precedence.Yield, E_TTT)
+ );
+ }
+ return parenthesize(result, Precedence.Yield, precedence);
+ },
+
+ AwaitExpression: function (expr, precedence, flags) {
+ var result = join(
+ expr.all ? 'await*' : 'await',
+ this.generateExpression(expr.argument, Precedence.Await, E_TTT)
+ );
+ return parenthesize(result, Precedence.Await, precedence);
+ },
+
+ UpdateExpression: function (expr, precedence, flags) {
+ if (expr.prefix) {
+ return parenthesize(
+ [
+ expr.operator,
+ this.generateExpression(expr.argument, Precedence.Unary, E_TTT)
+ ],
+ Precedence.Unary,
+ precedence
+ );
+ }
+ return parenthesize(
+ [
+ this.generateExpression(expr.argument, Precedence.Postfix, E_TTT),
+ expr.operator
+ ],
+ Precedence.Postfix,
+ precedence
+ );
+ },
+
+ FunctionExpression: function (expr, precedence, flags) {
+ var result = [
+ generateAsyncPrefix(expr, true),
+ 'function'
+ ];
+ if (expr.id) {
+ result.push(generateStarSuffix(expr) || noEmptySpace());
+ result.push(generateIdentifier(expr.id));
+ } else {
+ result.push(generateStarSuffix(expr) || space);
+ }
+ result.push(this.generateFunctionBody(expr));
+ return result;
+ },
+
+ ArrayPattern: function (expr, precedence, flags) {
+ return this.ArrayExpression(expr, precedence, flags, true);
+ },
+
+ ArrayExpression: function (expr, precedence, flags, isPattern) {
+ var result, multiline, that = this;
+ if (!expr.elements.length) {
+ return '[]';
+ }
+ multiline = isPattern ? false : expr.elements.length > 1;
+ result = ['[', multiline ? newline : ''];
+ withIndent(function (indent) {
+ var i, iz;
+ for (i = 0, iz = expr.elements.length; i < iz; ++i) {
+ if (!expr.elements[i]) {
+ if (multiline) {
+ result.push(indent);
+ }
+ if (i + 1 === iz) {
+ result.push(',');
+ }
+ } else {
+ result.push(multiline ? indent : '');
+ result.push(that.generateExpression(expr.elements[i], Precedence.Assignment, E_TTT));
+ }
+ if (i + 1 < iz) {
+ result.push(',' + (multiline ? newline : space));
+ }
+ }
+ });
+ if (multiline && !endsWithLineTerminator(toSourceNodeWhenNeeded(result).toString())) {
+ result.push(newline);
+ }
+ result.push(multiline ? base : '');
+ result.push(']');
+ return result;
+ },
+
+ RestElement: function(expr, precedence, flags) {
+ return '...' + this.generatePattern(expr.argument);
+ },
+
+ ClassExpression: function (expr, precedence, flags) {
+ var result, fragment;
+ result = ['class'];
+ if (expr.id) {
+ result = join(result, this.generateExpression(expr.id, Precedence.Sequence, E_TTT));
+ }
+ if (expr.superClass) {
+ fragment = join('extends', this.generateExpression(expr.superClass, Precedence.Unary, E_TTT));
+ result = join(result, fragment);
+ }
+ result.push(space);
+ result.push(this.generateStatement(expr.body, S_TFFT));
+ return result;
+ },
+
+ MethodDefinition: function (expr, precedence, flags) {
+ var result, fragment;
+ if (expr['static']) {
+ result = ['static' + space];
+ } else {
+ result = [];
+ }
+ if (expr.kind === 'get' || expr.kind === 'set') {
+ fragment = [
+ join(expr.kind, this.generatePropertyKey(expr.key, expr.computed)),
+ this.generateFunctionBody(expr.value)
+ ];
+ } else {
+ fragment = [
+ generateMethodPrefix(expr),
+ this.generatePropertyKey(expr.key, expr.computed),
+ this.generateFunctionBody(expr.value)
+ ];
+ }
+ return join(result, fragment);
+ },
+
+ Property: function (expr, precedence, flags) {
+ if (expr.kind === 'get' || expr.kind === 'set') {
+ return [
+ expr.kind, noEmptySpace(),
+ this.generatePropertyKey(expr.key, expr.computed),
+ this.generateFunctionBody(expr.value)
+ ];
+ }
+
+ if (expr.shorthand) {
+ if (expr.value.type === "AssignmentPattern") {
+ return this.AssignmentPattern(expr.value, Precedence.Sequence, E_TTT);
+ }
+ return this.generatePropertyKey(expr.key, expr.computed);
+ }
+
+ if (expr.method) {
+ return [
+ generateMethodPrefix(expr),
+ this.generatePropertyKey(expr.key, expr.computed),
+ this.generateFunctionBody(expr.value)
+ ];
+ }
+
+ return [
+ this.generatePropertyKey(expr.key, expr.computed),
+ ':' + space,
+ this.generateExpression(expr.value, Precedence.Assignment, E_TTT)
+ ];
+ },
+
+ ObjectExpression: function (expr, precedence, flags) {
+ var multiline, result, fragment, that = this;
+
+ if (!expr.properties.length) {
+ return '{}';
+ }
+ multiline = expr.properties.length > 1;
+
+ withIndent(function () {
+ fragment = that.generateExpression(expr.properties[0], Precedence.Sequence, E_TTT);
+ });
+
+ if (!multiline) {
+ // issues 4
+ // Do not transform from
+ // dejavu.Class.declare({
+ // method2: function () {}
+ // });
+ // to
+ // dejavu.Class.declare({method2: function () {
+ // }});
+ if (!hasLineTerminator(toSourceNodeWhenNeeded(fragment).toString())) {
+ return [ '{', space, fragment, space, '}' ];
+ }
+ }
+
+ withIndent(function (indent) {
+ var i, iz;
+ result = [ '{', newline, indent, fragment ];
+
+ if (multiline) {
+ result.push(',' + newline);
+ for (i = 1, iz = expr.properties.length; i < iz; ++i) {
+ result.push(indent);
+ result.push(that.generateExpression(expr.properties[i], Precedence.Sequence, E_TTT));
+ if (i + 1 < iz) {
+ result.push(',' + newline);
+ }
+ }
+ }
+ });
+
+ if (!endsWithLineTerminator(toSourceNodeWhenNeeded(result).toString())) {
+ result.push(newline);
+ }
+ result.push(base);
+ result.push('}');
+ return result;
+ },
+
+ AssignmentPattern: function(expr, precedence, flags) {
+ return this.generateAssignment(expr.left, expr.right, '=', precedence, flags);
+ },
+
+ ObjectPattern: function (expr, precedence, flags) {
+ var result, i, iz, multiline, property, that = this;
+ if (!expr.properties.length) {
+ return '{}';
+ }
+
+ multiline = false;
+ if (expr.properties.length === 1) {
+ property = expr.properties[0];
+ if (
+ property.type === Syntax.Property
+ && property.value.type !== Syntax.Identifier
+ ) {
+ multiline = true;
+ }
+ } else {
+ for (i = 0, iz = expr.properties.length; i < iz; ++i) {
+ property = expr.properties[i];
+ if (
+ property.type === Syntax.Property
+ && !property.shorthand
+ ) {
+ multiline = true;
+ break;
+ }
+ }
+ }
+ result = ['{', multiline ? newline : '' ];
+
+ withIndent(function (indent) {
+ var i, iz;
+ for (i = 0, iz = expr.properties.length; i < iz; ++i) {
+ result.push(multiline ? indent : '');
+ result.push(that.generateExpression(expr.properties[i], Precedence.Sequence, E_TTT));
+ if (i + 1 < iz) {
+ result.push(',' + (multiline ? newline : space));
+ }
+ }
+ });
+
+ if (multiline && !endsWithLineTerminator(toSourceNodeWhenNeeded(result).toString())) {
+ result.push(newline);
+ }
+ result.push(multiline ? base : '');
+ result.push('}');
+ return result;
+ },
+
+ ThisExpression: function (expr, precedence, flags) {
+ return 'this';
+ },
+
+ Super: function (expr, precedence, flags) {
+ return 'super';
+ },
+
+ Identifier: function (expr, precedence, flags) {
+ return generateIdentifier(expr);
+ },
+
+ ImportDefaultSpecifier: function (expr, precedence, flags) {
+ return generateIdentifier(expr.id || expr.local);
+ },
+
+ ImportNamespaceSpecifier: function (expr, precedence, flags) {
+ var result = ['*'];
+ var id = expr.id || expr.local;
+ if (id) {
+ result.push(space + 'as' + noEmptySpace() + generateIdentifier(id));
+ }
+ return result;
+ },
+
+ ImportSpecifier: function (expr, precedence, flags) {
+ var imported = expr.imported;
+ var result = [ imported.name ];
+ var local = expr.local;
+ if (local && local.name !== imported.name) {
+ result.push(noEmptySpace() + 'as' + noEmptySpace() + generateIdentifier(local));
+ }
+ return result;
+ },
+
+ ExportSpecifier: function (expr, precedence, flags) {
+ var local = expr.local;
+ var result = [ local.name ];
+ var exported = expr.exported;
+ if (exported && exported.name !== local.name) {
+ result.push(noEmptySpace() + 'as' + noEmptySpace() + generateIdentifier(exported));
+ }
+ return result;
+ },
+
+ Literal: function (expr, precedence, flags) {
+ var raw;
+ if (expr.hasOwnProperty('raw') && parse && extra.raw) {
+ try {
+ raw = parse(expr.raw).body[0].expression;
+ if (raw.type === Syntax.Literal) {
+ if (raw.value === expr.value) {
+ return expr.raw;
+ }
+ }
+ } catch (e) {
+ // not use raw property
+ }
+ }
+
+ if (expr.regex) {
+ return '/' + expr.regex.pattern + '/' + expr.regex.flags;
+ }
+
+ if (expr.value === null) {
+ return 'null';
+ }
+
+ if (typeof expr.value === 'string') {
+ return escapeString(expr.value);
+ }
+
+ if (typeof expr.value === 'number') {
+ return generateNumber(expr.value);
+ }
+
+ if (typeof expr.value === 'boolean') {
+ return expr.value ? 'true' : 'false';
+ }
+
+ return generateRegExp(expr.value);
+ },
+
+ GeneratorExpression: function (expr, precedence, flags) {
+ return this.ComprehensionExpression(expr, precedence, flags);
+ },
+
+ ComprehensionExpression: function (expr, precedence, flags) {
+ // GeneratorExpression should be parenthesized with (...), ComprehensionExpression with [...]
+ // Due to https://bugzilla.mozilla.org/show_bug.cgi?id=883468 position of expr.body can differ in Spidermonkey and ES6
+
+ var result, i, iz, fragment, that = this;
+ result = (expr.type === Syntax.GeneratorExpression) ? ['('] : ['['];
+
+ if (extra.moz.comprehensionExpressionStartsWithAssignment) {
+ fragment = this.generateExpression(expr.body, Precedence.Assignment, E_TTT);
+ result.push(fragment);
+ }
+
+ if (expr.blocks) {
+ withIndent(function () {
+ for (i = 0, iz = expr.blocks.length; i < iz; ++i) {
+ fragment = that.generateExpression(expr.blocks[i], Precedence.Sequence, E_TTT);
+ if (i > 0 || extra.moz.comprehensionExpressionStartsWithAssignment) {
+ result = join(result, fragment);
+ } else {
+ result.push(fragment);
+ }
+ }
+ });
+ }
+
+ if (expr.filter) {
+ result = join(result, 'if' + space);
+ fragment = this.generateExpression(expr.filter, Precedence.Sequence, E_TTT);
+ result = join(result, [ '(', fragment, ')' ]);
+ }
+
+ if (!extra.moz.comprehensionExpressionStartsWithAssignment) {
+ fragment = this.generateExpression(expr.body, Precedence.Assignment, E_TTT);
+
+ result = join(result, fragment);
+ }
+
+ result.push((expr.type === Syntax.GeneratorExpression) ? ')' : ']');
+ return result;
+ },
+
+ ComprehensionBlock: function (expr, precedence, flags) {
+ var fragment;
+ if (expr.left.type === Syntax.VariableDeclaration) {
+ fragment = [
+ expr.left.kind, noEmptySpace(),
+ this.generateStatement(expr.left.declarations[0], S_FFFF)
+ ];
+ } else {
+ fragment = this.generateExpression(expr.left, Precedence.Call, E_TTT);
+ }
+
+ fragment = join(fragment, expr.of ? 'of' : 'in');
+ fragment = join(fragment, this.generateExpression(expr.right, Precedence.Sequence, E_TTT));
+
+ return [ 'for' + space + '(', fragment, ')' ];
+ },
+
+ SpreadElement: function (expr, precedence, flags) {
+ return [
+ '...',
+ this.generateExpression(expr.argument, Precedence.Assignment, E_TTT)
+ ];
+ },
+
+ TaggedTemplateExpression: function (expr, precedence, flags) {
+ var itemFlags = E_TTF;
+ if (!(flags & F_ALLOW_CALL)) {
+ itemFlags = E_TFF;
+ }
+ var result = [
+ this.generateExpression(expr.tag, Precedence.Call, itemFlags),
+ this.generateExpression(expr.quasi, Precedence.Primary, E_FFT)
+ ];
+ return parenthesize(result, Precedence.TaggedTemplate, precedence);
+ },
+
+ TemplateElement: function (expr, precedence, flags) {
+ // Don't use "cooked". Since tagged template can use raw template
+ // representation. So if we do so, it breaks the script semantics.
+ return expr.value.raw;
+ },
+
+ TemplateLiteral: function (expr, precedence, flags) {
+ var result, i, iz;
+ result = [ '`' ];
+ for (i = 0, iz = expr.quasis.length; i < iz; ++i) {
+ result.push(this.generateExpression(expr.quasis[i], Precedence.Primary, E_TTT));
+ if (i + 1 < iz) {
+ result.push('${' + space);
+ result.push(this.generateExpression(expr.expressions[i], Precedence.Sequence, E_TTT));
+ result.push(space + '}');
+ }
+ }
+ result.push('`');
+ return result;
+ },
+
+ ModuleSpecifier: function (expr, precedence, flags) {
+ return this.Literal(expr, precedence, flags);
+ },
+
+ ImportExpression: function(expr, precedence, flag) {
+ return parenthesize([
+ 'import(',
+ this.generateExpression(expr.source, Precedence.Assignment, E_TTT),
+ ')'
+ ], Precedence.Call, precedence);
+ },
+
+ };
+
+ merge(CodeGenerator.prototype, CodeGenerator.Expression);
+
+ CodeGenerator.prototype.generateExpression = function (expr, precedence, flags) {
+ var result, type;
+
+ type = expr.type || Syntax.Property;
+
+ if (extra.verbatim && expr.hasOwnProperty(extra.verbatim)) {
+ return generateVerbatim(expr, precedence);
+ }
+
+ result = this[type](expr, precedence, flags);
+
+
+ if (extra.comment) {
+ result = addComments(expr, result);
+ }
+ return toSourceNodeWhenNeeded(result, expr);
+ };
+
+ CodeGenerator.prototype.generateStatement = function (stmt, flags) {
+ var result,
+ fragment;
+
+ result = this[stmt.type](stmt, flags);
+
+ // Attach comments
+
+ if (extra.comment) {
+ result = addComments(stmt, result);
+ }
+
+ fragment = toSourceNodeWhenNeeded(result).toString();
+ if (stmt.type === Syntax.Program && !safeConcatenation && newline === '' && fragment.charAt(fragment.length - 1) === '\n') {
+ result = sourceMap ? toSourceNodeWhenNeeded(result).replaceRight(/\s+$/, '') : fragment.replace(/\s+$/, '');
+ }
+
+ return toSourceNodeWhenNeeded(result, stmt);
+ };
+
+ function generateInternal(node) {
+ var codegen;
+
+ codegen = new CodeGenerator();
+ if (isStatement(node)) {
+ return codegen.generateStatement(node, S_TFFF);
+ }
+
+ if (isExpression(node)) {
+ return codegen.generateExpression(node, Precedence.Sequence, E_TTT);
+ }
+
+ throw new Error('Unknown node type: ' + node.type);
+ }
+
+ function generate(node, options) {
+ var defaultOptions = getDefaultOptions(), result, pair;
+
+ if (options != null) {
+ // Obsolete options
+ //
+ // `options.indent`
+ // `options.base`
+ //
+ // Instead of them, we can use `option.format.indent`.
+ if (typeof options.indent === 'string') {
+ defaultOptions.format.indent.style = options.indent;
+ }
+ if (typeof options.base === 'number') {
+ defaultOptions.format.indent.base = options.base;
+ }
+ options = updateDeeply(defaultOptions, options);
+ indent = options.format.indent.style;
+ if (typeof options.base === 'string') {
+ base = options.base;
+ } else {
+ base = stringRepeat(indent, options.format.indent.base);
+ }
+ } else {
+ options = defaultOptions;
+ indent = options.format.indent.style;
+ base = stringRepeat(indent, options.format.indent.base);
+ }
+ json = options.format.json;
+ renumber = options.format.renumber;
+ hexadecimal = json ? false : options.format.hexadecimal;
+ quotes = json ? 'double' : options.format.quotes;
+ escapeless = options.format.escapeless;
+ newline = options.format.newline;
+ space = options.format.space;
+ if (options.format.compact) {
+ newline = space = indent = base = '';
+ }
+ parentheses = options.format.parentheses;
+ semicolons = options.format.semicolons;
+ safeConcatenation = options.format.safeConcatenation;
+ directive = options.directive;
+ parse = json ? null : options.parse;
+ sourceMap = options.sourceMap;
+ sourceCode = options.sourceCode;
+ preserveBlankLines = options.format.preserveBlankLines && sourceCode !== null;
+ extra = options;
+
+ if (sourceMap) {
+ if (!exports.browser) {
+ // We assume environment is node.js
+ // And prevent from including source-map by browserify
+ SourceNode = (__webpack_require__(/*! source-map */ "../../../.yarn/berry/cache/source-map-npm-0.6.1-1a3621db16-9.zip/node_modules/source-map/source-map.js").SourceNode);
+ } else {
+ SourceNode = global.sourceMap.SourceNode;
+ }
+ }
+
+ result = generateInternal(node);
+
+ if (!sourceMap) {
+ pair = {code: result.toString(), map: null};
+ return options.sourceMapWithCode ? pair : pair.code;
+ }
+
+
+ pair = result.toStringWithSourceMap({
+ file: options.file,
+ sourceRoot: options.sourceMapRoot
+ });
+
+ if (options.sourceContent) {
+ pair.map.setSourceContent(options.sourceMap,
+ options.sourceContent);
+ }
+
+ if (options.sourceMapWithCode) {
+ return pair;
+ }
+
+ return pair.map.toString();
+ }
+
+ FORMAT_MINIFY = {
+ indent: {
+ style: '',
+ base: 0
+ },
+ renumber: true,
+ hexadecimal: true,
+ quotes: 'auto',
+ escapeless: true,
+ compact: true,
+ parentheses: false,
+ semicolons: false
+ };
+
+ FORMAT_DEFAULTS = getDefaultOptions().format;
+
+ exports.version = __webpack_require__(/*! ./package.json */ "../../../.yarn/berry/cache/escodegen-npm-1.14.3-a4dedc6eeb-9.zip/node_modules/escodegen/package.json").version;
+ exports.generate = generate;
+ exports.attachComments = estraverse.attachComments;
+ exports.Precedence = updateDeeply({}, Precedence);
+ exports.browser = false;
+ exports.FORMAT_MINIFY = FORMAT_MINIFY;
+ exports.FORMAT_DEFAULTS = FORMAT_DEFAULTS;
+}());
+/* vim: set sw=4 ts=4 et tw=80 : */
+
+
+/***/ }),
+
+/***/ "../../../.yarn/berry/cache/esprima-npm-4.0.1-1084e98778-9.zip/node_modules/esprima/dist/esprima.js":
+/*!**********************************************************************************************************!*\
+ !*** ../../../.yarn/berry/cache/esprima-npm-4.0.1-1084e98778-9.zip/node_modules/esprima/dist/esprima.js ***!
+ \**********************************************************************************************************/
+/***/ (function(module) {
+
+(function webpackUniversalModuleDefinition(root, factory) {
+/* istanbul ignore next */
+ if(true)
+ module.exports = factory();
+ else {}
+})(this, function() {
+return /******/ (function(modules) { // webpackBootstrap
+/******/ // The module cache
+/******/ var installedModules = {};
+
+/******/ // The require function
+/******/ function __nested_webpack_require_583__(moduleId) {
+
+/******/ // Check if module is in cache
+/* istanbul ignore if */
+/******/ if(installedModules[moduleId])
+/******/ return installedModules[moduleId].exports;
+
+/******/ // Create a new module (and put it into the cache)
+/******/ var module = installedModules[moduleId] = {
+/******/ exports: {},
+/******/ id: moduleId,
+/******/ loaded: false
+/******/ };
+
+/******/ // Execute the module function
+/******/ modules[moduleId].call(module.exports, module, module.exports, __nested_webpack_require_583__);
+
+/******/ // Flag the module as loaded
+/******/ module.loaded = true;
+
+/******/ // Return the exports of the module
+/******/ return module.exports;
+/******/ }
+
+
+/******/ // expose the modules object (__webpack_modules__)
+/******/ __nested_webpack_require_583__.m = modules;
+
+/******/ // expose the module cache
+/******/ __nested_webpack_require_583__.c = installedModules;
+
+/******/ // __webpack_public_path__
+/******/ __nested_webpack_require_583__.p = "";
+
+/******/ // Load entry module and return exports
+/******/ return __nested_webpack_require_583__(0);
+/******/ })
+/************************************************************************/
+/******/ ([
+/* 0 */
+/***/ function(module, exports, __nested_webpack_require_1808__) {
+
+ "use strict";
+ /*
+ Copyright JS Foundation and other contributors, https://js.foundation/
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var comment_handler_1 = __nested_webpack_require_1808__(1);
+ var jsx_parser_1 = __nested_webpack_require_1808__(3);
+ var parser_1 = __nested_webpack_require_1808__(8);
+ var tokenizer_1 = __nested_webpack_require_1808__(15);
+ function parse(code, options, delegate) {
+ var commentHandler = null;
+ var proxyDelegate = function (node, metadata) {
+ if (delegate) {
+ delegate(node, metadata);
+ }
+ if (commentHandler) {
+ commentHandler.visit(node, metadata);
+ }
+ };
+ var parserDelegate = (typeof delegate === 'function') ? proxyDelegate : null;
+ var collectComment = false;
+ if (options) {
+ collectComment = (typeof options.comment === 'boolean' && options.comment);
+ var attachComment = (typeof options.attachComment === 'boolean' && options.attachComment);
+ if (collectComment || attachComment) {
+ commentHandler = new comment_handler_1.CommentHandler();
+ commentHandler.attach = attachComment;
+ options.comment = true;
+ parserDelegate = proxyDelegate;
+ }
+ }
+ var isModule = false;
+ if (options && typeof options.sourceType === 'string') {
+ isModule = (options.sourceType === 'module');
+ }
+ var parser;
+ if (options && typeof options.jsx === 'boolean' && options.jsx) {
+ parser = new jsx_parser_1.JSXParser(code, options, parserDelegate);
+ }
+ else {
+ parser = new parser_1.Parser(code, options, parserDelegate);
+ }
+ var program = isModule ? parser.parseModule() : parser.parseScript();
+ var ast = program;
+ if (collectComment && commentHandler) {
+ ast.comments = commentHandler.comments;
+ }
+ if (parser.config.tokens) {
+ ast.tokens = parser.tokens;
+ }
+ if (parser.config.tolerant) {
+ ast.errors = parser.errorHandler.errors;
+ }
+ return ast;
+ }
+ exports.parse = parse;
+ function parseModule(code, options, delegate) {
+ var parsingOptions = options || {};
+ parsingOptions.sourceType = 'module';
+ return parse(code, parsingOptions, delegate);
+ }
+ exports.parseModule = parseModule;
+ function parseScript(code, options, delegate) {
+ var parsingOptions = options || {};
+ parsingOptions.sourceType = 'script';
+ return parse(code, parsingOptions, delegate);
+ }
+ exports.parseScript = parseScript;
+ function tokenize(code, options, delegate) {
+ var tokenizer = new tokenizer_1.Tokenizer(code, options);
+ var tokens;
+ tokens = [];
+ try {
+ while (true) {
+ var token = tokenizer.getNextToken();
+ if (!token) {
+ break;
+ }
+ if (delegate) {
+ token = delegate(token);
+ }
+ tokens.push(token);
+ }
+ }
+ catch (e) {
+ tokenizer.errorHandler.tolerate(e);
+ }
+ if (tokenizer.errorHandler.tolerant) {
+ tokens.errors = tokenizer.errors();
+ }
+ return tokens;
+ }
+ exports.tokenize = tokenize;
+ var syntax_1 = __nested_webpack_require_1808__(2);
+ exports.Syntax = syntax_1.Syntax;
+ // Sync with *.json manifests.
+ exports.version = '4.0.1';
+
+
+/***/ },
+/* 1 */
+/***/ function(module, exports, __nested_webpack_require_6456__) {
+
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var syntax_1 = __nested_webpack_require_6456__(2);
+ var CommentHandler = (function () {
+ function CommentHandler() {
+ this.attach = false;
+ this.comments = [];
+ this.stack = [];
+ this.leading = [];
+ this.trailing = [];
+ }
+ CommentHandler.prototype.insertInnerComments = function (node, metadata) {
+ // innnerComments for properties empty block
+ // `function a() {/** comments **\/}`
+ if (node.type === syntax_1.Syntax.BlockStatement && node.body.length === 0) {
+ var innerComments = [];
+ for (var i = this.leading.length - 1; i >= 0; --i) {
+ var entry = this.leading[i];
+ if (metadata.end.offset >= entry.start) {
+ innerComments.unshift(entry.comment);
+ this.leading.splice(i, 1);
+ this.trailing.splice(i, 1);
+ }
+ }
+ if (innerComments.length) {
+ node.innerComments = innerComments;
+ }
+ }
+ };
+ CommentHandler.prototype.findTrailingComments = function (metadata) {
+ var trailingComments = [];
+ if (this.trailing.length > 0) {
+ for (var i = this.trailing.length - 1; i >= 0; --i) {
+ var entry_1 = this.trailing[i];
+ if (entry_1.start >= metadata.end.offset) {
+ trailingComments.unshift(entry_1.comment);
+ }
+ }
+ this.trailing.length = 0;
+ return trailingComments;
+ }
+ var entry = this.stack[this.stack.length - 1];
+ if (entry && entry.node.trailingComments) {
+ var firstComment = entry.node.trailingComments[0];
+ if (firstComment && firstComment.range[0] >= metadata.end.offset) {
+ trailingComments = entry.node.trailingComments;
+ delete entry.node.trailingComments;
+ }
+ }
+ return trailingComments;
+ };
+ CommentHandler.prototype.findLeadingComments = function (metadata) {
+ var leadingComments = [];
+ var target;
+ while (this.stack.length > 0) {
+ var entry = this.stack[this.stack.length - 1];
+ if (entry && entry.start >= metadata.start.offset) {
+ target = entry.node;
+ this.stack.pop();
+ }
+ else {
+ break;
+ }
+ }
+ if (target) {
+ var count = target.leadingComments ? target.leadingComments.length : 0;
+ for (var i = count - 1; i >= 0; --i) {
+ var comment = target.leadingComments[i];
+ if (comment.range[1] <= metadata.start.offset) {
+ leadingComments.unshift(comment);
+ target.leadingComments.splice(i, 1);
+ }
+ }
+ if (target.leadingComments && target.leadingComments.length === 0) {
+ delete target.leadingComments;
+ }
+ return leadingComments;
+ }
+ for (var i = this.leading.length - 1; i >= 0; --i) {
+ var entry = this.leading[i];
+ if (entry.start <= metadata.start.offset) {
+ leadingComments.unshift(entry.comment);
+ this.leading.splice(i, 1);
+ }
+ }
+ return leadingComments;
+ };
+ CommentHandler.prototype.visitNode = function (node, metadata) {
+ if (node.type === syntax_1.Syntax.Program && node.body.length > 0) {
+ return;
+ }
+ this.insertInnerComments(node, metadata);
+ var trailingComments = this.findTrailingComments(metadata);
+ var leadingComments = this.findLeadingComments(metadata);
+ if (leadingComments.length > 0) {
+ node.leadingComments = leadingComments;
+ }
+ if (trailingComments.length > 0) {
+ node.trailingComments = trailingComments;
+ }
+ this.stack.push({
+ node: node,
+ start: metadata.start.offset
+ });
+ };
+ CommentHandler.prototype.visitComment = function (node, metadata) {
+ var type = (node.type[0] === 'L') ? 'Line' : 'Block';
+ var comment = {
+ type: type,
+ value: node.value
+ };
+ if (node.range) {
+ comment.range = node.range;
+ }
+ if (node.loc) {
+ comment.loc = node.loc;
+ }
+ this.comments.push(comment);
+ if (this.attach) {
+ var entry = {
+ comment: {
+ type: type,
+ value: node.value,
+ range: [metadata.start.offset, metadata.end.offset]
+ },
+ start: metadata.start.offset
+ };
+ if (node.loc) {
+ entry.comment.loc = node.loc;
+ }
+ node.type = type;
+ this.leading.push(entry);
+ this.trailing.push(entry);
+ }
+ };
+ CommentHandler.prototype.visit = function (node, metadata) {
+ if (node.type === 'LineComment') {
+ this.visitComment(node, metadata);
+ }
+ else if (node.type === 'BlockComment') {
+ this.visitComment(node, metadata);
+ }
+ else if (this.attach) {
+ this.visitNode(node, metadata);
+ }
+ };
+ return CommentHandler;
+ }());
+ exports.CommentHandler = CommentHandler;
+
+
+/***/ },
+/* 2 */
+/***/ function(module, exports) {
+
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.Syntax = {
+ AssignmentExpression: 'AssignmentExpression',
+ AssignmentPattern: 'AssignmentPattern',
+ ArrayExpression: 'ArrayExpression',
+ ArrayPattern: 'ArrayPattern',
+ ArrowFunctionExpression: 'ArrowFunctionExpression',
+ AwaitExpression: 'AwaitExpression',
+ BlockStatement: 'BlockStatement',
+ BinaryExpression: 'BinaryExpression',
+ BreakStatement: 'BreakStatement',
+ CallExpression: 'CallExpression',
+ CatchClause: 'CatchClause',
+ ClassBody: 'ClassBody',
+ ClassDeclaration: 'ClassDeclaration',
+ ClassExpression: 'ClassExpression',
+ ConditionalExpression: 'ConditionalExpression',
+ ContinueStatement: 'ContinueStatement',
+ DoWhileStatement: 'DoWhileStatement',
+ DebuggerStatement: 'DebuggerStatement',
+ EmptyStatement: 'EmptyStatement',
+ ExportAllDeclaration: 'ExportAllDeclaration',
+ ExportDefaultDeclaration: 'ExportDefaultDeclaration',
+ ExportNamedDeclaration: 'ExportNamedDeclaration',
+ ExportSpecifier: 'ExportSpecifier',
+ ExpressionStatement: 'ExpressionStatement',
+ ForStatement: 'ForStatement',
+ ForOfStatement: 'ForOfStatement',
+ ForInStatement: 'ForInStatement',
+ FunctionDeclaration: 'FunctionDeclaration',
+ FunctionExpression: 'FunctionExpression',
+ Identifier: 'Identifier',
+ IfStatement: 'IfStatement',
+ ImportDeclaration: 'ImportDeclaration',
+ ImportDefaultSpecifier: 'ImportDefaultSpecifier',
+ ImportNamespaceSpecifier: 'ImportNamespaceSpecifier',
+ ImportSpecifier: 'ImportSpecifier',
+ Literal: 'Literal',
+ LabeledStatement: 'LabeledStatement',
+ LogicalExpression: 'LogicalExpression',
+ MemberExpression: 'MemberExpression',
+ MetaProperty: 'MetaProperty',
+ MethodDefinition: 'MethodDefinition',
+ NewExpression: 'NewExpression',
+ ObjectExpression: 'ObjectExpression',
+ ObjectPattern: 'ObjectPattern',
+ Program: 'Program',
+ Property: 'Property',
+ RestElement: 'RestElement',
+ ReturnStatement: 'ReturnStatement',
+ SequenceExpression: 'SequenceExpression',
+ SpreadElement: 'SpreadElement',
+ Super: 'Super',
+ SwitchCase: 'SwitchCase',
+ SwitchStatement: 'SwitchStatement',
+ TaggedTemplateExpression: 'TaggedTemplateExpression',
+ TemplateElement: 'TemplateElement',
+ TemplateLiteral: 'TemplateLiteral',
+ ThisExpression: 'ThisExpression',
+ ThrowStatement: 'ThrowStatement',
+ TryStatement: 'TryStatement',
+ UnaryExpression: 'UnaryExpression',
+ UpdateExpression: 'UpdateExpression',
+ VariableDeclaration: 'VariableDeclaration',
+ VariableDeclarator: 'VariableDeclarator',
+ WhileStatement: 'WhileStatement',
+ WithStatement: 'WithStatement',
+ YieldExpression: 'YieldExpression'
+ };
+
+
+/***/ },
+/* 3 */
+/***/ function(module, exports, __nested_webpack_require_15019__) {
+
+ "use strict";
+/* istanbul ignore next */
+ var __extends = (this && this.__extends) || (function () {
+ var extendStatics = Object.setPrototypeOf ||
+ ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+ function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+ return function (d, b) {
+ extendStatics(d, b);
+ function __() { this.constructor = d; }
+ d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+ };
+ })();
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var character_1 = __nested_webpack_require_15019__(4);
+ var JSXNode = __nested_webpack_require_15019__(5);
+ var jsx_syntax_1 = __nested_webpack_require_15019__(6);
+ var Node = __nested_webpack_require_15019__(7);
+ var parser_1 = __nested_webpack_require_15019__(8);
+ var token_1 = __nested_webpack_require_15019__(13);
+ var xhtml_entities_1 = __nested_webpack_require_15019__(14);
+ token_1.TokenName[100 /* Identifier */] = 'JSXIdentifier';
+ token_1.TokenName[101 /* Text */] = 'JSXText';
+ // Fully qualified element name, e.g. returns "svg:path"
+ function getQualifiedElementName(elementName) {
+ var qualifiedName;
+ switch (elementName.type) {
+ case jsx_syntax_1.JSXSyntax.JSXIdentifier:
+ var id = elementName;
+ qualifiedName = id.name;
+ break;
+ case jsx_syntax_1.JSXSyntax.JSXNamespacedName:
+ var ns = elementName;
+ qualifiedName = getQualifiedElementName(ns.namespace) + ':' +
+ getQualifiedElementName(ns.name);
+ break;
+ case jsx_syntax_1.JSXSyntax.JSXMemberExpression:
+ var expr = elementName;
+ qualifiedName = getQualifiedElementName(expr.object) + '.' +
+ getQualifiedElementName(expr.property);
+ break;
+ /* istanbul ignore next */
+ default:
+ break;
+ }
+ return qualifiedName;
+ }
+ var JSXParser = (function (_super) {
+ __extends(JSXParser, _super);
+ function JSXParser(code, options, delegate) {
+ return _super.call(this, code, options, delegate) || this;
+ }
+ JSXParser.prototype.parsePrimaryExpression = function () {
+ return this.match('<') ? this.parseJSXRoot() : _super.prototype.parsePrimaryExpression.call(this);
+ };
+ JSXParser.prototype.startJSX = function () {
+ // Unwind the scanner before the lookahead token.
+ this.scanner.index = this.startMarker.index;
+ this.scanner.lineNumber = this.startMarker.line;
+ this.scanner.lineStart = this.startMarker.index - this.startMarker.column;
+ };
+ JSXParser.prototype.finishJSX = function () {
+ // Prime the next lookahead.
+ this.nextToken();
+ };
+ JSXParser.prototype.reenterJSX = function () {
+ this.startJSX();
+ this.expectJSX('}');
+ // Pop the closing '}' added from the lookahead.
+ if (this.config.tokens) {
+ this.tokens.pop();
+ }
+ };
+ JSXParser.prototype.createJSXNode = function () {
+ this.collectComments();
+ return {
+ index: this.scanner.index,
+ line: this.scanner.lineNumber,
+ column: this.scanner.index - this.scanner.lineStart
+ };
+ };
+ JSXParser.prototype.createJSXChildNode = function () {
+ return {
+ index: this.scanner.index,
+ line: this.scanner.lineNumber,
+ column: this.scanner.index - this.scanner.lineStart
+ };
+ };
+ JSXParser.prototype.scanXHTMLEntity = function (quote) {
+ var result = '&';
+ var valid = true;
+ var terminated = false;
+ var numeric = false;
+ var hex = false;
+ while (!this.scanner.eof() && valid && !terminated) {
+ var ch = this.scanner.source[this.scanner.index];
+ if (ch === quote) {
+ break;
+ }
+ terminated = (ch === ';');
+ result += ch;
+ ++this.scanner.index;
+ if (!terminated) {
+ switch (result.length) {
+ case 2:
+ // e.g. '{'
+ numeric = (ch === '#');
+ break;
+ case 3:
+ if (numeric) {
+ // e.g. 'A'
+ hex = (ch === 'x');
+ valid = hex || character_1.Character.isDecimalDigit(ch.charCodeAt(0));
+ numeric = numeric && !hex;
+ }
+ break;
+ default:
+ valid = valid && !(numeric && !character_1.Character.isDecimalDigit(ch.charCodeAt(0)));
+ valid = valid && !(hex && !character_1.Character.isHexDigit(ch.charCodeAt(0)));
+ break;
+ }
+ }
+ }
+ if (valid && terminated && result.length > 2) {
+ // e.g. 'A' becomes just '#x41'
+ var str = result.substr(1, result.length - 2);
+ if (numeric && str.length > 1) {
+ result = String.fromCharCode(parseInt(str.substr(1), 10));
+ }
+ else if (hex && str.length > 2) {
+ result = String.fromCharCode(parseInt('0' + str.substr(1), 16));
+ }
+ else if (!numeric && !hex && xhtml_entities_1.XHTMLEntities[str]) {
+ result = xhtml_entities_1.XHTMLEntities[str];
+ }
+ }
+ return result;
+ };
+ // Scan the next JSX token. This replaces Scanner#lex when in JSX mode.
+ JSXParser.prototype.lexJSX = function () {
+ var cp = this.scanner.source.charCodeAt(this.scanner.index);
+ // < > / : = { }
+ if (cp === 60 || cp === 62 || cp === 47 || cp === 58 || cp === 61 || cp === 123 || cp === 125) {
+ var value = this.scanner.source[this.scanner.index++];
+ return {
+ type: 7 /* Punctuator */,
+ value: value,
+ lineNumber: this.scanner.lineNumber,
+ lineStart: this.scanner.lineStart,
+ start: this.scanner.index - 1,
+ end: this.scanner.index
+ };
+ }
+ // " '
+ if (cp === 34 || cp === 39) {
+ var start = this.scanner.index;
+ var quote = this.scanner.source[this.scanner.index++];
+ var str = '';
+ while (!this.scanner.eof()) {
+ var ch = this.scanner.source[this.scanner.index++];
+ if (ch === quote) {
+ break;
+ }
+ else if (ch === '&') {
+ str += this.scanXHTMLEntity(quote);
+ }
+ else {
+ str += ch;
+ }
+ }
+ return {
+ type: 8 /* StringLiteral */,
+ value: str,
+ lineNumber: this.scanner.lineNumber,
+ lineStart: this.scanner.lineStart,
+ start: start,
+ end: this.scanner.index
+ };
+ }
+ // ... or .
+ if (cp === 46) {
+ var n1 = this.scanner.source.charCodeAt(this.scanner.index + 1);
+ var n2 = this.scanner.source.charCodeAt(this.scanner.index + 2);
+ var value = (n1 === 46 && n2 === 46) ? '...' : '.';
+ var start = this.scanner.index;
+ this.scanner.index += value.length;
+ return {
+ type: 7 /* Punctuator */,
+ value: value,
+ lineNumber: this.scanner.lineNumber,
+ lineStart: this.scanner.lineStart,
+ start: start,
+ end: this.scanner.index
+ };
+ }
+ // `
+ if (cp === 96) {
+ // Only placeholder, since it will be rescanned as a real assignment expression.
+ return {
+ type: 10 /* Template */,
+ value: '',
+ lineNumber: this.scanner.lineNumber,
+ lineStart: this.scanner.lineStart,
+ start: this.scanner.index,
+ end: this.scanner.index
+ };
+ }
+ // Identifer can not contain backslash (char code 92).
+ if (character_1.Character.isIdentifierStart(cp) && (cp !== 92)) {
+ var start = this.scanner.index;
+ ++this.scanner.index;
+ while (!this.scanner.eof()) {
+ var ch = this.scanner.source.charCodeAt(this.scanner.index);
+ if (character_1.Character.isIdentifierPart(ch) && (ch !== 92)) {
+ ++this.scanner.index;
+ }
+ else if (ch === 45) {
+ // Hyphen (char code 45) can be part of an identifier.
+ ++this.scanner.index;
+ }
+ else {
+ break;
+ }
+ }
+ var id = this.scanner.source.slice(start, this.scanner.index);
+ return {
+ type: 100 /* Identifier */,
+ value: id,
+ lineNumber: this.scanner.lineNumber,
+ lineStart: this.scanner.lineStart,
+ start: start,
+ end: this.scanner.index
+ };
+ }
+ return this.scanner.lex();
+ };
+ JSXParser.prototype.nextJSXToken = function () {
+ this.collectComments();
+ this.startMarker.index = this.scanner.index;
+ this.startMarker.line = this.scanner.lineNumber;
+ this.startMarker.column = this.scanner.index - this.scanner.lineStart;
+ var token = this.lexJSX();
+ this.lastMarker.index = this.scanner.index;
+ this.lastMarker.line = this.scanner.lineNumber;
+ this.lastMarker.column = this.scanner.index - this.scanner.lineStart;
+ if (this.config.tokens) {
+ this.tokens.push(this.convertToken(token));
+ }
+ return token;
+ };
+ JSXParser.prototype.nextJSXText = function () {
+ this.startMarker.index = this.scanner.index;
+ this.startMarker.line = this.scanner.lineNumber;
+ this.startMarker.column = this.scanner.index - this.scanner.lineStart;
+ var start = this.scanner.index;
+ var text = '';
+ while (!this.scanner.eof()) {
+ var ch = this.scanner.source[this.scanner.index];
+ if (ch === '{' || ch === '<') {
+ break;
+ }
+ ++this.scanner.index;
+ text += ch;
+ if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
+ ++this.scanner.lineNumber;
+ if (ch === '\r' && this.scanner.source[this.scanner.index] === '\n') {
+ ++this.scanner.index;
+ }
+ this.scanner.lineStart = this.scanner.index;
+ }
+ }
+ this.lastMarker.index = this.scanner.index;
+ this.lastMarker.line = this.scanner.lineNumber;
+ this.lastMarker.column = this.scanner.index - this.scanner.lineStart;
+ var token = {
+ type: 101 /* Text */,
+ value: text,
+ lineNumber: this.scanner.lineNumber,
+ lineStart: this.scanner.lineStart,
+ start: start,
+ end: this.scanner.index
+ };
+ if ((text.length > 0) && this.config.tokens) {
+ this.tokens.push(this.convertToken(token));
+ }
+ return token;
+ };
+ JSXParser.prototype.peekJSXToken = function () {
+ var state = this.scanner.saveState();
+ this.scanner.scanComments();
+ var next = this.lexJSX();
+ this.scanner.restoreState(state);
+ return next;
+ };
+ // Expect the next JSX token to match the specified punctuator.
+ // If not, an exception will be thrown.
+ JSXParser.prototype.expectJSX = function (value) {
+ var token = this.nextJSXToken();
+ if (token.type !== 7 /* Punctuator */ || token.value !== value) {
+ this.throwUnexpectedToken(token);
+ }
+ };
+ // Return true if the next JSX token matches the specified punctuator.
+ JSXParser.prototype.matchJSX = function (value) {
+ var next = this.peekJSXToken();
+ return next.type === 7 /* Punctuator */ && next.value === value;
+ };
+ JSXParser.prototype.parseJSXIdentifier = function () {
+ var node = this.createJSXNode();
+ var token = this.nextJSXToken();
+ if (token.type !== 100 /* Identifier */) {
+ this.throwUnexpectedToken(token);
+ }
+ return this.finalize(node, new JSXNode.JSXIdentifier(token.value));
+ };
+ JSXParser.prototype.parseJSXElementName = function () {
+ var node = this.createJSXNode();
+ var elementName = this.parseJSXIdentifier();
+ if (this.matchJSX(':')) {
+ var namespace = elementName;
+ this.expectJSX(':');
+ var name_1 = this.parseJSXIdentifier();
+ elementName = this.finalize(node, new JSXNode.JSXNamespacedName(namespace, name_1));
+ }
+ else if (this.matchJSX('.')) {
+ while (this.matchJSX('.')) {
+ var object = elementName;
+ this.expectJSX('.');
+ var property = this.parseJSXIdentifier();
+ elementName = this.finalize(node, new JSXNode.JSXMemberExpression(object, property));
+ }
+ }
+ return elementName;
+ };
+ JSXParser.prototype.parseJSXAttributeName = function () {
+ var node = this.createJSXNode();
+ var attributeName;
+ var identifier = this.parseJSXIdentifier();
+ if (this.matchJSX(':')) {
+ var namespace = identifier;
+ this.expectJSX(':');
+ var name_2 = this.parseJSXIdentifier();
+ attributeName = this.finalize(node, new JSXNode.JSXNamespacedName(namespace, name_2));
+ }
+ else {
+ attributeName = identifier;
+ }
+ return attributeName;
+ };
+ JSXParser.prototype.parseJSXStringLiteralAttribute = function () {
+ var node = this.createJSXNode();
+ var token = this.nextJSXToken();
+ if (token.type !== 8 /* StringLiteral */) {
+ this.throwUnexpectedToken(token);
+ }
+ var raw = this.getTokenRaw(token);
+ return this.finalize(node, new Node.Literal(token.value, raw));
+ };
+ JSXParser.prototype.parseJSXExpressionAttribute = function () {
+ var node = this.createJSXNode();
+ this.expectJSX('{');
+ this.finishJSX();
+ if (this.match('}')) {
+ this.tolerateError('JSX attributes must only be assigned a non-empty expression');
+ }
+ var expression = this.parseAssignmentExpression();
+ this.reenterJSX();
+ return this.finalize(node, new JSXNode.JSXExpressionContainer(expression));
+ };
+ JSXParser.prototype.parseJSXAttributeValue = function () {
+ return this.matchJSX('{') ? this.parseJSXExpressionAttribute() :
+ this.matchJSX('<') ? this.parseJSXElement() : this.parseJSXStringLiteralAttribute();
+ };
+ JSXParser.prototype.parseJSXNameValueAttribute = function () {
+ var node = this.createJSXNode();
+ var name = this.parseJSXAttributeName();
+ var value = null;
+ if (this.matchJSX('=')) {
+ this.expectJSX('=');
+ value = this.parseJSXAttributeValue();
+ }
+ return this.finalize(node, new JSXNode.JSXAttribute(name, value));
+ };
+ JSXParser.prototype.parseJSXSpreadAttribute = function () {
+ var node = this.createJSXNode();
+ this.expectJSX('{');
+ this.expectJSX('...');
+ this.finishJSX();
+ var argument = this.parseAssignmentExpression();
+ this.reenterJSX();
+ return this.finalize(node, new JSXNode.JSXSpreadAttribute(argument));
+ };
+ JSXParser.prototype.parseJSXAttributes = function () {
+ var attributes = [];
+ while (!this.matchJSX('/') && !this.matchJSX('>')) {
+ var attribute = this.matchJSX('{') ? this.parseJSXSpreadAttribute() :
+ this.parseJSXNameValueAttribute();
+ attributes.push(attribute);
+ }
+ return attributes;
+ };
+ JSXParser.prototype.parseJSXOpeningElement = function () {
+ var node = this.createJSXNode();
+ this.expectJSX('<');
+ var name = this.parseJSXElementName();
+ var attributes = this.parseJSXAttributes();
+ var selfClosing = this.matchJSX('/');
+ if (selfClosing) {
+ this.expectJSX('/');
+ }
+ this.expectJSX('>');
+ return this.finalize(node, new JSXNode.JSXOpeningElement(name, selfClosing, attributes));
+ };
+ JSXParser.prototype.parseJSXBoundaryElement = function () {
+ var node = this.createJSXNode();
+ this.expectJSX('<');
+ if (this.matchJSX('/')) {
+ this.expectJSX('/');
+ var name_3 = this.parseJSXElementName();
+ this.expectJSX('>');
+ return this.finalize(node, new JSXNode.JSXClosingElement(name_3));
+ }
+ var name = this.parseJSXElementName();
+ var attributes = this.parseJSXAttributes();
+ var selfClosing = this.matchJSX('/');
+ if (selfClosing) {
+ this.expectJSX('/');
+ }
+ this.expectJSX('>');
+ return this.finalize(node, new JSXNode.JSXOpeningElement(name, selfClosing, attributes));
+ };
+ JSXParser.prototype.parseJSXEmptyExpression = function () {
+ var node = this.createJSXChildNode();
+ this.collectComments();
+ this.lastMarker.index = this.scanner.index;
+ this.lastMarker.line = this.scanner.lineNumber;
+ this.lastMarker.column = this.scanner.index - this.scanner.lineStart;
+ return this.finalize(node, new JSXNode.JSXEmptyExpression());
+ };
+ JSXParser.prototype.parseJSXExpressionContainer = function () {
+ var node = this.createJSXNode();
+ this.expectJSX('{');
+ var expression;
+ if (this.matchJSX('}')) {
+ expression = this.parseJSXEmptyExpression();
+ this.expectJSX('}');
+ }
+ else {
+ this.finishJSX();
+ expression = this.parseAssignmentExpression();
+ this.reenterJSX();
+ }
+ return this.finalize(node, new JSXNode.JSXExpressionContainer(expression));
+ };
+ JSXParser.prototype.parseJSXChildren = function () {
+ var children = [];
+ while (!this.scanner.eof()) {
+ var node = this.createJSXChildNode();
+ var token = this.nextJSXText();
+ if (token.start < token.end) {
+ var raw = this.getTokenRaw(token);
+ var child = this.finalize(node, new JSXNode.JSXText(token.value, raw));
+ children.push(child);
+ }
+ if (this.scanner.source[this.scanner.index] === '{') {
+ var container = this.parseJSXExpressionContainer();
+ children.push(container);
+ }
+ else {
+ break;
+ }
+ }
+ return children;
+ };
+ JSXParser.prototype.parseComplexJSXElement = function (el) {
+ var stack = [];
+ while (!this.scanner.eof()) {
+ el.children = el.children.concat(this.parseJSXChildren());
+ var node = this.createJSXChildNode();
+ var element = this.parseJSXBoundaryElement();
+ if (element.type === jsx_syntax_1.JSXSyntax.JSXOpeningElement) {
+ var opening = element;
+ if (opening.selfClosing) {
+ var child = this.finalize(node, new JSXNode.JSXElement(opening, [], null));
+ el.children.push(child);
+ }
+ else {
+ stack.push(el);
+ el = { node: node, opening: opening, closing: null, children: [] };
+ }
+ }
+ if (element.type === jsx_syntax_1.JSXSyntax.JSXClosingElement) {
+ el.closing = element;
+ var open_1 = getQualifiedElementName(el.opening.name);
+ var close_1 = getQualifiedElementName(el.closing.name);
+ if (open_1 !== close_1) {
+ this.tolerateError('Expected corresponding JSX closing tag for %0', open_1);
+ }
+ if (stack.length > 0) {
+ var child = this.finalize(el.node, new JSXNode.JSXElement(el.opening, el.children, el.closing));
+ el = stack[stack.length - 1];
+ el.children.push(child);
+ stack.pop();
+ }
+ else {
+ break;
+ }
+ }
+ }
+ return el;
+ };
+ JSXParser.prototype.parseJSXElement = function () {
+ var node = this.createJSXNode();
+ var opening = this.parseJSXOpeningElement();
+ var children = [];
+ var closing = null;
+ if (!opening.selfClosing) {
+ var el = this.parseComplexJSXElement({ node: node, opening: opening, closing: closing, children: children });
+ children = el.children;
+ closing = el.closing;
+ }
+ return this.finalize(node, new JSXNode.JSXElement(opening, children, closing));
+ };
+ JSXParser.prototype.parseJSXRoot = function () {
+ // Pop the opening '<' added from the lookahead.
+ if (this.config.tokens) {
+ this.tokens.pop();
+ }
+ this.startJSX();
+ var element = this.parseJSXElement();
+ this.finishJSX();
+ return element;
+ };
+ JSXParser.prototype.isStartOfExpression = function () {
+ return _super.prototype.isStartOfExpression.call(this) || this.match('<');
+ };
+ return JSXParser;
+ }(parser_1.Parser));
+ exports.JSXParser = JSXParser;
+
+
+/***/ },
+/* 4 */
+/***/ function(module, exports) {
+
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ // See also tools/generate-unicode-regex.js.
+ var Regex = {
+ // Unicode v8.0.0 NonAsciiIdentifierStart:
+ NonAsciiIdentifierStart: /[\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\u0561-\u0587\u05D0-\u05EA\u05F0-\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\u08A0-\u08B4\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\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\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\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-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\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-\u2C2E\u2C30-\u2C5E\u2C60-\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-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\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-\uAB65\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]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDE80-\uDE9C\uDEA0-\uDED0\uDF00-\uDF1F\uDF30-\uDF4A\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE4\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC03-\uDC37\uDC83-\uDCAF\uDCD0-\uDCE8\uDD03-\uDD26\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE2B\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61]|\uD805[\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE80-\uDEAA\uDF00-\uDF19]|\uD806[\uDCA0-\uDCDF\uDCFF\uDEC0-\uDEF8]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50\uDF93-\uDF9F]|\uD82C[\uDC00\uDC01]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB]|\uD83A[\uDC00-\uDCC4]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1]|\uD87E[\uDC00-\uDE1D]/,
+ // Unicode v8.0.0 NonAsciiIdentifierPart:
+ NonAsciiIdentifierPart: /[\xAA\xB5\xB7\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u08A0-\u08B4\u08E3-\u0963\u0966-\u096F\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0AF9\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58-\u0C5A\u0C60-\u0C63\u0C66-\u0C6F\u0C81-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D01-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D57\u0D5F-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\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\u135D-\u135F\u1369-\u1371\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19DA\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1CD0-\u1CD2\u1CD4-\u1CF6\u1CF8\u1CF9\u1D00-\u1DF5\u1DFC-\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\u200C\u200D\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA827\uA840-\uA873\uA880-\uA8C4\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA8FD\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDDFD\uDE80-\uDE9C\uDEA0-\uDED0\uDEE0\uDF00-\uDF1F\uDF30-\uDF4A\uDF50-\uDF7A\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCA0-\uDCA9\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00-\uDE03\uDE05\uDE06\uDE0C-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE38-\uDE3A\uDE3F\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE6\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC00-\uDC46\uDC66-\uDC6F\uDC7F-\uDCBA\uDCD0-\uDCE8\uDCF0-\uDCF9\uDD00-\uDD34\uDD36-\uDD3F\uDD50-\uDD73\uDD76\uDD80-\uDDC4\uDDCA-\uDDCC\uDDD0-\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE37\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEEA\uDEF0-\uDEF9\uDF00-\uDF03\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3C-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF50\uDF57\uDF5D-\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDC80-\uDCC5\uDCC7\uDCD0-\uDCD9\uDD80-\uDDB5\uDDB8-\uDDC0\uDDD8-\uDDDD\uDE00-\uDE40\uDE44\uDE50-\uDE59\uDE80-\uDEB7\uDEC0-\uDEC9\uDF00-\uDF19\uDF1D-\uDF2B\uDF30-\uDF39]|\uD806[\uDCA0-\uDCE9\uDCFF\uDEC0-\uDEF8]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDE60-\uDE69\uDED0-\uDEED\uDEF0-\uDEF4\uDF00-\uDF36\uDF40-\uDF43\uDF50-\uDF59\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50-\uDF7E\uDF8F-\uDF9F]|\uD82C[\uDC00\uDC01]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99\uDC9D\uDC9E]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB\uDFCE-\uDFFF]|\uD836[\uDE00-\uDE36\uDE3B-\uDE6C\uDE75\uDE84\uDE9B-\uDE9F\uDEA1-\uDEAF]|\uD83A[\uDC00-\uDCC4\uDCD0-\uDCD6]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1]|\uD87E[\uDC00-\uDE1D]|\uDB40[\uDD00-\uDDEF]/
+ };
+ exports.Character = {
+ /* tslint:disable:no-bitwise */
+ fromCodePoint: function (cp) {
+ return (cp < 0x10000) ? String.fromCharCode(cp) :
+ String.fromCharCode(0xD800 + ((cp - 0x10000) >> 10)) +
+ String.fromCharCode(0xDC00 + ((cp - 0x10000) & 1023));
+ },
+ // https://tc39.github.io/ecma262/#sec-white-space
+ isWhiteSpace: function (cp) {
+ return (cp === 0x20) || (cp === 0x09) || (cp === 0x0B) || (cp === 0x0C) || (cp === 0xA0) ||
+ (cp >= 0x1680 && [0x1680, 0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006, 0x2007, 0x2008, 0x2009, 0x200A, 0x202F, 0x205F, 0x3000, 0xFEFF].indexOf(cp) >= 0);
+ },
+ // https://tc39.github.io/ecma262/#sec-line-terminators
+ isLineTerminator: function (cp) {
+ return (cp === 0x0A) || (cp === 0x0D) || (cp === 0x2028) || (cp === 0x2029);
+ },
+ // https://tc39.github.io/ecma262/#sec-names-and-keywords
+ isIdentifierStart: function (cp) {
+ return (cp === 0x24) || (cp === 0x5F) ||
+ (cp >= 0x41 && cp <= 0x5A) ||
+ (cp >= 0x61 && cp <= 0x7A) ||
+ (cp === 0x5C) ||
+ ((cp >= 0x80) && Regex.NonAsciiIdentifierStart.test(exports.Character.fromCodePoint(cp)));
+ },
+ isIdentifierPart: function (cp) {
+ return (cp === 0x24) || (cp === 0x5F) ||
+ (cp >= 0x41 && cp <= 0x5A) ||
+ (cp >= 0x61 && cp <= 0x7A) ||
+ (cp >= 0x30 && cp <= 0x39) ||
+ (cp === 0x5C) ||
+ ((cp >= 0x80) && Regex.NonAsciiIdentifierPart.test(exports.Character.fromCodePoint(cp)));
+ },
+ // https://tc39.github.io/ecma262/#sec-literals-numeric-literals
+ isDecimalDigit: function (cp) {
+ return (cp >= 0x30 && cp <= 0x39); // 0..9
+ },
+ isHexDigit: function (cp) {
+ return (cp >= 0x30 && cp <= 0x39) ||
+ (cp >= 0x41 && cp <= 0x46) ||
+ (cp >= 0x61 && cp <= 0x66); // a..f
+ },
+ isOctalDigit: function (cp) {
+ return (cp >= 0x30 && cp <= 0x37); // 0..7
+ }
+ };
+
+
+/***/ },
+/* 5 */
+/***/ function(module, exports, __nested_webpack_require_54354__) {
+
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var jsx_syntax_1 = __nested_webpack_require_54354__(6);
+ /* tslint:disable:max-classes-per-file */
+ var JSXClosingElement = (function () {
+ function JSXClosingElement(name) {
+ this.type = jsx_syntax_1.JSXSyntax.JSXClosingElement;
+ this.name = name;
+ }
+ return JSXClosingElement;
+ }());
+ exports.JSXClosingElement = JSXClosingElement;
+ var JSXElement = (function () {
+ function JSXElement(openingElement, children, closingElement) {
+ this.type = jsx_syntax_1.JSXSyntax.JSXElement;
+ this.openingElement = openingElement;
+ this.children = children;
+ this.closingElement = closingElement;
+ }
+ return JSXElement;
+ }());
+ exports.JSXElement = JSXElement;
+ var JSXEmptyExpression = (function () {
+ function JSXEmptyExpression() {
+ this.type = jsx_syntax_1.JSXSyntax.JSXEmptyExpression;
+ }
+ return JSXEmptyExpression;
+ }());
+ exports.JSXEmptyExpression = JSXEmptyExpression;
+ var JSXExpressionContainer = (function () {
+ function JSXExpressionContainer(expression) {
+ this.type = jsx_syntax_1.JSXSyntax.JSXExpressionContainer;
+ this.expression = expression;
+ }
+ return JSXExpressionContainer;
+ }());
+ exports.JSXExpressionContainer = JSXExpressionContainer;
+ var JSXIdentifier = (function () {
+ function JSXIdentifier(name) {
+ this.type = jsx_syntax_1.JSXSyntax.JSXIdentifier;
+ this.name = name;
+ }
+ return JSXIdentifier;
+ }());
+ exports.JSXIdentifier = JSXIdentifier;
+ var JSXMemberExpression = (function () {
+ function JSXMemberExpression(object, property) {
+ this.type = jsx_syntax_1.JSXSyntax.JSXMemberExpression;
+ this.object = object;
+ this.property = property;
+ }
+ return JSXMemberExpression;
+ }());
+ exports.JSXMemberExpression = JSXMemberExpression;
+ var JSXAttribute = (function () {
+ function JSXAttribute(name, value) {
+ this.type = jsx_syntax_1.JSXSyntax.JSXAttribute;
+ this.name = name;
+ this.value = value;
+ }
+ return JSXAttribute;
+ }());
+ exports.JSXAttribute = JSXAttribute;
+ var JSXNamespacedName = (function () {
+ function JSXNamespacedName(namespace, name) {
+ this.type = jsx_syntax_1.JSXSyntax.JSXNamespacedName;
+ this.namespace = namespace;
+ this.name = name;
+ }
+ return JSXNamespacedName;
+ }());
+ exports.JSXNamespacedName = JSXNamespacedName;
+ var JSXOpeningElement = (function () {
+ function JSXOpeningElement(name, selfClosing, attributes) {
+ this.type = jsx_syntax_1.JSXSyntax.JSXOpeningElement;
+ this.name = name;
+ this.selfClosing = selfClosing;
+ this.attributes = attributes;
+ }
+ return JSXOpeningElement;
+ }());
+ exports.JSXOpeningElement = JSXOpeningElement;
+ var JSXSpreadAttribute = (function () {
+ function JSXSpreadAttribute(argument) {
+ this.type = jsx_syntax_1.JSXSyntax.JSXSpreadAttribute;
+ this.argument = argument;
+ }
+ return JSXSpreadAttribute;
+ }());
+ exports.JSXSpreadAttribute = JSXSpreadAttribute;
+ var JSXText = (function () {
+ function JSXText(value, raw) {
+ this.type = jsx_syntax_1.JSXSyntax.JSXText;
+ this.value = value;
+ this.raw = raw;
+ }
+ return JSXText;
+ }());
+ exports.JSXText = JSXText;
+
+
+/***/ },
+/* 6 */
+/***/ function(module, exports) {
+
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.JSXSyntax = {
+ JSXAttribute: 'JSXAttribute',
+ JSXClosingElement: 'JSXClosingElement',
+ JSXElement: 'JSXElement',
+ JSXEmptyExpression: 'JSXEmptyExpression',
+ JSXExpressionContainer: 'JSXExpressionContainer',
+ JSXIdentifier: 'JSXIdentifier',
+ JSXMemberExpression: 'JSXMemberExpression',
+ JSXNamespacedName: 'JSXNamespacedName',
+ JSXOpeningElement: 'JSXOpeningElement',
+ JSXSpreadAttribute: 'JSXSpreadAttribute',
+ JSXText: 'JSXText'
+ };
+
+
+/***/ },
+/* 7 */
+/***/ function(module, exports, __nested_webpack_require_58416__) {
+
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var syntax_1 = __nested_webpack_require_58416__(2);
+ /* tslint:disable:max-classes-per-file */
+ var ArrayExpression = (function () {
+ function ArrayExpression(elements) {
+ this.type = syntax_1.Syntax.ArrayExpression;
+ this.elements = elements;
+ }
+ return ArrayExpression;
+ }());
+ exports.ArrayExpression = ArrayExpression;
+ var ArrayPattern = (function () {
+ function ArrayPattern(elements) {
+ this.type = syntax_1.Syntax.ArrayPattern;
+ this.elements = elements;
+ }
+ return ArrayPattern;
+ }());
+ exports.ArrayPattern = ArrayPattern;
+ var ArrowFunctionExpression = (function () {
+ function ArrowFunctionExpression(params, body, expression) {
+ this.type = syntax_1.Syntax.ArrowFunctionExpression;
+ this.id = null;
+ this.params = params;
+ this.body = body;
+ this.generator = false;
+ this.expression = expression;
+ this.async = false;
+ }
+ return ArrowFunctionExpression;
+ }());
+ exports.ArrowFunctionExpression = ArrowFunctionExpression;
+ var AssignmentExpression = (function () {
+ function AssignmentExpression(operator, left, right) {
+ this.type = syntax_1.Syntax.AssignmentExpression;
+ this.operator = operator;
+ this.left = left;
+ this.right = right;
+ }
+ return AssignmentExpression;
+ }());
+ exports.AssignmentExpression = AssignmentExpression;
+ var AssignmentPattern = (function () {
+ function AssignmentPattern(left, right) {
+ this.type = syntax_1.Syntax.AssignmentPattern;
+ this.left = left;
+ this.right = right;
+ }
+ return AssignmentPattern;
+ }());
+ exports.AssignmentPattern = AssignmentPattern;
+ var AsyncArrowFunctionExpression = (function () {
+ function AsyncArrowFunctionExpression(params, body, expression) {
+ this.type = syntax_1.Syntax.ArrowFunctionExpression;
+ this.id = null;
+ this.params = params;
+ this.body = body;
+ this.generator = false;
+ this.expression = expression;
+ this.async = true;
+ }
+ return AsyncArrowFunctionExpression;
+ }());
+ exports.AsyncArrowFunctionExpression = AsyncArrowFunctionExpression;
+ var AsyncFunctionDeclaration = (function () {
+ function AsyncFunctionDeclaration(id, params, body) {
+ this.type = syntax_1.Syntax.FunctionDeclaration;
+ this.id = id;
+ this.params = params;
+ this.body = body;
+ this.generator = false;
+ this.expression = false;
+ this.async = true;
+ }
+ return AsyncFunctionDeclaration;
+ }());
+ exports.AsyncFunctionDeclaration = AsyncFunctionDeclaration;
+ var AsyncFunctionExpression = (function () {
+ function AsyncFunctionExpression(id, params, body) {
+ this.type = syntax_1.Syntax.FunctionExpression;
+ this.id = id;
+ this.params = params;
+ this.body = body;
+ this.generator = false;
+ this.expression = false;
+ this.async = true;
+ }
+ return AsyncFunctionExpression;
+ }());
+ exports.AsyncFunctionExpression = AsyncFunctionExpression;
+ var AwaitExpression = (function () {
+ function AwaitExpression(argument) {
+ this.type = syntax_1.Syntax.AwaitExpression;
+ this.argument = argument;
+ }
+ return AwaitExpression;
+ }());
+ exports.AwaitExpression = AwaitExpression;
+ var BinaryExpression = (function () {
+ function BinaryExpression(operator, left, right) {
+ var logical = (operator === '||' || operator === '&&');
+ this.type = logical ? syntax_1.Syntax.LogicalExpression : syntax_1.Syntax.BinaryExpression;
+ this.operator = operator;
+ this.left = left;
+ this.right = right;
+ }
+ return BinaryExpression;
+ }());
+ exports.BinaryExpression = BinaryExpression;
+ var BlockStatement = (function () {
+ function BlockStatement(body) {
+ this.type = syntax_1.Syntax.BlockStatement;
+ this.body = body;
+ }
+ return BlockStatement;
+ }());
+ exports.BlockStatement = BlockStatement;
+ var BreakStatement = (function () {
+ function BreakStatement(label) {
+ this.type = syntax_1.Syntax.BreakStatement;
+ this.label = label;
+ }
+ return BreakStatement;
+ }());
+ exports.BreakStatement = BreakStatement;
+ var CallExpression = (function () {
+ function CallExpression(callee, args) {
+ this.type = syntax_1.Syntax.CallExpression;
+ this.callee = callee;
+ this.arguments = args;
+ }
+ return CallExpression;
+ }());
+ exports.CallExpression = CallExpression;
+ var CatchClause = (function () {
+ function CatchClause(param, body) {
+ this.type = syntax_1.Syntax.CatchClause;
+ this.param = param;
+ this.body = body;
+ }
+ return CatchClause;
+ }());
+ exports.CatchClause = CatchClause;
+ var ClassBody = (function () {
+ function ClassBody(body) {
+ this.type = syntax_1.Syntax.ClassBody;
+ this.body = body;
+ }
+ return ClassBody;
+ }());
+ exports.ClassBody = ClassBody;
+ var ClassDeclaration = (function () {
+ function ClassDeclaration(id, superClass, body) {
+ this.type = syntax_1.Syntax.ClassDeclaration;
+ this.id = id;
+ this.superClass = superClass;
+ this.body = body;
+ }
+ return ClassDeclaration;
+ }());
+ exports.ClassDeclaration = ClassDeclaration;
+ var ClassExpression = (function () {
+ function ClassExpression(id, superClass, body) {
+ this.type = syntax_1.Syntax.ClassExpression;
+ this.id = id;
+ this.superClass = superClass;
+ this.body = body;
+ }
+ return ClassExpression;
+ }());
+ exports.ClassExpression = ClassExpression;
+ var ComputedMemberExpression = (function () {
+ function ComputedMemberExpression(object, property) {
+ this.type = syntax_1.Syntax.MemberExpression;
+ this.computed = true;
+ this.object = object;
+ this.property = property;
+ }
+ return ComputedMemberExpression;
+ }());
+ exports.ComputedMemberExpression = ComputedMemberExpression;
+ var ConditionalExpression = (function () {
+ function ConditionalExpression(test, consequent, alternate) {
+ this.type = syntax_1.Syntax.ConditionalExpression;
+ this.test = test;
+ this.consequent = consequent;
+ this.alternate = alternate;
+ }
+ return ConditionalExpression;
+ }());
+ exports.ConditionalExpression = ConditionalExpression;
+ var ContinueStatement = (function () {
+ function ContinueStatement(label) {
+ this.type = syntax_1.Syntax.ContinueStatement;
+ this.label = label;
+ }
+ return ContinueStatement;
+ }());
+ exports.ContinueStatement = ContinueStatement;
+ var DebuggerStatement = (function () {
+ function DebuggerStatement() {
+ this.type = syntax_1.Syntax.DebuggerStatement;
+ }
+ return DebuggerStatement;
+ }());
+ exports.DebuggerStatement = DebuggerStatement;
+ var Directive = (function () {
+ function Directive(expression, directive) {
+ this.type = syntax_1.Syntax.ExpressionStatement;
+ this.expression = expression;
+ this.directive = directive;
+ }
+ return Directive;
+ }());
+ exports.Directive = Directive;
+ var DoWhileStatement = (function () {
+ function DoWhileStatement(body, test) {
+ this.type = syntax_1.Syntax.DoWhileStatement;
+ this.body = body;
+ this.test = test;
+ }
+ return DoWhileStatement;
+ }());
+ exports.DoWhileStatement = DoWhileStatement;
+ var EmptyStatement = (function () {
+ function EmptyStatement() {
+ this.type = syntax_1.Syntax.EmptyStatement;
+ }
+ return EmptyStatement;
+ }());
+ exports.EmptyStatement = EmptyStatement;
+ var ExportAllDeclaration = (function () {
+ function ExportAllDeclaration(source) {
+ this.type = syntax_1.Syntax.ExportAllDeclaration;
+ this.source = source;
+ }
+ return ExportAllDeclaration;
+ }());
+ exports.ExportAllDeclaration = ExportAllDeclaration;
+ var ExportDefaultDeclaration = (function () {
+ function ExportDefaultDeclaration(declaration) {
+ this.type = syntax_1.Syntax.ExportDefaultDeclaration;
+ this.declaration = declaration;
+ }
+ return ExportDefaultDeclaration;
+ }());
+ exports.ExportDefaultDeclaration = ExportDefaultDeclaration;
+ var ExportNamedDeclaration = (function () {
+ function ExportNamedDeclaration(declaration, specifiers, source) {
+ this.type = syntax_1.Syntax.ExportNamedDeclaration;
+ this.declaration = declaration;
+ this.specifiers = specifiers;
+ this.source = source;
+ }
+ return ExportNamedDeclaration;
+ }());
+ exports.ExportNamedDeclaration = ExportNamedDeclaration;
+ var ExportSpecifier = (function () {
+ function ExportSpecifier(local, exported) {
+ this.type = syntax_1.Syntax.ExportSpecifier;
+ this.exported = exported;
+ this.local = local;
+ }
+ return ExportSpecifier;
+ }());
+ exports.ExportSpecifier = ExportSpecifier;
+ var ExpressionStatement = (function () {
+ function ExpressionStatement(expression) {
+ this.type = syntax_1.Syntax.ExpressionStatement;
+ this.expression = expression;
+ }
+ return ExpressionStatement;
+ }());
+ exports.ExpressionStatement = ExpressionStatement;
+ var ForInStatement = (function () {
+ function ForInStatement(left, right, body) {
+ this.type = syntax_1.Syntax.ForInStatement;
+ this.left = left;
+ this.right = right;
+ this.body = body;
+ this.each = false;
+ }
+ return ForInStatement;
+ }());
+ exports.ForInStatement = ForInStatement;
+ var ForOfStatement = (function () {
+ function ForOfStatement(left, right, body) {
+ this.type = syntax_1.Syntax.ForOfStatement;
+ this.left = left;
+ this.right = right;
+ this.body = body;
+ }
+ return ForOfStatement;
+ }());
+ exports.ForOfStatement = ForOfStatement;
+ var ForStatement = (function () {
+ function ForStatement(init, test, update, body) {
+ this.type = syntax_1.Syntax.ForStatement;
+ this.init = init;
+ this.test = test;
+ this.update = update;
+ this.body = body;
+ }
+ return ForStatement;
+ }());
+ exports.ForStatement = ForStatement;
+ var FunctionDeclaration = (function () {
+ function FunctionDeclaration(id, params, body, generator) {
+ this.type = syntax_1.Syntax.FunctionDeclaration;
+ this.id = id;
+ this.params = params;
+ this.body = body;
+ this.generator = generator;
+ this.expression = false;
+ this.async = false;
+ }
+ return FunctionDeclaration;
+ }());
+ exports.FunctionDeclaration = FunctionDeclaration;
+ var FunctionExpression = (function () {
+ function FunctionExpression(id, params, body, generator) {
+ this.type = syntax_1.Syntax.FunctionExpression;
+ this.id = id;
+ this.params = params;
+ this.body = body;
+ this.generator = generator;
+ this.expression = false;
+ this.async = false;
+ }
+ return FunctionExpression;
+ }());
+ exports.FunctionExpression = FunctionExpression;
+ var Identifier = (function () {
+ function Identifier(name) {
+ this.type = syntax_1.Syntax.Identifier;
+ this.name = name;
+ }
+ return Identifier;
+ }());
+ exports.Identifier = Identifier;
+ var IfStatement = (function () {
+ function IfStatement(test, consequent, alternate) {
+ this.type = syntax_1.Syntax.IfStatement;
+ this.test = test;
+ this.consequent = consequent;
+ this.alternate = alternate;
+ }
+ return IfStatement;
+ }());
+ exports.IfStatement = IfStatement;
+ var ImportDeclaration = (function () {
+ function ImportDeclaration(specifiers, source) {
+ this.type = syntax_1.Syntax.ImportDeclaration;
+ this.specifiers = specifiers;
+ this.source = source;
+ }
+ return ImportDeclaration;
+ }());
+ exports.ImportDeclaration = ImportDeclaration;
+ var ImportDefaultSpecifier = (function () {
+ function ImportDefaultSpecifier(local) {
+ this.type = syntax_1.Syntax.ImportDefaultSpecifier;
+ this.local = local;
+ }
+ return ImportDefaultSpecifier;
+ }());
+ exports.ImportDefaultSpecifier = ImportDefaultSpecifier;
+ var ImportNamespaceSpecifier = (function () {
+ function ImportNamespaceSpecifier(local) {
+ this.type = syntax_1.Syntax.ImportNamespaceSpecifier;
+ this.local = local;
+ }
+ return ImportNamespaceSpecifier;
+ }());
+ exports.ImportNamespaceSpecifier = ImportNamespaceSpecifier;
+ var ImportSpecifier = (function () {
+ function ImportSpecifier(local, imported) {
+ this.type = syntax_1.Syntax.ImportSpecifier;
+ this.local = local;
+ this.imported = imported;
+ }
+ return ImportSpecifier;
+ }());
+ exports.ImportSpecifier = ImportSpecifier;
+ var LabeledStatement = (function () {
+ function LabeledStatement(label, body) {
+ this.type = syntax_1.Syntax.LabeledStatement;
+ this.label = label;
+ this.body = body;
+ }
+ return LabeledStatement;
+ }());
+ exports.LabeledStatement = LabeledStatement;
+ var Literal = (function () {
+ function Literal(value, raw) {
+ this.type = syntax_1.Syntax.Literal;
+ this.value = value;
+ this.raw = raw;
+ }
+ return Literal;
+ }());
+ exports.Literal = Literal;
+ var MetaProperty = (function () {
+ function MetaProperty(meta, property) {
+ this.type = syntax_1.Syntax.MetaProperty;
+ this.meta = meta;
+ this.property = property;
+ }
+ return MetaProperty;
+ }());
+ exports.MetaProperty = MetaProperty;
+ var MethodDefinition = (function () {
+ function MethodDefinition(key, computed, value, kind, isStatic) {
+ this.type = syntax_1.Syntax.MethodDefinition;
+ this.key = key;
+ this.computed = computed;
+ this.value = value;
+ this.kind = kind;
+ this.static = isStatic;
+ }
+ return MethodDefinition;
+ }());
+ exports.MethodDefinition = MethodDefinition;
+ var Module = (function () {
+ function Module(body) {
+ this.type = syntax_1.Syntax.Program;
+ this.body = body;
+ this.sourceType = 'module';
+ }
+ return Module;
+ }());
+ exports.Module = Module;
+ var NewExpression = (function () {
+ function NewExpression(callee, args) {
+ this.type = syntax_1.Syntax.NewExpression;
+ this.callee = callee;
+ this.arguments = args;
+ }
+ return NewExpression;
+ }());
+ exports.NewExpression = NewExpression;
+ var ObjectExpression = (function () {
+ function ObjectExpression(properties) {
+ this.type = syntax_1.Syntax.ObjectExpression;
+ this.properties = properties;
+ }
+ return ObjectExpression;
+ }());
+ exports.ObjectExpression = ObjectExpression;
+ var ObjectPattern = (function () {
+ function ObjectPattern(properties) {
+ this.type = syntax_1.Syntax.ObjectPattern;
+ this.properties = properties;
+ }
+ return ObjectPattern;
+ }());
+ exports.ObjectPattern = ObjectPattern;
+ var Property = (function () {
+ function Property(kind, key, computed, value, method, shorthand) {
+ this.type = syntax_1.Syntax.Property;
+ this.key = key;
+ this.computed = computed;
+ this.value = value;
+ this.kind = kind;
+ this.method = method;
+ this.shorthand = shorthand;
+ }
+ return Property;
+ }());
+ exports.Property = Property;
+ var RegexLiteral = (function () {
+ function RegexLiteral(value, raw, pattern, flags) {
+ this.type = syntax_1.Syntax.Literal;
+ this.value = value;
+ this.raw = raw;
+ this.regex = { pattern: pattern, flags: flags };
+ }
+ return RegexLiteral;
+ }());
+ exports.RegexLiteral = RegexLiteral;
+ var RestElement = (function () {
+ function RestElement(argument) {
+ this.type = syntax_1.Syntax.RestElement;
+ this.argument = argument;
+ }
+ return RestElement;
+ }());
+ exports.RestElement = RestElement;
+ var ReturnStatement = (function () {
+ function ReturnStatement(argument) {
+ this.type = syntax_1.Syntax.ReturnStatement;
+ this.argument = argument;
+ }
+ return ReturnStatement;
+ }());
+ exports.ReturnStatement = ReturnStatement;
+ var Script = (function () {
+ function Script(body) {
+ this.type = syntax_1.Syntax.Program;
+ this.body = body;
+ this.sourceType = 'script';
+ }
+ return Script;
+ }());
+ exports.Script = Script;
+ var SequenceExpression = (function () {
+ function SequenceExpression(expressions) {
+ this.type = syntax_1.Syntax.SequenceExpression;
+ this.expressions = expressions;
+ }
+ return SequenceExpression;
+ }());
+ exports.SequenceExpression = SequenceExpression;
+ var SpreadElement = (function () {
+ function SpreadElement(argument) {
+ this.type = syntax_1.Syntax.SpreadElement;
+ this.argument = argument;
+ }
+ return SpreadElement;
+ }());
+ exports.SpreadElement = SpreadElement;
+ var StaticMemberExpression = (function () {
+ function StaticMemberExpression(object, property) {
+ this.type = syntax_1.Syntax.MemberExpression;
+ this.computed = false;
+ this.object = object;
+ this.property = property;
+ }
+ return StaticMemberExpression;
+ }());
+ exports.StaticMemberExpression = StaticMemberExpression;
+ var Super = (function () {
+ function Super() {
+ this.type = syntax_1.Syntax.Super;
+ }
+ return Super;
+ }());
+ exports.Super = Super;
+ var SwitchCase = (function () {
+ function SwitchCase(test, consequent) {
+ this.type = syntax_1.Syntax.SwitchCase;
+ this.test = test;
+ this.consequent = consequent;
+ }
+ return SwitchCase;
+ }());
+ exports.SwitchCase = SwitchCase;
+ var SwitchStatement = (function () {
+ function SwitchStatement(discriminant, cases) {
+ this.type = syntax_1.Syntax.SwitchStatement;
+ this.discriminant = discriminant;
+ this.cases = cases;
+ }
+ return SwitchStatement;
+ }());
+ exports.SwitchStatement = SwitchStatement;
+ var TaggedTemplateExpression = (function () {
+ function TaggedTemplateExpression(tag, quasi) {
+ this.type = syntax_1.Syntax.TaggedTemplateExpression;
+ this.tag = tag;
+ this.quasi = quasi;
+ }
+ return TaggedTemplateExpression;
+ }());
+ exports.TaggedTemplateExpression = TaggedTemplateExpression;
+ var TemplateElement = (function () {
+ function TemplateElement(value, tail) {
+ this.type = syntax_1.Syntax.TemplateElement;
+ this.value = value;
+ this.tail = tail;
+ }
+ return TemplateElement;
+ }());
+ exports.TemplateElement = TemplateElement;
+ var TemplateLiteral = (function () {
+ function TemplateLiteral(quasis, expressions) {
+ this.type = syntax_1.Syntax.TemplateLiteral;
+ this.quasis = quasis;
+ this.expressions = expressions;
+ }
+ return TemplateLiteral;
+ }());
+ exports.TemplateLiteral = TemplateLiteral;
+ var ThisExpression = (function () {
+ function ThisExpression() {
+ this.type = syntax_1.Syntax.ThisExpression;
+ }
+ return ThisExpression;
+ }());
+ exports.ThisExpression = ThisExpression;
+ var ThrowStatement = (function () {
+ function ThrowStatement(argument) {
+ this.type = syntax_1.Syntax.ThrowStatement;
+ this.argument = argument;
+ }
+ return ThrowStatement;
+ }());
+ exports.ThrowStatement = ThrowStatement;
+ var TryStatement = (function () {
+ function TryStatement(block, handler, finalizer) {
+ this.type = syntax_1.Syntax.TryStatement;
+ this.block = block;
+ this.handler = handler;
+ this.finalizer = finalizer;
+ }
+ return TryStatement;
+ }());
+ exports.TryStatement = TryStatement;
+ var UnaryExpression = (function () {
+ function UnaryExpression(operator, argument) {
+ this.type = syntax_1.Syntax.UnaryExpression;
+ this.operator = operator;
+ this.argument = argument;
+ this.prefix = true;
+ }
+ return UnaryExpression;
+ }());
+ exports.UnaryExpression = UnaryExpression;
+ var UpdateExpression = (function () {
+ function UpdateExpression(operator, argument, prefix) {
+ this.type = syntax_1.Syntax.UpdateExpression;
+ this.operator = operator;
+ this.argument = argument;
+ this.prefix = prefix;
+ }
+ return UpdateExpression;
+ }());
+ exports.UpdateExpression = UpdateExpression;
+ var VariableDeclaration = (function () {
+ function VariableDeclaration(declarations, kind) {
+ this.type = syntax_1.Syntax.VariableDeclaration;
+ this.declarations = declarations;
+ this.kind = kind;
+ }
+ return VariableDeclaration;
+ }());
+ exports.VariableDeclaration = VariableDeclaration;
+ var VariableDeclarator = (function () {
+ function VariableDeclarator(id, init) {
+ this.type = syntax_1.Syntax.VariableDeclarator;
+ this.id = id;
+ this.init = init;
+ }
+ return VariableDeclarator;
+ }());
+ exports.VariableDeclarator = VariableDeclarator;
+ var WhileStatement = (function () {
+ function WhileStatement(test, body) {
+ this.type = syntax_1.Syntax.WhileStatement;
+ this.test = test;
+ this.body = body;
+ }
+ return WhileStatement;
+ }());
+ exports.WhileStatement = WhileStatement;
+ var WithStatement = (function () {
+ function WithStatement(object, body) {
+ this.type = syntax_1.Syntax.WithStatement;
+ this.object = object;
+ this.body = body;
+ }
+ return WithStatement;
+ }());
+ exports.WithStatement = WithStatement;
+ var YieldExpression = (function () {
+ function YieldExpression(argument, delegate) {
+ this.type = syntax_1.Syntax.YieldExpression;
+ this.argument = argument;
+ this.delegate = delegate;
+ }
+ return YieldExpression;
+ }());
+ exports.YieldExpression = YieldExpression;
+
+
+/***/ },
+/* 8 */
+/***/ function(module, exports, __nested_webpack_require_80491__) {
+
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var assert_1 = __nested_webpack_require_80491__(9);
+ var error_handler_1 = __nested_webpack_require_80491__(10);
+ var messages_1 = __nested_webpack_require_80491__(11);
+ var Node = __nested_webpack_require_80491__(7);
+ var scanner_1 = __nested_webpack_require_80491__(12);
+ var syntax_1 = __nested_webpack_require_80491__(2);
+ var token_1 = __nested_webpack_require_80491__(13);
+ var ArrowParameterPlaceHolder = 'ArrowParameterPlaceHolder';
+ var Parser = (function () {
+ function Parser(code, options, delegate) {
+ if (options === void 0) { options = {}; }
+ this.config = {
+ range: (typeof options.range === 'boolean') && options.range,
+ loc: (typeof options.loc === 'boolean') && options.loc,
+ source: null,
+ tokens: (typeof options.tokens === 'boolean') && options.tokens,
+ comment: (typeof options.comment === 'boolean') && options.comment,
+ tolerant: (typeof options.tolerant === 'boolean') && options.tolerant
+ };
+ if (this.config.loc && options.source && options.source !== null) {
+ this.config.source = String(options.source);
+ }
+ this.delegate = delegate;
+ this.errorHandler = new error_handler_1.ErrorHandler();
+ this.errorHandler.tolerant = this.config.tolerant;
+ this.scanner = new scanner_1.Scanner(code, this.errorHandler);
+ this.scanner.trackComment = this.config.comment;
+ this.operatorPrecedence = {
+ ')': 0,
+ ';': 0,
+ ',': 0,
+ '=': 0,
+ ']': 0,
+ '||': 1,
+ '&&': 2,
+ '|': 3,
+ '^': 4,
+ '&': 5,
+ '==': 6,
+ '!=': 6,
+ '===': 6,
+ '!==': 6,
+ '<': 7,
+ '>': 7,
+ '<=': 7,
+ '>=': 7,
+ '<<': 8,
+ '>>': 8,
+ '>>>': 8,
+ '+': 9,
+ '-': 9,
+ '*': 11,
+ '/': 11,
+ '%': 11
+ };
+ this.lookahead = {
+ type: 2 /* EOF */,
+ value: '',
+ lineNumber: this.scanner.lineNumber,
+ lineStart: 0,
+ start: 0,
+ end: 0
+ };
+ this.hasLineTerminator = false;
+ this.context = {
+ isModule: false,
+ await: false,
+ allowIn: true,
+ allowStrictDirective: true,
+ allowYield: true,
+ firstCoverInitializedNameError: null,
+ isAssignmentTarget: false,
+ isBindingElement: false,
+ inFunctionBody: false,
+ inIteration: false,
+ inSwitch: false,
+ labelSet: {},
+ strict: false
+ };
+ this.tokens = [];
+ this.startMarker = {
+ index: 0,
+ line: this.scanner.lineNumber,
+ column: 0
+ };
+ this.lastMarker = {
+ index: 0,
+ line: this.scanner.lineNumber,
+ column: 0
+ };
+ this.nextToken();
+ this.lastMarker = {
+ index: this.scanner.index,
+ line: this.scanner.lineNumber,
+ column: this.scanner.index - this.scanner.lineStart
+ };
+ }
+ Parser.prototype.throwError = function (messageFormat) {
+ var values = [];
+ for (var _i = 1; _i < arguments.length; _i++) {
+ values[_i - 1] = arguments[_i];
+ }
+ var args = Array.prototype.slice.call(arguments, 1);
+ var msg = messageFormat.replace(/%(\d)/g, function (whole, idx) {
+ assert_1.assert(idx < args.length, 'Message reference must be in range');
+ return args[idx];
+ });
+ var index = this.lastMarker.index;
+ var line = this.lastMarker.line;
+ var column = this.lastMarker.column + 1;
+ throw this.errorHandler.createError(index, line, column, msg);
+ };
+ Parser.prototype.tolerateError = function (messageFormat) {
+ var values = [];
+ for (var _i = 1; _i < arguments.length; _i++) {
+ values[_i - 1] = arguments[_i];
+ }
+ var args = Array.prototype.slice.call(arguments, 1);
+ var msg = messageFormat.replace(/%(\d)/g, function (whole, idx) {
+ assert_1.assert(idx < args.length, 'Message reference must be in range');
+ return args[idx];
+ });
+ var index = this.lastMarker.index;
+ var line = this.scanner.lineNumber;
+ var column = this.lastMarker.column + 1;
+ this.errorHandler.tolerateError(index, line, column, msg);
+ };
+ // Throw an exception because of the token.
+ Parser.prototype.unexpectedTokenError = function (token, message) {
+ var msg = message || messages_1.Messages.UnexpectedToken;
+ var value;
+ if (token) {
+ if (!message) {
+ msg = (token.type === 2 /* EOF */) ? messages_1.Messages.UnexpectedEOS :
+ (token.type === 3 /* Identifier */) ? messages_1.Messages.UnexpectedIdentifier :
+ (token.type === 6 /* NumericLiteral */) ? messages_1.Messages.UnexpectedNumber :
+ (token.type === 8 /* StringLiteral */) ? messages_1.Messages.UnexpectedString :
+ (token.type === 10 /* Template */) ? messages_1.Messages.UnexpectedTemplate :
+ messages_1.Messages.UnexpectedToken;
+ if (token.type === 4 /* Keyword */) {
+ if (this.scanner.isFutureReservedWord(token.value)) {
+ msg = messages_1.Messages.UnexpectedReserved;
+ }
+ else if (this.context.strict && this.scanner.isStrictModeReservedWord(token.value)) {
+ msg = messages_1.Messages.StrictReservedWord;
+ }
+ }
+ }
+ value = token.value;
+ }
+ else {
+ value = 'ILLEGAL';
+ }
+ msg = msg.replace('%0', value);
+ if (token && typeof token.lineNumber === 'number') {
+ var index = token.start;
+ var line = token.lineNumber;
+ var lastMarkerLineStart = this.lastMarker.index - this.lastMarker.column;
+ var column = token.start - lastMarkerLineStart + 1;
+ return this.errorHandler.createError(index, line, column, msg);
+ }
+ else {
+ var index = this.lastMarker.index;
+ var line = this.lastMarker.line;
+ var column = this.lastMarker.column + 1;
+ return this.errorHandler.createError(index, line, column, msg);
+ }
+ };
+ Parser.prototype.throwUnexpectedToken = function (token, message) {
+ throw this.unexpectedTokenError(token, message);
+ };
+ Parser.prototype.tolerateUnexpectedToken = function (token, message) {
+ this.errorHandler.tolerate(this.unexpectedTokenError(token, message));
+ };
+ Parser.prototype.collectComments = function () {
+ if (!this.config.comment) {
+ this.scanner.scanComments();
+ }
+ else {
+ var comments = this.scanner.scanComments();
+ if (comments.length > 0 && this.delegate) {
+ for (var i = 0; i < comments.length; ++i) {
+ var e = comments[i];
+ var node = void 0;
+ node = {
+ type: e.multiLine ? 'BlockComment' : 'LineComment',
+ value: this.scanner.source.slice(e.slice[0], e.slice[1])
+ };
+ if (this.config.range) {
+ node.range = e.range;
+ }
+ if (this.config.loc) {
+ node.loc = e.loc;
+ }
+ var metadata = {
+ start: {
+ line: e.loc.start.line,
+ column: e.loc.start.column,
+ offset: e.range[0]
+ },
+ end: {
+ line: e.loc.end.line,
+ column: e.loc.end.column,
+ offset: e.range[1]
+ }
+ };
+ this.delegate(node, metadata);
+ }
+ }
+ }
+ };
+ // From internal representation to an external structure
+ Parser.prototype.getTokenRaw = function (token) {
+ return this.scanner.source.slice(token.start, token.end);
+ };
+ Parser.prototype.convertToken = function (token) {
+ var t = {
+ type: token_1.TokenName[token.type],
+ value: this.getTokenRaw(token)
+ };
+ if (this.config.range) {
+ t.range = [token.start, token.end];
+ }
+ if (this.config.loc) {
+ t.loc = {
+ start: {
+ line: this.startMarker.line,
+ column: this.startMarker.column
+ },
+ end: {
+ line: this.scanner.lineNumber,
+ column: this.scanner.index - this.scanner.lineStart
+ }
+ };
+ }
+ if (token.type === 9 /* RegularExpression */) {
+ var pattern = token.pattern;
+ var flags = token.flags;
+ t.regex = { pattern: pattern, flags: flags };
+ }
+ return t;
+ };
+ Parser.prototype.nextToken = function () {
+ var token = this.lookahead;
+ this.lastMarker.index = this.scanner.index;
+ this.lastMarker.line = this.scanner.lineNumber;
+ this.lastMarker.column = this.scanner.index - this.scanner.lineStart;
+ this.collectComments();
+ if (this.scanner.index !== this.startMarker.index) {
+ this.startMarker.index = this.scanner.index;
+ this.startMarker.line = this.scanner.lineNumber;
+ this.startMarker.column = this.scanner.index - this.scanner.lineStart;
+ }
+ var next = this.scanner.lex();
+ this.hasLineTerminator = (token.lineNumber !== next.lineNumber);
+ if (next && this.context.strict && next.type === 3 /* Identifier */) {
+ if (this.scanner.isStrictModeReservedWord(next.value)) {
+ next.type = 4 /* Keyword */;
+ }
+ }
+ this.lookahead = next;
+ if (this.config.tokens && next.type !== 2 /* EOF */) {
+ this.tokens.push(this.convertToken(next));
+ }
+ return token;
+ };
+ Parser.prototype.nextRegexToken = function () {
+ this.collectComments();
+ var token = this.scanner.scanRegExp();
+ if (this.config.tokens) {
+ // Pop the previous token, '/' or '/='
+ // This is added from the lookahead token.
+ this.tokens.pop();
+ this.tokens.push(this.convertToken(token));
+ }
+ // Prime the next lookahead.
+ this.lookahead = token;
+ this.nextToken();
+ return token;
+ };
+ Parser.prototype.createNode = function () {
+ return {
+ index: this.startMarker.index,
+ line: this.startMarker.line,
+ column: this.startMarker.column
+ };
+ };
+ Parser.prototype.startNode = function (token, lastLineStart) {
+ if (lastLineStart === void 0) { lastLineStart = 0; }
+ var column = token.start - token.lineStart;
+ var line = token.lineNumber;
+ if (column < 0) {
+ column += lastLineStart;
+ line--;
+ }
+ return {
+ index: token.start,
+ line: line,
+ column: column
+ };
+ };
+ Parser.prototype.finalize = function (marker, node) {
+ if (this.config.range) {
+ node.range = [marker.index, this.lastMarker.index];
+ }
+ if (this.config.loc) {
+ node.loc = {
+ start: {
+ line: marker.line,
+ column: marker.column,
+ },
+ end: {
+ line: this.lastMarker.line,
+ column: this.lastMarker.column
+ }
+ };
+ if (this.config.source) {
+ node.loc.source = this.config.source;
+ }
+ }
+ if (this.delegate) {
+ var metadata = {
+ start: {
+ line: marker.line,
+ column: marker.column,
+ offset: marker.index
+ },
+ end: {
+ line: this.lastMarker.line,
+ column: this.lastMarker.column,
+ offset: this.lastMarker.index
+ }
+ };
+ this.delegate(node, metadata);
+ }
+ return node;
+ };
+ // Expect the next token to match the specified punctuator.
+ // If not, an exception will be thrown.
+ Parser.prototype.expect = function (value) {
+ var token = this.nextToken();
+ if (token.type !== 7 /* Punctuator */ || token.value !== value) {
+ this.throwUnexpectedToken(token);
+ }
+ };
+ // Quietly expect a comma when in tolerant mode, otherwise delegates to expect().
+ Parser.prototype.expectCommaSeparator = function () {
+ if (this.config.tolerant) {
+ var token = this.lookahead;
+ if (token.type === 7 /* Punctuator */ && token.value === ',') {
+ this.nextToken();
+ }
+ else if (token.type === 7 /* Punctuator */ && token.value === ';') {
+ this.nextToken();
+ this.tolerateUnexpectedToken(token);
+ }
+ else {
+ this.tolerateUnexpectedToken(token, messages_1.Messages.UnexpectedToken);
+ }
+ }
+ else {
+ this.expect(',');
+ }
+ };
+ // Expect the next token to match the specified keyword.
+ // If not, an exception will be thrown.
+ Parser.prototype.expectKeyword = function (keyword) {
+ var token = this.nextToken();
+ if (token.type !== 4 /* Keyword */ || token.value !== keyword) {
+ this.throwUnexpectedToken(token);
+ }
+ };
+ // Return true if the next token matches the specified punctuator.
+ Parser.prototype.match = function (value) {
+ return this.lookahead.type === 7 /* Punctuator */ && this.lookahead.value === value;
+ };
+ // Return true if the next token matches the specified keyword
+ Parser.prototype.matchKeyword = function (keyword) {
+ return this.lookahead.type === 4 /* Keyword */ && this.lookahead.value === keyword;
+ };
+ // Return true if the next token matches the specified contextual keyword
+ // (where an identifier is sometimes a keyword depending on the context)
+ Parser.prototype.matchContextualKeyword = function (keyword) {
+ return this.lookahead.type === 3 /* Identifier */ && this.lookahead.value === keyword;
+ };
+ // Return true if the next token is an assignment operator
+ Parser.prototype.matchAssign = function () {
+ if (this.lookahead.type !== 7 /* Punctuator */) {
+ return false;
+ }
+ var op = this.lookahead.value;
+ return op === '=' ||
+ op === '*=' ||
+ op === '**=' ||
+ op === '/=' ||
+ op === '%=' ||
+ op === '+=' ||
+ op === '-=' ||
+ op === '<<=' ||
+ op === '>>=' ||
+ op === '>>>=' ||
+ op === '&=' ||
+ op === '^=' ||
+ op === '|=';
+ };
+ // Cover grammar support.
+ //
+ // When an assignment expression position starts with an left parenthesis, the determination of the type
+ // of the syntax is to be deferred arbitrarily long until the end of the parentheses pair (plus a lookahead)
+ // or the first comma. This situation also defers the determination of all the expressions nested in the pair.
+ //
+ // There are three productions that can be parsed in a parentheses pair that needs to be determined
+ // after the outermost pair is closed. They are:
+ //
+ // 1. AssignmentExpression
+ // 2. BindingElements
+ // 3. AssignmentTargets
+ //
+ // In order to avoid exponential backtracking, we use two flags to denote if the production can be
+ // binding element or assignment target.
+ //
+ // The three productions have the relationship:
+ //
+ // BindingElements ⊆ AssignmentTargets ⊆ AssignmentExpression
+ //
+ // with a single exception that CoverInitializedName when used directly in an Expression, generates
+ // an early error. Therefore, we need the third state, firstCoverInitializedNameError, to track the
+ // first usage of CoverInitializedName and report it when we reached the end of the parentheses pair.
+ //
+ // isolateCoverGrammar function runs the given parser function with a new cover grammar context, and it does not
+ // effect the current flags. This means the production the parser parses is only used as an expression. Therefore
+ // the CoverInitializedName check is conducted.
+ //
+ // inheritCoverGrammar function runs the given parse function with a new cover grammar context, and it propagates
+ // the flags outside of the parser. This means the production the parser parses is used as a part of a potential
+ // pattern. The CoverInitializedName check is deferred.
+ Parser.prototype.isolateCoverGrammar = function (parseFunction) {
+ var previousIsBindingElement = this.context.isBindingElement;
+ var previousIsAssignmentTarget = this.context.isAssignmentTarget;
+ var previousFirstCoverInitializedNameError = this.context.firstCoverInitializedNameError;
+ this.context.isBindingElement = true;
+ this.context.isAssignmentTarget = true;
+ this.context.firstCoverInitializedNameError = null;
+ var result = parseFunction.call(this);
+ if (this.context.firstCoverInitializedNameError !== null) {
+ this.throwUnexpectedToken(this.context.firstCoverInitializedNameError);
+ }
+ this.context.isBindingElement = previousIsBindingElement;
+ this.context.isAssignmentTarget = previousIsAssignmentTarget;
+ this.context.firstCoverInitializedNameError = previousFirstCoverInitializedNameError;
+ return result;
+ };
+ Parser.prototype.inheritCoverGrammar = function (parseFunction) {
+ var previousIsBindingElement = this.context.isBindingElement;
+ var previousIsAssignmentTarget = this.context.isAssignmentTarget;
+ var previousFirstCoverInitializedNameError = this.context.firstCoverInitializedNameError;
+ this.context.isBindingElement = true;
+ this.context.isAssignmentTarget = true;
+ this.context.firstCoverInitializedNameError = null;
+ var result = parseFunction.call(this);
+ this.context.isBindingElement = this.context.isBindingElement && previousIsBindingElement;
+ this.context.isAssignmentTarget = this.context.isAssignmentTarget && previousIsAssignmentTarget;
+ this.context.firstCoverInitializedNameError = previousFirstCoverInitializedNameError || this.context.firstCoverInitializedNameError;
+ return result;
+ };
+ Parser.prototype.consumeSemicolon = function () {
+ if (this.match(';')) {
+ this.nextToken();
+ }
+ else if (!this.hasLineTerminator) {
+ if (this.lookahead.type !== 2 /* EOF */ && !this.match('}')) {
+ this.throwUnexpectedToken(this.lookahead);
+ }
+ this.lastMarker.index = this.startMarker.index;
+ this.lastMarker.line = this.startMarker.line;
+ this.lastMarker.column = this.startMarker.column;
+ }
+ };
+ // https://tc39.github.io/ecma262/#sec-primary-expression
+ Parser.prototype.parsePrimaryExpression = function () {
+ var node = this.createNode();
+ var expr;
+ var token, raw;
+ switch (this.lookahead.type) {
+ case 3 /* Identifier */:
+ if ((this.context.isModule || this.context.await) && this.lookahead.value === 'await') {
+ this.tolerateUnexpectedToken(this.lookahead);
+ }
+ expr = this.matchAsyncFunction() ? this.parseFunctionExpression() : this.finalize(node, new Node.Identifier(this.nextToken().value));
+ break;
+ case 6 /* NumericLiteral */:
+ case 8 /* StringLiteral */:
+ if (this.context.strict && this.lookahead.octal) {
+ this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.StrictOctalLiteral);
+ }
+ this.context.isAssignmentTarget = false;
+ this.context.isBindingElement = false;
+ token = this.nextToken();
+ raw = this.getTokenRaw(token);
+ expr = this.finalize(node, new Node.Literal(token.value, raw));
+ break;
+ case 1 /* BooleanLiteral */:
+ this.context.isAssignmentTarget = false;
+ this.context.isBindingElement = false;
+ token = this.nextToken();
+ raw = this.getTokenRaw(token);
+ expr = this.finalize(node, new Node.Literal(token.value === 'true', raw));
+ break;
+ case 5 /* NullLiteral */:
+ this.context.isAssignmentTarget = false;
+ this.context.isBindingElement = false;
+ token = this.nextToken();
+ raw = this.getTokenRaw(token);
+ expr = this.finalize(node, new Node.Literal(null, raw));
+ break;
+ case 10 /* Template */:
+ expr = this.parseTemplateLiteral();
+ break;
+ case 7 /* Punctuator */:
+ switch (this.lookahead.value) {
+ case '(':
+ this.context.isBindingElement = false;
+ expr = this.inheritCoverGrammar(this.parseGroupExpression);
+ break;
+ case '[':
+ expr = this.inheritCoverGrammar(this.parseArrayInitializer);
+ break;
+ case '{':
+ expr = this.inheritCoverGrammar(this.parseObjectInitializer);
+ break;
+ case '/':
+ case '/=':
+ this.context.isAssignmentTarget = false;
+ this.context.isBindingElement = false;
+ this.scanner.index = this.startMarker.index;
+ token = this.nextRegexToken();
+ raw = this.getTokenRaw(token);
+ expr = this.finalize(node, new Node.RegexLiteral(token.regex, raw, token.pattern, token.flags));
+ break;
+ default:
+ expr = this.throwUnexpectedToken(this.nextToken());
+ }
+ break;
+ case 4 /* Keyword */:
+ if (!this.context.strict && this.context.allowYield && this.matchKeyword('yield')) {
+ expr = this.parseIdentifierName();
+ }
+ else if (!this.context.strict && this.matchKeyword('let')) {
+ expr = this.finalize(node, new Node.Identifier(this.nextToken().value));
+ }
+ else {
+ this.context.isAssignmentTarget = false;
+ this.context.isBindingElement = false;
+ if (this.matchKeyword('function')) {
+ expr = this.parseFunctionExpression();
+ }
+ else if (this.matchKeyword('this')) {
+ this.nextToken();
+ expr = this.finalize(node, new Node.ThisExpression());
+ }
+ else if (this.matchKeyword('class')) {
+ expr = this.parseClassExpression();
+ }
+ else {
+ expr = this.throwUnexpectedToken(this.nextToken());
+ }
+ }
+ break;
+ default:
+ expr = this.throwUnexpectedToken(this.nextToken());
+ }
+ return expr;
+ };
+ // https://tc39.github.io/ecma262/#sec-array-initializer
+ Parser.prototype.parseSpreadElement = function () {
+ var node = this.createNode();
+ this.expect('...');
+ var arg = this.inheritCoverGrammar(this.parseAssignmentExpression);
+ return this.finalize(node, new Node.SpreadElement(arg));
+ };
+ Parser.prototype.parseArrayInitializer = function () {
+ var node = this.createNode();
+ var elements = [];
+ this.expect('[');
+ while (!this.match(']')) {
+ if (this.match(',')) {
+ this.nextToken();
+ elements.push(null);
+ }
+ else if (this.match('...')) {
+ var element = this.parseSpreadElement();
+ if (!this.match(']')) {
+ this.context.isAssignmentTarget = false;
+ this.context.isBindingElement = false;
+ this.expect(',');
+ }
+ elements.push(element);
+ }
+ else {
+ elements.push(this.inheritCoverGrammar(this.parseAssignmentExpression));
+ if (!this.match(']')) {
+ this.expect(',');
+ }
+ }
+ }
+ this.expect(']');
+ return this.finalize(node, new Node.ArrayExpression(elements));
+ };
+ // https://tc39.github.io/ecma262/#sec-object-initializer
+ Parser.prototype.parsePropertyMethod = function (params) {
+ this.context.isAssignmentTarget = false;
+ this.context.isBindingElement = false;
+ var previousStrict = this.context.strict;
+ var previousAllowStrictDirective = this.context.allowStrictDirective;
+ this.context.allowStrictDirective = params.simple;
+ var body = this.isolateCoverGrammar(this.parseFunctionSourceElements);
+ if (this.context.strict && params.firstRestricted) {
+ this.tolerateUnexpectedToken(params.firstRestricted, params.message);
+ }
+ if (this.context.strict && params.stricted) {
+ this.tolerateUnexpectedToken(params.stricted, params.message);
+ }
+ this.context.strict = previousStrict;
+ this.context.allowStrictDirective = previousAllowStrictDirective;
+ return body;
+ };
+ Parser.prototype.parsePropertyMethodFunction = function () {
+ var isGenerator = false;
+ var node = this.createNode();
+ var previousAllowYield = this.context.allowYield;
+ this.context.allowYield = true;
+ var params = this.parseFormalParameters();
+ var method = this.parsePropertyMethod(params);
+ this.context.allowYield = previousAllowYield;
+ return this.finalize(node, new Node.FunctionExpression(null, params.params, method, isGenerator));
+ };
+ Parser.prototype.parsePropertyMethodAsyncFunction = function () {
+ var node = this.createNode();
+ var previousAllowYield = this.context.allowYield;
+ var previousAwait = this.context.await;
+ this.context.allowYield = false;
+ this.context.await = true;
+ var params = this.parseFormalParameters();
+ var method = this.parsePropertyMethod(params);
+ this.context.allowYield = previousAllowYield;
+ this.context.await = previousAwait;
+ return this.finalize(node, new Node.AsyncFunctionExpression(null, params.params, method));
+ };
+ Parser.prototype.parseObjectPropertyKey = function () {
+ var node = this.createNode();
+ var token = this.nextToken();
+ var key;
+ switch (token.type) {
+ case 8 /* StringLiteral */:
+ case 6 /* NumericLiteral */:
+ if (this.context.strict && token.octal) {
+ this.tolerateUnexpectedToken(token, messages_1.Messages.StrictOctalLiteral);
+ }
+ var raw = this.getTokenRaw(token);
+ key = this.finalize(node, new Node.Literal(token.value, raw));
+ break;
+ case 3 /* Identifier */:
+ case 1 /* BooleanLiteral */:
+ case 5 /* NullLiteral */:
+ case 4 /* Keyword */:
+ key = this.finalize(node, new Node.Identifier(token.value));
+ break;
+ case 7 /* Punctuator */:
+ if (token.value === '[') {
+ key = this.isolateCoverGrammar(this.parseAssignmentExpression);
+ this.expect(']');
+ }
+ else {
+ key = this.throwUnexpectedToken(token);
+ }
+ break;
+ default:
+ key = this.throwUnexpectedToken(token);
+ }
+ return key;
+ };
+ Parser.prototype.isPropertyKey = function (key, value) {
+ return (key.type === syntax_1.Syntax.Identifier && key.name === value) ||
+ (key.type === syntax_1.Syntax.Literal && key.value === value);
+ };
+ Parser.prototype.parseObjectProperty = function (hasProto) {
+ var node = this.createNode();
+ var token = this.lookahead;
+ var kind;
+ var key = null;
+ var value = null;
+ var computed = false;
+ var method = false;
+ var shorthand = false;
+ var isAsync = false;
+ if (token.type === 3 /* Identifier */) {
+ var id = token.value;
+ this.nextToken();
+ computed = this.match('[');
+ isAsync = !this.hasLineTerminator && (id === 'async') &&
+ !this.match(':') && !this.match('(') && !this.match('*') && !this.match(',');
+ key = isAsync ? this.parseObjectPropertyKey() : this.finalize(node, new Node.Identifier(id));
+ }
+ else if (this.match('*')) {
+ this.nextToken();
+ }
+ else {
+ computed = this.match('[');
+ key = this.parseObjectPropertyKey();
+ }
+ var lookaheadPropertyKey = this.qualifiedPropertyName(this.lookahead);
+ if (token.type === 3 /* Identifier */ && !isAsync && token.value === 'get' && lookaheadPropertyKey) {
+ kind = 'get';
+ computed = this.match('[');
+ key = this.parseObjectPropertyKey();
+ this.context.allowYield = false;
+ value = this.parseGetterMethod();
+ }
+ else if (token.type === 3 /* Identifier */ && !isAsync && token.value === 'set' && lookaheadPropertyKey) {
+ kind = 'set';
+ computed = this.match('[');
+ key = this.parseObjectPropertyKey();
+ value = this.parseSetterMethod();
+ }
+ else if (token.type === 7 /* Punctuator */ && token.value === '*' && lookaheadPropertyKey) {
+ kind = 'init';
+ computed = this.match('[');
+ key = this.parseObjectPropertyKey();
+ value = this.parseGeneratorMethod();
+ method = true;
+ }
+ else {
+ if (!key) {
+ this.throwUnexpectedToken(this.lookahead);
+ }
+ kind = 'init';
+ if (this.match(':') && !isAsync) {
+ if (!computed && this.isPropertyKey(key, '__proto__')) {
+ if (hasProto.value) {
+ this.tolerateError(messages_1.Messages.DuplicateProtoProperty);
+ }
+ hasProto.value = true;
+ }
+ this.nextToken();
+ value = this.inheritCoverGrammar(this.parseAssignmentExpression);
+ }
+ else if (this.match('(')) {
+ value = isAsync ? this.parsePropertyMethodAsyncFunction() : this.parsePropertyMethodFunction();
+ method = true;
+ }
+ else if (token.type === 3 /* Identifier */) {
+ var id = this.finalize(node, new Node.Identifier(token.value));
+ if (this.match('=')) {
+ this.context.firstCoverInitializedNameError = this.lookahead;
+ this.nextToken();
+ shorthand = true;
+ var init = this.isolateCoverGrammar(this.parseAssignmentExpression);
+ value = this.finalize(node, new Node.AssignmentPattern(id, init));
+ }
+ else {
+ shorthand = true;
+ value = id;
+ }
+ }
+ else {
+ this.throwUnexpectedToken(this.nextToken());
+ }
+ }
+ return this.finalize(node, new Node.Property(kind, key, computed, value, method, shorthand));
+ };
+ Parser.prototype.parseObjectInitializer = function () {
+ var node = this.createNode();
+ this.expect('{');
+ var properties = [];
+ var hasProto = { value: false };
+ while (!this.match('}')) {
+ properties.push(this.parseObjectProperty(hasProto));
+ if (!this.match('}')) {
+ this.expectCommaSeparator();
+ }
+ }
+ this.expect('}');
+ return this.finalize(node, new Node.ObjectExpression(properties));
+ };
+ // https://tc39.github.io/ecma262/#sec-template-literals
+ Parser.prototype.parseTemplateHead = function () {
+ assert_1.assert(this.lookahead.head, 'Template literal must start with a template head');
+ var node = this.createNode();
+ var token = this.nextToken();
+ var raw = token.value;
+ var cooked = token.cooked;
+ return this.finalize(node, new Node.TemplateElement({ raw: raw, cooked: cooked }, token.tail));
+ };
+ Parser.prototype.parseTemplateElement = function () {
+ if (this.lookahead.type !== 10 /* Template */) {
+ this.throwUnexpectedToken();
+ }
+ var node = this.createNode();
+ var token = this.nextToken();
+ var raw = token.value;
+ var cooked = token.cooked;
+ return this.finalize(node, new Node.TemplateElement({ raw: raw, cooked: cooked }, token.tail));
+ };
+ Parser.prototype.parseTemplateLiteral = function () {
+ var node = this.createNode();
+ var expressions = [];
+ var quasis = [];
+ var quasi = this.parseTemplateHead();
+ quasis.push(quasi);
+ while (!quasi.tail) {
+ expressions.push(this.parseExpression());
+ quasi = this.parseTemplateElement();
+ quasis.push(quasi);
+ }
+ return this.finalize(node, new Node.TemplateLiteral(quasis, expressions));
+ };
+ // https://tc39.github.io/ecma262/#sec-grouping-operator
+ Parser.prototype.reinterpretExpressionAsPattern = function (expr) {
+ switch (expr.type) {
+ case syntax_1.Syntax.Identifier:
+ case syntax_1.Syntax.MemberExpression:
+ case syntax_1.Syntax.RestElement:
+ case syntax_1.Syntax.AssignmentPattern:
+ break;
+ case syntax_1.Syntax.SpreadElement:
+ expr.type = syntax_1.Syntax.RestElement;
+ this.reinterpretExpressionAsPattern(expr.argument);
+ break;
+ case syntax_1.Syntax.ArrayExpression:
+ expr.type = syntax_1.Syntax.ArrayPattern;
+ for (var i = 0; i < expr.elements.length; i++) {
+ if (expr.elements[i] !== null) {
+ this.reinterpretExpressionAsPattern(expr.elements[i]);
+ }
+ }
+ break;
+ case syntax_1.Syntax.ObjectExpression:
+ expr.type = syntax_1.Syntax.ObjectPattern;
+ for (var i = 0; i < expr.properties.length; i++) {
+ this.reinterpretExpressionAsPattern(expr.properties[i].value);
+ }
+ break;
+ case syntax_1.Syntax.AssignmentExpression:
+ expr.type = syntax_1.Syntax.AssignmentPattern;
+ delete expr.operator;
+ this.reinterpretExpressionAsPattern(expr.left);
+ break;
+ default:
+ // Allow other node type for tolerant parsing.
+ break;
+ }
+ };
+ Parser.prototype.parseGroupExpression = function () {
+ var expr;
+ this.expect('(');
+ if (this.match(')')) {
+ this.nextToken();
+ if (!this.match('=>')) {
+ this.expect('=>');
+ }
+ expr = {
+ type: ArrowParameterPlaceHolder,
+ params: [],
+ async: false
+ };
+ }
+ else {
+ var startToken = this.lookahead;
+ var params = [];
+ if (this.match('...')) {
+ expr = this.parseRestElement(params);
+ this.expect(')');
+ if (!this.match('=>')) {
+ this.expect('=>');
+ }
+ expr = {
+ type: ArrowParameterPlaceHolder,
+ params: [expr],
+ async: false
+ };
+ }
+ else {
+ var arrow = false;
+ this.context.isBindingElement = true;
+ expr = this.inheritCoverGrammar(this.parseAssignmentExpression);
+ if (this.match(',')) {
+ var expressions = [];
+ this.context.isAssignmentTarget = false;
+ expressions.push(expr);
+ while (this.lookahead.type !== 2 /* EOF */) {
+ if (!this.match(',')) {
+ break;
+ }
+ this.nextToken();
+ if (this.match(')')) {
+ this.nextToken();
+ for (var i = 0; i < expressions.length; i++) {
+ this.reinterpretExpressionAsPattern(expressions[i]);
+ }
+ arrow = true;
+ expr = {
+ type: ArrowParameterPlaceHolder,
+ params: expressions,
+ async: false
+ };
+ }
+ else if (this.match('...')) {
+ if (!this.context.isBindingElement) {
+ this.throwUnexpectedToken(this.lookahead);
+ }
+ expressions.push(this.parseRestElement(params));
+ this.expect(')');
+ if (!this.match('=>')) {
+ this.expect('=>');
+ }
+ this.context.isBindingElement = false;
+ for (var i = 0; i < expressions.length; i++) {
+ this.reinterpretExpressionAsPattern(expressions[i]);
+ }
+ arrow = true;
+ expr = {
+ type: ArrowParameterPlaceHolder,
+ params: expressions,
+ async: false
+ };
+ }
+ else {
+ expressions.push(this.inheritCoverGrammar(this.parseAssignmentExpression));
+ }
+ if (arrow) {
+ break;
+ }
+ }
+ if (!arrow) {
+ expr = this.finalize(this.startNode(startToken), new Node.SequenceExpression(expressions));
+ }
+ }
+ if (!arrow) {
+ this.expect(')');
+ if (this.match('=>')) {
+ if (expr.type === syntax_1.Syntax.Identifier && expr.name === 'yield') {
+ arrow = true;
+ expr = {
+ type: ArrowParameterPlaceHolder,
+ params: [expr],
+ async: false
+ };
+ }
+ if (!arrow) {
+ if (!this.context.isBindingElement) {
+ this.throwUnexpectedToken(this.lookahead);
+ }
+ if (expr.type === syntax_1.Syntax.SequenceExpression) {
+ for (var i = 0; i < expr.expressions.length; i++) {
+ this.reinterpretExpressionAsPattern(expr.expressions[i]);
+ }
+ }
+ else {
+ this.reinterpretExpressionAsPattern(expr);
+ }
+ var parameters = (expr.type === syntax_1.Syntax.SequenceExpression ? expr.expressions : [expr]);
+ expr = {
+ type: ArrowParameterPlaceHolder,
+ params: parameters,
+ async: false
+ };
+ }
+ }
+ this.context.isBindingElement = false;
+ }
+ }
+ }
+ return expr;
+ };
+ // https://tc39.github.io/ecma262/#sec-left-hand-side-expressions
+ Parser.prototype.parseArguments = function () {
+ this.expect('(');
+ var args = [];
+ if (!this.match(')')) {
+ while (true) {
+ var expr = this.match('...') ? this.parseSpreadElement() :
+ this.isolateCoverGrammar(this.parseAssignmentExpression);
+ args.push(expr);
+ if (this.match(')')) {
+ break;
+ }
+ this.expectCommaSeparator();
+ if (this.match(')')) {
+ break;
+ }
+ }
+ }
+ this.expect(')');
+ return args;
+ };
+ Parser.prototype.isIdentifierName = function (token) {
+ return token.type === 3 /* Identifier */ ||
+ token.type === 4 /* Keyword */ ||
+ token.type === 1 /* BooleanLiteral */ ||
+ token.type === 5 /* NullLiteral */;
+ };
+ Parser.prototype.parseIdentifierName = function () {
+ var node = this.createNode();
+ var token = this.nextToken();
+ if (!this.isIdentifierName(token)) {
+ this.throwUnexpectedToken(token);
+ }
+ return this.finalize(node, new Node.Identifier(token.value));
+ };
+ Parser.prototype.parseNewExpression = function () {
+ var node = this.createNode();
+ var id = this.parseIdentifierName();
+ assert_1.assert(id.name === 'new', 'New expression must start with `new`');
+ var expr;
+ if (this.match('.')) {
+ this.nextToken();
+ if (this.lookahead.type === 3 /* Identifier */ && this.context.inFunctionBody && this.lookahead.value === 'target') {
+ var property = this.parseIdentifierName();
+ expr = new Node.MetaProperty(id, property);
+ }
+ else {
+ this.throwUnexpectedToken(this.lookahead);
+ }
+ }
+ else {
+ var callee = this.isolateCoverGrammar(this.parseLeftHandSideExpression);
+ var args = this.match('(') ? this.parseArguments() : [];
+ expr = new Node.NewExpression(callee, args);
+ this.context.isAssignmentTarget = false;
+ this.context.isBindingElement = false;
+ }
+ return this.finalize(node, expr);
+ };
+ Parser.prototype.parseAsyncArgument = function () {
+ var arg = this.parseAssignmentExpression();
+ this.context.firstCoverInitializedNameError = null;
+ return arg;
+ };
+ Parser.prototype.parseAsyncArguments = function () {
+ this.expect('(');
+ var args = [];
+ if (!this.match(')')) {
+ while (true) {
+ var expr = this.match('...') ? this.parseSpreadElement() :
+ this.isolateCoverGrammar(this.parseAsyncArgument);
+ args.push(expr);
+ if (this.match(')')) {
+ break;
+ }
+ this.expectCommaSeparator();
+ if (this.match(')')) {
+ break;
+ }
+ }
+ }
+ this.expect(')');
+ return args;
+ };
+ Parser.prototype.parseLeftHandSideExpressionAllowCall = function () {
+ var startToken = this.lookahead;
+ var maybeAsync = this.matchContextualKeyword('async');
+ var previousAllowIn = this.context.allowIn;
+ this.context.allowIn = true;
+ var expr;
+ if (this.matchKeyword('super') && this.context.inFunctionBody) {
+ expr = this.createNode();
+ this.nextToken();
+ expr = this.finalize(expr, new Node.Super());
+ if (!this.match('(') && !this.match('.') && !this.match('[')) {
+ this.throwUnexpectedToken(this.lookahead);
+ }
+ }
+ else {
+ expr = this.inheritCoverGrammar(this.matchKeyword('new') ? this.parseNewExpression : this.parsePrimaryExpression);
+ }
+ while (true) {
+ if (this.match('.')) {
+ this.context.isBindingElement = false;
+ this.context.isAssignmentTarget = true;
+ this.expect('.');
+ var property = this.parseIdentifierName();
+ expr = this.finalize(this.startNode(startToken), new Node.StaticMemberExpression(expr, property));
+ }
+ else if (this.match('(')) {
+ var asyncArrow = maybeAsync && (startToken.lineNumber === this.lookahead.lineNumber);
+ this.context.isBindingElement = false;
+ this.context.isAssignmentTarget = false;
+ var args = asyncArrow ? this.parseAsyncArguments() : this.parseArguments();
+ expr = this.finalize(this.startNode(startToken), new Node.CallExpression(expr, args));
+ if (asyncArrow && this.match('=>')) {
+ for (var i = 0; i < args.length; ++i) {
+ this.reinterpretExpressionAsPattern(args[i]);
+ }
+ expr = {
+ type: ArrowParameterPlaceHolder,
+ params: args,
+ async: true
+ };
+ }
+ }
+ else if (this.match('[')) {
+ this.context.isBindingElement = false;
+ this.context.isAssignmentTarget = true;
+ this.expect('[');
+ var property = this.isolateCoverGrammar(this.parseExpression);
+ this.expect(']');
+ expr = this.finalize(this.startNode(startToken), new Node.ComputedMemberExpression(expr, property));
+ }
+ else if (this.lookahead.type === 10 /* Template */ && this.lookahead.head) {
+ var quasi = this.parseTemplateLiteral();
+ expr = this.finalize(this.startNode(startToken), new Node.TaggedTemplateExpression(expr, quasi));
+ }
+ else {
+ break;
+ }
+ }
+ this.context.allowIn = previousAllowIn;
+ return expr;
+ };
+ Parser.prototype.parseSuper = function () {
+ var node = this.createNode();
+ this.expectKeyword('super');
+ if (!this.match('[') && !this.match('.')) {
+ this.throwUnexpectedToken(this.lookahead);
+ }
+ return this.finalize(node, new Node.Super());
+ };
+ Parser.prototype.parseLeftHandSideExpression = function () {
+ assert_1.assert(this.context.allowIn, 'callee of new expression always allow in keyword.');
+ var node = this.startNode(this.lookahead);
+ var expr = (this.matchKeyword('super') && this.context.inFunctionBody) ? this.parseSuper() :
+ this.inheritCoverGrammar(this.matchKeyword('new') ? this.parseNewExpression : this.parsePrimaryExpression);
+ while (true) {
+ if (this.match('[')) {
+ this.context.isBindingElement = false;
+ this.context.isAssignmentTarget = true;
+ this.expect('[');
+ var property = this.isolateCoverGrammar(this.parseExpression);
+ this.expect(']');
+ expr = this.finalize(node, new Node.ComputedMemberExpression(expr, property));
+ }
+ else if (this.match('.')) {
+ this.context.isBindingElement = false;
+ this.context.isAssignmentTarget = true;
+ this.expect('.');
+ var property = this.parseIdentifierName();
+ expr = this.finalize(node, new Node.StaticMemberExpression(expr, property));
+ }
+ else if (this.lookahead.type === 10 /* Template */ && this.lookahead.head) {
+ var quasi = this.parseTemplateLiteral();
+ expr = this.finalize(node, new Node.TaggedTemplateExpression(expr, quasi));
+ }
+ else {
+ break;
+ }
+ }
+ return expr;
+ };
+ // https://tc39.github.io/ecma262/#sec-update-expressions
+ Parser.prototype.parseUpdateExpression = function () {
+ var expr;
+ var startToken = this.lookahead;
+ if (this.match('++') || this.match('--')) {
+ var node = this.startNode(startToken);
+ var token = this.nextToken();
+ expr = this.inheritCoverGrammar(this.parseUnaryExpression);
+ if (this.context.strict && expr.type === syntax_1.Syntax.Identifier && this.scanner.isRestrictedWord(expr.name)) {
+ this.tolerateError(messages_1.Messages.StrictLHSPrefix);
+ }
+ if (!this.context.isAssignmentTarget) {
+ this.tolerateError(messages_1.Messages.InvalidLHSInAssignment);
+ }
+ var prefix = true;
+ expr = this.finalize(node, new Node.UpdateExpression(token.value, expr, prefix));
+ this.context.isAssignmentTarget = false;
+ this.context.isBindingElement = false;
+ }
+ else {
+ expr = this.inheritCoverGrammar(this.parseLeftHandSideExpressionAllowCall);
+ if (!this.hasLineTerminator && this.lookahead.type === 7 /* Punctuator */) {
+ if (this.match('++') || this.match('--')) {
+ if (this.context.strict && expr.type === syntax_1.Syntax.Identifier && this.scanner.isRestrictedWord(expr.name)) {
+ this.tolerateError(messages_1.Messages.StrictLHSPostfix);
+ }
+ if (!this.context.isAssignmentTarget) {
+ this.tolerateError(messages_1.Messages.InvalidLHSInAssignment);
+ }
+ this.context.isAssignmentTarget = false;
+ this.context.isBindingElement = false;
+ var operator = this.nextToken().value;
+ var prefix = false;
+ expr = this.finalize(this.startNode(startToken), new Node.UpdateExpression(operator, expr, prefix));
+ }
+ }
+ }
+ return expr;
+ };
+ // https://tc39.github.io/ecma262/#sec-unary-operators
+ Parser.prototype.parseAwaitExpression = function () {
+ var node = this.createNode();
+ this.nextToken();
+ var argument = this.parseUnaryExpression();
+ return this.finalize(node, new Node.AwaitExpression(argument));
+ };
+ Parser.prototype.parseUnaryExpression = function () {
+ var expr;
+ if (this.match('+') || this.match('-') || this.match('~') || this.match('!') ||
+ this.matchKeyword('delete') || this.matchKeyword('void') || this.matchKeyword('typeof')) {
+ var node = this.startNode(this.lookahead);
+ var token = this.nextToken();
+ expr = this.inheritCoverGrammar(this.parseUnaryExpression);
+ expr = this.finalize(node, new Node.UnaryExpression(token.value, expr));
+ if (this.context.strict && expr.operator === 'delete' && expr.argument.type === syntax_1.Syntax.Identifier) {
+ this.tolerateError(messages_1.Messages.StrictDelete);
+ }
+ this.context.isAssignmentTarget = false;
+ this.context.isBindingElement = false;
+ }
+ else if (this.context.await && this.matchContextualKeyword('await')) {
+ expr = this.parseAwaitExpression();
+ }
+ else {
+ expr = this.parseUpdateExpression();
+ }
+ return expr;
+ };
+ Parser.prototype.parseExponentiationExpression = function () {
+ var startToken = this.lookahead;
+ var expr = this.inheritCoverGrammar(this.parseUnaryExpression);
+ if (expr.type !== syntax_1.Syntax.UnaryExpression && this.match('**')) {
+ this.nextToken();
+ this.context.isAssignmentTarget = false;
+ this.context.isBindingElement = false;
+ var left = expr;
+ var right = this.isolateCoverGrammar(this.parseExponentiationExpression);
+ expr = this.finalize(this.startNode(startToken), new Node.BinaryExpression('**', left, right));
+ }
+ return expr;
+ };
+ // https://tc39.github.io/ecma262/#sec-exp-operator
+ // https://tc39.github.io/ecma262/#sec-multiplicative-operators
+ // https://tc39.github.io/ecma262/#sec-additive-operators
+ // https://tc39.github.io/ecma262/#sec-bitwise-shift-operators
+ // https://tc39.github.io/ecma262/#sec-relational-operators
+ // https://tc39.github.io/ecma262/#sec-equality-operators
+ // https://tc39.github.io/ecma262/#sec-binary-bitwise-operators
+ // https://tc39.github.io/ecma262/#sec-binary-logical-operators
+ Parser.prototype.binaryPrecedence = function (token) {
+ var op = token.value;
+ var precedence;
+ if (token.type === 7 /* Punctuator */) {
+ precedence = this.operatorPrecedence[op] || 0;
+ }
+ else if (token.type === 4 /* Keyword */) {
+ precedence = (op === 'instanceof' || (this.context.allowIn && op === 'in')) ? 7 : 0;
+ }
+ else {
+ precedence = 0;
+ }
+ return precedence;
+ };
+ Parser.prototype.parseBinaryExpression = function () {
+ var startToken = this.lookahead;
+ var expr = this.inheritCoverGrammar(this.parseExponentiationExpression);
+ var token = this.lookahead;
+ var prec = this.binaryPrecedence(token);
+ if (prec > 0) {
+ this.nextToken();
+ this.context.isAssignmentTarget = false;
+ this.context.isBindingElement = false;
+ var markers = [startToken, this.lookahead];
+ var left = expr;
+ var right = this.isolateCoverGrammar(this.parseExponentiationExpression);
+ var stack = [left, token.value, right];
+ var precedences = [prec];
+ while (true) {
+ prec = this.binaryPrecedence(this.lookahead);
+ if (prec <= 0) {
+ break;
+ }
+ // Reduce: make a binary expression from the three topmost entries.
+ while ((stack.length > 2) && (prec <= precedences[precedences.length - 1])) {
+ right = stack.pop();
+ var operator = stack.pop();
+ precedences.pop();
+ left = stack.pop();
+ markers.pop();
+ var node = this.startNode(markers[markers.length - 1]);
+ stack.push(this.finalize(node, new Node.BinaryExpression(operator, left, right)));
+ }
+ // Shift.
+ stack.push(this.nextToken().value);
+ precedences.push(prec);
+ markers.push(this.lookahead);
+ stack.push(this.isolateCoverGrammar(this.parseExponentiationExpression));
+ }
+ // Final reduce to clean-up the stack.
+ var i = stack.length - 1;
+ expr = stack[i];
+ var lastMarker = markers.pop();
+ while (i > 1) {
+ var marker = markers.pop();
+ var lastLineStart = lastMarker && lastMarker.lineStart;
+ var node = this.startNode(marker, lastLineStart);
+ var operator = stack[i - 1];
+ expr = this.finalize(node, new Node.BinaryExpression(operator, stack[i - 2], expr));
+ i -= 2;
+ lastMarker = marker;
+ }
+ }
+ return expr;
+ };
+ // https://tc39.github.io/ecma262/#sec-conditional-operator
+ Parser.prototype.parseConditionalExpression = function () {
+ var startToken = this.lookahead;
+ var expr = this.inheritCoverGrammar(this.parseBinaryExpression);
+ if (this.match('?')) {
+ this.nextToken();
+ var previousAllowIn = this.context.allowIn;
+ this.context.allowIn = true;
+ var consequent = this.isolateCoverGrammar(this.parseAssignmentExpression);
+ this.context.allowIn = previousAllowIn;
+ this.expect(':');
+ var alternate = this.isolateCoverGrammar(this.parseAssignmentExpression);
+ expr = this.finalize(this.startNode(startToken), new Node.ConditionalExpression(expr, consequent, alternate));
+ this.context.isAssignmentTarget = false;
+ this.context.isBindingElement = false;
+ }
+ return expr;
+ };
+ // https://tc39.github.io/ecma262/#sec-assignment-operators
+ Parser.prototype.checkPatternParam = function (options, param) {
+ switch (param.type) {
+ case syntax_1.Syntax.Identifier:
+ this.validateParam(options, param, param.name);
+ break;
+ case syntax_1.Syntax.RestElement:
+ this.checkPatternParam(options, param.argument);
+ break;
+ case syntax_1.Syntax.AssignmentPattern:
+ this.checkPatternParam(options, param.left);
+ break;
+ case syntax_1.Syntax.ArrayPattern:
+ for (var i = 0; i < param.elements.length; i++) {
+ if (param.elements[i] !== null) {
+ this.checkPatternParam(options, param.elements[i]);
+ }
+ }
+ break;
+ case syntax_1.Syntax.ObjectPattern:
+ for (var i = 0; i < param.properties.length; i++) {
+ this.checkPatternParam(options, param.properties[i].value);
+ }
+ break;
+ default:
+ break;
+ }
+ options.simple = options.simple && (param instanceof Node.Identifier);
+ };
+ Parser.prototype.reinterpretAsCoverFormalsList = function (expr) {
+ var params = [expr];
+ var options;
+ var asyncArrow = false;
+ switch (expr.type) {
+ case syntax_1.Syntax.Identifier:
+ break;
+ case ArrowParameterPlaceHolder:
+ params = expr.params;
+ asyncArrow = expr.async;
+ break;
+ default:
+ return null;
+ }
+ options = {
+ simple: true,
+ paramSet: {}
+ };
+ for (var i = 0; i < params.length; ++i) {
+ var param = params[i];
+ if (param.type === syntax_1.Syntax.AssignmentPattern) {
+ if (param.right.type === syntax_1.Syntax.YieldExpression) {
+ if (param.right.argument) {
+ this.throwUnexpectedToken(this.lookahead);
+ }
+ param.right.type = syntax_1.Syntax.Identifier;
+ param.right.name = 'yield';
+ delete param.right.argument;
+ delete param.right.delegate;
+ }
+ }
+ else if (asyncArrow && param.type === syntax_1.Syntax.Identifier && param.name === 'await') {
+ this.throwUnexpectedToken(this.lookahead);
+ }
+ this.checkPatternParam(options, param);
+ params[i] = param;
+ }
+ if (this.context.strict || !this.context.allowYield) {
+ for (var i = 0; i < params.length; ++i) {
+ var param = params[i];
+ if (param.type === syntax_1.Syntax.YieldExpression) {
+ this.throwUnexpectedToken(this.lookahead);
+ }
+ }
+ }
+ if (options.message === messages_1.Messages.StrictParamDupe) {
+ var token = this.context.strict ? options.stricted : options.firstRestricted;
+ this.throwUnexpectedToken(token, options.message);
+ }
+ return {
+ simple: options.simple,
+ params: params,
+ stricted: options.stricted,
+ firstRestricted: options.firstRestricted,
+ message: options.message
+ };
+ };
+ Parser.prototype.parseAssignmentExpression = function () {
+ var expr;
+ if (!this.context.allowYield && this.matchKeyword('yield')) {
+ expr = this.parseYieldExpression();
+ }
+ else {
+ var startToken = this.lookahead;
+ var token = startToken;
+ expr = this.parseConditionalExpression();
+ if (token.type === 3 /* Identifier */ && (token.lineNumber === this.lookahead.lineNumber) && token.value === 'async') {
+ if (this.lookahead.type === 3 /* Identifier */ || this.matchKeyword('yield')) {
+ var arg = this.parsePrimaryExpression();
+ this.reinterpretExpressionAsPattern(arg);
+ expr = {
+ type: ArrowParameterPlaceHolder,
+ params: [arg],
+ async: true
+ };
+ }
+ }
+ if (expr.type === ArrowParameterPlaceHolder || this.match('=>')) {
+ // https://tc39.github.io/ecma262/#sec-arrow-function-definitions
+ this.context.isAssignmentTarget = false;
+ this.context.isBindingElement = false;
+ var isAsync = expr.async;
+ var list = this.reinterpretAsCoverFormalsList(expr);
+ if (list) {
+ if (this.hasLineTerminator) {
+ this.tolerateUnexpectedToken(this.lookahead);
+ }
+ this.context.firstCoverInitializedNameError = null;
+ var previousStrict = this.context.strict;
+ var previousAllowStrictDirective = this.context.allowStrictDirective;
+ this.context.allowStrictDirective = list.simple;
+ var previousAllowYield = this.context.allowYield;
+ var previousAwait = this.context.await;
+ this.context.allowYield = true;
+ this.context.await = isAsync;
+ var node = this.startNode(startToken);
+ this.expect('=>');
+ var body = void 0;
+ if (this.match('{')) {
+ var previousAllowIn = this.context.allowIn;
+ this.context.allowIn = true;
+ body = this.parseFunctionSourceElements();
+ this.context.allowIn = previousAllowIn;
+ }
+ else {
+ body = this.isolateCoverGrammar(this.parseAssignmentExpression);
+ }
+ var expression = body.type !== syntax_1.Syntax.BlockStatement;
+ if (this.context.strict && list.firstRestricted) {
+ this.throwUnexpectedToken(list.firstRestricted, list.message);
+ }
+ if (this.context.strict && list.stricted) {
+ this.tolerateUnexpectedToken(list.stricted, list.message);
+ }
+ expr = isAsync ? this.finalize(node, new Node.AsyncArrowFunctionExpression(list.params, body, expression)) :
+ this.finalize(node, new Node.ArrowFunctionExpression(list.params, body, expression));
+ this.context.strict = previousStrict;
+ this.context.allowStrictDirective = previousAllowStrictDirective;
+ this.context.allowYield = previousAllowYield;
+ this.context.await = previousAwait;
+ }
+ }
+ else {
+ if (this.matchAssign()) {
+ if (!this.context.isAssignmentTarget) {
+ this.tolerateError(messages_1.Messages.InvalidLHSInAssignment);
+ }
+ if (this.context.strict && expr.type === syntax_1.Syntax.Identifier) {
+ var id = expr;
+ if (this.scanner.isRestrictedWord(id.name)) {
+ this.tolerateUnexpectedToken(token, messages_1.Messages.StrictLHSAssignment);
+ }
+ if (this.scanner.isStrictModeReservedWord(id.name)) {
+ this.tolerateUnexpectedToken(token, messages_1.Messages.StrictReservedWord);
+ }
+ }
+ if (!this.match('=')) {
+ this.context.isAssignmentTarget = false;
+ this.context.isBindingElement = false;
+ }
+ else {
+ this.reinterpretExpressionAsPattern(expr);
+ }
+ token = this.nextToken();
+ var operator = token.value;
+ var right = this.isolateCoverGrammar(this.parseAssignmentExpression);
+ expr = this.finalize(this.startNode(startToken), new Node.AssignmentExpression(operator, expr, right));
+ this.context.firstCoverInitializedNameError = null;
+ }
+ }
+ }
+ return expr;
+ };
+ // https://tc39.github.io/ecma262/#sec-comma-operator
+ Parser.prototype.parseExpression = function () {
+ var startToken = this.lookahead;
+ var expr = this.isolateCoverGrammar(this.parseAssignmentExpression);
+ if (this.match(',')) {
+ var expressions = [];
+ expressions.push(expr);
+ while (this.lookahead.type !== 2 /* EOF */) {
+ if (!this.match(',')) {
+ break;
+ }
+ this.nextToken();
+ expressions.push(this.isolateCoverGrammar(this.parseAssignmentExpression));
+ }
+ expr = this.finalize(this.startNode(startToken), new Node.SequenceExpression(expressions));
+ }
+ return expr;
+ };
+ // https://tc39.github.io/ecma262/#sec-block
+ Parser.prototype.parseStatementListItem = function () {
+ var statement;
+ this.context.isAssignmentTarget = true;
+ this.context.isBindingElement = true;
+ if (this.lookahead.type === 4 /* Keyword */) {
+ switch (this.lookahead.value) {
+ case 'export':
+ if (!this.context.isModule) {
+ this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.IllegalExportDeclaration);
+ }
+ statement = this.parseExportDeclaration();
+ break;
+ case 'import':
+ if (!this.context.isModule) {
+ this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.IllegalImportDeclaration);
+ }
+ statement = this.parseImportDeclaration();
+ break;
+ case 'const':
+ statement = this.parseLexicalDeclaration({ inFor: false });
+ break;
+ case 'function':
+ statement = this.parseFunctionDeclaration();
+ break;
+ case 'class':
+ statement = this.parseClassDeclaration();
+ break;
+ case 'let':
+ statement = this.isLexicalDeclaration() ? this.parseLexicalDeclaration({ inFor: false }) : this.parseStatement();
+ break;
+ default:
+ statement = this.parseStatement();
+ break;
+ }
+ }
+ else {
+ statement = this.parseStatement();
+ }
+ return statement;
+ };
+ Parser.prototype.parseBlock = function () {
+ var node = this.createNode();
+ this.expect('{');
+ var block = [];
+ while (true) {
+ if (this.match('}')) {
+ break;
+ }
+ block.push(this.parseStatementListItem());
+ }
+ this.expect('}');
+ return this.finalize(node, new Node.BlockStatement(block));
+ };
+ // https://tc39.github.io/ecma262/#sec-let-and-const-declarations
+ Parser.prototype.parseLexicalBinding = function (kind, options) {
+ var node = this.createNode();
+ var params = [];
+ var id = this.parsePattern(params, kind);
+ if (this.context.strict && id.type === syntax_1.Syntax.Identifier) {
+ if (this.scanner.isRestrictedWord(id.name)) {
+ this.tolerateError(messages_1.Messages.StrictVarName);
+ }
+ }
+ var init = null;
+ if (kind === 'const') {
+ if (!this.matchKeyword('in') && !this.matchContextualKeyword('of')) {
+ if (this.match('=')) {
+ this.nextToken();
+ init = this.isolateCoverGrammar(this.parseAssignmentExpression);
+ }
+ else {
+ this.throwError(messages_1.Messages.DeclarationMissingInitializer, 'const');
+ }
+ }
+ }
+ else if ((!options.inFor && id.type !== syntax_1.Syntax.Identifier) || this.match('=')) {
+ this.expect('=');
+ init = this.isolateCoverGrammar(this.parseAssignmentExpression);
+ }
+ return this.finalize(node, new Node.VariableDeclarator(id, init));
+ };
+ Parser.prototype.parseBindingList = function (kind, options) {
+ var list = [this.parseLexicalBinding(kind, options)];
+ while (this.match(',')) {
+ this.nextToken();
+ list.push(this.parseLexicalBinding(kind, options));
+ }
+ return list;
+ };
+ Parser.prototype.isLexicalDeclaration = function () {
+ var state = this.scanner.saveState();
+ this.scanner.scanComments();
+ var next = this.scanner.lex();
+ this.scanner.restoreState(state);
+ return (next.type === 3 /* Identifier */) ||
+ (next.type === 7 /* Punctuator */ && next.value === '[') ||
+ (next.type === 7 /* Punctuator */ && next.value === '{') ||
+ (next.type === 4 /* Keyword */ && next.value === 'let') ||
+ (next.type === 4 /* Keyword */ && next.value === 'yield');
+ };
+ Parser.prototype.parseLexicalDeclaration = function (options) {
+ var node = this.createNode();
+ var kind = this.nextToken().value;
+ assert_1.assert(kind === 'let' || kind === 'const', 'Lexical declaration must be either let or const');
+ var declarations = this.parseBindingList(kind, options);
+ this.consumeSemicolon();
+ return this.finalize(node, new Node.VariableDeclaration(declarations, kind));
+ };
+ // https://tc39.github.io/ecma262/#sec-destructuring-binding-patterns
+ Parser.prototype.parseBindingRestElement = function (params, kind) {
+ var node = this.createNode();
+ this.expect('...');
+ var arg = this.parsePattern(params, kind);
+ return this.finalize(node, new Node.RestElement(arg));
+ };
+ Parser.prototype.parseArrayPattern = function (params, kind) {
+ var node = this.createNode();
+ this.expect('[');
+ var elements = [];
+ while (!this.match(']')) {
+ if (this.match(',')) {
+ this.nextToken();
+ elements.push(null);
+ }
+ else {
+ if (this.match('...')) {
+ elements.push(this.parseBindingRestElement(params, kind));
+ break;
+ }
+ else {
+ elements.push(this.parsePatternWithDefault(params, kind));
+ }
+ if (!this.match(']')) {
+ this.expect(',');
+ }
+ }
+ }
+ this.expect(']');
+ return this.finalize(node, new Node.ArrayPattern(elements));
+ };
+ Parser.prototype.parsePropertyPattern = function (params, kind) {
+ var node = this.createNode();
+ var computed = false;
+ var shorthand = false;
+ var method = false;
+ var key;
+ var value;
+ if (this.lookahead.type === 3 /* Identifier */) {
+ var keyToken = this.lookahead;
+ key = this.parseVariableIdentifier();
+ var init = this.finalize(node, new Node.Identifier(keyToken.value));
+ if (this.match('=')) {
+ params.push(keyToken);
+ shorthand = true;
+ this.nextToken();
+ var expr = this.parseAssignmentExpression();
+ value = this.finalize(this.startNode(keyToken), new Node.AssignmentPattern(init, expr));
+ }
+ else if (!this.match(':')) {
+ params.push(keyToken);
+ shorthand = true;
+ value = init;
+ }
+ else {
+ this.expect(':');
+ value = this.parsePatternWithDefault(params, kind);
+ }
+ }
+ else {
+ computed = this.match('[');
+ key = this.parseObjectPropertyKey();
+ this.expect(':');
+ value = this.parsePatternWithDefault(params, kind);
+ }
+ return this.finalize(node, new Node.Property('init', key, computed, value, method, shorthand));
+ };
+ Parser.prototype.parseObjectPattern = function (params, kind) {
+ var node = this.createNode();
+ var properties = [];
+ this.expect('{');
+ while (!this.match('}')) {
+ properties.push(this.parsePropertyPattern(params, kind));
+ if (!this.match('}')) {
+ this.expect(',');
+ }
+ }
+ this.expect('}');
+ return this.finalize(node, new Node.ObjectPattern(properties));
+ };
+ Parser.prototype.parsePattern = function (params, kind) {
+ var pattern;
+ if (this.match('[')) {
+ pattern = this.parseArrayPattern(params, kind);
+ }
+ else if (this.match('{')) {
+ pattern = this.parseObjectPattern(params, kind);
+ }
+ else {
+ if (this.matchKeyword('let') && (kind === 'const' || kind === 'let')) {
+ this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.LetInLexicalBinding);
+ }
+ params.push(this.lookahead);
+ pattern = this.parseVariableIdentifier(kind);
+ }
+ return pattern;
+ };
+ Parser.prototype.parsePatternWithDefault = function (params, kind) {
+ var startToken = this.lookahead;
+ var pattern = this.parsePattern(params, kind);
+ if (this.match('=')) {
+ this.nextToken();
+ var previousAllowYield = this.context.allowYield;
+ this.context.allowYield = true;
+ var right = this.isolateCoverGrammar(this.parseAssignmentExpression);
+ this.context.allowYield = previousAllowYield;
+ pattern = this.finalize(this.startNode(startToken), new Node.AssignmentPattern(pattern, right));
+ }
+ return pattern;
+ };
+ // https://tc39.github.io/ecma262/#sec-variable-statement
+ Parser.prototype.parseVariableIdentifier = function (kind) {
+ var node = this.createNode();
+ var token = this.nextToken();
+ if (token.type === 4 /* Keyword */ && token.value === 'yield') {
+ if (this.context.strict) {
+ this.tolerateUnexpectedToken(token, messages_1.Messages.StrictReservedWord);
+ }
+ else if (!this.context.allowYield) {
+ this.throwUnexpectedToken(token);
+ }
+ }
+ else if (token.type !== 3 /* Identifier */) {
+ if (this.context.strict && token.type === 4 /* Keyword */ && this.scanner.isStrictModeReservedWord(token.value)) {
+ this.tolerateUnexpectedToken(token, messages_1.Messages.StrictReservedWord);
+ }
+ else {
+ if (this.context.strict || token.value !== 'let' || kind !== 'var') {
+ this.throwUnexpectedToken(token);
+ }
+ }
+ }
+ else if ((this.context.isModule || this.context.await) && token.type === 3 /* Identifier */ && token.value === 'await') {
+ this.tolerateUnexpectedToken(token);
+ }
+ return this.finalize(node, new Node.Identifier(token.value));
+ };
+ Parser.prototype.parseVariableDeclaration = function (options) {
+ var node = this.createNode();
+ var params = [];
+ var id = this.parsePattern(params, 'var');
+ if (this.context.strict && id.type === syntax_1.Syntax.Identifier) {
+ if (this.scanner.isRestrictedWord(id.name)) {
+ this.tolerateError(messages_1.Messages.StrictVarName);
+ }
+ }
+ var init = null;
+ if (this.match('=')) {
+ this.nextToken();
+ init = this.isolateCoverGrammar(this.parseAssignmentExpression);
+ }
+ else if (id.type !== syntax_1.Syntax.Identifier && !options.inFor) {
+ this.expect('=');
+ }
+ return this.finalize(node, new Node.VariableDeclarator(id, init));
+ };
+ Parser.prototype.parseVariableDeclarationList = function (options) {
+ var opt = { inFor: options.inFor };
+ var list = [];
+ list.push(this.parseVariableDeclaration(opt));
+ while (this.match(',')) {
+ this.nextToken();
+ list.push(this.parseVariableDeclaration(opt));
+ }
+ return list;
+ };
+ Parser.prototype.parseVariableStatement = function () {
+ var node = this.createNode();
+ this.expectKeyword('var');
+ var declarations = this.parseVariableDeclarationList({ inFor: false });
+ this.consumeSemicolon();
+ return this.finalize(node, new Node.VariableDeclaration(declarations, 'var'));
+ };
+ // https://tc39.github.io/ecma262/#sec-empty-statement
+ Parser.prototype.parseEmptyStatement = function () {
+ var node = this.createNode();
+ this.expect(';');
+ return this.finalize(node, new Node.EmptyStatement());
+ };
+ // https://tc39.github.io/ecma262/#sec-expression-statement
+ Parser.prototype.parseExpressionStatement = function () {
+ var node = this.createNode();
+ var expr = this.parseExpression();
+ this.consumeSemicolon();
+ return this.finalize(node, new Node.ExpressionStatement(expr));
+ };
+ // https://tc39.github.io/ecma262/#sec-if-statement
+ Parser.prototype.parseIfClause = function () {
+ if (this.context.strict && this.matchKeyword('function')) {
+ this.tolerateError(messages_1.Messages.StrictFunction);
+ }
+ return this.parseStatement();
+ };
+ Parser.prototype.parseIfStatement = function () {
+ var node = this.createNode();
+ var consequent;
+ var alternate = null;
+ this.expectKeyword('if');
+ this.expect('(');
+ var test = this.parseExpression();
+ if (!this.match(')') && this.config.tolerant) {
+ this.tolerateUnexpectedToken(this.nextToken());
+ consequent = this.finalize(this.createNode(), new Node.EmptyStatement());
+ }
+ else {
+ this.expect(')');
+ consequent = this.parseIfClause();
+ if (this.matchKeyword('else')) {
+ this.nextToken();
+ alternate = this.parseIfClause();
+ }
+ }
+ return this.finalize(node, new Node.IfStatement(test, consequent, alternate));
+ };
+ // https://tc39.github.io/ecma262/#sec-do-while-statement
+ Parser.prototype.parseDoWhileStatement = function () {
+ var node = this.createNode();
+ this.expectKeyword('do');
+ var previousInIteration = this.context.inIteration;
+ this.context.inIteration = true;
+ var body = this.parseStatement();
+ this.context.inIteration = previousInIteration;
+ this.expectKeyword('while');
+ this.expect('(');
+ var test = this.parseExpression();
+ if (!this.match(')') && this.config.tolerant) {
+ this.tolerateUnexpectedToken(this.nextToken());
+ }
+ else {
+ this.expect(')');
+ if (this.match(';')) {
+ this.nextToken();
+ }
+ }
+ return this.finalize(node, new Node.DoWhileStatement(body, test));
+ };
+ // https://tc39.github.io/ecma262/#sec-while-statement
+ Parser.prototype.parseWhileStatement = function () {
+ var node = this.createNode();
+ var body;
+ this.expectKeyword('while');
+ this.expect('(');
+ var test = this.parseExpression();
+ if (!this.match(')') && this.config.tolerant) {
+ this.tolerateUnexpectedToken(this.nextToken());
+ body = this.finalize(this.createNode(), new Node.EmptyStatement());
+ }
+ else {
+ this.expect(')');
+ var previousInIteration = this.context.inIteration;
+ this.context.inIteration = true;
+ body = this.parseStatement();
+ this.context.inIteration = previousInIteration;
+ }
+ return this.finalize(node, new Node.WhileStatement(test, body));
+ };
+ // https://tc39.github.io/ecma262/#sec-for-statement
+ // https://tc39.github.io/ecma262/#sec-for-in-and-for-of-statements
+ Parser.prototype.parseForStatement = function () {
+ var init = null;
+ var test = null;
+ var update = null;
+ var forIn = true;
+ var left, right;
+ var node = this.createNode();
+ this.expectKeyword('for');
+ this.expect('(');
+ if (this.match(';')) {
+ this.nextToken();
+ }
+ else {
+ if (this.matchKeyword('var')) {
+ init = this.createNode();
+ this.nextToken();
+ var previousAllowIn = this.context.allowIn;
+ this.context.allowIn = false;
+ var declarations = this.parseVariableDeclarationList({ inFor: true });
+ this.context.allowIn = previousAllowIn;
+ if (declarations.length === 1 && this.matchKeyword('in')) {
+ var decl = declarations[0];
+ if (decl.init && (decl.id.type === syntax_1.Syntax.ArrayPattern || decl.id.type === syntax_1.Syntax.ObjectPattern || this.context.strict)) {
+ this.tolerateError(messages_1.Messages.ForInOfLoopInitializer, 'for-in');
+ }
+ init = this.finalize(init, new Node.VariableDeclaration(declarations, 'var'));
+ this.nextToken();
+ left = init;
+ right = this.parseExpression();
+ init = null;
+ }
+ else if (declarations.length === 1 && declarations[0].init === null && this.matchContextualKeyword('of')) {
+ init = this.finalize(init, new Node.VariableDeclaration(declarations, 'var'));
+ this.nextToken();
+ left = init;
+ right = this.parseAssignmentExpression();
+ init = null;
+ forIn = false;
+ }
+ else {
+ init = this.finalize(init, new Node.VariableDeclaration(declarations, 'var'));
+ this.expect(';');
+ }
+ }
+ else if (this.matchKeyword('const') || this.matchKeyword('let')) {
+ init = this.createNode();
+ var kind = this.nextToken().value;
+ if (!this.context.strict && this.lookahead.value === 'in') {
+ init = this.finalize(init, new Node.Identifier(kind));
+ this.nextToken();
+ left = init;
+ right = this.parseExpression();
+ init = null;
+ }
+ else {
+ var previousAllowIn = this.context.allowIn;
+ this.context.allowIn = false;
+ var declarations = this.parseBindingList(kind, { inFor: true });
+ this.context.allowIn = previousAllowIn;
+ if (declarations.length === 1 && declarations[0].init === null && this.matchKeyword('in')) {
+ init = this.finalize(init, new Node.VariableDeclaration(declarations, kind));
+ this.nextToken();
+ left = init;
+ right = this.parseExpression();
+ init = null;
+ }
+ else if (declarations.length === 1 && declarations[0].init === null && this.matchContextualKeyword('of')) {
+ init = this.finalize(init, new Node.VariableDeclaration(declarations, kind));
+ this.nextToken();
+ left = init;
+ right = this.parseAssignmentExpression();
+ init = null;
+ forIn = false;
+ }
+ else {
+ this.consumeSemicolon();
+ init = this.finalize(init, new Node.VariableDeclaration(declarations, kind));
+ }
+ }
+ }
+ else {
+ var initStartToken = this.lookahead;
+ var previousAllowIn = this.context.allowIn;
+ this.context.allowIn = false;
+ init = this.inheritCoverGrammar(this.parseAssignmentExpression);
+ this.context.allowIn = previousAllowIn;
+ if (this.matchKeyword('in')) {
+ if (!this.context.isAssignmentTarget || init.type === syntax_1.Syntax.AssignmentExpression) {
+ this.tolerateError(messages_1.Messages.InvalidLHSInForIn);
+ }
+ this.nextToken();
+ this.reinterpretExpressionAsPattern(init);
+ left = init;
+ right = this.parseExpression();
+ init = null;
+ }
+ else if (this.matchContextualKeyword('of')) {
+ if (!this.context.isAssignmentTarget || init.type === syntax_1.Syntax.AssignmentExpression) {
+ this.tolerateError(messages_1.Messages.InvalidLHSInForLoop);
+ }
+ this.nextToken();
+ this.reinterpretExpressionAsPattern(init);
+ left = init;
+ right = this.parseAssignmentExpression();
+ init = null;
+ forIn = false;
+ }
+ else {
+ if (this.match(',')) {
+ var initSeq = [init];
+ while (this.match(',')) {
+ this.nextToken();
+ initSeq.push(this.isolateCoverGrammar(this.parseAssignmentExpression));
+ }
+ init = this.finalize(this.startNode(initStartToken), new Node.SequenceExpression(initSeq));
+ }
+ this.expect(';');
+ }
+ }
+ }
+ if (typeof left === 'undefined') {
+ if (!this.match(';')) {
+ test = this.parseExpression();
+ }
+ this.expect(';');
+ if (!this.match(')')) {
+ update = this.parseExpression();
+ }
+ }
+ var body;
+ if (!this.match(')') && this.config.tolerant) {
+ this.tolerateUnexpectedToken(this.nextToken());
+ body = this.finalize(this.createNode(), new Node.EmptyStatement());
+ }
+ else {
+ this.expect(')');
+ var previousInIteration = this.context.inIteration;
+ this.context.inIteration = true;
+ body = this.isolateCoverGrammar(this.parseStatement);
+ this.context.inIteration = previousInIteration;
+ }
+ return (typeof left === 'undefined') ?
+ this.finalize(node, new Node.ForStatement(init, test, update, body)) :
+ forIn ? this.finalize(node, new Node.ForInStatement(left, right, body)) :
+ this.finalize(node, new Node.ForOfStatement(left, right, body));
+ };
+ // https://tc39.github.io/ecma262/#sec-continue-statement
+ Parser.prototype.parseContinueStatement = function () {
+ var node = this.createNode();
+ this.expectKeyword('continue');
+ var label = null;
+ if (this.lookahead.type === 3 /* Identifier */ && !this.hasLineTerminator) {
+ var id = this.parseVariableIdentifier();
+ label = id;
+ var key = '$' + id.name;
+ if (!Object.prototype.hasOwnProperty.call(this.context.labelSet, key)) {
+ this.throwError(messages_1.Messages.UnknownLabel, id.name);
+ }
+ }
+ this.consumeSemicolon();
+ if (label === null && !this.context.inIteration) {
+ this.throwError(messages_1.Messages.IllegalContinue);
+ }
+ return this.finalize(node, new Node.ContinueStatement(label));
+ };
+ // https://tc39.github.io/ecma262/#sec-break-statement
+ Parser.prototype.parseBreakStatement = function () {
+ var node = this.createNode();
+ this.expectKeyword('break');
+ var label = null;
+ if (this.lookahead.type === 3 /* Identifier */ && !this.hasLineTerminator) {
+ var id = this.parseVariableIdentifier();
+ var key = '$' + id.name;
+ if (!Object.prototype.hasOwnProperty.call(this.context.labelSet, key)) {
+ this.throwError(messages_1.Messages.UnknownLabel, id.name);
+ }
+ label = id;
+ }
+ this.consumeSemicolon();
+ if (label === null && !this.context.inIteration && !this.context.inSwitch) {
+ this.throwError(messages_1.Messages.IllegalBreak);
+ }
+ return this.finalize(node, new Node.BreakStatement(label));
+ };
+ // https://tc39.github.io/ecma262/#sec-return-statement
+ Parser.prototype.parseReturnStatement = function () {
+ if (!this.context.inFunctionBody) {
+ this.tolerateError(messages_1.Messages.IllegalReturn);
+ }
+ var node = this.createNode();
+ this.expectKeyword('return');
+ var hasArgument = (!this.match(';') && !this.match('}') &&
+ !this.hasLineTerminator && this.lookahead.type !== 2 /* EOF */) ||
+ this.lookahead.type === 8 /* StringLiteral */ ||
+ this.lookahead.type === 10 /* Template */;
+ var argument = hasArgument ? this.parseExpression() : null;
+ this.consumeSemicolon();
+ return this.finalize(node, new Node.ReturnStatement(argument));
+ };
+ // https://tc39.github.io/ecma262/#sec-with-statement
+ Parser.prototype.parseWithStatement = function () {
+ if (this.context.strict) {
+ this.tolerateError(messages_1.Messages.StrictModeWith);
+ }
+ var node = this.createNode();
+ var body;
+ this.expectKeyword('with');
+ this.expect('(');
+ var object = this.parseExpression();
+ if (!this.match(')') && this.config.tolerant) {
+ this.tolerateUnexpectedToken(this.nextToken());
+ body = this.finalize(this.createNode(), new Node.EmptyStatement());
+ }
+ else {
+ this.expect(')');
+ body = this.parseStatement();
+ }
+ return this.finalize(node, new Node.WithStatement(object, body));
+ };
+ // https://tc39.github.io/ecma262/#sec-switch-statement
+ Parser.prototype.parseSwitchCase = function () {
+ var node = this.createNode();
+ var test;
+ if (this.matchKeyword('default')) {
+ this.nextToken();
+ test = null;
+ }
+ else {
+ this.expectKeyword('case');
+ test = this.parseExpression();
+ }
+ this.expect(':');
+ var consequent = [];
+ while (true) {
+ if (this.match('}') || this.matchKeyword('default') || this.matchKeyword('case')) {
+ break;
+ }
+ consequent.push(this.parseStatementListItem());
+ }
+ return this.finalize(node, new Node.SwitchCase(test, consequent));
+ };
+ Parser.prototype.parseSwitchStatement = function () {
+ var node = this.createNode();
+ this.expectKeyword('switch');
+ this.expect('(');
+ var discriminant = this.parseExpression();
+ this.expect(')');
+ var previousInSwitch = this.context.inSwitch;
+ this.context.inSwitch = true;
+ var cases = [];
+ var defaultFound = false;
+ this.expect('{');
+ while (true) {
+ if (this.match('}')) {
+ break;
+ }
+ var clause = this.parseSwitchCase();
+ if (clause.test === null) {
+ if (defaultFound) {
+ this.throwError(messages_1.Messages.MultipleDefaultsInSwitch);
+ }
+ defaultFound = true;
+ }
+ cases.push(clause);
+ }
+ this.expect('}');
+ this.context.inSwitch = previousInSwitch;
+ return this.finalize(node, new Node.SwitchStatement(discriminant, cases));
+ };
+ // https://tc39.github.io/ecma262/#sec-labelled-statements
+ Parser.prototype.parseLabelledStatement = function () {
+ var node = this.createNode();
+ var expr = this.parseExpression();
+ var statement;
+ if ((expr.type === syntax_1.Syntax.Identifier) && this.match(':')) {
+ this.nextToken();
+ var id = expr;
+ var key = '$' + id.name;
+ if (Object.prototype.hasOwnProperty.call(this.context.labelSet, key)) {
+ this.throwError(messages_1.Messages.Redeclaration, 'Label', id.name);
+ }
+ this.context.labelSet[key] = true;
+ var body = void 0;
+ if (this.matchKeyword('class')) {
+ this.tolerateUnexpectedToken(this.lookahead);
+ body = this.parseClassDeclaration();
+ }
+ else if (this.matchKeyword('function')) {
+ var token = this.lookahead;
+ var declaration = this.parseFunctionDeclaration();
+ if (this.context.strict) {
+ this.tolerateUnexpectedToken(token, messages_1.Messages.StrictFunction);
+ }
+ else if (declaration.generator) {
+ this.tolerateUnexpectedToken(token, messages_1.Messages.GeneratorInLegacyContext);
+ }
+ body = declaration;
+ }
+ else {
+ body = this.parseStatement();
+ }
+ delete this.context.labelSet[key];
+ statement = new Node.LabeledStatement(id, body);
+ }
+ else {
+ this.consumeSemicolon();
+ statement = new Node.ExpressionStatement(expr);
+ }
+ return this.finalize(node, statement);
+ };
+ // https://tc39.github.io/ecma262/#sec-throw-statement
+ Parser.prototype.parseThrowStatement = function () {
+ var node = this.createNode();
+ this.expectKeyword('throw');
+ if (this.hasLineTerminator) {
+ this.throwError(messages_1.Messages.NewlineAfterThrow);
+ }
+ var argument = this.parseExpression();
+ this.consumeSemicolon();
+ return this.finalize(node, new Node.ThrowStatement(argument));
+ };
+ // https://tc39.github.io/ecma262/#sec-try-statement
+ Parser.prototype.parseCatchClause = function () {
+ var node = this.createNode();
+ this.expectKeyword('catch');
+ this.expect('(');
+ if (this.match(')')) {
+ this.throwUnexpectedToken(this.lookahead);
+ }
+ var params = [];
+ var param = this.parsePattern(params);
+ var paramMap = {};
+ for (var i = 0; i < params.length; i++) {
+ var key = '$' + params[i].value;
+ if (Object.prototype.hasOwnProperty.call(paramMap, key)) {
+ this.tolerateError(messages_1.Messages.DuplicateBinding, params[i].value);
+ }
+ paramMap[key] = true;
+ }
+ if (this.context.strict && param.type === syntax_1.Syntax.Identifier) {
+ if (this.scanner.isRestrictedWord(param.name)) {
+ this.tolerateError(messages_1.Messages.StrictCatchVariable);
+ }
+ }
+ this.expect(')');
+ var body = this.parseBlock();
+ return this.finalize(node, new Node.CatchClause(param, body));
+ };
+ Parser.prototype.parseFinallyClause = function () {
+ this.expectKeyword('finally');
+ return this.parseBlock();
+ };
+ Parser.prototype.parseTryStatement = function () {
+ var node = this.createNode();
+ this.expectKeyword('try');
+ var block = this.parseBlock();
+ var handler = this.matchKeyword('catch') ? this.parseCatchClause() : null;
+ var finalizer = this.matchKeyword('finally') ? this.parseFinallyClause() : null;
+ if (!handler && !finalizer) {
+ this.throwError(messages_1.Messages.NoCatchOrFinally);
+ }
+ return this.finalize(node, new Node.TryStatement(block, handler, finalizer));
+ };
+ // https://tc39.github.io/ecma262/#sec-debugger-statement
+ Parser.prototype.parseDebuggerStatement = function () {
+ var node = this.createNode();
+ this.expectKeyword('debugger');
+ this.consumeSemicolon();
+ return this.finalize(node, new Node.DebuggerStatement());
+ };
+ // https://tc39.github.io/ecma262/#sec-ecmascript-language-statements-and-declarations
+ Parser.prototype.parseStatement = function () {
+ var statement;
+ switch (this.lookahead.type) {
+ case 1 /* BooleanLiteral */:
+ case 5 /* NullLiteral */:
+ case 6 /* NumericLiteral */:
+ case 8 /* StringLiteral */:
+ case 10 /* Template */:
+ case 9 /* RegularExpression */:
+ statement = this.parseExpressionStatement();
+ break;
+ case 7 /* Punctuator */:
+ var value = this.lookahead.value;
+ if (value === '{') {
+ statement = this.parseBlock();
+ }
+ else if (value === '(') {
+ statement = this.parseExpressionStatement();
+ }
+ else if (value === ';') {
+ statement = this.parseEmptyStatement();
+ }
+ else {
+ statement = this.parseExpressionStatement();
+ }
+ break;
+ case 3 /* Identifier */:
+ statement = this.matchAsyncFunction() ? this.parseFunctionDeclaration() : this.parseLabelledStatement();
+ break;
+ case 4 /* Keyword */:
+ switch (this.lookahead.value) {
+ case 'break':
+ statement = this.parseBreakStatement();
+ break;
+ case 'continue':
+ statement = this.parseContinueStatement();
+ break;
+ case 'debugger':
+ statement = this.parseDebuggerStatement();
+ break;
+ case 'do':
+ statement = this.parseDoWhileStatement();
+ break;
+ case 'for':
+ statement = this.parseForStatement();
+ break;
+ case 'function':
+ statement = this.parseFunctionDeclaration();
+ break;
+ case 'if':
+ statement = this.parseIfStatement();
+ break;
+ case 'return':
+ statement = this.parseReturnStatement();
+ break;
+ case 'switch':
+ statement = this.parseSwitchStatement();
+ break;
+ case 'throw':
+ statement = this.parseThrowStatement();
+ break;
+ case 'try':
+ statement = this.parseTryStatement();
+ break;
+ case 'var':
+ statement = this.parseVariableStatement();
+ break;
+ case 'while':
+ statement = this.parseWhileStatement();
+ break;
+ case 'with':
+ statement = this.parseWithStatement();
+ break;
+ default:
+ statement = this.parseExpressionStatement();
+ break;
+ }
+ break;
+ default:
+ statement = this.throwUnexpectedToken(this.lookahead);
+ }
+ return statement;
+ };
+ // https://tc39.github.io/ecma262/#sec-function-definitions
+ Parser.prototype.parseFunctionSourceElements = function () {
+ var node = this.createNode();
+ this.expect('{');
+ var body = this.parseDirectivePrologues();
+ var previousLabelSet = this.context.labelSet;
+ var previousInIteration = this.context.inIteration;
+ var previousInSwitch = this.context.inSwitch;
+ var previousInFunctionBody = this.context.inFunctionBody;
+ this.context.labelSet = {};
+ this.context.inIteration = false;
+ this.context.inSwitch = false;
+ this.context.inFunctionBody = true;
+ while (this.lookahead.type !== 2 /* EOF */) {
+ if (this.match('}')) {
+ break;
+ }
+ body.push(this.parseStatementListItem());
+ }
+ this.expect('}');
+ this.context.labelSet = previousLabelSet;
+ this.context.inIteration = previousInIteration;
+ this.context.inSwitch = previousInSwitch;
+ this.context.inFunctionBody = previousInFunctionBody;
+ return this.finalize(node, new Node.BlockStatement(body));
+ };
+ Parser.prototype.validateParam = function (options, param, name) {
+ var key = '$' + name;
+ if (this.context.strict) {
+ if (this.scanner.isRestrictedWord(name)) {
+ options.stricted = param;
+ options.message = messages_1.Messages.StrictParamName;
+ }
+ if (Object.prototype.hasOwnProperty.call(options.paramSet, key)) {
+ options.stricted = param;
+ options.message = messages_1.Messages.StrictParamDupe;
+ }
+ }
+ else if (!options.firstRestricted) {
+ if (this.scanner.isRestrictedWord(name)) {
+ options.firstRestricted = param;
+ options.message = messages_1.Messages.StrictParamName;
+ }
+ else if (this.scanner.isStrictModeReservedWord(name)) {
+ options.firstRestricted = param;
+ options.message = messages_1.Messages.StrictReservedWord;
+ }
+ else if (Object.prototype.hasOwnProperty.call(options.paramSet, key)) {
+ options.stricted = param;
+ options.message = messages_1.Messages.StrictParamDupe;
+ }
+ }
+ /* istanbul ignore next */
+ if (typeof Object.defineProperty === 'function') {
+ Object.defineProperty(options.paramSet, key, { value: true, enumerable: true, writable: true, configurable: true });
+ }
+ else {
+ options.paramSet[key] = true;
+ }
+ };
+ Parser.prototype.parseRestElement = function (params) {
+ var node = this.createNode();
+ this.expect('...');
+ var arg = this.parsePattern(params);
+ if (this.match('=')) {
+ this.throwError(messages_1.Messages.DefaultRestParameter);
+ }
+ if (!this.match(')')) {
+ this.throwError(messages_1.Messages.ParameterAfterRestParameter);
+ }
+ return this.finalize(node, new Node.RestElement(arg));
+ };
+ Parser.prototype.parseFormalParameter = function (options) {
+ var params = [];
+ var param = this.match('...') ? this.parseRestElement(params) : this.parsePatternWithDefault(params);
+ for (var i = 0; i < params.length; i++) {
+ this.validateParam(options, params[i], params[i].value);
+ }
+ options.simple = options.simple && (param instanceof Node.Identifier);
+ options.params.push(param);
+ };
+ Parser.prototype.parseFormalParameters = function (firstRestricted) {
+ var options;
+ options = {
+ simple: true,
+ params: [],
+ firstRestricted: firstRestricted
+ };
+ this.expect('(');
+ if (!this.match(')')) {
+ options.paramSet = {};
+ while (this.lookahead.type !== 2 /* EOF */) {
+ this.parseFormalParameter(options);
+ if (this.match(')')) {
+ break;
+ }
+ this.expect(',');
+ if (this.match(')')) {
+ break;
+ }
+ }
+ }
+ this.expect(')');
+ return {
+ simple: options.simple,
+ params: options.params,
+ stricted: options.stricted,
+ firstRestricted: options.firstRestricted,
+ message: options.message
+ };
+ };
+ Parser.prototype.matchAsyncFunction = function () {
+ var match = this.matchContextualKeyword('async');
+ if (match) {
+ var state = this.scanner.saveState();
+ this.scanner.scanComments();
+ var next = this.scanner.lex();
+ this.scanner.restoreState(state);
+ match = (state.lineNumber === next.lineNumber) && (next.type === 4 /* Keyword */) && (next.value === 'function');
+ }
+ return match;
+ };
+ Parser.prototype.parseFunctionDeclaration = function (identifierIsOptional) {
+ var node = this.createNode();
+ var isAsync = this.matchContextualKeyword('async');
+ if (isAsync) {
+ this.nextToken();
+ }
+ this.expectKeyword('function');
+ var isGenerator = isAsync ? false : this.match('*');
+ if (isGenerator) {
+ this.nextToken();
+ }
+ var message;
+ var id = null;
+ var firstRestricted = null;
+ if (!identifierIsOptional || !this.match('(')) {
+ var token = this.lookahead;
+ id = this.parseVariableIdentifier();
+ if (this.context.strict) {
+ if (this.scanner.isRestrictedWord(token.value)) {
+ this.tolerateUnexpectedToken(token, messages_1.Messages.StrictFunctionName);
+ }
+ }
+ else {
+ if (this.scanner.isRestrictedWord(token.value)) {
+ firstRestricted = token;
+ message = messages_1.Messages.StrictFunctionName;
+ }
+ else if (this.scanner.isStrictModeReservedWord(token.value)) {
+ firstRestricted = token;
+ message = messages_1.Messages.StrictReservedWord;
+ }
+ }
+ }
+ var previousAllowAwait = this.context.await;
+ var previousAllowYield = this.context.allowYield;
+ this.context.await = isAsync;
+ this.context.allowYield = !isGenerator;
+ var formalParameters = this.parseFormalParameters(firstRestricted);
+ var params = formalParameters.params;
+ var stricted = formalParameters.stricted;
+ firstRestricted = formalParameters.firstRestricted;
+ if (formalParameters.message) {
+ message = formalParameters.message;
+ }
+ var previousStrict = this.context.strict;
+ var previousAllowStrictDirective = this.context.allowStrictDirective;
+ this.context.allowStrictDirective = formalParameters.simple;
+ var body = this.parseFunctionSourceElements();
+ if (this.context.strict && firstRestricted) {
+ this.throwUnexpectedToken(firstRestricted, message);
+ }
+ if (this.context.strict && stricted) {
+ this.tolerateUnexpectedToken(stricted, message);
+ }
+ this.context.strict = previousStrict;
+ this.context.allowStrictDirective = previousAllowStrictDirective;
+ this.context.await = previousAllowAwait;
+ this.context.allowYield = previousAllowYield;
+ return isAsync ? this.finalize(node, new Node.AsyncFunctionDeclaration(id, params, body)) :
+ this.finalize(node, new Node.FunctionDeclaration(id, params, body, isGenerator));
+ };
+ Parser.prototype.parseFunctionExpression = function () {
+ var node = this.createNode();
+ var isAsync = this.matchContextualKeyword('async');
+ if (isAsync) {
+ this.nextToken();
+ }
+ this.expectKeyword('function');
+ var isGenerator = isAsync ? false : this.match('*');
+ if (isGenerator) {
+ this.nextToken();
+ }
+ var message;
+ var id = null;
+ var firstRestricted;
+ var previousAllowAwait = this.context.await;
+ var previousAllowYield = this.context.allowYield;
+ this.context.await = isAsync;
+ this.context.allowYield = !isGenerator;
+ if (!this.match('(')) {
+ var token = this.lookahead;
+ id = (!this.context.strict && !isGenerator && this.matchKeyword('yield')) ? this.parseIdentifierName() : this.parseVariableIdentifier();
+ if (this.context.strict) {
+ if (this.scanner.isRestrictedWord(token.value)) {
+ this.tolerateUnexpectedToken(token, messages_1.Messages.StrictFunctionName);
+ }
+ }
+ else {
+ if (this.scanner.isRestrictedWord(token.value)) {
+ firstRestricted = token;
+ message = messages_1.Messages.StrictFunctionName;
+ }
+ else if (this.scanner.isStrictModeReservedWord(token.value)) {
+ firstRestricted = token;
+ message = messages_1.Messages.StrictReservedWord;
+ }
+ }
+ }
+ var formalParameters = this.parseFormalParameters(firstRestricted);
+ var params = formalParameters.params;
+ var stricted = formalParameters.stricted;
+ firstRestricted = formalParameters.firstRestricted;
+ if (formalParameters.message) {
+ message = formalParameters.message;
+ }
+ var previousStrict = this.context.strict;
+ var previousAllowStrictDirective = this.context.allowStrictDirective;
+ this.context.allowStrictDirective = formalParameters.simple;
+ var body = this.parseFunctionSourceElements();
+ if (this.context.strict && firstRestricted) {
+ this.throwUnexpectedToken(firstRestricted, message);
+ }
+ if (this.context.strict && stricted) {
+ this.tolerateUnexpectedToken(stricted, message);
+ }
+ this.context.strict = previousStrict;
+ this.context.allowStrictDirective = previousAllowStrictDirective;
+ this.context.await = previousAllowAwait;
+ this.context.allowYield = previousAllowYield;
+ return isAsync ? this.finalize(node, new Node.AsyncFunctionExpression(id, params, body)) :
+ this.finalize(node, new Node.FunctionExpression(id, params, body, isGenerator));
+ };
+ // https://tc39.github.io/ecma262/#sec-directive-prologues-and-the-use-strict-directive
+ Parser.prototype.parseDirective = function () {
+ var token = this.lookahead;
+ var node = this.createNode();
+ var expr = this.parseExpression();
+ var directive = (expr.type === syntax_1.Syntax.Literal) ? this.getTokenRaw(token).slice(1, -1) : null;
+ this.consumeSemicolon();
+ return this.finalize(node, directive ? new Node.Directive(expr, directive) : new Node.ExpressionStatement(expr));
+ };
+ Parser.prototype.parseDirectivePrologues = function () {
+ var firstRestricted = null;
+ var body = [];
+ while (true) {
+ var token = this.lookahead;
+ if (token.type !== 8 /* StringLiteral */) {
+ break;
+ }
+ var statement = this.parseDirective();
+ body.push(statement);
+ var directive = statement.directive;
+ if (typeof directive !== 'string') {
+ break;
+ }
+ if (directive === 'use strict') {
+ this.context.strict = true;
+ if (firstRestricted) {
+ this.tolerateUnexpectedToken(firstRestricted, messages_1.Messages.StrictOctalLiteral);
+ }
+ if (!this.context.allowStrictDirective) {
+ this.tolerateUnexpectedToken(token, messages_1.Messages.IllegalLanguageModeDirective);
+ }
+ }
+ else {
+ if (!firstRestricted && token.octal) {
+ firstRestricted = token;
+ }
+ }
+ }
+ return body;
+ };
+ // https://tc39.github.io/ecma262/#sec-method-definitions
+ Parser.prototype.qualifiedPropertyName = function (token) {
+ switch (token.type) {
+ case 3 /* Identifier */:
+ case 8 /* StringLiteral */:
+ case 1 /* BooleanLiteral */:
+ case 5 /* NullLiteral */:
+ case 6 /* NumericLiteral */:
+ case 4 /* Keyword */:
+ return true;
+ case 7 /* Punctuator */:
+ return token.value === '[';
+ default:
+ break;
+ }
+ return false;
+ };
+ Parser.prototype.parseGetterMethod = function () {
+ var node = this.createNode();
+ var isGenerator = false;
+ var previousAllowYield = this.context.allowYield;
+ this.context.allowYield = !isGenerator;
+ var formalParameters = this.parseFormalParameters();
+ if (formalParameters.params.length > 0) {
+ this.tolerateError(messages_1.Messages.BadGetterArity);
+ }
+ var method = this.parsePropertyMethod(formalParameters);
+ this.context.allowYield = previousAllowYield;
+ return this.finalize(node, new Node.FunctionExpression(null, formalParameters.params, method, isGenerator));
+ };
+ Parser.prototype.parseSetterMethod = function () {
+ var node = this.createNode();
+ var isGenerator = false;
+ var previousAllowYield = this.context.allowYield;
+ this.context.allowYield = !isGenerator;
+ var formalParameters = this.parseFormalParameters();
+ if (formalParameters.params.length !== 1) {
+ this.tolerateError(messages_1.Messages.BadSetterArity);
+ }
+ else if (formalParameters.params[0] instanceof Node.RestElement) {
+ this.tolerateError(messages_1.Messages.BadSetterRestParameter);
+ }
+ var method = this.parsePropertyMethod(formalParameters);
+ this.context.allowYield = previousAllowYield;
+ return this.finalize(node, new Node.FunctionExpression(null, formalParameters.params, method, isGenerator));
+ };
+ Parser.prototype.parseGeneratorMethod = function () {
+ var node = this.createNode();
+ var isGenerator = true;
+ var previousAllowYield = this.context.allowYield;
+ this.context.allowYield = true;
+ var params = this.parseFormalParameters();
+ this.context.allowYield = false;
+ var method = this.parsePropertyMethod(params);
+ this.context.allowYield = previousAllowYield;
+ return this.finalize(node, new Node.FunctionExpression(null, params.params, method, isGenerator));
+ };
+ // https://tc39.github.io/ecma262/#sec-generator-function-definitions
+ Parser.prototype.isStartOfExpression = function () {
+ var start = true;
+ var value = this.lookahead.value;
+ switch (this.lookahead.type) {
+ case 7 /* Punctuator */:
+ start = (value === '[') || (value === '(') || (value === '{') ||
+ (value === '+') || (value === '-') ||
+ (value === '!') || (value === '~') ||
+ (value === '++') || (value === '--') ||
+ (value === '/') || (value === '/='); // regular expression literal
+ break;
+ case 4 /* Keyword */:
+ start = (value === 'class') || (value === 'delete') ||
+ (value === 'function') || (value === 'let') || (value === 'new') ||
+ (value === 'super') || (value === 'this') || (value === 'typeof') ||
+ (value === 'void') || (value === 'yield');
+ break;
+ default:
+ break;
+ }
+ return start;
+ };
+ Parser.prototype.parseYieldExpression = function () {
+ var node = this.createNode();
+ this.expectKeyword('yield');
+ var argument = null;
+ var delegate = false;
+ if (!this.hasLineTerminator) {
+ var previousAllowYield = this.context.allowYield;
+ this.context.allowYield = false;
+ delegate = this.match('*');
+ if (delegate) {
+ this.nextToken();
+ argument = this.parseAssignmentExpression();
+ }
+ else if (this.isStartOfExpression()) {
+ argument = this.parseAssignmentExpression();
+ }
+ this.context.allowYield = previousAllowYield;
+ }
+ return this.finalize(node, new Node.YieldExpression(argument, delegate));
+ };
+ // https://tc39.github.io/ecma262/#sec-class-definitions
+ Parser.prototype.parseClassElement = function (hasConstructor) {
+ var token = this.lookahead;
+ var node = this.createNode();
+ var kind = '';
+ var key = null;
+ var value = null;
+ var computed = false;
+ var method = false;
+ var isStatic = false;
+ var isAsync = false;
+ if (this.match('*')) {
+ this.nextToken();
+ }
+ else {
+ computed = this.match('[');
+ key = this.parseObjectPropertyKey();
+ var id = key;
+ if (id.name === 'static' && (this.qualifiedPropertyName(this.lookahead) || this.match('*'))) {
+ token = this.lookahead;
+ isStatic = true;
+ computed = this.match('[');
+ if (this.match('*')) {
+ this.nextToken();
+ }
+ else {
+ key = this.parseObjectPropertyKey();
+ }
+ }
+ if ((token.type === 3 /* Identifier */) && !this.hasLineTerminator && (token.value === 'async')) {
+ var punctuator = this.lookahead.value;
+ if (punctuator !== ':' && punctuator !== '(' && punctuator !== '*') {
+ isAsync = true;
+ token = this.lookahead;
+ key = this.parseObjectPropertyKey();
+ if (token.type === 3 /* Identifier */ && token.value === 'constructor') {
+ this.tolerateUnexpectedToken(token, messages_1.Messages.ConstructorIsAsync);
+ }
+ }
+ }
+ }
+ var lookaheadPropertyKey = this.qualifiedPropertyName(this.lookahead);
+ if (token.type === 3 /* Identifier */) {
+ if (token.value === 'get' && lookaheadPropertyKey) {
+ kind = 'get';
+ computed = this.match('[');
+ key = this.parseObjectPropertyKey();
+ this.context.allowYield = false;
+ value = this.parseGetterMethod();
+ }
+ else if (token.value === 'set' && lookaheadPropertyKey) {
+ kind = 'set';
+ computed = this.match('[');
+ key = this.parseObjectPropertyKey();
+ value = this.parseSetterMethod();
+ }
+ }
+ else if (token.type === 7 /* Punctuator */ && token.value === '*' && lookaheadPropertyKey) {
+ kind = 'init';
+ computed = this.match('[');
+ key = this.parseObjectPropertyKey();
+ value = this.parseGeneratorMethod();
+ method = true;
+ }
+ if (!kind && key && this.match('(')) {
+ kind = 'init';
+ value = isAsync ? this.parsePropertyMethodAsyncFunction() : this.parsePropertyMethodFunction();
+ method = true;
+ }
+ if (!kind) {
+ this.throwUnexpectedToken(this.lookahead);
+ }
+ if (kind === 'init') {
+ kind = 'method';
+ }
+ if (!computed) {
+ if (isStatic && this.isPropertyKey(key, 'prototype')) {
+ this.throwUnexpectedToken(token, messages_1.Messages.StaticPrototype);
+ }
+ if (!isStatic && this.isPropertyKey(key, 'constructor')) {
+ if (kind !== 'method' || !method || (value && value.generator)) {
+ this.throwUnexpectedToken(token, messages_1.Messages.ConstructorSpecialMethod);
+ }
+ if (hasConstructor.value) {
+ this.throwUnexpectedToken(token, messages_1.Messages.DuplicateConstructor);
+ }
+ else {
+ hasConstructor.value = true;
+ }
+ kind = 'constructor';
+ }
+ }
+ return this.finalize(node, new Node.MethodDefinition(key, computed, value, kind, isStatic));
+ };
+ Parser.prototype.parseClassElementList = function () {
+ var body = [];
+ var hasConstructor = { value: false };
+ this.expect('{');
+ while (!this.match('}')) {
+ if (this.match(';')) {
+ this.nextToken();
+ }
+ else {
+ body.push(this.parseClassElement(hasConstructor));
+ }
+ }
+ this.expect('}');
+ return body;
+ };
+ Parser.prototype.parseClassBody = function () {
+ var node = this.createNode();
+ var elementList = this.parseClassElementList();
+ return this.finalize(node, new Node.ClassBody(elementList));
+ };
+ Parser.prototype.parseClassDeclaration = function (identifierIsOptional) {
+ var node = this.createNode();
+ var previousStrict = this.context.strict;
+ this.context.strict = true;
+ this.expectKeyword('class');
+ var id = (identifierIsOptional && (this.lookahead.type !== 3 /* Identifier */)) ? null : this.parseVariableIdentifier();
+ var superClass = null;
+ if (this.matchKeyword('extends')) {
+ this.nextToken();
+ superClass = this.isolateCoverGrammar(this.parseLeftHandSideExpressionAllowCall);
+ }
+ var classBody = this.parseClassBody();
+ this.context.strict = previousStrict;
+ return this.finalize(node, new Node.ClassDeclaration(id, superClass, classBody));
+ };
+ Parser.prototype.parseClassExpression = function () {
+ var node = this.createNode();
+ var previousStrict = this.context.strict;
+ this.context.strict = true;
+ this.expectKeyword('class');
+ var id = (this.lookahead.type === 3 /* Identifier */) ? this.parseVariableIdentifier() : null;
+ var superClass = null;
+ if (this.matchKeyword('extends')) {
+ this.nextToken();
+ superClass = this.isolateCoverGrammar(this.parseLeftHandSideExpressionAllowCall);
+ }
+ var classBody = this.parseClassBody();
+ this.context.strict = previousStrict;
+ return this.finalize(node, new Node.ClassExpression(id, superClass, classBody));
+ };
+ // https://tc39.github.io/ecma262/#sec-scripts
+ // https://tc39.github.io/ecma262/#sec-modules
+ Parser.prototype.parseModule = function () {
+ this.context.strict = true;
+ this.context.isModule = true;
+ this.scanner.isModule = true;
+ var node = this.createNode();
+ var body = this.parseDirectivePrologues();
+ while (this.lookahead.type !== 2 /* EOF */) {
+ body.push(this.parseStatementListItem());
+ }
+ return this.finalize(node, new Node.Module(body));
+ };
+ Parser.prototype.parseScript = function () {
+ var node = this.createNode();
+ var body = this.parseDirectivePrologues();
+ while (this.lookahead.type !== 2 /* EOF */) {
+ body.push(this.parseStatementListItem());
+ }
+ return this.finalize(node, new Node.Script(body));
+ };
+ // https://tc39.github.io/ecma262/#sec-imports
+ Parser.prototype.parseModuleSpecifier = function () {
+ var node = this.createNode();
+ if (this.lookahead.type !== 8 /* StringLiteral */) {
+ this.throwError(messages_1.Messages.InvalidModuleSpecifier);
+ }
+ var token = this.nextToken();
+ var raw = this.getTokenRaw(token);
+ return this.finalize(node, new Node.Literal(token.value, raw));
+ };
+ // import {} ...;
+ Parser.prototype.parseImportSpecifier = function () {
+ var node = this.createNode();
+ var imported;
+ var local;
+ if (this.lookahead.type === 3 /* Identifier */) {
+ imported = this.parseVariableIdentifier();
+ local = imported;
+ if (this.matchContextualKeyword('as')) {
+ this.nextToken();
+ local = this.parseVariableIdentifier();
+ }
+ }
+ else {
+ imported = this.parseIdentifierName();
+ local = imported;
+ if (this.matchContextualKeyword('as')) {
+ this.nextToken();
+ local = this.parseVariableIdentifier();
+ }
+ else {
+ this.throwUnexpectedToken(this.nextToken());
+ }
+ }
+ return this.finalize(node, new Node.ImportSpecifier(local, imported));
+ };
+ // {foo, bar as bas}
+ Parser.prototype.parseNamedImports = function () {
+ this.expect('{');
+ var specifiers = [];
+ while (!this.match('}')) {
+ specifiers.push(this.parseImportSpecifier());
+ if (!this.match('}')) {
+ this.expect(',');
+ }
+ }
+ this.expect('}');
+ return specifiers;
+ };
+ // import ...;
+ Parser.prototype.parseImportDefaultSpecifier = function () {
+ var node = this.createNode();
+ var local = this.parseIdentifierName();
+ return this.finalize(node, new Node.ImportDefaultSpecifier(local));
+ };
+ // import <* as foo> ...;
+ Parser.prototype.parseImportNamespaceSpecifier = function () {
+ var node = this.createNode();
+ this.expect('*');
+ if (!this.matchContextualKeyword('as')) {
+ this.throwError(messages_1.Messages.NoAsAfterImportNamespace);
+ }
+ this.nextToken();
+ var local = this.parseIdentifierName();
+ return this.finalize(node, new Node.ImportNamespaceSpecifier(local));
+ };
+ Parser.prototype.parseImportDeclaration = function () {
+ if (this.context.inFunctionBody) {
+ this.throwError(messages_1.Messages.IllegalImportDeclaration);
+ }
+ var node = this.createNode();
+ this.expectKeyword('import');
+ var src;
+ var specifiers = [];
+ if (this.lookahead.type === 8 /* StringLiteral */) {
+ // import 'foo';
+ src = this.parseModuleSpecifier();
+ }
+ else {
+ if (this.match('{')) {
+ // import {bar}
+ specifiers = specifiers.concat(this.parseNamedImports());
+ }
+ else if (this.match('*')) {
+ // import * as foo
+ specifiers.push(this.parseImportNamespaceSpecifier());
+ }
+ else if (this.isIdentifierName(this.lookahead) && !this.matchKeyword('default')) {
+ // import foo
+ specifiers.push(this.parseImportDefaultSpecifier());
+ if (this.match(',')) {
+ this.nextToken();
+ if (this.match('*')) {
+ // import foo, * as foo
+ specifiers.push(this.parseImportNamespaceSpecifier());
+ }
+ else if (this.match('{')) {
+ // import foo, {bar}
+ specifiers = specifiers.concat(this.parseNamedImports());
+ }
+ else {
+ this.throwUnexpectedToken(this.lookahead);
+ }
+ }
+ }
+ else {
+ this.throwUnexpectedToken(this.nextToken());
+ }
+ if (!this.matchContextualKeyword('from')) {
+ var message = this.lookahead.value ? messages_1.Messages.UnexpectedToken : messages_1.Messages.MissingFromClause;
+ this.throwError(message, this.lookahead.value);
+ }
+ this.nextToken();
+ src = this.parseModuleSpecifier();
+ }
+ this.consumeSemicolon();
+ return this.finalize(node, new Node.ImportDeclaration(specifiers, src));
+ };
+ // https://tc39.github.io/ecma262/#sec-exports
+ Parser.prototype.parseExportSpecifier = function () {
+ var node = this.createNode();
+ var local = this.parseIdentifierName();
+ var exported = local;
+ if (this.matchContextualKeyword('as')) {
+ this.nextToken();
+ exported = this.parseIdentifierName();
+ }
+ return this.finalize(node, new Node.ExportSpecifier(local, exported));
+ };
+ Parser.prototype.parseExportDeclaration = function () {
+ if (this.context.inFunctionBody) {
+ this.throwError(messages_1.Messages.IllegalExportDeclaration);
+ }
+ var node = this.createNode();
+ this.expectKeyword('export');
+ var exportDeclaration;
+ if (this.matchKeyword('default')) {
+ // export default ...
+ this.nextToken();
+ if (this.matchKeyword('function')) {
+ // export default function foo () {}
+ // export default function () {}
+ var declaration = this.parseFunctionDeclaration(true);
+ exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration));
+ }
+ else if (this.matchKeyword('class')) {
+ // export default class foo {}
+ var declaration = this.parseClassDeclaration(true);
+ exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration));
+ }
+ else if (this.matchContextualKeyword('async')) {
+ // export default async function f () {}
+ // export default async function () {}
+ // export default async x => x
+ var declaration = this.matchAsyncFunction() ? this.parseFunctionDeclaration(true) : this.parseAssignmentExpression();
+ exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration));
+ }
+ else {
+ if (this.matchContextualKeyword('from')) {
+ this.throwError(messages_1.Messages.UnexpectedToken, this.lookahead.value);
+ }
+ // export default {};
+ // export default [];
+ // export default (1 + 2);
+ var declaration = this.match('{') ? this.parseObjectInitializer() :
+ this.match('[') ? this.parseArrayInitializer() : this.parseAssignmentExpression();
+ this.consumeSemicolon();
+ exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration));
+ }
+ }
+ else if (this.match('*')) {
+ // export * from 'foo';
+ this.nextToken();
+ if (!this.matchContextualKeyword('from')) {
+ var message = this.lookahead.value ? messages_1.Messages.UnexpectedToken : messages_1.Messages.MissingFromClause;
+ this.throwError(message, this.lookahead.value);
+ }
+ this.nextToken();
+ var src = this.parseModuleSpecifier();
+ this.consumeSemicolon();
+ exportDeclaration = this.finalize(node, new Node.ExportAllDeclaration(src));
+ }
+ else if (this.lookahead.type === 4 /* Keyword */) {
+ // export var f = 1;
+ var declaration = void 0;
+ switch (this.lookahead.value) {
+ case 'let':
+ case 'const':
+ declaration = this.parseLexicalDeclaration({ inFor: false });
+ break;
+ case 'var':
+ case 'class':
+ case 'function':
+ declaration = this.parseStatementListItem();
+ break;
+ default:
+ this.throwUnexpectedToken(this.lookahead);
+ }
+ exportDeclaration = this.finalize(node, new Node.ExportNamedDeclaration(declaration, [], null));
+ }
+ else if (this.matchAsyncFunction()) {
+ var declaration = this.parseFunctionDeclaration();
+ exportDeclaration = this.finalize(node, new Node.ExportNamedDeclaration(declaration, [], null));
+ }
+ else {
+ var specifiers = [];
+ var source = null;
+ var isExportFromIdentifier = false;
+ this.expect('{');
+ while (!this.match('}')) {
+ isExportFromIdentifier = isExportFromIdentifier || this.matchKeyword('default');
+ specifiers.push(this.parseExportSpecifier());
+ if (!this.match('}')) {
+ this.expect(',');
+ }
+ }
+ this.expect('}');
+ if (this.matchContextualKeyword('from')) {
+ // export {default} from 'foo';
+ // export {foo} from 'foo';
+ this.nextToken();
+ source = this.parseModuleSpecifier();
+ this.consumeSemicolon();
+ }
+ else if (isExportFromIdentifier) {
+ // export {default}; // missing fromClause
+ var message = this.lookahead.value ? messages_1.Messages.UnexpectedToken : messages_1.Messages.MissingFromClause;
+ this.throwError(message, this.lookahead.value);
+ }
+ else {
+ // export {foo};
+ this.consumeSemicolon();
+ }
+ exportDeclaration = this.finalize(node, new Node.ExportNamedDeclaration(null, specifiers, source));
+ }
+ return exportDeclaration;
+ };
+ return Parser;
+ }());
+ exports.Parser = Parser;
+
+
+/***/ },
+/* 9 */
+/***/ function(module, exports) {
+
+ "use strict";
+ // Ensure the condition is true, otherwise throw an error.
+ // This is only to have a better contract semantic, i.e. another safety net
+ // to catch a logic error. The condition shall be fulfilled in normal case.
+ // Do NOT use this to enforce a certain condition on any user input.
+ Object.defineProperty(exports, "__esModule", { value: true });
+ function assert(condition, message) {
+ /* istanbul ignore if */
+ if (!condition) {
+ throw new Error('ASSERT: ' + message);
+ }
+ }
+ exports.assert = assert;
+
+
+/***/ },
+/* 10 */
+/***/ function(module, exports) {
+
+ "use strict";
+ /* tslint:disable:max-classes-per-file */
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var ErrorHandler = (function () {
+ function ErrorHandler() {
+ this.errors = [];
+ this.tolerant = false;
+ }
+ ErrorHandler.prototype.recordError = function (error) {
+ this.errors.push(error);
+ };
+ ErrorHandler.prototype.tolerate = function (error) {
+ if (this.tolerant) {
+ this.recordError(error);
+ }
+ else {
+ throw error;
+ }
+ };
+ ErrorHandler.prototype.constructError = function (msg, column) {
+ var error = new Error(msg);
+ try {
+ throw error;
+ }
+ catch (base) {
+ /* istanbul ignore else */
+ if (Object.create && Object.defineProperty) {
+ error = Object.create(base);
+ Object.defineProperty(error, 'column', { value: column });
+ }
+ }
+ /* istanbul ignore next */
+ return error;
+ };
+ ErrorHandler.prototype.createError = function (index, line, col, description) {
+ var msg = 'Line ' + line + ': ' + description;
+ var error = this.constructError(msg, col);
+ error.index = index;
+ error.lineNumber = line;
+ error.description = description;
+ return error;
+ };
+ ErrorHandler.prototype.throwError = function (index, line, col, description) {
+ throw this.createError(index, line, col, description);
+ };
+ ErrorHandler.prototype.tolerateError = function (index, line, col, description) {
+ var error = this.createError(index, line, col, description);
+ if (this.tolerant) {
+ this.recordError(error);
+ }
+ else {
+ throw error;
+ }
+ };
+ return ErrorHandler;
+ }());
+ exports.ErrorHandler = ErrorHandler;
+
+
+/***/ },
+/* 11 */
+/***/ function(module, exports) {
+
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ // Error messages should be identical to V8.
+ exports.Messages = {
+ BadGetterArity: 'Getter must not have any formal parameters',
+ BadSetterArity: 'Setter must have exactly one formal parameter',
+ BadSetterRestParameter: 'Setter function argument must not be a rest parameter',
+ ConstructorIsAsync: 'Class constructor may not be an async method',
+ ConstructorSpecialMethod: 'Class constructor may not be an accessor',
+ DeclarationMissingInitializer: 'Missing initializer in %0 declaration',
+ DefaultRestParameter: 'Unexpected token =',
+ DuplicateBinding: 'Duplicate binding %0',
+ DuplicateConstructor: 'A class may only have one constructor',
+ DuplicateProtoProperty: 'Duplicate __proto__ fields are not allowed in object literals',
+ ForInOfLoopInitializer: '%0 loop variable declaration may not have an initializer',
+ GeneratorInLegacyContext: 'Generator declarations are not allowed in legacy contexts',
+ IllegalBreak: 'Illegal break statement',
+ IllegalContinue: 'Illegal continue statement',
+ IllegalExportDeclaration: 'Unexpected token',
+ IllegalImportDeclaration: 'Unexpected token',
+ IllegalLanguageModeDirective: 'Illegal \'use strict\' directive in function with non-simple parameter list',
+ IllegalReturn: 'Illegal return statement',
+ InvalidEscapedReservedWord: 'Keyword must not contain escaped characters',
+ InvalidHexEscapeSequence: 'Invalid hexadecimal escape sequence',
+ InvalidLHSInAssignment: 'Invalid left-hand side in assignment',
+ InvalidLHSInForIn: 'Invalid left-hand side in for-in',
+ InvalidLHSInForLoop: 'Invalid left-hand side in for-loop',
+ InvalidModuleSpecifier: 'Unexpected token',
+ InvalidRegExp: 'Invalid regular expression',
+ LetInLexicalBinding: 'let is disallowed as a lexically bound name',
+ MissingFromClause: 'Unexpected token',
+ MultipleDefaultsInSwitch: 'More than one default clause in switch statement',
+ NewlineAfterThrow: 'Illegal newline after throw',
+ NoAsAfterImportNamespace: 'Unexpected token',
+ NoCatchOrFinally: 'Missing catch or finally after try',
+ ParameterAfterRestParameter: 'Rest parameter must be last formal parameter',
+ Redeclaration: '%0 \'%1\' has already been declared',
+ StaticPrototype: 'Classes may not have static property named prototype',
+ StrictCatchVariable: 'Catch variable may not be eval or arguments in strict mode',
+ StrictDelete: 'Delete of an unqualified identifier in strict mode.',
+ StrictFunction: 'In strict mode code, functions can only be declared at top level or inside a block',
+ StrictFunctionName: 'Function name may not be eval or arguments in strict mode',
+ StrictLHSAssignment: 'Assignment to eval or arguments is not allowed in strict mode',
+ StrictLHSPostfix: 'Postfix increment/decrement may not have eval or arguments operand in strict mode',
+ StrictLHSPrefix: 'Prefix increment/decrement may not have eval or arguments operand in strict mode',
+ StrictModeWith: 'Strict mode code may not include a with statement',
+ StrictOctalLiteral: 'Octal literals are not allowed in strict mode.',
+ StrictParamDupe: 'Strict mode function may not have duplicate parameter names',
+ StrictParamName: 'Parameter name eval or arguments is not allowed in strict mode',
+ StrictReservedWord: 'Use of future reserved word in strict mode',
+ StrictVarName: 'Variable name may not be eval or arguments in strict mode',
+ TemplateOctalLiteral: 'Octal literals are not allowed in template strings.',
+ UnexpectedEOS: 'Unexpected end of input',
+ UnexpectedIdentifier: 'Unexpected identifier',
+ UnexpectedNumber: 'Unexpected number',
+ UnexpectedReserved: 'Unexpected reserved word',
+ UnexpectedString: 'Unexpected string',
+ UnexpectedTemplate: 'Unexpected quasi %0',
+ UnexpectedToken: 'Unexpected token %0',
+ UnexpectedTokenIllegal: 'Unexpected token ILLEGAL',
+ UnknownLabel: 'Undefined label \'%0\'',
+ UnterminatedRegExp: 'Invalid regular expression: missing /'
+ };
+
+
+/***/ },
+/* 12 */
+/***/ function(module, exports, __nested_webpack_require_226595__) {
+
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var assert_1 = __nested_webpack_require_226595__(9);
+ var character_1 = __nested_webpack_require_226595__(4);
+ var messages_1 = __nested_webpack_require_226595__(11);
+ function hexValue(ch) {
+ return '0123456789abcdef'.indexOf(ch.toLowerCase());
+ }
+ function octalValue(ch) {
+ return '01234567'.indexOf(ch);
+ }
+ var Scanner = (function () {
+ function Scanner(code, handler) {
+ this.source = code;
+ this.errorHandler = handler;
+ this.trackComment = false;
+ this.isModule = false;
+ this.length = code.length;
+ this.index = 0;
+ this.lineNumber = (code.length > 0) ? 1 : 0;
+ this.lineStart = 0;
+ this.curlyStack = [];
+ }
+ Scanner.prototype.saveState = function () {
+ return {
+ index: this.index,
+ lineNumber: this.lineNumber,
+ lineStart: this.lineStart
+ };
+ };
+ Scanner.prototype.restoreState = function (state) {
+ this.index = state.index;
+ this.lineNumber = state.lineNumber;
+ this.lineStart = state.lineStart;
+ };
+ Scanner.prototype.eof = function () {
+ return this.index >= this.length;
+ };
+ Scanner.prototype.throwUnexpectedToken = function (message) {
+ if (message === void 0) { message = messages_1.Messages.UnexpectedTokenIllegal; }
+ return this.errorHandler.throwError(this.index, this.lineNumber, this.index - this.lineStart + 1, message);
+ };
+ Scanner.prototype.tolerateUnexpectedToken = function (message) {
+ if (message === void 0) { message = messages_1.Messages.UnexpectedTokenIllegal; }
+ this.errorHandler.tolerateError(this.index, this.lineNumber, this.index - this.lineStart + 1, message);
+ };
+ // https://tc39.github.io/ecma262/#sec-comments
+ Scanner.prototype.skipSingleLineComment = function (offset) {
+ var comments = [];
+ var start, loc;
+ if (this.trackComment) {
+ comments = [];
+ start = this.index - offset;
+ loc = {
+ start: {
+ line: this.lineNumber,
+ column: this.index - this.lineStart - offset
+ },
+ end: {}
+ };
+ }
+ while (!this.eof()) {
+ var ch = this.source.charCodeAt(this.index);
+ ++this.index;
+ if (character_1.Character.isLineTerminator(ch)) {
+ if (this.trackComment) {
+ loc.end = {
+ line: this.lineNumber,
+ column: this.index - this.lineStart - 1
+ };
+ var entry = {
+ multiLine: false,
+ slice: [start + offset, this.index - 1],
+ range: [start, this.index - 1],
+ loc: loc
+ };
+ comments.push(entry);
+ }
+ if (ch === 13 && this.source.charCodeAt(this.index) === 10) {
+ ++this.index;
+ }
+ ++this.lineNumber;
+ this.lineStart = this.index;
+ return comments;
+ }
+ }
+ if (this.trackComment) {
+ loc.end = {
+ line: this.lineNumber,
+ column: this.index - this.lineStart
+ };
+ var entry = {
+ multiLine: false,
+ slice: [start + offset, this.index],
+ range: [start, this.index],
+ loc: loc
+ };
+ comments.push(entry);
+ }
+ return comments;
+ };
+ Scanner.prototype.skipMultiLineComment = function () {
+ var comments = [];
+ var start, loc;
+ if (this.trackComment) {
+ comments = [];
+ start = this.index - 2;
+ loc = {
+ start: {
+ line: this.lineNumber,
+ column: this.index - this.lineStart - 2
+ },
+ end: {}
+ };
+ }
+ while (!this.eof()) {
+ var ch = this.source.charCodeAt(this.index);
+ if (character_1.Character.isLineTerminator(ch)) {
+ if (ch === 0x0D && this.source.charCodeAt(this.index + 1) === 0x0A) {
+ ++this.index;
+ }
+ ++this.lineNumber;
+ ++this.index;
+ this.lineStart = this.index;
+ }
+ else if (ch === 0x2A) {
+ // Block comment ends with '*/'.
+ if (this.source.charCodeAt(this.index + 1) === 0x2F) {
+ this.index += 2;
+ if (this.trackComment) {
+ loc.end = {
+ line: this.lineNumber,
+ column: this.index - this.lineStart
+ };
+ var entry = {
+ multiLine: true,
+ slice: [start + 2, this.index - 2],
+ range: [start, this.index],
+ loc: loc
+ };
+ comments.push(entry);
+ }
+ return comments;
+ }
+ ++this.index;
+ }
+ else {
+ ++this.index;
+ }
+ }
+ // Ran off the end of the file - the whole thing is a comment
+ if (this.trackComment) {
+ loc.end = {
+ line: this.lineNumber,
+ column: this.index - this.lineStart
+ };
+ var entry = {
+ multiLine: true,
+ slice: [start + 2, this.index],
+ range: [start, this.index],
+ loc: loc
+ };
+ comments.push(entry);
+ }
+ this.tolerateUnexpectedToken();
+ return comments;
+ };
+ Scanner.prototype.scanComments = function () {
+ var comments;
+ if (this.trackComment) {
+ comments = [];
+ }
+ var start = (this.index === 0);
+ while (!this.eof()) {
+ var ch = this.source.charCodeAt(this.index);
+ if (character_1.Character.isWhiteSpace(ch)) {
+ ++this.index;
+ }
+ else if (character_1.Character.isLineTerminator(ch)) {
+ ++this.index;
+ if (ch === 0x0D && this.source.charCodeAt(this.index) === 0x0A) {
+ ++this.index;
+ }
+ ++this.lineNumber;
+ this.lineStart = this.index;
+ start = true;
+ }
+ else if (ch === 0x2F) {
+ ch = this.source.charCodeAt(this.index + 1);
+ if (ch === 0x2F) {
+ this.index += 2;
+ var comment = this.skipSingleLineComment(2);
+ if (this.trackComment) {
+ comments = comments.concat(comment);
+ }
+ start = true;
+ }
+ else if (ch === 0x2A) {
+ this.index += 2;
+ var comment = this.skipMultiLineComment();
+ if (this.trackComment) {
+ comments = comments.concat(comment);
+ }
+ }
+ else {
+ break;
+ }
+ }
+ else if (start && ch === 0x2D) {
+ // U+003E is '>'
+ if ((this.source.charCodeAt(this.index + 1) === 0x2D) && (this.source.charCodeAt(this.index + 2) === 0x3E)) {
+ // '-->' 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; // ` regexps
+ set = set.map((s, si, set) => s.map(this.parse, this))
+
+ this.debug(this.pattern, set)
+
+ // filter out everything that didn't compile properly.
+ set = set.filter(s => s.indexOf(false) === -1)
+
+ this.debug(this.pattern, set)
+
+ this.set = set
+ }
+
+ parseNegate () {
+ if (this.options.nonegate) return
+
+ const pattern = this.pattern
+ let negate = false
+ let negateOffset = 0
+
+ for (let i = 0; i < pattern.length && pattern.charAt(i) === '!'; i++) {
+ negate = !negate
+ negateOffset++
+ }
+
+ if (negateOffset) this.pattern = pattern.slice(negateOffset)
+ this.negate = negate
+ }
+
+ // set partial to true to test if, for example,
+ // "/a/b" matches the start of "/*/b/*/d"
+ // Partial means, if you run out of file before you run
+ // out of pattern, then that's fine, as long as all
+ // the parts match.
+ matchOne (file, pattern, partial) {
+ var options = this.options
+
+ this.debug('matchOne',
+ { 'this': this, file: file, pattern: pattern })
+
+ this.debug('matchOne', file.length, pattern.length)
+
+ for (var fi = 0,
+ pi = 0,
+ fl = file.length,
+ pl = pattern.length
+ ; (fi < fl) && (pi < pl)
+ ; fi++, pi++) {
+ this.debug('matchOne loop')
+ var p = pattern[pi]
+ var f = file[fi]
+
+ this.debug(pattern, p, f)
+
+ // should be impossible.
+ // some invalid regexp stuff in the set.
+ /* istanbul ignore if */
+ if (p === false) return false
+
+ if (p === GLOBSTAR) {
+ this.debug('GLOBSTAR', [pattern, p, f])
+
+ // "**"
+ // a/**/b/**/c would match the following:
+ // a/b/x/y/z/c
+ // a/x/y/z/b/c
+ // a/b/x/b/x/c
+ // a/b/c
+ // To do this, take the rest of the pattern after
+ // the **, and see if it would match the file remainder.
+ // If so, return success.
+ // If not, the ** "swallows" a segment, and try again.
+ // This is recursively awful.
+ //
+ // a/**/b/**/c matching a/b/x/y/z/c
+ // - a matches a
+ // - doublestar
+ // - matchOne(b/x/y/z/c, b/**/c)
+ // - b matches b
+ // - doublestar
+ // - matchOne(x/y/z/c, c) -> no
+ // - matchOne(y/z/c, c) -> no
+ // - matchOne(z/c, c) -> no
+ // - matchOne(c, c) yes, hit
+ var fr = fi
+ var pr = pi + 1
+ if (pr === pl) {
+ this.debug('** at the end')
+ // a ** at the end will just swallow the rest.
+ // We have found a match.
+ // however, it will not swallow /.x, unless
+ // options.dot is set.
+ // . and .. are *never* matched by **, for explosively
+ // exponential reasons.
+ for (; fi < fl; fi++) {
+ if (file[fi] === '.' || file[fi] === '..' ||
+ (!options.dot && file[fi].charAt(0) === '.')) return false
+ }
+ return true
+ }
+
+ // ok, let's see if we can swallow whatever we can.
+ while (fr < fl) {
+ var swallowee = file[fr]
+
+ this.debug('\nglobstar while', file, fr, pattern, pr, swallowee)
+
+ // XXX remove this slice. Just pass the start index.
+ if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
+ this.debug('globstar found match!', fr, fl, swallowee)
+ // found a match.
+ return true
+ } else {
+ // can't swallow "." or ".." ever.
+ // can only swallow ".foo" when explicitly asked.
+ if (swallowee === '.' || swallowee === '..' ||
+ (!options.dot && swallowee.charAt(0) === '.')) {
+ this.debug('dot detected!', file, fr, pattern, pr)
+ break
+ }
+
+ // ** swallows a segment, and continue.
+ this.debug('globstar swallow a segment, and continue')
+ fr++
+ }
+ }
+
+ // no match was found.
+ // However, in partial mode, we can't say this is necessarily over.
+ // If there's more *pattern* left, then
+ /* istanbul ignore if */
+ if (partial) {
+ // ran out of file
+ this.debug('\n>>> no match, partial?', file, fr, pattern, pr)
+ if (fr === fl) return true
+ }
+ return false
+ }
+
+ // something other than **
+ // non-magic patterns just have to match exactly
+ // patterns with magic have been turned into regexps.
+ var hit
+ if (typeof p === 'string') {
+ hit = f === p
+ this.debug('string match', p, f, hit)
+ } else {
+ hit = f.match(p)
+ this.debug('pattern match', p, f, hit)
+ }
+
+ if (!hit) return false
+ }
+
+ // Note: ending in / means that we'll get a final ""
+ // at the end of the pattern. This can only match a
+ // corresponding "" at the end of the file.
+ // If the file ends in /, then it can only match a
+ // a pattern that ends in /, unless the pattern just
+ // doesn't have any more for it. But, a/b/ should *not*
+ // match "a/b/*", even though "" matches against the
+ // [^/]*? pattern, except in partial mode, where it might
+ // simply not be reached yet.
+ // However, a/b/ should still satisfy a/*
+
+ // now either we fell off the end of the pattern, or we're done.
+ if (fi === fl && pi === pl) {
+ // ran out of pattern and filename at the same time.
+ // an exact hit!
+ return true
+ } else if (fi === fl) {
+ // ran out of file, but still had pattern left.
+ // this is ok if we're doing the match as part of
+ // a glob fs traversal.
+ return partial
+ } else /* istanbul ignore else */ if (pi === pl) {
+ // ran out of pattern, still have file left.
+ // this is only acceptable if we're on the very last
+ // empty segment of a file with a trailing slash.
+ // a/* should match a/b/
+ return (fi === fl - 1) && (file[fi] === '')
+ }
+
+ // should be unreachable.
+ /* istanbul ignore next */
+ throw new Error('wtf?')
+ }
+
+ braceExpand () {
+ return braceExpand(this.pattern, this.options)
+ }
+
+ parse (pattern, isSub) {
+ assertValidPattern(pattern)
+
+ const options = this.options
+
+ // shortcuts
+ if (pattern === '**') {
+ if (!options.noglobstar)
+ return GLOBSTAR
+ else
+ pattern = '*'
+ }
+ if (pattern === '') return ''
+
+ let re = ''
+ let hasMagic = !!options.nocase
+ let escaping = false
+ // ? => one single character
+ const patternListStack = []
+ const negativeLists = []
+ let stateChar
+ let inClass = false
+ let reClassStart = -1
+ let classStart = -1
+ let cs
+ let pl
+ let sp
+ // . and .. never match anything that doesn't start with .,
+ // even when options.dot is set.
+ const patternStart = pattern.charAt(0) === '.' ? '' // anything
+ // not (start or / followed by . or .. followed by / or end)
+ : options.dot ? '(?!(?:^|\\\/)\\.{1,2}(?:$|\\\/))'
+ : '(?!\\.)'
+
+ const clearStateChar = () => {
+ if (stateChar) {
+ // we had some state-tracking character
+ // that wasn't consumed by this pass.
+ switch (stateChar) {
+ case '*':
+ re += star
+ hasMagic = true
+ break
+ case '?':
+ re += qmark
+ hasMagic = true
+ break
+ default:
+ re += '\\' + stateChar
+ break
+ }
+ this.debug('clearStateChar %j %j', stateChar, re)
+ stateChar = false
+ }
+ }
+
+ for (let i = 0, c; (i < pattern.length) && (c = pattern.charAt(i)); i++) {
+ this.debug('%s\t%s %s %j', pattern, i, re, c)
+
+ // skip over any that are escaped.
+ if (escaping) {
+ /* istanbul ignore next - completely not allowed, even escaped. */
+ if (c === '/') {
+ return false
+ }
+
+ if (reSpecials[c]) {
+ re += '\\'
+ }
+ re += c
+ escaping = false
+ continue
+ }
+
+ switch (c) {
+ /* istanbul ignore next */
+ case '/': {
+ // Should already be path-split by now.
+ return false
+ }
+
+ case '\\':
+ clearStateChar()
+ escaping = true
+ continue
+
+ // the various stateChar values
+ // for the "extglob" stuff.
+ case '?':
+ case '*':
+ case '+':
+ case '@':
+ case '!':
+ this.debug('%s\t%s %s %j <-- stateChar', pattern, i, re, c)
+
+ // all of those are literals inside a class, except that
+ // the glob [!a] means [^a] in regexp
+ if (inClass) {
+ this.debug(' in class')
+ if (c === '!' && i === classStart + 1) c = '^'
+ re += c
+ continue
+ }
+
+ // if we already have a stateChar, then it means
+ // that there was something like ** or +? in there.
+ // Handle the stateChar, then proceed with this one.
+ this.debug('call clearStateChar %j', stateChar)
+ clearStateChar()
+ stateChar = c
+ // if extglob is disabled, then +(asdf|foo) isn't a thing.
+ // just clear the statechar *now*, rather than even diving into
+ // the patternList stuff.
+ if (options.noext) clearStateChar()
+ continue
+
+ case '(':
+ if (inClass) {
+ re += '('
+ continue
+ }
+
+ if (!stateChar) {
+ re += '\\('
+ continue
+ }
+
+ patternListStack.push({
+ type: stateChar,
+ start: i - 1,
+ reStart: re.length,
+ open: plTypes[stateChar].open,
+ close: plTypes[stateChar].close
+ })
+ // negation is (?:(?!js)[^/]*)
+ re += stateChar === '!' ? '(?:(?!(?:' : '(?:'
+ this.debug('plType %j %j', stateChar, re)
+ stateChar = false
+ continue
+
+ case ')':
+ if (inClass || !patternListStack.length) {
+ re += '\\)'
+ continue
+ }
+
+ clearStateChar()
+ hasMagic = true
+ pl = patternListStack.pop()
+ // negation is (?:(?!js)[^/]*)
+ // The others are (?:)
+ re += pl.close
+ if (pl.type === '!') {
+ negativeLists.push(pl)
+ }
+ pl.reEnd = re.length
+ continue
+
+ case '|':
+ if (inClass || !patternListStack.length) {
+ re += '\\|'
+ continue
+ }
+
+ clearStateChar()
+ re += '|'
+ continue
+
+ // these are mostly the same in regexp and glob
+ case '[':
+ // swallow any state-tracking char before the [
+ clearStateChar()
+
+ if (inClass) {
+ re += '\\' + c
+ continue
+ }
+
+ inClass = true
+ classStart = i
+ reClassStart = re.length
+ re += c
+ continue
+
+ case ']':
+ // a right bracket shall lose its special
+ // meaning and represent itself in
+ // a bracket expression if it occurs
+ // first in the list. -- POSIX.2 2.8.3.2
+ if (i === classStart + 1 || !inClass) {
+ re += '\\' + c
+ continue
+ }
+
+ // handle the case where we left a class open.
+ // "[z-a]" is valid, equivalent to "\[z-a\]"
+ // split where the last [ was, make sure we don't have
+ // an invalid re. if so, re-walk the contents of the
+ // would-be class to re-translate any characters that
+ // were passed through as-is
+ // TODO: It would probably be faster to determine this
+ // without a try/catch and a new RegExp, but it's tricky
+ // to do safely. For now, this is safe and works.
+ cs = pattern.substring(classStart + 1, i)
+ try {
+ RegExp('[' + cs + ']')
+ } catch (er) {
+ // not a valid class!
+ sp = this.parse(cs, SUBPARSE)
+ re = re.substring(0, reClassStart) + '\\[' + sp[0] + '\\]'
+ hasMagic = hasMagic || sp[1]
+ inClass = false
+ continue
+ }
+
+ // finish up the class.
+ hasMagic = true
+ inClass = false
+ re += c
+ continue
+
+ default:
+ // swallow any state char that wasn't consumed
+ clearStateChar()
+
+ if (reSpecials[c] && !(c === '^' && inClass)) {
+ re += '\\'
+ }
+
+ re += c
+ break
+
+ } // switch
+ } // for
+
+ // handle the case where we left a class open.
+ // "[abc" is valid, equivalent to "\[abc"
+ if (inClass) {
+ // split where the last [ was, and escape it
+ // this is a huge pita. We now have to re-walk
+ // the contents of the would-be class to re-translate
+ // any characters that were passed through as-is
+ cs = pattern.slice(classStart + 1)
+ sp = this.parse(cs, SUBPARSE)
+ re = re.substring(0, reClassStart) + '\\[' + sp[0]
+ hasMagic = hasMagic || sp[1]
+ }
+
+ // handle the case where we had a +( thing at the *end*
+ // of the pattern.
+ // each pattern list stack adds 3 chars, and we need to go through
+ // and escape any | chars that were passed through as-is for the regexp.
+ // Go through and escape them, taking care not to double-escape any
+ // | chars that were already escaped.
+ for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) {
+ let tail
+ tail = re.slice(pl.reStart + pl.open.length)
+ this.debug('setting tail', re, pl)
+ // maybe some even number of \, then maybe 1 \, followed by a |
+ tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, (_, $1, $2) => {
+ /* istanbul ignore else - should already be done */
+ if (!$2) {
+ // the | isn't already escaped, so escape it.
+ $2 = '\\'
+ }
+
+ // need to escape all those slashes *again*, without escaping the
+ // one that we need for escaping the | character. As it works out,
+ // escaping an even number of slashes can be done by simply repeating
+ // it exactly after itself. That's why this trick works.
+ //
+ // I am sorry that you have to see this.
+ return $1 + $1 + $2 + '|'
+ })
+
+ this.debug('tail=%j\n %s', tail, tail, pl, re)
+ const t = pl.type === '*' ? star
+ : pl.type === '?' ? qmark
+ : '\\' + pl.type
+
+ hasMagic = true
+ re = re.slice(0, pl.reStart) + t + '\\(' + tail
+ }
+
+ // handle trailing things that only matter at the very end.
+ clearStateChar()
+ if (escaping) {
+ // trailing \\
+ re += '\\\\'
+ }
+
+ // only need to apply the nodot start if the re starts with
+ // something that could conceivably capture a dot
+ const addPatternStart = addPatternStartSet[re.charAt(0)]
+
+ // Hack to work around lack of negative lookbehind in JS
+ // A pattern like: *.!(x).!(y|z) needs to ensure that a name
+ // like 'a.xyz.yz' doesn't match. So, the first negative
+ // lookahead, has to look ALL the way ahead, to the end of
+ // the pattern.
+ for (let n = negativeLists.length - 1; n > -1; n--) {
+ const nl = negativeLists[n]
+
+ const nlBefore = re.slice(0, nl.reStart)
+ const nlFirst = re.slice(nl.reStart, nl.reEnd - 8)
+ let nlAfter = re.slice(nl.reEnd)
+ const nlLast = re.slice(nl.reEnd - 8, nl.reEnd) + nlAfter
+
+ // Handle nested stuff like *(*.js|!(*.json)), where open parens
+ // mean that we should *not* include the ) in the bit that is considered
+ // "after" the negated section.
+ const openParensBefore = nlBefore.split('(').length - 1
+ let cleanAfter = nlAfter
+ for (let i = 0; i < openParensBefore; i++) {
+ cleanAfter = cleanAfter.replace(/\)[+*?]?/, '')
+ }
+ nlAfter = cleanAfter
+
+ const dollar = nlAfter === '' && isSub !== SUBPARSE ? '$' : ''
+ re = nlBefore + nlFirst + nlAfter + dollar + nlLast
+ }
+
+ // if the re is not "" at this point, then we need to make sure
+ // it doesn't match against an empty path part.
+ // Otherwise a/* will match a/, which it should not.
+ if (re !== '' && hasMagic) {
+ re = '(?=.)' + re
+ }
+
+ if (addPatternStart) {
+ re = patternStart + re
+ }
+
+ // parsing just a piece of a larger pattern.
+ if (isSub === SUBPARSE) {
+ return [re, hasMagic]
+ }
+
+ // skip the regexp for non-magical patterns
+ // unescape anything in it, though, so that it'll be
+ // an exact match against a file etc.
+ if (!hasMagic) {
+ return globUnescape(pattern)
+ }
+
+ const flags = options.nocase ? 'i' : ''
+ try {
+ return Object.assign(new RegExp('^' + re + '$', flags), {
+ _glob: pattern,
+ _src: re,
+ })
+ } catch (er) /* istanbul ignore next - should be impossible */ {
+ // If it was an invalid regular expression, then it can't match
+ // anything. This trick looks for a character after the end of
+ // the string, which is of course impossible, except in multi-line
+ // mode, but it's not a /m regex.
+ return new RegExp('$.')
+ }
+ }
+
+ makeRe () {
+ if (this.regexp || this.regexp === false) return this.regexp
+
+ // at this point, this.set is a 2d array of partial
+ // pattern strings, or "**".
+ //
+ // It's better to use .match(). This function shouldn't
+ // be used, really, but it's pretty convenient sometimes,
+ // when you just want to work with a regex.
+ const set = this.set
+
+ if (!set.length) {
+ this.regexp = false
+ return this.regexp
+ }
+ const options = this.options
+
+ const twoStar = options.noglobstar ? star
+ : options.dot ? twoStarDot
+ : twoStarNoDot
+ const flags = options.nocase ? 'i' : ''
+
+ // coalesce globstars and regexpify non-globstar patterns
+ // if it's the only item, then we just do one twoStar
+ // if it's the first, and there are more, prepend (\/|twoStar\/)? to next
+ // if it's the last, append (\/twoStar|) to previous
+ // if it's in the middle, append (\/|\/twoStar\/) to previous
+ // then filter out GLOBSTAR symbols
+ let re = set.map(pattern => {
+ pattern = pattern.map(p =>
+ typeof p === 'string' ? regExpEscape(p)
+ : p === GLOBSTAR ? GLOBSTAR
+ : p._src
+ ).reduce((set, p) => {
+ if (!(set[set.length - 1] === GLOBSTAR && p === GLOBSTAR)) {
+ set.push(p)
+ }
+ return set
+ }, [])
+ pattern.forEach((p, i) => {
+ if (p !== GLOBSTAR || pattern[i-1] === GLOBSTAR) {
+ return
+ }
+ if (i === 0) {
+ if (pattern.length > 1) {
+ pattern[i+1] = '(?:\\\/|' + twoStar + '\\\/)?' + pattern[i+1]
+ } else {
+ pattern[i] = twoStar
+ }
+ } else if (i === pattern.length - 1) {
+ pattern[i-1] += '(?:\\\/|' + twoStar + ')?'
+ } else {
+ pattern[i-1] += '(?:\\\/|\\\/' + twoStar + '\\\/)' + pattern[i+1]
+ pattern[i+1] = GLOBSTAR
+ }
+ })
+ return pattern.filter(p => p !== GLOBSTAR).join('/')
+ }).join('|')
+
+ // must match entire pattern
+ // ending in a * or ** will make it less strict.
+ re = '^(?:' + re + ')$'
+
+ // can match anything, as long as it's not this.
+ if (this.negate) re = '^(?!' + re + ').*$'
+
+ try {
+ this.regexp = new RegExp(re, flags)
+ } catch (ex) /* istanbul ignore next - should be impossible */ {
+ this.regexp = false
+ }
+ return this.regexp
+ }
+
+ match (f, partial = this.partial) {
+ this.debug('match', f, this.pattern)
+ // short-circuit in the case of busted things.
+ // comments, etc.
+ if (this.comment) return false
+ if (this.empty) return f === ''
+
+ if (f === '/' && partial) return true
+
+ const options = this.options
+
+ // windows: need to use /, not \
+ if (path.sep !== '/') {
+ f = f.split(path.sep).join('/')
+ }
+
+ // treat the test path as a set of pathparts.
+ f = f.split(slashSplit)
+ this.debug(this.pattern, 'split', f)
+
+ // just ONE of the pattern sets in this.set needs to match
+ // in order for it to be valid. If negating, then just one
+ // match means that we have failed.
+ // Either way, return on the first hit.
+
+ const set = this.set
+ this.debug(this.pattern, 'set', set)
+
+ // Find the basename of the path by looking for the last non-empty segment
+ let filename
+ for (let i = f.length - 1; i >= 0; i--) {
+ filename = f[i]
+ if (filename) break
+ }
+
+ for (let i = 0; i < set.length; i++) {
+ const pattern = set[i]
+ let file = f
+ if (options.matchBase && pattern.length === 1) {
+ file = [filename]
+ }
+ const hit = this.matchOne(file, pattern, partial)
+ if (hit) {
+ if (options.flipNegate) return true
+ return !this.negate
+ }
+ }
+
+ // didn't get any hits. this is success if it's a negative
+ // pattern, failure otherwise.
+ if (options.flipNegate) return false
+ return this.negate
+ }
+
+ static defaults (def) {
+ return minimatch.defaults(def).Minimatch
+ }
+}
+
+minimatch.Minimatch = Minimatch
diff --git a/deps/npm/node_modules/mute-stream/mute.js b/deps/npm/node_modules/mute-stream/mute.js
new file mode 100644
index 00000000000000..a24fc09975bb32
--- /dev/null
+++ b/deps/npm/node_modules/mute-stream/mute.js
@@ -0,0 +1,145 @@
+var Stream = require('stream')
+
+module.exports = MuteStream
+
+// var out = new MuteStream(process.stdout)
+// argument auto-pipes
+function MuteStream (opts) {
+ Stream.apply(this)
+ opts = opts || {}
+ this.writable = this.readable = true
+ this.muted = false
+ this.on('pipe', this._onpipe)
+ this.replace = opts.replace
+
+ // For readline-type situations
+ // This much at the start of a line being redrawn after a ctrl char
+ // is seen (such as backspace) won't be redrawn as the replacement
+ this._prompt = opts.prompt || null
+ this._hadControl = false
+}
+
+MuteStream.prototype = Object.create(Stream.prototype)
+
+Object.defineProperty(MuteStream.prototype, 'constructor', {
+ value: MuteStream,
+ enumerable: false
+})
+
+MuteStream.prototype.mute = function () {
+ this.muted = true
+}
+
+MuteStream.prototype.unmute = function () {
+ this.muted = false
+}
+
+Object.defineProperty(MuteStream.prototype, '_onpipe', {
+ value: onPipe,
+ enumerable: false,
+ writable: true,
+ configurable: true
+})
+
+function onPipe (src) {
+ this._src = src
+}
+
+Object.defineProperty(MuteStream.prototype, 'isTTY', {
+ get: getIsTTY,
+ set: setIsTTY,
+ enumerable: true,
+ configurable: true
+})
+
+function getIsTTY () {
+ return( (this._dest) ? this._dest.isTTY
+ : (this._src) ? this._src.isTTY
+ : false
+ )
+}
+
+// basically just get replace the getter/setter with a regular value
+function setIsTTY (isTTY) {
+ Object.defineProperty(this, 'isTTY', {
+ value: isTTY,
+ enumerable: true,
+ writable: true,
+ configurable: true
+ })
+}
+
+Object.defineProperty(MuteStream.prototype, 'rows', {
+ get: function () {
+ return( this._dest ? this._dest.rows
+ : this._src ? this._src.rows
+ : undefined )
+ }, enumerable: true, configurable: true })
+
+Object.defineProperty(MuteStream.prototype, 'columns', {
+ get: function () {
+ return( this._dest ? this._dest.columns
+ : this._src ? this._src.columns
+ : undefined )
+ }, enumerable: true, configurable: true })
+
+
+MuteStream.prototype.pipe = function (dest, options) {
+ this._dest = dest
+ return Stream.prototype.pipe.call(this, dest, options)
+}
+
+MuteStream.prototype.pause = function () {
+ if (this._src) return this._src.pause()
+}
+
+MuteStream.prototype.resume = function () {
+ if (this._src) return this._src.resume()
+}
+
+MuteStream.prototype.write = function (c) {
+ if (this.muted) {
+ if (!this.replace) return true
+ if (c.match(/^\u001b/)) {
+ if(c.indexOf(this._prompt) === 0) {
+ c = c.substr(this._prompt.length);
+ c = c.replace(/./g, this.replace);
+ c = this._prompt + c;
+ }
+ this._hadControl = true
+ return this.emit('data', c)
+ } else {
+ if (this._prompt && this._hadControl &&
+ c.indexOf(this._prompt) === 0) {
+ this._hadControl = false
+ this.emit('data', this._prompt)
+ c = c.substr(this._prompt.length)
+ }
+ c = c.toString().replace(/./g, this.replace)
+ }
+ }
+ this.emit('data', c)
+}
+
+MuteStream.prototype.end = function (c) {
+ if (this.muted) {
+ if (c && this.replace) {
+ c = c.toString().replace(/./g, this.replace)
+ } else {
+ c = null
+ }
+ }
+ if (c) this.emit('data', c)
+ this.emit('end')
+}
+
+function proxy (fn) { return function () {
+ var d = this._dest
+ var s = this._src
+ if (d && d[fn]) d[fn].apply(d, arguments)
+ if (s && s[fn]) s[fn].apply(s, arguments)
+}}
+
+MuteStream.prototype.destroy = proxy('destroy')
+MuteStream.prototype.destroySoon = proxy('destroySoon')
+MuteStream.prototype.close = proxy('close')
diff --git a/deps/npm/node_modules/node-gyp/node_modules/@npmcli/move-file/LICENSE.md b/deps/npm/node_modules/node-gyp/node_modules/@npmcli/move-file/LICENSE.md
new file mode 100644
index 00000000000000..072bf20840acd6
--- /dev/null
+++ b/deps/npm/node_modules/node-gyp/node_modules/@npmcli/move-file/LICENSE.md
@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) Sindre Sorhus (https://sindresorhus.com)
+Copyright (c) npm, 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.
diff --git a/deps/npm/node_modules/node-gyp/node_modules/@npmcli/move-file/lib/index.js b/deps/npm/node_modules/node-gyp/node_modules/@npmcli/move-file/lib/index.js
new file mode 100644
index 00000000000000..5789bb127e0966
--- /dev/null
+++ b/deps/npm/node_modules/node-gyp/node_modules/@npmcli/move-file/lib/index.js
@@ -0,0 +1,185 @@
+const { dirname, join, resolve, relative, isAbsolute } = require('path')
+const rimraf_ = require('rimraf')
+const { promisify } = require('util')
+const {
+ access: access_,
+ accessSync,
+ copyFile: copyFile_,
+ copyFileSync,
+ readdir: readdir_,
+ readdirSync,
+ rename: rename_,
+ renameSync,
+ stat: stat_,
+ statSync,
+ lstat: lstat_,
+ lstatSync,
+ symlink: symlink_,
+ symlinkSync,
+ readlink: readlink_,
+ readlinkSync,
+} = require('fs')
+
+const access = promisify(access_)
+const copyFile = promisify(copyFile_)
+const readdir = promisify(readdir_)
+const rename = promisify(rename_)
+const stat = promisify(stat_)
+const lstat = promisify(lstat_)
+const symlink = promisify(symlink_)
+const readlink = promisify(readlink_)
+const rimraf = promisify(rimraf_)
+const rimrafSync = rimraf_.sync
+
+const mkdirp = require('mkdirp')
+
+const pathExists = async path => {
+ try {
+ await access(path)
+ return true
+ } catch (er) {
+ return er.code !== 'ENOENT'
+ }
+}
+
+const pathExistsSync = path => {
+ try {
+ accessSync(path)
+ return true
+ } catch (er) {
+ return er.code !== 'ENOENT'
+ }
+}
+
+const moveFile = async (source, destination, options = {}, root = true, symlinks = []) => {
+ if (!source || !destination) {
+ throw new TypeError('`source` and `destination` file required')
+ }
+
+ options = {
+ overwrite: true,
+ ...options,
+ }
+
+ if (!options.overwrite && await pathExists(destination)) {
+ throw new Error(`The destination file exists: ${destination}`)
+ }
+
+ await mkdirp(dirname(destination))
+
+ try {
+ await rename(source, destination)
+ } catch (error) {
+ if (error.code === 'EXDEV' || error.code === 'EPERM') {
+ const sourceStat = await lstat(source)
+ if (sourceStat.isDirectory()) {
+ const files = await readdir(source)
+ await Promise.all(files.map((file) =>
+ moveFile(join(source, file), join(destination, file), options, false, symlinks)
+ ))
+ } else if (sourceStat.isSymbolicLink()) {
+ symlinks.push({ source, destination })
+ } else {
+ await copyFile(source, destination)
+ }
+ } else {
+ throw error
+ }
+ }
+
+ if (root) {
+ await Promise.all(symlinks.map(async ({ source: symSource, destination: symDestination }) => {
+ let target = await readlink(symSource)
+ // junction symlinks in windows will be absolute paths, so we need to
+ // make sure they point to the symlink destination
+ if (isAbsolute(target)) {
+ target = resolve(symDestination, relative(symSource, target))
+ }
+ // try to determine what the actual file is so we can create the correct
+ // type of symlink in windows
+ let targetStat = 'file'
+ try {
+ targetStat = await stat(resolve(dirname(symSource), target))
+ if (targetStat.isDirectory()) {
+ targetStat = 'junction'
+ }
+ } catch {
+ // targetStat remains 'file'
+ }
+ await symlink(
+ target,
+ symDestination,
+ targetStat
+ )
+ }))
+ await rimraf(source)
+ }
+}
+
+const moveFileSync = (source, destination, options = {}, root = true, symlinks = []) => {
+ if (!source || !destination) {
+ throw new TypeError('`source` and `destination` file required')
+ }
+
+ options = {
+ overwrite: true,
+ ...options,
+ }
+
+ if (!options.overwrite && pathExistsSync(destination)) {
+ throw new Error(`The destination file exists: ${destination}`)
+ }
+
+ mkdirp.sync(dirname(destination))
+
+ try {
+ renameSync(source, destination)
+ } catch (error) {
+ if (error.code === 'EXDEV' || error.code === 'EPERM') {
+ const sourceStat = lstatSync(source)
+ if (sourceStat.isDirectory()) {
+ const files = readdirSync(source)
+ for (const file of files) {
+ moveFileSync(join(source, file), join(destination, file), options, false, symlinks)
+ }
+ } else if (sourceStat.isSymbolicLink()) {
+ symlinks.push({ source, destination })
+ } else {
+ copyFileSync(source, destination)
+ }
+ } else {
+ throw error
+ }
+ }
+
+ if (root) {
+ for (const { source: symSource, destination: symDestination } of symlinks) {
+ let target = readlinkSync(symSource)
+ // junction symlinks in windows will be absolute paths, so we need to
+ // make sure they point to the symlink destination
+ if (isAbsolute(target)) {
+ target = resolve(symDestination, relative(symSource, target))
+ }
+ // try to determine what the actual file is so we can create the correct
+ // type of symlink in windows
+ let targetStat = 'file'
+ try {
+ targetStat = statSync(resolve(dirname(symSource), target))
+ if (targetStat.isDirectory()) {
+ targetStat = 'junction'
+ }
+ } catch {
+ // targetStat remains 'file'
+ }
+ symlinkSync(
+ target,
+ symDestination,
+ targetStat
+ )
+ }
+ rimrafSync(source)
+ }
+}
+
+module.exports = moveFile
+module.exports.sync = moveFileSync
diff --git a/deps/npm/node_modules/node-gyp/node_modules/@npmcli/move-file/package.json b/deps/npm/node_modules/node-gyp/node_modules/@npmcli/move-file/package.json
new file mode 100644
index 00000000000000..58793b93a9ca0f
--- /dev/null
+++ b/deps/npm/node_modules/node-gyp/node_modules/@npmcli/move-file/package.json
@@ -0,0 +1,47 @@
+{
+ "name": "@npmcli/move-file",
+ "version": "2.0.1",
+ "files": [
+ "bin/",
+ "lib/"
+ ],
+ "main": "lib/index.js",
+ "description": "move a file (fork of move-file)",
+ "dependencies": {
+ "mkdirp": "^1.0.4",
+ "rimraf": "^3.0.2"
+ },
+ "devDependencies": {
+ "@npmcli/eslint-config": "^3.0.1",
+ "@npmcli/template-oss": "3.5.0",
+ "tap": "^16.0.1"
+ },
+ "scripts": {
+ "test": "tap",
+ "snap": "tap",
+ "preversion": "npm test",
+ "postversion": "npm publish",
+ "prepublishOnly": "git push origin --follow-tags",
+ "lint": "eslint \"**/*.js\"",
+ "postlint": "template-oss-check",
+ "template-oss-apply": "template-oss-apply --force",
+ "lintfix": "npm run lint -- --fix",
+ "posttest": "npm run lint"
+ },
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/npm/move-file.git"
+ },
+ "tap": {
+ "check-coverage": true
+ },
+ "license": "MIT",
+ "engines": {
+ "node": "^12.13.0 || ^14.15.0 || >=16.0.0"
+ },
+ "author": "GitHub Inc.",
+ "templateOSS": {
+ "//@npmcli/template-oss": "This file is partially managed by @npmcli/template-oss. Edits may be overwritten.",
+ "version": "3.5.0"
+ }
+}
diff --git a/deps/npm/node_modules/npm-user-validate/npm-user-validate.js b/deps/npm/node_modules/npm-user-validate/npm-user-validate.js
new file mode 100644
index 00000000000000..ffd8791c7eb95d
--- /dev/null
+++ b/deps/npm/node_modules/npm-user-validate/npm-user-validate.js
@@ -0,0 +1,61 @@
+exports.email = email
+exports.pw = pw
+exports.username = username
+var requirements = exports.requirements = {
+ username: {
+ length: 'Name length must be less than or equal to 214 characters long',
+ lowerCase: 'Name must be lowercase',
+ urlSafe: 'Name may not contain non-url-safe chars',
+ dot: 'Name may not start with "."',
+ illegal: 'Name may not contain illegal character'
+ },
+ password: {},
+ email: {
+ length: 'Email length must be less then or equal to 254 characters long',
+ valid: 'Email must be an email address'
+ }
+}
+
+var illegalCharacterRe = new RegExp('([' + [
+ "'"
+].join() + '])')
+
+function username (un) {
+ if (un !== un.toLowerCase()) {
+ return new Error(requirements.username.lowerCase)
+ }
+
+ if (un !== encodeURIComponent(un)) {
+ return new Error(requirements.username.urlSafe)
+ }
+
+ if (un.charAt(0) === '.') {
+ return new Error(requirements.username.dot)
+ }
+
+ if (un.length > 214) {
+ return new Error(requirements.username.length)
+ }
+
+ var illegal = un.match(illegalCharacterRe)
+ if (illegal) {
+ return new Error(requirements.username.illegal + ' "' + illegal[0] + '"')
+ }
+
+ return null
+}
+
+function email (em) {
+ if (em.length > 254) {
+ return new Error(requirements.email.length)
+ }
+ if (!em.match(/^[^@]+@.+\..+$/)) {
+ return new Error(requirements.email.valid)
+ }
+
+ return null
+}
+
+function pw (pw) {
+ return null
+}
diff --git a/deps/npm/node_modules/promzard/example/buffer.js b/deps/npm/node_modules/promzard/example/buffer.js
new file mode 100644
index 00000000000000..828f9d1df9da2f
--- /dev/null
+++ b/deps/npm/node_modules/promzard/example/buffer.js
@@ -0,0 +1,12 @@
+var pz = require('../promzard')
+
+var path = require('path')
+var file = path.resolve(__dirname, 'substack-input.js')
+var buf = require('fs').readFileSync(file)
+var ctx = { basename: path.basename(path.dirname(file)) }
+
+pz.fromBuffer(buf, ctx, function (er, res) {
+ if (er)
+ throw er
+ console.error(JSON.stringify(res, null, 2))
+})
diff --git a/deps/npm/node_modules/promzard/example/index.js b/deps/npm/node_modules/promzard/example/index.js
new file mode 100644
index 00000000000000..435131f3a6d1e2
--- /dev/null
+++ b/deps/npm/node_modules/promzard/example/index.js
@@ -0,0 +1,11 @@
+var pz = require('../promzard')
+
+var path = require('path')
+var file = path.resolve(__dirname, 'substack-input.js')
+var ctx = { basename: path.basename(path.dirname(file)) }
+
+pz(file, ctx, function (er, res) {
+ if (er)
+ throw er
+ console.error(JSON.stringify(res, null, 2))
+})
diff --git a/deps/npm/node_modules/promzard/example/npm-init/init-input.js b/deps/npm/node_modules/promzard/example/npm-init/init-input.js
new file mode 100644
index 00000000000000..ba7781b3539e4d
--- /dev/null
+++ b/deps/npm/node_modules/promzard/example/npm-init/init-input.js
@@ -0,0 +1,191 @@
+var fs = require('fs')
+var path = require('path');
+
+module.exports = {
+ "name" : prompt('name',
+ typeof name === 'undefined'
+ ? basename.replace(/^node-|[.-]js$/g, ''): name),
+ "version" : prompt('version', typeof version !== "undefined"
+ ? version : '0.0.0'),
+ "description" : (function () {
+ if (typeof description !== 'undefined' && description) {
+ return description
+ }
+ var value;
+ try {
+ var src = fs.readFileSync('README.md', 'utf8');
+ value = src.split('\n').filter(function (line) {
+ return /\s+/.test(line)
+ && line.trim() !== basename.replace(/^node-/, '')
+ && !line.trim().match(/^#/)
+ ;
+ })[0]
+ .trim()
+ .replace(/^./, function (c) { return c.toLowerCase() })
+ .replace(/\.$/, '')
+ ;
+ }
+ catch (e) {
+ try {
+ // Wouldn't it be nice if that file mattered?
+ var d = fs.readFileSync('.git/description', 'utf8')
+ } catch (e) {}
+ if (d.trim() && !value) value = d
+ }
+ return prompt('description', value);
+ })(),
+ "main" : (function () {
+ var f
+ try {
+ f = fs.readdirSync(dirname).filter(function (f) {
+ return f.match(/\.js$/)
+ })
+ if (f.indexOf('index.js') !== -1)
+ f = 'index.js'
+ else if (f.indexOf('main.js') !== -1)
+ f = 'main.js'
+ else if (f.indexOf(basename + '.js') !== -1)
+ f = basename + '.js'
+ else
+ f = f[0]
+ } catch (e) {}
+
+ return prompt('entry point', f || 'index.js')
+ })(),
+ "bin" : function (cb) {
+ fs.readdir(dirname + '/bin', function (er, d) {
+ // no bins
+ if (er) return cb()
+ // just take the first js file we find there, or nada
+ return cb(null, d.filter(function (f) {
+ return f.match(/\.js$/)
+ })[0])
+ })
+ },
+ "directories" : function (cb) {
+ fs.readdir('.', function (er, dirs) {
+ if (er) return cb(er)
+ var res = {}
+ dirs.forEach(function (d) {
+ switch (d) {
+ case 'example': case 'examples': return res.example = d
+ case 'test': case 'tests': return res.test = d
+ case 'doc': case 'docs': return res.doc = d
+ case 'man': return res.man = d
+ }
+ })
+ if (Object.keys(res).length === 0) res = undefined
+ return cb(null, res)
+ })
+ },
+ "dependencies" : typeof dependencies !== 'undefined' ? dependencies
+ : function (cb) {
+ fs.readdir('node_modules', function (er, dir) {
+ if (er) return cb()
+ var deps = {}
+ var n = dir.length
+ dir.forEach(function (d) {
+ if (d.match(/^\./)) return next()
+ if (d.match(/^(expresso|mocha|tap|coffee-script|coco|streamline)$/))
+ return next()
+ fs.readFile('node_modules/' + d + '/package.json', function (er, p) {
+ if (er) return next()
+ try { p = JSON.parse(p) } catch (e) { return next() }
+ if (!p.version) return next()
+ deps[d] = '~' + p.version
+ return next()
+ })
+ })
+ function next () {
+ if (--n === 0) return cb(null, deps)
+ }
+ })
+ },
+ "devDependencies" : typeof devDependencies !== 'undefined' ? devDependencies
+ : function (cb) {
+ // same as dependencies but for dev deps
+ fs.readdir('node_modules', function (er, dir) {
+ if (er) return cb()
+ var deps = {}
+ var n = dir.length
+ dir.forEach(function (d) {
+ if (d.match(/^\./)) return next()
+ if (!d.match(/^(expresso|mocha|tap|coffee-script|coco|streamline)$/))
+ return next()
+ fs.readFile('node_modules/' + d + '/package.json', function (er, p) {
+ if (er) return next()
+ try { p = JSON.parse(p) } catch (e) { return next() }
+ if (!p.version) return next()
+ deps[d] = '~' + p.version
+ return next()
+ })
+ })
+ function next () {
+ if (--n === 0) return cb(null, deps)
+ }
+ })
+ },
+ "scripts" : (function () {
+ // check to see what framework is in use, if any
+ try { var d = fs.readdirSync('node_modules') }
+ catch (e) { d = [] }
+ var s = typeof scripts === 'undefined' ? {} : scripts
+
+ if (d.indexOf('coffee-script') !== -1)
+ s.prepublish = prompt('build command',
+ s.prepublish || 'coffee src/*.coffee -o lib')
+
+ var notest = 'echo "Error: no test specified" && exit 1'
+ function tx (test) {
+ return test || notest
+ }
+
+ if (!s.test || s.test === notest) {
+ if (d.indexOf('tap') !== -1)
+ s.test = prompt('test command', 'tap test/*.js', tx)
+ else if (d.indexOf('expresso') !== -1)
+ s.test = prompt('test command', 'expresso test', tx)
+ else if (d.indexOf('mocha') !== -1)
+ s.test = prompt('test command', 'mocha', tx)
+ else
+ s.test = prompt('test command', tx)
+ }
+
+ return s
+
+ })(),
+
+ "repository" : (function () {
+ try { var gconf = fs.readFileSync('.git/config') }
+ catch (e) { gconf = null }
+ if (gconf) {
+ gconf = gconf.split(/\r?\n/)
+ var i = gconf.indexOf('[remote "origin"]')
+ if (i !== -1) {
+ var u = gconf[i + 1]
+ if (!u.match(/^\s*url =/)) u = gconf[i + 2]
+ if (!u.match(/^\s*url =/)) u = null
+ else u = u.replace(/^\s*url = /, '')
+ }
+ if (u && u.match(/^git@github.com:/))
+ u = u.replace(/^git@github.com:/, 'git://github.com/')
+ }
+
+ return prompt('git repository', u)
+ })(),
+
+ "keywords" : prompt(function (s) {
+ if (!s) return undefined
+ if (Array.isArray(s)) s = s.join(' ')
+ if (typeof s !== 'string') return s
+ return s.split(/[\s,]+/)
+ }),
+ "author" : config['init.author.name']
+ ? {
+ "name" : config['init.author.name'],
+ "email" : config['init.author.email'],
+ "url" : config['init.author.url']
+ }
+ : undefined,
+ "license" : prompt('license', 'BSD')
+}
diff --git a/deps/npm/node_modules/promzard/example/npm-init/init.js b/deps/npm/node_modules/promzard/example/npm-init/init.js
new file mode 100644
index 00000000000000..09484cd1c19911
--- /dev/null
+++ b/deps/npm/node_modules/promzard/example/npm-init/init.js
@@ -0,0 +1,37 @@
+var PZ = require('../../promzard').PromZard
+var path = require('path')
+var input = path.resolve(__dirname, 'init-input.js')
+
+var fs = require('fs')
+var package = path.resolve(__dirname, 'package.json')
+var pkg
+
+fs.readFile(package, 'utf8', function (er, d) {
+ if (er) ctx = {}
+ try { ctx = JSON.parse(d); pkg = JSON.parse(d) }
+ catch (e) { ctx = {} }
+
+ ctx.dirname = path.dirname(package)
+ ctx.basename = path.basename(ctx.dirname)
+ if (!ctx.version) ctx.version = undefined
+
+ // this should be replaced with the npm conf object
+ ctx.config = {}
+
+ console.error('ctx=', ctx)
+
+ var pz = new PZ(input, ctx)
+
+ pz.on('data', function (data) {
+ console.error('pz data', data)
+ if (!pkg) pkg = {}
+ Object.keys(data).forEach(function (k) {
+ if (data[k] !== undefined && data[k] !== null) pkg[k] = data[k]
+ })
+ console.error('package data %s', JSON.stringify(data, null, 2))
+ fs.writeFile(package, JSON.stringify(pkg, null, 2), function (er) {
+ if (er) throw er
+ console.log('ok')
+ })
+ })
+})
diff --git a/deps/npm/node_modules/promzard/example/npm-init/package.json b/deps/npm/node_modules/promzard/example/npm-init/package.json
new file mode 100644
index 00000000000000..89c6d1fb6e2acf
--- /dev/null
+++ b/deps/npm/node_modules/promzard/example/npm-init/package.json
@@ -0,0 +1,10 @@
+{
+ "name": "npm-init",
+ "version": "0.0.0",
+ "description": "an initter you init wit, innit?",
+ "main": "index.js",
+ "scripts": {
+ "test": "asdf"
+ },
+ "license": "BSD"
+}
\ No newline at end of file
diff --git a/deps/npm/node_modules/promzard/example/substack-input.js b/deps/npm/node_modules/promzard/example/substack-input.js
new file mode 100644
index 00000000000000..bf7aedb82d41fd
--- /dev/null
+++ b/deps/npm/node_modules/promzard/example/substack-input.js
@@ -0,0 +1,61 @@
+module.exports = {
+ "name" : basename.replace(/^node-/, ''),
+ "version" : "0.0.0",
+ "description" : (function (cb) {
+ var fs = require('fs');
+ var value;
+ try {
+ var src = fs.readFileSync('README.markdown', 'utf8');
+ value = src.split('\n').filter(function (line) {
+ return /\s+/.test(line)
+ && line.trim() !== basename.replace(/^node-/, '')
+ ;
+ })[0]
+ .trim()
+ .replace(/^./, function (c) { return c.toLowerCase() })
+ .replace(/\.$/, '')
+ ;
+ }
+ catch (e) {}
+
+ return prompt('description', value);
+ })(),
+ "main" : prompt('entry point', 'index.js'),
+ "bin" : function (cb) {
+ var path = require('path');
+ var fs = require('fs');
+ var exists = fs.exists || path.exists;
+ exists('bin/cmd.js', function (ex) {
+ var bin
+ if (ex) {
+ var bin = {}
+ bin[basename.replace(/^node-/, '')] = 'bin/cmd.js'
+ }
+ cb(null, bin);
+ });
+ },
+ "directories" : {
+ "example" : "example",
+ "test" : "test"
+ },
+ "dependencies" : {},
+ "devDependencies" : {
+ "tap" : "~0.2.5"
+ },
+ "scripts" : {
+ "test" : "tap test/*.js"
+ },
+ "repository" : {
+ "type" : "git",
+ "url" : "git://github.com/substack/" + basename + ".git"
+ },
+ "homepage" : "https://github.com/substack/" + basename,
+ "keywords" : prompt(function (s) { return s.split(/\s+/) }),
+ "author" : {
+ "name" : "James Halliday",
+ "email" : "mail@substack.net",
+ "url" : "http://substack.net"
+ },
+ "license" : "MIT",
+ "engine" : { "node" : ">=0.6" }
+}
diff --git a/deps/npm/node_modules/promzard/promzard.js b/deps/npm/node_modules/promzard/promzard.js
new file mode 100644
index 00000000000000..da1abca9535e4f
--- /dev/null
+++ b/deps/npm/node_modules/promzard/promzard.js
@@ -0,0 +1,238 @@
+module.exports = promzard
+promzard.PromZard = PromZard
+
+var fs = require('fs')
+var vm = require('vm')
+var util = require('util')
+var files = {}
+var crypto = require('crypto')
+var EventEmitter = require('events').EventEmitter
+var read = require('read')
+
+var Module = require('module').Module
+var path = require('path')
+
+function promzard (file, ctx, cb) {
+ if (typeof ctx === 'function') cb = ctx, ctx = null;
+ if (!ctx) ctx = {};
+ var pz = new PromZard(file, ctx)
+ pz.on('error', cb)
+ pz.on('data', function (data) {
+ cb(null, data)
+ })
+}
+promzard.fromBuffer = function (buf, ctx, cb) {
+ var filename = 0
+ do {
+ filename = '\0' + Math.random();
+ } while (files[filename])
+ files[filename] = buf
+ var ret = promzard(filename, ctx, cb)
+ delete files[filename]
+ return ret
+}
+
+function PromZard (file, ctx) {
+ if (!(this instanceof PromZard))
+ return new PromZard(file, ctx)
+ EventEmitter.call(this)
+ this.file = file
+ this.ctx = ctx
+ this.unique = crypto.randomBytes(8).toString('hex')
+ this.load()
+}
+
+PromZard.prototype = Object.create(
+ EventEmitter.prototype,
+ { constructor: {
+ value: PromZard,
+ readable: true,
+ configurable: true,
+ writable: true,
+ enumerable: false } } )
+
+PromZard.prototype.load = function () {
+ if (files[this.file])
+ return this.loaded()
+
+ fs.readFile(this.file, 'utf8', function (er, d) {
+ if (er && this.backupFile) {
+ this.file = this.backupFile
+ delete this.backupFile
+ return this.load()
+ }
+ if (er)
+ return this.emit('error', this.error = er)
+ files[this.file] = d
+ this.loaded()
+ }.bind(this))
+}
+
+PromZard.prototype.loaded = function () {
+ this.ctx.prompt = this.makePrompt()
+ this.ctx.__filename = this.file
+ this.ctx.__dirname = path.dirname(this.file)
+ this.ctx.__basename = path.basename(this.file)
+ var mod = this.ctx.module = this.makeModule()
+ this.ctx.require = function (path) {
+ return mod.require(path)
+ }
+ this.ctx.require.resolve = function(path) {
+ return Module._resolveFilename(path, mod);
+ }
+ this.ctx.exports = mod.exports
+
+ this.script = this.wrap(files[this.file])
+ var fn = vm.runInThisContext(this.script, this.file)
+ var args = Object.keys(this.ctx).map(function (k) {
+ return this.ctx[k]
+ }.bind(this))
+ try { var res = fn.apply(this.ctx, args) }
+ catch (er) { this.emit('error', er) }
+ if (res &&
+ typeof res === 'object' &&
+ exports === mod.exports &&
+ Object.keys(exports).length === 1) {
+ this.result = res
+ } else {
+ this.result = mod.exports
+ }
+ this.walk()
+}
+
+PromZard.prototype.makeModule = function () {
+ var mod = new Module(this.file, module)
+ mod.loaded = true
+ mod.filename = this.file
+ mod.id = this.file
+ mod.paths = Module._nodeModulePaths(path.dirname(this.file))
+ return mod
+}
+
+PromZard.prototype.wrap = function (body) {
+ var s = '(function( %s ) { %s\n })'
+ var args = Object.keys(this.ctx).join(', ')
+ return util.format(s, args, body)
+}
+
+PromZard.prototype.makePrompt = function () {
+ this.prompts = []
+ return prompt.bind(this)
+ function prompt () {
+ var p, d, t
+ for (var i = 0; i < arguments.length; i++) {
+ var a = arguments[i]
+ if (typeof a === 'string' && p)
+ d = a
+ else if (typeof a === 'string')
+ p = a
+ else if (typeof a === 'function')
+ t = a
+ else if (a && typeof a === 'object') {
+ p = a.prompt || p
+ d = a.default || d
+ t = a.transform || t
+ }
+ }
+
+ try { return this.unique + '-' + this.prompts.length }
+ finally { this.prompts.push([p, d, t]) }
+ }
+}
+
+PromZard.prototype.walk = function (o, cb) {
+ o = o || this.result
+ cb = cb || function (er, res) {
+ if (er)
+ return this.emit('error', this.error = er)
+ this.result = res
+ return this.emit('data', res)
+ }
+ cb = cb.bind(this)
+ var keys = Object.keys(o)
+ var i = 0
+ var len = keys.length
+
+ L.call(this)
+ function L () {
+ if (this.error)
+ return
+ while (i < len) {
+ var k = keys[i]
+ var v = o[k]
+ i++
+
+ if (v && typeof v === 'object') {
+ return this.walk(v, function (er, res) {
+ if (er) return cb(er)
+ o[k] = res
+ L.call(this)
+ }.bind(this))
+ } else if (v &&
+ typeof v === 'string' &&
+ v.indexOf(this.unique) === 0) {
+ var n = +v.substr(this.unique.length + 1)
+ var prompt = this.prompts[n]
+ if (isNaN(n) || !prompt)
+ continue
+
+ // default to the key
+ if (undefined === prompt[0])
+ prompt[0] = k
+
+ // default to the ctx value, if there is one
+ if (undefined === prompt[1])
+ prompt[1] = this.ctx[k]
+
+ return this.prompt(prompt, function (er, res) {
+ if (er) {
+ if (!er.notValid) {
+ return this.emit('error', this.error = er);
+ }
+ console.log(er.message)
+ i --
+ return L.call(this)
+ }
+ o[k] = res
+ L.call(this)
+ }.bind(this))
+ } else if (typeof v === 'function') {
+ try { return v.call(this.ctx, function (er, res) {
+ if (er)
+ return this.emit('error', this.error = er)
+ o[k] = res
+ // back up so that we process this one again.
+ // this is because it might return a prompt() call in the cb.
+ i --
+ L.call(this)
+ }.bind(this)) }
+ catch (er) { this.emit('error', er) }
+ }
+ }
+ // made it to the end of the loop, maybe
+ if (i >= len)
+ return cb(null, o)
+ }
+}
+
+PromZard.prototype.prompt = function (pdt, cb) {
+ var prompt = pdt[0]
+ var def = pdt[1]
+ var tx = pdt[2]
+
+ if (tx) {
+ cb = function (cb) { return function (er, data) {
+ try {
+ var res = tx(data)
+ if (!er && res instanceof Error && !!res.notValid) {
+ return cb(res, null)
+ }
+ return cb(er, res)
+ }
+ catch (er) { this.emit('error', er) }
+ }}(cb).bind(this)
+ }
+
+ read({ prompt: prompt + ':' , default: def }, cb)
+}
+
diff --git a/deps/npm/node_modules/promzard/test/basic.js b/deps/npm/node_modules/promzard/test/basic.js
new file mode 100644
index 00000000000000..ad1c92df9c4c05
--- /dev/null
+++ b/deps/npm/node_modules/promzard/test/basic.js
@@ -0,0 +1,91 @@
+var tap = require('tap')
+var pz = require('../promzard.js')
+var spawn = require('child_process').spawn
+
+tap.test('run the example', function (t) {
+
+ var example = require.resolve('../example/index.js')
+ var node = process.execPath
+
+ var expect = {
+ "name": "example",
+ "version": "0.0.0",
+ "description": "testing description",
+ "main": "test-entry.js",
+ "directories": {
+ "example": "example",
+ "test": "test"
+ },
+ "dependencies": {},
+ "devDependencies": {
+ "tap": "~0.2.5"
+ },
+ "scripts": {
+ "test": "tap test/*.js"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/substack/example.git"
+ },
+ "homepage": "https://github.com/substack/example",
+ "keywords": [
+ "fugazi",
+ "function",
+ "waiting",
+ "room"
+ ],
+ "author": {
+ "name": "James Halliday",
+ "email": "mail@substack.net",
+ "url": "http://substack.net"
+ },
+ "license": "MIT",
+ "engine": {
+ "node": ">=0.6"
+ }
+ }
+
+ console.error('%s %s', node, example)
+ var c = spawn(node, [example], { customFds: [-1,-1,-1] })
+ var output = ''
+ c.stdout.on('data', function (d) {
+ output += d
+ respond()
+ })
+
+ var actual = ''
+ c.stderr.on('data', function (d) {
+ actual += d
+ })
+
+ function respond () {
+ console.error('respond', output)
+ if (output.match(/description: $/)) {
+ c.stdin.write('testing description\n')
+ return
+ }
+ if (output.match(/entry point: \(index\.js\) $/)) {
+ c.stdin.write('test-entry.js\n')
+ return
+ }
+ if (output.match(/keywords: $/)) {
+ c.stdin.write('fugazi function waiting room\n')
+ // "read" module is weird on node >= 0.10 when not a TTY
+ // requires explicit ending for reasons.
+ // could dig in, but really just wanna make tests pass, whatever.
+ c.stdin.end()
+ return
+ }
+ }
+
+ c.on('exit', function () {
+ console.error('exit event')
+ })
+
+ c.on('close', function () {
+ console.error('actual', actual)
+ actual = JSON.parse(actual)
+ t.deepEqual(actual, expect)
+ t.end()
+ })
+})
diff --git a/deps/npm/node_modules/promzard/test/buffer.js b/deps/npm/node_modules/promzard/test/buffer.js
new file mode 100644
index 00000000000000..e1d240e2e4f480
--- /dev/null
+++ b/deps/npm/node_modules/promzard/test/buffer.js
@@ -0,0 +1,84 @@
+var tap = require('tap')
+var pz = require('../promzard.js')
+var spawn = require('child_process').spawn
+
+tap.test('run the example using a buffer', function (t) {
+
+ var example = require.resolve('../example/buffer.js')
+ var node = process.execPath
+
+ var expect = {
+ "name": "example",
+ "version": "0.0.0",
+ "description": "testing description",
+ "main": "test-entry.js",
+ "directories": {
+ "example": "example",
+ "test": "test"
+ },
+ "dependencies": {},
+ "devDependencies": {
+ "tap": "~0.2.5"
+ },
+ "scripts": {
+ "test": "tap test/*.js"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/substack/example.git"
+ },
+ "homepage": "https://github.com/substack/example",
+ "keywords": [
+ "fugazi",
+ "function",
+ "waiting",
+ "room"
+ ],
+ "author": {
+ "name": "James Halliday",
+ "email": "mail@substack.net",
+ "url": "http://substack.net"
+ },
+ "license": "MIT",
+ "engine": {
+ "node": ">=0.6"
+ }
+ }
+
+ var c = spawn(node, [example], { customFds: [-1,-1,-1] })
+ var output = ''
+ c.stdout.on('data', function (d) {
+ output += d
+ respond()
+ })
+
+ var actual = ''
+ c.stderr.on('data', function (d) {
+ actual += d
+ })
+
+ function respond () {
+ if (output.match(/description: $/)) {
+ c.stdin.write('testing description\n')
+ return
+ }
+ if (output.match(/entry point: \(index\.js\) $/)) {
+ c.stdin.write('test-entry.js\n')
+ return
+ }
+ if (output.match(/keywords: $/)) {
+ c.stdin.write('fugazi function waiting room\n')
+ // "read" module is weird on node >= 0.10 when not a TTY
+ // requires explicit ending for reasons.
+ // could dig in, but really just wanna make tests pass, whatever.
+ c.stdin.end()
+ return
+ }
+ }
+
+ c.on('close', function () {
+ actual = JSON.parse(actual)
+ t.deepEqual(actual, expect)
+ t.end()
+ })
+})
diff --git a/deps/npm/node_modules/promzard/test/exports.input b/deps/npm/node_modules/promzard/test/exports.input
new file mode 100644
index 00000000000000..061cbfe1055aa2
--- /dev/null
+++ b/deps/npm/node_modules/promzard/test/exports.input
@@ -0,0 +1,5 @@
+exports.a = 1 + 2
+exports.b = prompt('To be or not to be?', '!2b')
+exports.c = {}
+exports.c.x = prompt()
+exports.c.y = tmpdir + "/y/file.txt"
diff --git a/deps/npm/node_modules/promzard/test/exports.js b/deps/npm/node_modules/promzard/test/exports.js
new file mode 100644
index 00000000000000..c17993a4e9e754
--- /dev/null
+++ b/deps/npm/node_modules/promzard/test/exports.js
@@ -0,0 +1,48 @@
+var test = require('tap').test;
+var promzard = require('../');
+
+if (process.argv[2] === 'child') {
+ return child()
+}
+
+test('exports', function (t) {
+ t.plan(1);
+
+ var spawn = require('child_process').spawn
+ var child = spawn(process.execPath, [__filename, 'child'])
+
+ var output = ''
+ child.stderr.on('data', function (c) {
+ output += c
+ })
+
+ setTimeout(function () {
+ child.stdin.write('\n');
+ }, 100)
+ setTimeout(function () {
+ child.stdin.end('55\n');
+ }, 200)
+
+ child.on('close', function () {
+ console.error('output=%j', output)
+ output = JSON.parse(output)
+ t.same({
+ a : 3,
+ b : '!2b',
+ c : {
+ x : 55,
+ y : '/tmp/y/file.txt',
+ }
+ }, output);
+ t.end()
+ })
+});
+
+function child () {
+ var ctx = { tmpdir : '/tmp' }
+ var file = __dirname + '/exports.input';
+
+ promzard(file, ctx, function (err, output) {
+ console.error(JSON.stringify(output))
+ });
+}
diff --git a/deps/npm/node_modules/promzard/test/fn.input b/deps/npm/node_modules/promzard/test/fn.input
new file mode 100644
index 00000000000000..ed6c3f1c80c5b5
--- /dev/null
+++ b/deps/npm/node_modules/promzard/test/fn.input
@@ -0,0 +1,18 @@
+var fs = require('fs')
+
+module.exports = {
+ "a": 1 + 2,
+ "b": prompt('To be or not to be?', '!2b', function (s) {
+ return s.toUpperCase() + '...'
+ }),
+ "c": {
+ "x": prompt(function (x) { return x * 100 }),
+ "y": tmpdir + "/y/file.txt"
+ },
+ a_function: function (cb) {
+ fs.readFile(__filename, 'utf8', cb)
+ },
+ asyncPrompt: function (cb) {
+ return cb(null, prompt('a prompt at any other time would smell as sweet'))
+ }
+}
diff --git a/deps/npm/node_modules/promzard/test/fn.js b/deps/npm/node_modules/promzard/test/fn.js
new file mode 100644
index 00000000000000..899ebedbdd010c
--- /dev/null
+++ b/deps/npm/node_modules/promzard/test/fn.js
@@ -0,0 +1,56 @@
+var test = require('tap').test;
+var promzard = require('../');
+var fs = require('fs')
+var file = __dirname + '/fn.input';
+
+var expect = {
+ a : 3,
+ b : '!2B...',
+ c : {
+ x : 5500,
+ y : '/tmp/y/file.txt',
+ }
+}
+expect.a_function = fs.readFileSync(file, 'utf8')
+expect.asyncPrompt = 'async prompt'
+
+if (process.argv[2] === 'child') {
+ return child()
+}
+
+test('prompt callback param', function (t) {
+ t.plan(1);
+
+ var spawn = require('child_process').spawn
+ var child = spawn(process.execPath, [__filename, 'child'])
+
+ var output = ''
+ child.stderr.on('data', function (c) {
+ output += c
+ })
+
+ child.on('close', function () {
+ console.error('output=%j', output)
+ output = JSON.parse(output)
+ t.same(output, expect);
+ t.end()
+ })
+
+ setTimeout(function () {
+ child.stdin.write('\n')
+ }, 100)
+ setTimeout(function () {
+ child.stdin.write('55\n')
+ }, 150)
+ setTimeout(function () {
+ child.stdin.end('async prompt\n')
+ }, 200)
+})
+
+function child () {
+ var ctx = { tmpdir : '/tmp' }
+ var file = __dirname + '/fn.input';
+ promzard(file, ctx, function (err, output) {
+ console.error(JSON.stringify(output))
+ })
+}
diff --git a/deps/npm/node_modules/promzard/test/simple.input b/deps/npm/node_modules/promzard/test/simple.input
new file mode 100644
index 00000000000000..e49def6470d599
--- /dev/null
+++ b/deps/npm/node_modules/promzard/test/simple.input
@@ -0,0 +1,8 @@
+module.exports = {
+ "a": 1 + 2,
+ "b": prompt('To be or not to be?', '!2b'),
+ "c": {
+ "x": prompt(),
+ "y": tmpdir + "/y/file.txt"
+ }
+}
diff --git a/deps/npm/node_modules/promzard/test/simple.js b/deps/npm/node_modules/promzard/test/simple.js
new file mode 100644
index 00000000000000..034a86475afbd5
--- /dev/null
+++ b/deps/npm/node_modules/promzard/test/simple.js
@@ -0,0 +1,30 @@
+var test = require('tap').test;
+var promzard = require('../');
+
+test('simple', function (t) {
+ t.plan(1);
+
+ var ctx = { tmpdir : '/tmp' }
+ var file = __dirname + '/simple.input';
+ promzard(file, ctx, function (err, output) {
+ t.same(
+ {
+ a : 3,
+ b : '!2b',
+ c : {
+ x : 55,
+ y : '/tmp/y/file.txt',
+ }
+ },
+ output
+ );
+ });
+
+ setTimeout(function () {
+ process.stdin.emit('data', '\n');
+ }, 100);
+
+ setTimeout(function () {
+ process.stdin.emit('data', '55\n');
+ }, 200);
+});
diff --git a/deps/npm/node_modules/promzard/test/validate.input b/deps/npm/node_modules/promzard/test/validate.input
new file mode 100644
index 00000000000000..839c0652294ac0
--- /dev/null
+++ b/deps/npm/node_modules/promzard/test/validate.input
@@ -0,0 +1,8 @@
+module.exports = {
+ "name": prompt("name", function (data) {
+ if (data === 'cool') return data
+ var er = new Error('not cool')
+ er.notValid = true
+ return er
+ })
+}
diff --git a/deps/npm/node_modules/promzard/test/validate.js b/deps/npm/node_modules/promzard/test/validate.js
new file mode 100644
index 00000000000000..a120681494e60d
--- /dev/null
+++ b/deps/npm/node_modules/promzard/test/validate.js
@@ -0,0 +1,20 @@
+
+var promzard = require('../')
+var test = require('tap').test
+
+test('validate', function (t) {
+ t.plan(2)
+ var ctx = { tmpdir : '/tmp' }
+ var file = __dirname + '/validate.input'
+ promzard(file, ctx, function (er, found) {
+ t.ok(!er)
+ var wanted = { name: 'cool' }
+ t.same(found, wanted)
+ })
+ setTimeout(function () {
+ process.stdin.emit('data', 'not cool\n')
+ }, 100)
+ setTimeout(function () {
+ process.stdin.emit('data', 'cool\n')
+ }, 200)
+})
diff --git a/deps/npm/node_modules/readable-stream/CONTRIBUTING.md b/deps/npm/node_modules/readable-stream/CONTRIBUTING.md
new file mode 100644
index 00000000000000..f478d58dca85b2
--- /dev/null
+++ b/deps/npm/node_modules/readable-stream/CONTRIBUTING.md
@@ -0,0 +1,38 @@
+# Developer's Certificate of Origin 1.1
+
+By making a contribution to this project, I certify that:
+
+* (a) The contribution was created in whole or in part by me and I
+ have the right to submit it under the open source license
+ indicated in the file; or
+
+* (b) The contribution is based upon previous work that, to the best
+ of my knowledge, is covered under an appropriate open source
+ license and I have the right under that license to submit that
+ work with modifications, whether created in whole or in part
+ by me, under the same open source license (unless I am
+ permitted to submit under a different license), as indicated
+ in the file; or
+
+* (c) The contribution was provided directly to me by some other
+ person who certified (a), (b) or (c) and I have not modified
+ it.
+
+* (d) I understand and agree that this project and the contribution
+ are public and that a record of the contribution (including all
+ personal information I submit with it, including my sign-off) is
+ maintained indefinitely and may be redistributed consistent with
+ this project or the open source license(s) involved.
+
+## Moderation Policy
+
+The [Node.js Moderation Policy] applies to this WG.
+
+## Code of Conduct
+
+The [Node.js Code of Conduct][] applies to this WG.
+
+[Node.js Code of Conduct]:
+https://github.com/nodejs/node/blob/master/CODE_OF_CONDUCT.md
+[Node.js Moderation Policy]:
+https://github.com/nodejs/TSC/blob/master/Moderation-Policy.md
diff --git a/deps/npm/node_modules/readable-stream/GOVERNANCE.md b/deps/npm/node_modules/readable-stream/GOVERNANCE.md
new file mode 100644
index 00000000000000..16ffb93f24bece
--- /dev/null
+++ b/deps/npm/node_modules/readable-stream/GOVERNANCE.md
@@ -0,0 +1,136 @@
+### Streams Working Group
+
+The Node.js Streams is jointly governed by a Working Group
+(WG)
+that is responsible for high-level guidance of the project.
+
+The WG has final authority over this project including:
+
+* Technical direction
+* Project governance and process (including this policy)
+* Contribution policy
+* GitHub repository hosting
+* Conduct guidelines
+* Maintaining the list of additional Collaborators
+
+For the current list of WG members, see the project
+[README.md](./README.md#current-project-team-members).
+
+### Collaborators
+
+The readable-stream GitHub repository is
+maintained by the WG and additional Collaborators who are added by the
+WG on an ongoing basis.
+
+Individuals making significant and valuable contributions are made
+Collaborators and given commit-access to the project. These
+individuals are identified by the WG and their addition as
+Collaborators is discussed during the WG meeting.
+
+_Note:_ If you make a significant contribution and are not considered
+for commit-access log an issue or contact a WG member directly and it
+will be brought up in the next WG meeting.
+
+Modifications of the contents of the readable-stream repository are
+made on
+a collaborative basis. Anybody with a GitHub account may propose a
+modification via pull request and it will be considered by the project
+Collaborators. All pull requests must be reviewed and accepted by a
+Collaborator with sufficient expertise who is able to take full
+responsibility for the change. In the case of pull requests proposed
+by an existing Collaborator, an additional Collaborator is required
+for sign-off. Consensus should be sought if additional Collaborators
+participate and there is disagreement around a particular
+modification. See _Consensus Seeking Process_ below for further detail
+on the consensus model used for governance.
+
+Collaborators may opt to elevate significant or controversial
+modifications, or modifications that have not found consensus to the
+WG for discussion by assigning the ***WG-agenda*** tag to a pull
+request or issue. The WG should serve as the final arbiter where
+required.
+
+For the current list of Collaborators, see the project
+[README.md](./README.md#members).
+
+### WG Membership
+
+WG seats are not time-limited. There is no fixed size of the WG.
+However, the expected target is between 6 and 12, to ensure adequate
+coverage of important areas of expertise, balanced with the ability to
+make decisions efficiently.
+
+There is no specific set of requirements or qualifications for WG
+membership beyond these rules.
+
+The WG may add additional members to the WG by unanimous consensus.
+
+A WG member may be removed from the WG by voluntary resignation, or by
+unanimous consensus of all other WG members.
+
+Changes to WG membership should be posted in the agenda, and may be
+suggested as any other agenda item (see "WG Meetings" below).
+
+If an addition or removal is proposed during a meeting, and the full
+WG is not in attendance to participate, then the addition or removal
+is added to the agenda for the subsequent meeting. This is to ensure
+that all members are given the opportunity to participate in all
+membership decisions. If a WG member is unable to attend a meeting
+where a planned membership decision is being made, then their consent
+is assumed.
+
+No more than 1/3 of the WG members may be affiliated with the same
+employer. If removal or resignation of a WG member, or a change of
+employment by a WG member, creates a situation where more than 1/3 of
+the WG membership shares an employer, then the situation must be
+immediately remedied by the resignation or removal of one or more WG
+members affiliated with the over-represented employer(s).
+
+### WG Meetings
+
+The WG meets occasionally on a Google Hangout On Air. A designated moderator
+approved by the WG runs the meeting. Each meeting should be
+published to YouTube.
+
+Items are added to the WG agenda that are considered contentious or
+are modifications of governance, contribution policy, WG membership,
+or release process.
+
+The intention of the agenda is not to approve or review all patches;
+that should happen continuously on GitHub and be handled by the larger
+group of Collaborators.
+
+Any community member or contributor can ask that something be added to
+the next meeting's agenda by logging a GitHub Issue. Any Collaborator,
+WG member or the moderator can add the item to the agenda by adding
+the ***WG-agenda*** tag to the issue.
+
+Prior to each WG meeting the moderator will share the Agenda with
+members of the WG. WG members can add any items they like to the
+agenda at the beginning of each meeting. The moderator and the WG
+cannot veto or remove items.
+
+The WG may invite persons or representatives from certain projects to
+participate in a non-voting capacity.
+
+The moderator is responsible for summarizing the discussion of each
+agenda item and sends it as a pull request after the meeting.
+
+### Consensus Seeking Process
+
+The WG follows a
+[Consensus
+Seeking](http://en.wikipedia.org/wiki/Consensus-seeking_decision-making)
+decision-making model.
+
+When an agenda item has appeared to reach a consensus the moderator
+will ask "Does anyone object?" as a final call for dissent from the
+consensus.
+
+If an agenda item cannot reach a consensus a WG member can call for
+either a closing vote or a vote to table the issue to the next
+meeting. The call for a vote must be seconded by a majority of the WG
+or else the discussion will continue. Simple majority wins.
+
+Note that changes to WG membership require a majority consensus. See
+"WG Membership" above.
diff --git a/deps/npm/node_modules/readable-stream/errors-browser.js b/deps/npm/node_modules/readable-stream/errors-browser.js
new file mode 100644
index 00000000000000..fb8e73e1893b10
--- /dev/null
+++ b/deps/npm/node_modules/readable-stream/errors-browser.js
@@ -0,0 +1,127 @@
+'use strict';
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }
+
+var codes = {};
+
+function createErrorType(code, message, Base) {
+ if (!Base) {
+ Base = Error;
+ }
+
+ function getMessage(arg1, arg2, arg3) {
+ if (typeof message === 'string') {
+ return message;
+ } else {
+ return message(arg1, arg2, arg3);
+ }
+ }
+
+ var NodeError =
+ /*#__PURE__*/
+ function (_Base) {
+ _inheritsLoose(NodeError, _Base);
+
+ function NodeError(arg1, arg2, arg3) {
+ return _Base.call(this, getMessage(arg1, arg2, arg3)) || this;
+ }
+
+ return NodeError;
+ }(Base);
+
+ NodeError.prototype.name = Base.name;
+ NodeError.prototype.code = code;
+ codes[code] = NodeError;
+} // https://github.com/nodejs/node/blob/v10.8.0/lib/internal/errors.js
+
+
+function oneOf(expected, thing) {
+ if (Array.isArray(expected)) {
+ var len = expected.length;
+ expected = expected.map(function (i) {
+ return String(i);
+ });
+
+ if (len > 2) {
+ return "one of ".concat(thing, " ").concat(expected.slice(0, len - 1).join(', '), ", or ") + expected[len - 1];
+ } else if (len === 2) {
+ return "one of ".concat(thing, " ").concat(expected[0], " or ").concat(expected[1]);
+ } else {
+ return "of ".concat(thing, " ").concat(expected[0]);
+ }
+ } else {
+ return "of ".concat(thing, " ").concat(String(expected));
+ }
+} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith
+
+
+function startsWith(str, search, pos) {
+ return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;
+} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith
+
+
+function endsWith(str, search, this_len) {
+ if (this_len === undefined || this_len > str.length) {
+ this_len = str.length;
+ }
+
+ return str.substring(this_len - search.length, this_len) === search;
+} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes
+
+
+function includes(str, search, start) {
+ if (typeof start !== 'number') {
+ start = 0;
+ }
+
+ if (start + search.length > str.length) {
+ return false;
+ } else {
+ return str.indexOf(search, start) !== -1;
+ }
+}
+
+createErrorType('ERR_INVALID_OPT_VALUE', function (name, value) {
+ return 'The value "' + value + '" is invalid for option "' + name + '"';
+}, TypeError);
+createErrorType('ERR_INVALID_ARG_TYPE', function (name, expected, actual) {
+ // determiner: 'must be' or 'must not be'
+ var determiner;
+
+ if (typeof expected === 'string' && startsWith(expected, 'not ')) {
+ determiner = 'must not be';
+ expected = expected.replace(/^not /, '');
+ } else {
+ determiner = 'must be';
+ }
+
+ var msg;
+
+ if (endsWith(name, ' argument')) {
+ // For cases like 'first argument'
+ msg = "The ".concat(name, " ").concat(determiner, " ").concat(oneOf(expected, 'type'));
+ } else {
+ var type = includes(name, '.') ? 'property' : 'argument';
+ msg = "The \"".concat(name, "\" ").concat(type, " ").concat(determiner, " ").concat(oneOf(expected, 'type'));
+ }
+
+ msg += ". Received type ".concat(typeof actual);
+ return msg;
+}, TypeError);
+createErrorType('ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF');
+createErrorType('ERR_METHOD_NOT_IMPLEMENTED', function (name) {
+ return 'The ' + name + ' method is not implemented';
+});
+createErrorType('ERR_STREAM_PREMATURE_CLOSE', 'Premature close');
+createErrorType('ERR_STREAM_DESTROYED', function (name) {
+ return 'Cannot call ' + name + ' after a stream was destroyed';
+});
+createErrorType('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times');
+createErrorType('ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable');
+createErrorType('ERR_STREAM_WRITE_AFTER_END', 'write after end');
+createErrorType('ERR_STREAM_NULL_VALUES', 'May not write null values to stream', TypeError);
+createErrorType('ERR_UNKNOWN_ENCODING', function (arg) {
+ return 'Unknown encoding: ' + arg;
+}, TypeError);
+createErrorType('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event');
+module.exports.codes = codes;
diff --git a/deps/npm/node_modules/readable-stream/errors.js b/deps/npm/node_modules/readable-stream/errors.js
new file mode 100644
index 00000000000000..8471526d6e7f75
--- /dev/null
+++ b/deps/npm/node_modules/readable-stream/errors.js
@@ -0,0 +1,116 @@
+'use strict';
+
+const codes = {};
+
+function createErrorType(code, message, Base) {
+ if (!Base) {
+ Base = Error
+ }
+
+ function getMessage (arg1, arg2, arg3) {
+ if (typeof message === 'string') {
+ return message
+ } else {
+ return message(arg1, arg2, arg3)
+ }
+ }
+
+ class NodeError extends Base {
+ constructor (arg1, arg2, arg3) {
+ super(getMessage(arg1, arg2, arg3));
+ }
+ }
+
+ NodeError.prototype.name = Base.name;
+ NodeError.prototype.code = code;
+
+ codes[code] = NodeError;
+}
+
+// https://github.com/nodejs/node/blob/v10.8.0/lib/internal/errors.js
+function oneOf(expected, thing) {
+ if (Array.isArray(expected)) {
+ const len = expected.length;
+ expected = expected.map((i) => String(i));
+ if (len > 2) {
+ return `one of ${thing} ${expected.slice(0, len - 1).join(', ')}, or ` +
+ expected[len - 1];
+ } else if (len === 2) {
+ return `one of ${thing} ${expected[0]} or ${expected[1]}`;
+ } else {
+ return `of ${thing} ${expected[0]}`;
+ }
+ } else {
+ return `of ${thing} ${String(expected)}`;
+ }
+}
+
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith
+function startsWith(str, search, pos) {
+ return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;
+}
+
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith
+function endsWith(str, search, this_len) {
+ if (this_len === undefined || this_len > str.length) {
+ this_len = str.length;
+ }
+ return str.substring(this_len - search.length, this_len) === search;
+}
+
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes
+function includes(str, search, start) {
+ if (typeof start !== 'number') {
+ start = 0;
+ }
+
+ if (start + search.length > str.length) {
+ return false;
+ } else {
+ return str.indexOf(search, start) !== -1;
+ }
+}
+
+createErrorType('ERR_INVALID_OPT_VALUE', function (name, value) {
+ return 'The value "' + value + '" is invalid for option "' + name + '"'
+}, TypeError);
+createErrorType('ERR_INVALID_ARG_TYPE', function (name, expected, actual) {
+ // determiner: 'must be' or 'must not be'
+ let determiner;
+ if (typeof expected === 'string' && startsWith(expected, 'not ')) {
+ determiner = 'must not be';
+ expected = expected.replace(/^not /, '');
+ } else {
+ determiner = 'must be';
+ }
+
+ let msg;
+ if (endsWith(name, ' argument')) {
+ // For cases like 'first argument'
+ msg = `The ${name} ${determiner} ${oneOf(expected, 'type')}`;
+ } else {
+ const type = includes(name, '.') ? 'property' : 'argument';
+ msg = `The "${name}" ${type} ${determiner} ${oneOf(expected, 'type')}`;
+ }
+
+ msg += `. Received type ${typeof actual}`;
+ return msg;
+}, TypeError);
+createErrorType('ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF');
+createErrorType('ERR_METHOD_NOT_IMPLEMENTED', function (name) {
+ return 'The ' + name + ' method is not implemented'
+});
+createErrorType('ERR_STREAM_PREMATURE_CLOSE', 'Premature close');
+createErrorType('ERR_STREAM_DESTROYED', function (name) {
+ return 'Cannot call ' + name + ' after a stream was destroyed';
+});
+createErrorType('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times');
+createErrorType('ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable');
+createErrorType('ERR_STREAM_WRITE_AFTER_END', 'write after end');
+createErrorType('ERR_STREAM_NULL_VALUES', 'May not write null values to stream', TypeError);
+createErrorType('ERR_UNKNOWN_ENCODING', function (arg) {
+ return 'Unknown encoding: ' + arg
+}, TypeError);
+createErrorType('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event');
+
+module.exports.codes = codes;
diff --git a/deps/npm/node_modules/readable-stream/experimentalWarning.js b/deps/npm/node_modules/readable-stream/experimentalWarning.js
new file mode 100644
index 00000000000000..78e841495bf24d
--- /dev/null
+++ b/deps/npm/node_modules/readable-stream/experimentalWarning.js
@@ -0,0 +1,17 @@
+'use strict'
+
+var experimentalWarnings = new Set();
+
+function emitExperimentalWarning(feature) {
+ if (experimentalWarnings.has(feature)) return;
+ var msg = feature + ' is an experimental feature. This feature could ' +
+ 'change at any time';
+ experimentalWarnings.add(feature);
+ process.emitWarning(msg, 'ExperimentalWarning');
+}
+
+function noop() {}
+
+module.exports.emitExperimentalWarning = process.emitWarning
+ ? emitExperimentalWarning
+ : noop;
diff --git a/deps/npm/node_modules/readable-stream/lib/internal/streams/async_iterator.js b/deps/npm/node_modules/readable-stream/lib/internal/streams/async_iterator.js
new file mode 100644
index 00000000000000..9fb615a2f3bc44
--- /dev/null
+++ b/deps/npm/node_modules/readable-stream/lib/internal/streams/async_iterator.js
@@ -0,0 +1,207 @@
+'use strict';
+
+var _Object$setPrototypeO;
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var finished = require('./end-of-stream');
+
+var kLastResolve = Symbol('lastResolve');
+var kLastReject = Symbol('lastReject');
+var kError = Symbol('error');
+var kEnded = Symbol('ended');
+var kLastPromise = Symbol('lastPromise');
+var kHandlePromise = Symbol('handlePromise');
+var kStream = Symbol('stream');
+
+function createIterResult(value, done) {
+ return {
+ value: value,
+ done: done
+ };
+}
+
+function readAndResolve(iter) {
+ var resolve = iter[kLastResolve];
+
+ if (resolve !== null) {
+ var data = iter[kStream].read(); // we defer if data is null
+ // we can be expecting either 'end' or
+ // 'error'
+
+ if (data !== null) {
+ iter[kLastPromise] = null;
+ iter[kLastResolve] = null;
+ iter[kLastReject] = null;
+ resolve(createIterResult(data, false));
+ }
+ }
+}
+
+function onReadable(iter) {
+ // we wait for the next tick, because it might
+ // emit an error with process.nextTick
+ process.nextTick(readAndResolve, iter);
+}
+
+function wrapForNext(lastPromise, iter) {
+ return function (resolve, reject) {
+ lastPromise.then(function () {
+ if (iter[kEnded]) {
+ resolve(createIterResult(undefined, true));
+ return;
+ }
+
+ iter[kHandlePromise](resolve, reject);
+ }, reject);
+ };
+}
+
+var AsyncIteratorPrototype = Object.getPrototypeOf(function () {});
+var ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPrototypeO = {
+ get stream() {
+ return this[kStream];
+ },
+
+ next: function next() {
+ var _this = this;
+
+ // if we have detected an error in the meanwhile
+ // reject straight away
+ var error = this[kError];
+
+ if (error !== null) {
+ return Promise.reject(error);
+ }
+
+ if (this[kEnded]) {
+ return Promise.resolve(createIterResult(undefined, true));
+ }
+
+ if (this[kStream].destroyed) {
+ // We need to defer via nextTick because if .destroy(err) is
+ // called, the error will be emitted via nextTick, and
+ // we cannot guarantee that there is no error lingering around
+ // waiting to be emitted.
+ return new Promise(function (resolve, reject) {
+ process.nextTick(function () {
+ if (_this[kError]) {
+ reject(_this[kError]);
+ } else {
+ resolve(createIterResult(undefined, true));
+ }
+ });
+ });
+ } // if we have multiple next() calls
+ // we will wait for the previous Promise to finish
+ // this logic is optimized to support for await loops,
+ // where next() is only called once at a time
+
+
+ var lastPromise = this[kLastPromise];
+ var promise;
+
+ if (lastPromise) {
+ promise = new Promise(wrapForNext(lastPromise, this));
+ } else {
+ // fast path needed to support multiple this.push()
+ // without triggering the next() queue
+ var data = this[kStream].read();
+
+ if (data !== null) {
+ return Promise.resolve(createIterResult(data, false));
+ }
+
+ promise = new Promise(this[kHandlePromise]);
+ }
+
+ this[kLastPromise] = promise;
+ return promise;
+ }
+}, _defineProperty(_Object$setPrototypeO, Symbol.asyncIterator, function () {
+ return this;
+}), _defineProperty(_Object$setPrototypeO, "return", function _return() {
+ var _this2 = this;
+
+ // destroy(err, cb) is a private API
+ // we can guarantee we have that here, because we control the
+ // Readable class this is attached to
+ return new Promise(function (resolve, reject) {
+ _this2[kStream].destroy(null, function (err) {
+ if (err) {
+ reject(err);
+ return;
+ }
+
+ resolve(createIterResult(undefined, true));
+ });
+ });
+}), _Object$setPrototypeO), AsyncIteratorPrototype);
+
+var createReadableStreamAsyncIterator = function createReadableStreamAsyncIterator(stream) {
+ var _Object$create;
+
+ var iterator = Object.create(ReadableStreamAsyncIteratorPrototype, (_Object$create = {}, _defineProperty(_Object$create, kStream, {
+ value: stream,
+ writable: true
+ }), _defineProperty(_Object$create, kLastResolve, {
+ value: null,
+ writable: true
+ }), _defineProperty(_Object$create, kLastReject, {
+ value: null,
+ writable: true
+ }), _defineProperty(_Object$create, kError, {
+ value: null,
+ writable: true
+ }), _defineProperty(_Object$create, kEnded, {
+ value: stream._readableState.endEmitted,
+ writable: true
+ }), _defineProperty(_Object$create, kHandlePromise, {
+ value: function value(resolve, reject) {
+ var data = iterator[kStream].read();
+
+ if (data) {
+ iterator[kLastPromise] = null;
+ iterator[kLastResolve] = null;
+ iterator[kLastReject] = null;
+ resolve(createIterResult(data, false));
+ } else {
+ iterator[kLastResolve] = resolve;
+ iterator[kLastReject] = reject;
+ }
+ },
+ writable: true
+ }), _Object$create));
+ iterator[kLastPromise] = null;
+ finished(stream, function (err) {
+ if (err && err.code !== 'ERR_STREAM_PREMATURE_CLOSE') {
+ var reject = iterator[kLastReject]; // reject if we are waiting for data in the Promise
+ // returned by next() and store the error
+
+ if (reject !== null) {
+ iterator[kLastPromise] = null;
+ iterator[kLastResolve] = null;
+ iterator[kLastReject] = null;
+ reject(err);
+ }
+
+ iterator[kError] = err;
+ return;
+ }
+
+ var resolve = iterator[kLastResolve];
+
+ if (resolve !== null) {
+ iterator[kLastPromise] = null;
+ iterator[kLastResolve] = null;
+ iterator[kLastReject] = null;
+ resolve(createIterResult(undefined, true));
+ }
+
+ iterator[kEnded] = true;
+ });
+ stream.on('readable', onReadable.bind(null, iterator));
+ return iterator;
+};
+
+module.exports = createReadableStreamAsyncIterator;
\ No newline at end of file
diff --git a/deps/npm/node_modules/readable-stream/lib/internal/streams/from-browser.js b/deps/npm/node_modules/readable-stream/lib/internal/streams/from-browser.js
new file mode 100644
index 00000000000000..a4ce56f3c90f60
--- /dev/null
+++ b/deps/npm/node_modules/readable-stream/lib/internal/streams/from-browser.js
@@ -0,0 +1,3 @@
+module.exports = function () {
+ throw new Error('Readable.from is not available in the browser')
+};
diff --git a/deps/npm/node_modules/readable-stream/lib/internal/streams/stream-browser.js b/deps/npm/node_modules/readable-stream/lib/internal/streams/stream-browser.js
new file mode 100644
index 00000000000000..9332a3fdae7060
--- /dev/null
+++ b/deps/npm/node_modules/readable-stream/lib/internal/streams/stream-browser.js
@@ -0,0 +1 @@
+module.exports = require('events').EventEmitter;
diff --git a/deps/npm/node_modules/readable-stream/lib/internal/streams/stream.js b/deps/npm/node_modules/readable-stream/lib/internal/streams/stream.js
new file mode 100644
index 00000000000000..ce2ad5b6ee57f4
--- /dev/null
+++ b/deps/npm/node_modules/readable-stream/lib/internal/streams/stream.js
@@ -0,0 +1 @@
+module.exports = require('stream');
diff --git a/deps/npm/node_modules/readable-stream/readable-browser.js b/deps/npm/node_modules/readable-stream/readable-browser.js
new file mode 100644
index 00000000000000..adbf60de832f9d
--- /dev/null
+++ b/deps/npm/node_modules/readable-stream/readable-browser.js
@@ -0,0 +1,9 @@
+exports = module.exports = require('./lib/_stream_readable.js');
+exports.Stream = exports;
+exports.Readable = exports;
+exports.Writable = require('./lib/_stream_writable.js');
+exports.Duplex = require('./lib/_stream_duplex.js');
+exports.Transform = require('./lib/_stream_transform.js');
+exports.PassThrough = require('./lib/_stream_passthrough.js');
+exports.finished = require('./lib/internal/streams/end-of-stream.js');
+exports.pipeline = require('./lib/internal/streams/pipeline.js');
diff --git a/deps/npm/node_modules/readable-stream/readable.js b/deps/npm/node_modules/readable-stream/readable.js
new file mode 100644
index 00000000000000..9e0ca120ded827
--- /dev/null
+++ b/deps/npm/node_modules/readable-stream/readable.js
@@ -0,0 +1,16 @@
+var Stream = require('stream');
+if (process.env.READABLE_STREAM === 'disable' && Stream) {
+ module.exports = Stream.Readable;
+ Object.assign(module.exports, Stream);
+ module.exports.Stream = Stream;
+} else {
+ exports = module.exports = require('./lib/_stream_readable.js');
+ exports.Stream = Stream || exports;
+ exports.Readable = exports;
+ exports.Writable = require('./lib/_stream_writable.js');
+ exports.Duplex = require('./lib/_stream_duplex.js');
+ exports.Transform = require('./lib/_stream_transform.js');
+ exports.PassThrough = require('./lib/_stream_passthrough.js');
+ exports.finished = require('./lib/internal/streams/end-of-stream.js');
+ exports.pipeline = require('./lib/internal/streams/pipeline.js');
+}
diff --git a/deps/v8/.vpython b/deps/v8/.vpython
new file mode 100644
index 00000000000000..d4a07677ca9a22
--- /dev/null
+++ b/deps/v8/.vpython
@@ -0,0 +1,91 @@
+# This is a vpython "spec" file.
+#
+# It describes patterns for python wheel dependencies of the python scripts in
+# the V8 repo, particularly for dependencies that have compiled components
+# (since pure-python dependencies can be easily vendored into third_party).
+#
+# When vpython is invoked, it finds this file and builds a python VirtualEnv,
+# containing all of the dependencies described in this file, fetching them from
+# CIPD (the "Chrome Infrastructure Package Deployer" service). Unlike `pip`,
+# this never requires the end-user machine to have a working python extension
+# compilation environment. All of these packages are built using:
+# https://chromium.googlesource.com/infra/infra/+/master/infra/tools/dockerbuild/
+#
+# All python scripts in the repo share this same spec, to avoid dependency
+# fragmentation.
+#
+# If you have depot_tools installed in your $PATH, you can invoke python scripts
+# in this repo by running them as you normally would run them, except
+# substituting `vpython` instead of `python` on the command line, e.g.:
+# vpython path/to/script.py some --arguments
+#
+# Read more about `vpython` and how to modify this file here:
+# https://chromium.googlesource.com/infra/infra/+/master/doc/users/vpython.md
+
+python_version: "2.7"
+
+# The default set of platforms vpython checks does not yet include mac-arm64.
+# Setting `verify_pep425_tag` to the list of platforms we explicitly must support
+# allows us to ensure that vpython specs stay mac-arm64-friendly
+verify_pep425_tag: [
+ {python: "cp27", abi: "cp27mu", platform: "manylinux1_x86_64"},
+ {python: "cp27", abi: "cp27mu", platform: "linux_arm64"},
+ {python: "cp27", abi: "cp27mu", platform: "linux_armv6l"},
+
+ {python: "cp27", abi: "cp27m", platform: "macosx_10_10_intel"},
+ {python: "cp27", abi: "cp27m", platform: "macosx_11_0_arm64"},
+
+ {python: "cp27", abi: "cp27m", platform: "win32"},
+ {python: "cp27", abi: "cp27m", platform: "win_amd64"}
+]
+
+# Needed by third_party/catapult/devil/devil, which is imported by
+# build/android/test_runner.py when running performance tests.
+wheel: <
+ name: "infra/python/wheels/psutil/${vpython_platform}"
+ version: "version:5.2.2"
+>
+
+# Used by:
+# build/toolchain/win
+wheel: <
+ name: "infra/python/wheels/pypiwin32/${vpython_platform}"
+ version: "version:219"
+ match_tag: <
+ platform: "win32"
+ >
+ match_tag: <
+ platform: "win_amd64"
+ >
+>
+
+# Used by:
+# tools/unittests/run_perf_test.py
+wheel: <
+ name: "infra/python/wheels/coverage/${vpython_platform}"
+ version: "version:4.3.4"
+>
+wheel: <
+ name: "infra/python/wheels/six-py2_py3"
+ version: "version:1.10.0"
+>
+wheel: <
+ name: "infra/python/wheels/pbr-py2_py3"
+ version: "version:3.0.0"
+>
+wheel: <
+ name: "infra/python/wheels/funcsigs-py2_py3"
+ version: "version:1.0.2"
+>
+wheel: <
+ name: "infra/python/wheels/mock-py2_py3"
+ version: "version:2.0.0"
+>
+
+# Used by:
+# tools/run_perf.py
+# tools/unittests/run_perf_test.py
+wheel: <
+ name: "infra/python/wheels/numpy/${vpython_platform}"
+ version: "version:1.11.3"
+>
diff --git a/deps/v8/bazel/BUILD.zlib b/deps/v8/bazel/BUILD.zlib
new file mode 100644
index 00000000000000..25a2c35313b981
--- /dev/null
+++ b/deps/v8/bazel/BUILD.zlib
@@ -0,0 +1,69 @@
+# Copyright 2021 the V8 project authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+cc_library(
+ name = "zlib",
+ srcs = [
+ "adler32.c",
+ "chromeconf.h",
+ "compress.c",
+ "contrib/optimizations/insert_string.h",
+ "contrib/optimizations/slide_hash_neon.h",
+ "cpu_features.c",
+ "cpu_features.h",
+ "crc32.c",
+ "crc32.h",
+ "deflate.c",
+ "deflate.h",
+ "gzclose.c",
+ "gzguts.h",
+ "gzlib.c",
+ "gzread.c",
+ "gzwrite.c",
+ "infback.c",
+ "inffast.c",
+ "inffast.h",
+ "inffixed.h",
+ "inflate.c",
+ "inflate.h",
+ "inftrees.c",
+ "inftrees.h",
+ "trees.c",
+ "trees.h",
+ "uncompr.c",
+ "zconf.h",
+ "zlib.h",
+ "zutil.c",
+ "zutil.h",
+ ],
+ hdrs = [
+ "zlib.h",
+ ],
+ defines = [
+ "CHROMIUM_ZLIB_NO_CHROMECONF",
+ "CPU_NO_SIMD",
+ ] + select({
+ "@platforms//os:windows": [],
+ "//conditions:default": [
+ "HAVE_HIDDEN",
+ ],
+ }),
+ include_prefix = "third_party/zlib",
+ visibility = ["//visibility:public"],
+)
+
+cc_library(
+ name = "zlib_compression_utils",
+ srcs = [
+ "google/compression_utils_portable.cc",
+ ],
+ hdrs = [
+ "google/compression_utils_portable.h",
+ ],
+ include_prefix = "third_party/zlib",
+ visibility = ["//visibility:public"],
+ deps = [
+ "//external:zlib",
+ ],
+)
diff --git a/deps/v8/gni/v8.cmx b/deps/v8/gni/v8.cmx
new file mode 100644
index 00000000000000..45fd74a09faffa
--- /dev/null
+++ b/deps/v8/gni/v8.cmx
@@ -0,0 +1,52 @@
+{
+ "facets": {
+ "fuchsia.test": {
+ "system-services": [
+ "fuchsia.kernel.VmexResource"
+ ]
+ }
+ },
+ "sandbox": {
+ "dev": [
+ "null",
+ "zero"
+ ],
+ "features": [
+ "deprecated-ambient-replace-as-executable",
+ "isolated-cache-storage",
+ "isolated-persistent-storage",
+ "isolated-temp",
+ "root-ssl-certificates",
+ "vulkan"
+ ],
+ "services": [
+ "fuchsia.accessibility.semantics.SemanticsManager",
+ "fuchsia.camera3.DeviceWatcher",
+ "fuchsia.device.NameProvider",
+ "fuchsia.fonts.Provider",
+ "fuchsia.intl.PropertyProvider",
+ "fuchsia.kernel.VmexResource",
+ "fuchsia.logger.Log",
+ "fuchsia.logger.LogSink",
+ "fuchsia.media.Audio",
+ "fuchsia.media.SessionAudioConsumerFactory",
+ "fuchsia.media.drm.Widevine",
+ "fuchsia.mediacodec.CodecFactory",
+ "fuchsia.memorypressure.Provider",
+ "fuchsia.net.NameLookup",
+ "fuchsia.net.interfaces.State",
+ "fuchsia.posix.socket.Provider",
+ "fuchsia.process.Launcher",
+ "fuchsia.sys.Environment",
+ "fuchsia.sys.Launcher",
+ "fuchsia.sys.Loader",
+ "fuchsia.sysmem.Allocator",
+ "fuchsia.ui.input.ImeService",
+ "fuchsia.ui.input.ImeVisibilityService",
+ "fuchsia.ui.scenic.Scenic",
+ "fuchsia.ui.policy.Presenter",
+ "fuchsia.vulkan.loader.Loader",
+ "fuchsia.web.ContextProvider"
+ ]
+ }
+}
diff --git a/deps/v8/src/base/atomicops_internals_atomicword_compat.h b/deps/v8/src/base/atomicops_internals_atomicword_compat.h
new file mode 100644
index 00000000000000..5ed7d5594e527f
--- /dev/null
+++ b/deps/v8/src/base/atomicops_internals_atomicword_compat.h
@@ -0,0 +1,89 @@
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// This file is an internal atomic implementation, use atomicops.h instead.
+
+#ifndef V8_BASE_ATOMICOPS_INTERNALS_ATOMICWORD_COMPAT_H_
+#define V8_BASE_ATOMICOPS_INTERNALS_ATOMICWORD_COMPAT_H_
+
+// AtomicWord is a synonym for intptr_t, and Atomic32 is a synonym for int32,
+// which in turn means int. On some LP32 platforms, intptr_t is an int, but
+// on others, it's a long. When AtomicWord and Atomic32 are based on different
+// fundamental types, their pointers are incompatible.
+//
+// This file defines function overloads to allow both AtomicWord and Atomic32
+// data to be used with this interface.
+//
+// On LP64 platforms, AtomicWord and Atomic64 are both always long,
+// so this problem doesn't occur.
+
+#if !defined(V8_HOST_ARCH_64_BIT)
+
+namespace v8 {
+namespace base {
+
+inline AtomicWord Relaxed_CompareAndSwap(volatile AtomicWord* ptr,
+ AtomicWord old_value,
+ AtomicWord new_value) {
+ return Relaxed_CompareAndSwap(reinterpret_cast(ptr),
+ old_value, new_value);
+}
+
+inline AtomicWord Relaxed_AtomicExchange(volatile AtomicWord* ptr,
+ AtomicWord new_value) {
+ return Relaxed_AtomicExchange(reinterpret_cast(ptr),
+ new_value);
+}
+
+inline AtomicWord Relaxed_AtomicIncrement(volatile AtomicWord* ptr,
+ AtomicWord increment) {
+ return Relaxed_AtomicIncrement(reinterpret_cast(ptr),
+ increment);
+}
+
+inline AtomicWord Acquire_CompareAndSwap(volatile AtomicWord* ptr,
+ AtomicWord old_value,
+ AtomicWord new_value) {
+ return v8::base::Acquire_CompareAndSwap(
+ reinterpret_cast(ptr), old_value, new_value);
+}
+
+inline AtomicWord Release_CompareAndSwap(volatile AtomicWord* ptr,
+ AtomicWord old_value,
+ AtomicWord new_value) {
+ return v8::base::Release_CompareAndSwap(
+ reinterpret_cast(ptr), old_value, new_value);
+}
+
+inline AtomicWord AcquireRelease_CompareAndSwap(volatile AtomicWord* ptr,
+ AtomicWord old_value,
+ AtomicWord new_value) {
+ return v8::base::AcquireRelease_CompareAndSwap(
+ reinterpret_cast(ptr), old_value, new_value);
+}
+
+inline void Relaxed_Store(volatile AtomicWord* ptr, AtomicWord value) {
+ Relaxed_Store(reinterpret_cast(ptr), value);
+}
+
+inline void Release_Store(volatile AtomicWord* ptr, AtomicWord value) {
+ return v8::base::Release_Store(
+ reinterpret_cast(ptr), value);
+}
+
+inline AtomicWord Relaxed_Load(volatile const AtomicWord* ptr) {
+ return Relaxed_Load(reinterpret_cast(ptr));
+}
+
+inline AtomicWord Acquire_Load(volatile const AtomicWord* ptr) {
+ return v8::base::Acquire_Load(
+ reinterpret_cast(ptr));
+}
+
+} // namespace base
+} // namespace v8
+
+#endif // !defined(V8_HOST_ARCH_64_BIT)
+
+#endif // V8_BASE_ATOMICOPS_INTERNALS_ATOMICWORD_COMPAT_H_
diff --git a/deps/v8/src/base/functional.cc b/deps/v8/src/base/functional.cc
new file mode 100644
index 00000000000000..dffb91f3cc1af4
--- /dev/null
+++ b/deps/v8/src/base/functional.cc
@@ -0,0 +1,110 @@
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// This also contains public domain code from MurmurHash. From the
+// MurmurHash header:
+//
+// MurmurHash3 was written by Austin Appleby, and is placed in the public
+// domain. The author hereby disclaims copyright to this source code.
+
+#include "src/base/functional.h"
+
+#include
+
+#include "src/base/bits.h"
+
+namespace v8 {
+namespace base {
+
+namespace {
+
+// Thomas Wang, Integer Hash Functions.
+// https://gist.github.com/badboy/6267743
+template
+V8_INLINE size_t hash_value_unsigned(T v) {
+ switch (sizeof(T)) {
+ case 4: {
+ // "32 bit Mix Functions"
+ v = ~v + (v << 15); // v = (v << 15) - v - 1;
+ v = v ^ (v >> 12);
+ v = v + (v << 2);
+ v = v ^ (v >> 4);
+ v = v * 2057; // v = (v + (v << 3)) + (v << 11);
+ v = v ^ (v >> 16);
+ return static_cast(v);
+ }
+ case 8: {
+ switch (sizeof(size_t)) {
+ case 4: {
+ // "64 bit to 32 bit Hash Functions"
+ v = ~v + (v << 18); // v = (v << 18) - v - 1;
+ v = v ^ (v >> 31);
+ v = v * 21; // v = (v + (v << 2)) + (v << 4);
+ v = v ^ (v >> 11);
+ v = v + (v << 6);
+ v = v ^ (v >> 22);
+ return static_cast(v);
+ }
+ case 8: {
+ // "64 bit Mix Functions"
+ v = ~v + (v << 21); // v = (v << 21) - v - 1;
+ v = v ^ (v >> 24);
+ v = (v + (v << 3)) + (v << 8); // v * 265
+ v = v ^ (v >> 14);
+ v = (v + (v << 2)) + (v << 4); // v * 21
+ v = v ^ (v >> 28);
+ v = v + (v << 31);
+ return static_cast(v);
+ }
+ }
+ }
+ }
+ UNREACHABLE();
+}
+
+} // namespace
+
+
+// This code was taken from MurmurHash.
+size_t hash_combine(size_t seed, size_t value) {
+#if V8_HOST_ARCH_32_BIT
+ const uint32_t c1 = 0xCC9E2D51;
+ const uint32_t c2 = 0x1B873593;
+
+ value *= c1;
+ value = bits::RotateRight32(value, 15);
+ value *= c2;
+
+ seed ^= value;
+ seed = bits::RotateRight32(seed, 13);
+ seed = seed * 5 + 0xE6546B64;
+#else
+ const uint64_t m = uint64_t{0xC6A4A7935BD1E995};
+ const uint32_t r = 47;
+
+ value *= m;
+ value ^= value >> r;
+ value *= m;
+
+ seed ^= value;
+ seed *= m;
+#endif // V8_HOST_ARCH_32_BIT
+ return seed;
+}
+
+
+size_t hash_value(unsigned int v) { return hash_value_unsigned(v); }
+
+
+size_t hash_value(unsigned long v) { // NOLINT(runtime/int)
+ return hash_value_unsigned(v);
+}
+
+
+size_t hash_value(unsigned long long v) { // NOLINT(runtime/int)
+ return hash_value_unsigned(v);
+}
+
+} // namespace base
+} // namespace v8
diff --git a/deps/v8/src/baseline/mips/baseline-assembler-mips-inl.h b/deps/v8/src/baseline/mips/baseline-assembler-mips-inl.h
new file mode 100644
index 00000000000000..237f706ea6ac9e
--- /dev/null
+++ b/deps/v8/src/baseline/mips/baseline-assembler-mips-inl.h
@@ -0,0 +1,526 @@
+// Copyright 2021 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef V8_BASELINE_MIPS_BASELINE_ASSEMBLER_MIPS_INL_H_
+#define V8_BASELINE_MIPS_BASELINE_ASSEMBLER_MIPS_INL_H_
+
+#include "src/baseline/baseline-assembler.h"
+#include "src/codegen/interface-descriptors.h"
+#include "src/codegen/mips/assembler-mips-inl.h"
+
+namespace v8 {
+namespace internal {
+namespace baseline {
+
+class BaselineAssembler::ScratchRegisterScope {
+ public:
+ explicit ScratchRegisterScope(BaselineAssembler* assembler)
+ : assembler_(assembler),
+ prev_scope_(assembler->scratch_register_scope_),
+ wrapped_scope_(assembler->masm()) {
+ if (!assembler_->scratch_register_scope_) {
+ // If we haven't opened a scratch scope yet, for the first one add a
+ // couple of extra registers.
+ wrapped_scope_.Include({t4, t5, t6, t7});
+ }
+ assembler_->scratch_register_scope_ = this;
+ }
+ ~ScratchRegisterScope() { assembler_->scratch_register_scope_ = prev_scope_; }
+
+ Register AcquireScratch() { return wrapped_scope_.Acquire(); }
+
+ private:
+ BaselineAssembler* assembler_;
+ ScratchRegisterScope* prev_scope_;
+ UseScratchRegisterScope wrapped_scope_;
+};
+
+enum class Condition : uint32_t {
+ kEqual = eq,
+ kNotEqual = ne,
+
+ kLessThan = lt,
+ kGreaterThan = gt,
+ kLessThanEqual = le,
+ kGreaterThanEqual = ge,
+
+ kUnsignedLessThan = Uless,
+ kUnsignedGreaterThan = Ugreater,
+ kUnsignedLessThanEqual = Uless_equal,
+ kUnsignedGreaterThanEqual = Ugreater_equal,
+
+ kOverflow = overflow,
+ kNoOverflow = no_overflow,
+
+ kZero = eq,
+ kNotZero = ne,
+};
+
+inline internal::Condition AsMasmCondition(Condition cond) {
+ // This is important for arm, where the internal::Condition where each value
+ // represents an encoded bit field value.
+ STATIC_ASSERT(sizeof(internal::Condition) == sizeof(Condition));
+ return static_cast(cond);
+}
+
+namespace detail {
+
+#ifdef DEBUG
+inline bool Clobbers(Register target, MemOperand op) {
+ return op.is_reg() && op.rm() == target;
+}
+#endif
+
+} // namespace detail
+
+#define __ masm_->
+
+MemOperand BaselineAssembler::RegisterFrameOperand(
+ interpreter::Register interpreter_register) {
+ return MemOperand(fp, interpreter_register.ToOperand() * kSystemPointerSize);
+}
+void BaselineAssembler::RegisterFrameAddress(
+ interpreter::Register interpreter_register, Register rscratch) {
+ return __ Addu(rscratch, fp,
+ interpreter_register.ToOperand() * kSystemPointerSize);
+}
+MemOperand BaselineAssembler::FeedbackVectorOperand() {
+ return MemOperand(fp, BaselineFrameConstants::kFeedbackVectorFromFp);
+}
+
+void BaselineAssembler::Bind(Label* label) { __ bind(label); }
+
+void BaselineAssembler::BindWithoutJumpTarget(Label* label) { __ bind(label); }
+
+void BaselineAssembler::JumpTarget() {
+ // NOP.
+}
+void BaselineAssembler::Jump(Label* target, Label::Distance distance) {
+ __ Branch(target);
+}
+void BaselineAssembler::JumpIfRoot(Register value, RootIndex index,
+ Label* target, Label::Distance) {
+ __ JumpIfRoot(value, index, target);
+}
+void BaselineAssembler::JumpIfNotRoot(Register value, RootIndex index,
+ Label* target, Label::Distance) {
+ __ JumpIfNotRoot(value, index, target);
+}
+void BaselineAssembler::JumpIfSmi(Register value, Label* target,
+ Label::Distance) {
+ __ JumpIfSmi(value, target);
+}
+void BaselineAssembler::JumpIfNotSmi(Register value, Label* target,
+ Label::Distance) {
+ __ JumpIfNotSmi(value, target);
+}
+void BaselineAssembler::JumpIfImmediate(Condition cc, Register left, int right,
+ Label* target,
+ Label::Distance distance) {
+ JumpIf(cc, left, Operand(right), target, distance);
+}
+
+void BaselineAssembler::CallBuiltin(Builtin builtin) {
+ ASM_CODE_COMMENT_STRING(masm_,
+ __ CommentForOffHeapTrampoline("call", builtin));
+ Register temp = t9;
+ __ LoadEntryFromBuiltin(builtin, temp);
+ __ Call(temp);
+}
+
+void BaselineAssembler::TailCallBuiltin(Builtin builtin) {
+ ASM_CODE_COMMENT_STRING(masm_,
+ __ CommentForOffHeapTrampoline("tail call", builtin));
+ Register temp = t9;
+ __ LoadEntryFromBuiltin(builtin, temp);
+ __ Jump(temp);
+}
+
+void BaselineAssembler::TestAndBranch(Register value, int mask, Condition cc,
+ Label* target, Label::Distance) {
+ ScratchRegisterScope temps(this);
+ Register scratch = temps.AcquireScratch();
+ __ And(scratch, value, Operand(mask));
+ __ Branch(target, AsMasmCondition(cc), scratch, Operand(zero_reg));
+}
+
+void BaselineAssembler::JumpIf(Condition cc, Register lhs, const Operand& rhs,
+ Label* target, Label::Distance) {
+ __ Branch(target, AsMasmCondition(cc), lhs, Operand(rhs));
+}
+void BaselineAssembler::JumpIfObjectType(Condition cc, Register object,
+ InstanceType instance_type,
+ Register map, Label* target,
+ Label::Distance) {
+ ScratchRegisterScope temps(this);
+ Register type = temps.AcquireScratch();
+ __ GetObjectType(object, map, type);
+ __ Branch(target, AsMasmCondition(cc), type, Operand(instance_type));
+}
+void BaselineAssembler::JumpIfInstanceType(Condition cc, Register map,
+ InstanceType instance_type,
+ Label* target, Label::Distance) {
+ ScratchRegisterScope temps(this);
+ Register type = temps.AcquireScratch();
+ if (FLAG_debug_code) {
+ __ AssertNotSmi(map);
+ __ GetObjectType(map, type, type);
+ __ Assert(eq, AbortReason::kUnexpectedValue, type, Operand(MAP_TYPE));
+ }
+ __ Lw(type, FieldMemOperand(map, Map::kInstanceTypeOffset));
+ __ Branch(target, AsMasmCondition(cc), type, Operand(instance_type));
+}
+void BaselineAssembler::JumpIfPointer(Condition cc, Register value,
+ MemOperand operand, Label* target,
+ Label::Distance) {
+ ScratchRegisterScope temps(this);
+ Register scratch = temps.AcquireScratch();
+ __ Lw(scratch, operand);
+ __ Branch(target, AsMasmCondition(cc), value, Operand(scratch));
+}
+void BaselineAssembler::JumpIfSmi(Condition cc, Register value, Smi smi,
+ Label* target, Label::Distance) {
+ ScratchRegisterScope temps(this);
+ Register scratch = temps.AcquireScratch();
+ __ li(scratch, Operand(smi));
+ __ SmiUntag(scratch);
+ __ Branch(target, AsMasmCondition(cc), value, Operand(scratch));
+}
+void BaselineAssembler::JumpIfSmi(Condition cc, Register lhs, Register rhs,
+ Label* target, Label::Distance) {
+ __ AssertSmi(lhs);
+ __ AssertSmi(rhs);
+ __ Branch(target, AsMasmCondition(cc), lhs, Operand(rhs));
+}
+void BaselineAssembler::JumpIfTagged(Condition cc, Register value,
+ MemOperand operand, Label* target,
+ Label::Distance) {
+ ScratchRegisterScope temps(this);
+ Register scratch = temps.AcquireScratch();
+ __ Lw(scratch, operand);
+ __ Branch(target, AsMasmCondition(cc), value, Operand(scratch));
+}
+void BaselineAssembler::JumpIfTagged(Condition cc, MemOperand operand,
+ Register value, Label* target,
+ Label::Distance) {
+ ScratchRegisterScope temps(this);
+ Register scratch = temps.AcquireScratch();
+ __ Lw(scratch, operand);
+ __ Branch(target, AsMasmCondition(cc), scratch, Operand(value));
+}
+void BaselineAssembler::JumpIfByte(Condition cc, Register value, int32_t byte,
+ Label* target, Label::Distance) {
+ __ Branch(target, AsMasmCondition(cc), value, Operand(byte));
+}
+
+void BaselineAssembler::Move(interpreter::Register output, Register source) {
+ Move(RegisterFrameOperand(output), source);
+}
+void BaselineAssembler::Move(Register output, TaggedIndex value) {
+ __ li(output, Operand(value.ptr()));
+}
+void BaselineAssembler::Move(MemOperand output, Register source) {
+ __ Sw(source, output);
+}
+void BaselineAssembler::Move(Register output, ExternalReference reference) {
+ __ li(output, Operand(reference));
+}
+void BaselineAssembler::Move(Register output, Handle value) {
+ __ li(output, Operand(value));
+}
+void BaselineAssembler::Move(Register output, int32_t value) {
+ __ li(output, Operand(value));
+}
+void BaselineAssembler::MoveMaybeSmi(Register output, Register source) {
+ __ Move(output, source);
+}
+void BaselineAssembler::MoveSmi(Register output, Register source) {
+ __ Move(output, source);
+}
+
+namespace detail {
+
+template
+inline Register ToRegister(BaselineAssembler* basm,
+ BaselineAssembler::ScratchRegisterScope* scope,
+ Arg arg) {
+ Register reg = scope->AcquireScratch();
+ basm->Move(reg, arg);
+ return reg;
+}
+inline Register ToRegister(BaselineAssembler* basm,
+ BaselineAssembler::ScratchRegisterScope* scope,
+ Register reg) {
+ return reg;
+}
+
+template
+struct PushAllHelper;
+template <>
+struct PushAllHelper<> {
+ static int Push(BaselineAssembler* basm) { return 0; }
+ static int PushReverse(BaselineAssembler* basm) { return 0; }
+};
+// TODO(ishell): try to pack sequence of pushes into one instruction by
+// looking at regiser codes. For example, Push(r1, r2, r5, r0, r3, r4)
+// could be generated as two pushes: Push(r1, r2, r5) and Push(r0, r3, r4).
+template
+struct PushAllHelper {
+ static int Push(BaselineAssembler* basm, Arg arg) {
+ BaselineAssembler::ScratchRegisterScope scope(basm);
+ basm->masm()->Push(ToRegister(basm, &scope, arg));
+ return 1;
+ }
+ static int PushReverse(BaselineAssembler* basm, Arg arg) {
+ return Push(basm, arg);
+ }
+};
+// TODO(ishell): try to pack sequence of pushes into one instruction by
+// looking at regiser codes. For example, Push(r1, r2, r5, r0, r3, r4)
+// could be generated as two pushes: Push(r1, r2, r5) and Push(r0, r3, r4).
+template
+struct PushAllHelper {
+ static int Push(BaselineAssembler* basm, Arg arg, Args... args) {
+ PushAllHelper::Push(basm, arg);
+ return 1 + PushAllHelper::Push(basm, args...);
+ }
+ static int PushReverse(BaselineAssembler* basm, Arg arg, Args... args) {
+ int nargs = PushAllHelper::PushReverse(basm, args...);
+ PushAllHelper::Push(basm, arg);
+ return nargs + 1;
+ }
+};
+template <>
+struct PushAllHelper {
+ static int Push(BaselineAssembler* basm, interpreter::RegisterList list) {
+ for (int reg_index = 0; reg_index < list.register_count(); ++reg_index) {
+ PushAllHelper::Push(basm, list[reg_index]);
+ }
+ return list.register_count();
+ }
+ static int PushReverse(BaselineAssembler* basm,
+ interpreter::RegisterList list) {
+ for (int reg_index = list.register_count() - 1; reg_index >= 0;
+ --reg_index) {
+ PushAllHelper::Push(basm, list[reg_index]);
+ }
+ return list.register_count();
+ }
+};
+
+template
+struct PopAllHelper;
+template <>
+struct PopAllHelper<> {
+ static void Pop(BaselineAssembler* basm) {}
+};
+// TODO(ishell): try to pack sequence of pops into one instruction by
+// looking at regiser codes. For example, Pop(r1, r2, r5, r0, r3, r4)
+// could be generated as two pops: Pop(r1, r2, r5) and Pop(r0, r3, r4).
+template <>
+struct PopAllHelper {
+ static void Pop(BaselineAssembler* basm, Register reg) {
+ basm->masm()->Pop(reg);
+ }
+};
+template
+struct PopAllHelper {
+ static void Pop(BaselineAssembler* basm, Register reg, T... tail) {
+ PopAllHelper::Pop(basm, reg);
+ PopAllHelper::Pop(basm, tail...);
+ }
+};
+
+} // namespace detail
+
+template
+int BaselineAssembler::Push(T... vals) {
+ return detail::PushAllHelper::Push(this, vals...);
+}
+
+template
+void BaselineAssembler::PushReverse(T... vals) {
+ detail::PushAllHelper::PushReverse(this, vals...);
+}
+
+template
+void BaselineAssembler::Pop(T... registers) {
+ detail::PopAllHelper::Pop(this, registers...);
+}
+
+void BaselineAssembler::LoadTaggedPointerField(Register output, Register source,
+ int offset) {
+ __ Lw(output, FieldMemOperand(source, offset));
+}
+void BaselineAssembler::LoadTaggedSignedField(Register output, Register source,
+ int offset) {
+ __ Lw(output, FieldMemOperand(source, offset));
+}
+void BaselineAssembler::LoadTaggedAnyField(Register output, Register source,
+ int offset) {
+ __ Lw(output, FieldMemOperand(source, offset));
+}
+void BaselineAssembler::LoadWord16FieldZeroExtend(Register output,
+ Register source, int offset) {
+ __ lhu(output, FieldMemOperand(source, offset));
+}
+void BaselineAssembler::LoadWord8Field(Register output, Register source,
+ int offset) {
+ __ lb(output, FieldMemOperand(source, offset));
+}
+void BaselineAssembler::StoreTaggedSignedField(Register target, int offset,
+ Smi value) {
+ ASM_CODE_COMMENT(masm_);
+ ScratchRegisterScope temps(this);
+ Register scratch = temps.AcquireScratch();
+ __ li(scratch, Operand(value));
+ __ Sw(scratch, FieldMemOperand(target, offset));
+}
+void BaselineAssembler::StoreTaggedFieldWithWriteBarrier(Register target,
+ int offset,
+ Register value) {
+ ASM_CODE_COMMENT(masm_);
+ __ Sw(value, FieldMemOperand(target, offset));
+ ScratchRegisterScope temps(this);
+ Register scratch = temps.AcquireScratch();
+ __ RecordWriteField(target, offset, value, scratch, kRAHasNotBeenSaved,
+ SaveFPRegsMode::kIgnore);
+}
+void BaselineAssembler::StoreTaggedFieldNoWriteBarrier(Register target,
+ int offset,
+ Register value) {
+ __ Sw(value, FieldMemOperand(target, offset));
+}
+
+void BaselineAssembler::AddToInterruptBudgetAndJumpIfNotExceeded(
+ int32_t weight, Label* skip_interrupt_label) {
+ ASM_CODE_COMMENT(masm_);
+ ScratchRegisterScope scratch_scope(this);
+ Register feedback_cell = scratch_scope.AcquireScratch();
+ LoadFunction(feedback_cell);
+ LoadTaggedPointerField(feedback_cell, feedback_cell,
+ JSFunction::kFeedbackCellOffset);
+
+ Register interrupt_budget = scratch_scope.AcquireScratch();
+ __ Lw(interrupt_budget,
+ FieldMemOperand(feedback_cell, FeedbackCell::kInterruptBudgetOffset));
+ __ Addu(interrupt_budget, interrupt_budget, weight);
+ __ Sw(interrupt_budget,
+ FieldMemOperand(feedback_cell, FeedbackCell::kInterruptBudgetOffset));
+ if (skip_interrupt_label) {
+ DCHECK_LT(weight, 0);
+ __ Branch(skip_interrupt_label, ge, interrupt_budget, Operand(zero_reg));
+ }
+}
+void BaselineAssembler::AddToInterruptBudgetAndJumpIfNotExceeded(
+ Register weight, Label* skip_interrupt_label) {
+ ASM_CODE_COMMENT(masm_);
+ ScratchRegisterScope scratch_scope(this);
+ Register feedback_cell = scratch_scope.AcquireScratch();
+ LoadFunction(feedback_cell);
+ LoadTaggedPointerField(feedback_cell, feedback_cell,
+ JSFunction::kFeedbackCellOffset);
+
+ Register interrupt_budget = scratch_scope.AcquireScratch();
+ __ Lw(interrupt_budget,
+ FieldMemOperand(feedback_cell, FeedbackCell::kInterruptBudgetOffset));
+ __ Addu(interrupt_budget, interrupt_budget, weight);
+ __ Sw(interrupt_budget,
+ FieldMemOperand(feedback_cell, FeedbackCell::kInterruptBudgetOffset));
+ if (skip_interrupt_label)
+ __ Branch(skip_interrupt_label, ge, interrupt_budget, Operand(zero_reg));
+}
+
+void BaselineAssembler::AddSmi(Register lhs, Smi rhs) {
+ __ Addu(lhs, lhs, Operand(rhs));
+}
+
+void BaselineAssembler::Word32And(Register output, Register lhs, int rhs) {
+ __ And(output, lhs, Operand(rhs));
+}
+
+void BaselineAssembler::Switch(Register reg, int case_value_base,
+ Label** labels, int num_labels) {
+ ASM_CODE_COMMENT(masm_);
+ Label fallthrough;
+ if (case_value_base != 0) {
+ __ Subu(reg, reg, Operand(case_value_base));
+ }
+
+ __ Branch(&fallthrough, AsMasmCondition(Condition::kUnsignedGreaterThanEqual),
+ reg, Operand(num_labels));
+
+ __ GenerateSwitchTable(reg, num_labels,
+ [labels](size_t i) { return labels[i]; });
+
+ __ bind(&fallthrough);
+}
+
+#undef __
+
+#define __ basm.
+
+void BaselineAssembler::EmitReturn(MacroAssembler* masm) {
+ ASM_CODE_COMMENT(masm);
+ BaselineAssembler basm(masm);
+
+ Register weight = BaselineLeaveFrameDescriptor::WeightRegister();
+ Register params_size = BaselineLeaveFrameDescriptor::ParamsSizeRegister();
+
+ {
+ ASM_CODE_COMMENT_STRING(masm, "Update Interrupt Budget");
+
+ Label skip_interrupt_label;
+ __ AddToInterruptBudgetAndJumpIfNotExceeded(weight, &skip_interrupt_label);
+ __ masm()->SmiTag(params_size);
+ __ masm()->Push(params_size, kInterpreterAccumulatorRegister);
+
+ __ LoadContext(kContextRegister);
+ __ LoadFunction(kJSFunctionRegister);
+ __ masm()->Push(kJSFunctionRegister);
+ __ CallRuntime(Runtime::kBytecodeBudgetInterrupt, 1);
+
+ __ masm()->Pop(params_size, kInterpreterAccumulatorRegister);
+ __ masm()->SmiUntag(params_size);
+
+ __ Bind(&skip_interrupt_label);
+ }
+
+ BaselineAssembler::ScratchRegisterScope temps(&basm);
+ Register actual_params_size = temps.AcquireScratch();
+ // Compute the size of the actual parameters + receiver (in bytes).
+ __ Move(actual_params_size,
+ MemOperand(fp, StandardFrameConstants::kArgCOffset));
+
+ // If actual is bigger than formal, then we should use it to free up the stack
+ // arguments.
+ Label corrected_args_count;
+ __ masm()->Branch(&corrected_args_count, ge, params_size,
+ Operand(actual_params_size));
+ __ masm()->Move(params_size, actual_params_size);
+ __ Bind(&corrected_args_count);
+
+ // Leave the frame (also dropping the register file).
+ __ masm()->LeaveFrame(StackFrame::BASELINE);
+
+ // Drop receiver + arguments.
+ __ masm()->DropArguments(params_size, TurboAssembler::kCountIsInteger,
+ TurboAssembler::kCountIncludesReceiver);
+
+ __ masm()->Ret();
+}
+
+#undef __
+
+inline void EnsureAccumulatorPreservedScope::AssertEqualToAccumulator(
+ Register reg) {
+ assembler_->masm()->Assert(eq, AbortReason::kUnexpectedValue, reg,
+ Operand(kInterpreterAccumulatorRegister));
+}
+
+} // namespace baseline
+} // namespace internal
+} // namespace v8
+
+#endif // V8_BASELINE_MIPS_BASELINE_ASSEMBLER_MIPS_INL_H_
diff --git a/deps/v8/src/baseline/mips/baseline-compiler-mips-inl.h b/deps/v8/src/baseline/mips/baseline-compiler-mips-inl.h
new file mode 100644
index 00000000000000..3e8bb98e14c196
--- /dev/null
+++ b/deps/v8/src/baseline/mips/baseline-compiler-mips-inl.h
@@ -0,0 +1,78 @@
+// Copyright 2021 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef V8_BASELINE_MIPS_BASELINE_COMPILER_MIPS_INL_H_
+#define V8_BASELINE_MIPS_BASELINE_COMPILER_MIPS_INL_H_
+
+#include "src/base/logging.h"
+#include "src/baseline/baseline-compiler.h"
+
+namespace v8 {
+namespace internal {
+namespace baseline {
+
+#define __ basm_.
+
+void BaselineCompiler::Prologue() {
+ ASM_CODE_COMMENT(&masm_);
+ __ masm()->EnterFrame(StackFrame::BASELINE);
+ DCHECK_EQ(kJSFunctionRegister, kJavaScriptCallTargetRegister);
+ int max_frame_size =
+ bytecode_->frame_size() + max_call_args_ * kSystemPointerSize;
+ CallBuiltin(
+ kContextRegister, kJSFunctionRegister, kJavaScriptCallArgCountRegister,
+ max_frame_size, kJavaScriptCallNewTargetRegister, bytecode_);
+
+ PrologueFillFrame();
+}
+
+void BaselineCompiler::PrologueFillFrame() {
+ ASM_CODE_COMMENT(&masm_);
+ // Inlined register frame fill
+ interpreter::Register new_target_or_generator_register =
+ bytecode_->incoming_new_target_or_generator_register();
+ __ LoadRoot(kInterpreterAccumulatorRegister, RootIndex::kUndefinedValue);
+ int register_count = bytecode_->register_count();
+ // Magic value
+ const int kLoopUnrollSize = 8;
+ const int new_target_index = new_target_or_generator_register.index();
+ const bool has_new_target = new_target_index != kMaxInt;
+ if (has_new_target) {
+ DCHECK_LE(new_target_index, register_count);
+ __ masm()->Addu(sp, sp, Operand(-(kPointerSize * new_target_index)));
+ for (int i = 0; i < new_target_index; i++) {
+ __ masm()->Sw(kInterpreterAccumulatorRegister, MemOperand(sp, i * 4));
+ }
+ // Push new_target_or_generator.
+ __ Push(kJavaScriptCallNewTargetRegister);
+ register_count -= new_target_index + 1;
+ }
+ if (register_count < 2 * kLoopUnrollSize) {
+ // If the frame is small enough, just unroll the frame fill completely.
+ __ masm()->Addu(sp, sp, Operand(-(kPointerSize * register_count)));
+ for (int i = 0; i < register_count; ++i) {
+ __ masm()->Sw(kInterpreterAccumulatorRegister, MemOperand(sp, i * 4));
+ }
+ } else {
+ __ masm()->Addu(sp, sp, Operand(-(kPointerSize * register_count)));
+ for (int i = 0; i < register_count; ++i) {
+ __ masm()->Sw(kInterpreterAccumulatorRegister, MemOperand(sp, i * 4));
+ }
+ }
+}
+
+void BaselineCompiler::VerifyFrameSize() {
+ ASM_CODE_COMMENT(&masm_);
+ __ masm()->Addu(kScratchReg, sp,
+ Operand(InterpreterFrameConstants::kFixedFrameSizeFromFp +
+ bytecode_->frame_size()));
+ __ masm()->Assert(eq, AbortReason::kUnexpectedStackPointer, kScratchReg,
+ Operand(fp));
+}
+
+} // namespace baseline
+} // namespace internal
+} // namespace v8
+
+#endif // V8_BASELINE_MIPS_BASELINE_COMPILER_MIPS_INL_H_
diff --git a/deps/v8/src/baseline/riscv64/baseline-assembler-riscv64-inl.h b/deps/v8/src/baseline/riscv64/baseline-assembler-riscv64-inl.h
new file mode 100644
index 00000000000000..d7b9566a166b69
--- /dev/null
+++ b/deps/v8/src/baseline/riscv64/baseline-assembler-riscv64-inl.h
@@ -0,0 +1,540 @@
+// Copyright 2021 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef V8_BASELINE_RISCV64_BASELINE_ASSEMBLER_RISCV64_INL_H_
+#define V8_BASELINE_RISCV64_BASELINE_ASSEMBLER_RISCV64_INL_H_
+
+#include "src/baseline/baseline-assembler.h"
+#include "src/codegen/assembler-inl.h"
+#include "src/codegen/interface-descriptors.h"
+namespace v8 {
+namespace internal {
+namespace baseline {
+
+class BaselineAssembler::ScratchRegisterScope {
+ public:
+ explicit ScratchRegisterScope(BaselineAssembler* assembler)
+ : assembler_(assembler),
+ prev_scope_(assembler->scratch_register_scope_),
+ wrapped_scope_(assembler->masm()) {
+ if (!assembler_->scratch_register_scope_) {
+ // If we haven't opened a scratch scope yet, for the first one add a
+ // couple of extra registers.
+ wrapped_scope_.Include(kScratchReg, kScratchReg2);
+ }
+ assembler_->scratch_register_scope_ = this;
+ }
+ ~ScratchRegisterScope() { assembler_->scratch_register_scope_ = prev_scope_; }
+
+ Register AcquireScratch() { return wrapped_scope_.Acquire(); }
+
+ private:
+ BaselineAssembler* assembler_;
+ ScratchRegisterScope* prev_scope_;
+ UseScratchRegisterScope wrapped_scope_;
+};
+
+enum class Condition : uint32_t {
+ kEqual = eq,
+ kNotEqual = ne,
+
+ kLessThan = lt,
+ kGreaterThan = gt,
+ kLessThanEqual = le,
+ kGreaterThanEqual = ge,
+
+ kUnsignedLessThan = Uless,
+ kUnsignedGreaterThan = Ugreater,
+ kUnsignedLessThanEqual = Uless_equal,
+ kUnsignedGreaterThanEqual = Ugreater_equal,
+
+ kOverflow = overflow,
+ kNoOverflow = no_overflow,
+
+ kZero = eq,
+ kNotZero = ne,
+};
+
+inline internal::Condition AsMasmCondition(Condition cond) {
+ return static_cast(cond);
+}
+
+namespace detail {
+
+#ifdef DEBUG
+inline bool Clobbers(Register target, MemOperand op) {
+ return op.is_reg() && op.rm() == target;
+}
+#endif
+
+} // namespace detail
+
+#define __ masm_->
+
+MemOperand BaselineAssembler::RegisterFrameOperand(
+ interpreter::Register interpreter_register) {
+ return MemOperand(fp, interpreter_register.ToOperand() * kSystemPointerSize);
+}
+void BaselineAssembler::RegisterFrameAddress(
+ interpreter::Register interpreter_register, Register rscratch) {
+ return __ Add64(rscratch, fp,
+ interpreter_register.ToOperand() * kSystemPointerSize);
+}
+MemOperand BaselineAssembler::FeedbackVectorOperand() {
+ return MemOperand(fp, BaselineFrameConstants::kFeedbackVectorFromFp);
+}
+
+void BaselineAssembler::Bind(Label* label) { __ bind(label); }
+
+void BaselineAssembler::BindWithoutJumpTarget(Label* label) { __ bind(label); }
+
+void BaselineAssembler::JumpTarget() {
+ // Nop
+}
+
+void BaselineAssembler::Jump(Label* target, Label::Distance distance) {
+ __ jmp(target);
+}
+void BaselineAssembler::JumpIfRoot(Register value, RootIndex index,
+ Label* target, Label::Distance) {
+ __ JumpIfRoot(value, index, target);
+}
+void BaselineAssembler::JumpIfNotRoot(Register value, RootIndex index,
+ Label* target, Label::Distance) {
+ __ JumpIfNotRoot(value, index, target);
+}
+void BaselineAssembler::JumpIfSmi(Register value, Label* target,
+ Label::Distance) {
+ __ JumpIfSmi(value, target);
+}
+void BaselineAssembler::JumpIfNotSmi(Register value, Label* target,
+ Label::Distance) {
+ __ JumpIfSmi(value, target);
+}
+void BaselineAssembler::JumpIfImmediate(Condition cc, Register left, int right,
+ Label* target,
+ Label::Distance distance) {
+ JumpIf(cc, left, Operand(right), target, distance);
+}
+void BaselineAssembler::CallBuiltin(Builtin builtin) {
+ ASM_CODE_COMMENT_STRING(masm_,
+ __ CommentForOffHeapTrampoline("call", builtin));
+ Register temp = t6;
+ __ LoadEntryFromBuiltin(builtin, temp);
+ __ Call(temp);
+}
+
+void BaselineAssembler::TailCallBuiltin(Builtin builtin) {
+ ASM_CODE_COMMENT_STRING(masm_,
+ __ CommentForOffHeapTrampoline("tail call", builtin));
+ Register temp = t6;
+ __ LoadEntryFromBuiltin(builtin, temp);
+ __ Jump(temp);
+}
+
+void BaselineAssembler::TestAndBranch(Register value, int mask, Condition cc,
+ Label* target, Label::Distance) {
+ ScratchRegisterScope temps(this);
+ Register tmp = temps.AcquireScratch();
+ __ And(tmp, value, Operand(mask));
+ __ Branch(target, AsMasmCondition(cc), tmp, Operand(zero_reg));
+}
+
+void BaselineAssembler::JumpIf(Condition cc, Register lhs, const Operand& rhs,
+ Label* target, Label::Distance) {
+ __ Branch(target, AsMasmCondition(cc), lhs, Operand(rhs));
+}
+void BaselineAssembler::JumpIfObjectType(Condition cc, Register object,
+ InstanceType instance_type,
+ Register map, Label* target,
+ Label::Distance) {
+ ScratchRegisterScope temps(this);
+ Register type = temps.AcquireScratch();
+ __ GetObjectType(object, map, type);
+ __ Branch(target, AsMasmCondition(cc), type, Operand(instance_type));
+}
+void BaselineAssembler::JumpIfInstanceType(Condition cc, Register map,
+ InstanceType instance_type,
+ Label* target, Label::Distance) {
+ ScratchRegisterScope temps(this);
+ Register type = temps.AcquireScratch();
+ if (FLAG_debug_code) {
+ __ AssertNotSmi(map);
+ __ GetObjectType(map, type, type);
+ __ Assert(eq, AbortReason::kUnexpectedValue, type, Operand(MAP_TYPE));
+ }
+ __ Ld(type, FieldMemOperand(map, Map::kInstanceTypeOffset));
+ __ Branch(target, AsMasmCondition(cc), type, Operand(instance_type));
+}
+void BaselineAssembler::JumpIfPointer(Condition cc, Register value,
+ MemOperand operand, Label* target,
+ Label::Distance) {
+ ScratchRegisterScope temps(this);
+ Register temp = temps.AcquireScratch();
+ __ Ld(temp, operand);
+ __ Branch(target, AsMasmCondition(cc), value, Operand(temp));
+}
+void BaselineAssembler::JumpIfSmi(Condition cc, Register value, Smi smi,
+ Label* target, Label::Distance) {
+ ScratchRegisterScope temps(this);
+ Register temp = temps.AcquireScratch();
+ __ li(temp, Operand(smi));
+ __ SmiUntag(temp);
+ __ Branch(target, AsMasmCondition(cc), value, Operand(temp));
+}
+void BaselineAssembler::JumpIfSmi(Condition cc, Register lhs, Register rhs,
+ Label* target, Label::Distance) {
+ // todo: compress pointer
+ __ AssertSmi(lhs);
+ __ AssertSmi(rhs);
+ __ Branch(target, AsMasmCondition(cc), lhs, Operand(rhs));
+}
+void BaselineAssembler::JumpIfTagged(Condition cc, Register value,
+ MemOperand operand, Label* target,
+ Label::Distance) {
+ // todo: compress pointer
+ ScratchRegisterScope temps(this);
+ Register scratch = temps.AcquireScratch();
+ __ Ld(scratch, operand);
+ __ Branch(target, AsMasmCondition(cc), value, Operand(scratch));
+}
+void BaselineAssembler::JumpIfTagged(Condition cc, MemOperand operand,
+ Register value, Label* target,
+ Label::Distance) {
+ // todo: compress pointer
+ ScratchRegisterScope temps(this);
+ Register scratch = temps.AcquireScratch();
+ __ Ld(scratch, operand);
+ __ Branch(target, AsMasmCondition(cc), scratch, Operand(value));
+}
+void BaselineAssembler::JumpIfByte(Condition cc, Register value, int32_t byte,
+ Label* target, Label::Distance) {
+ __ Branch(target, AsMasmCondition(cc), value, Operand(byte));
+}
+
+void BaselineAssembler::Move(interpreter::Register output, Register source) {
+ Move(RegisterFrameOperand(output), source);
+}
+void BaselineAssembler::Move(Register output, TaggedIndex value) {
+ __ li(output, Operand(value.ptr()));
+}
+void BaselineAssembler::Move(MemOperand output, Register source) {
+ __ Sd(source, output);
+}
+void BaselineAssembler::Move(Register output, ExternalReference reference) {
+ __ li(output, Operand(reference));
+}
+void BaselineAssembler::Move(Register output, Handle value) {
+ __ li(output, Operand(value));
+}
+void BaselineAssembler::Move(Register output, int32_t value) {
+ __ li(output, Operand(value));
+}
+void BaselineAssembler::MoveMaybeSmi(Register output, Register source) {
+ __ Move(output, source);
+}
+void BaselineAssembler::MoveSmi(Register output, Register source) {
+ __ Move(output, source);
+}
+
+namespace detail {
+
+template
+inline Register ToRegister(BaselineAssembler* basm,
+ BaselineAssembler::ScratchRegisterScope* scope,
+ Arg arg) {
+ Register reg = scope->AcquireScratch();
+ basm->Move(reg, arg);
+ return reg;
+}
+inline Register ToRegister(BaselineAssembler* basm,
+ BaselineAssembler::ScratchRegisterScope* scope,
+ Register reg) {
+ return reg;
+}
+
+template
+struct PushAllHelper;
+template <>
+struct PushAllHelper<> {
+ static int Push(BaselineAssembler* basm) { return 0; }
+ static int PushReverse(BaselineAssembler* basm) { return 0; }
+};
+template
+struct PushAllHelper {
+ static int Push(BaselineAssembler* basm, Arg arg) {
+ BaselineAssembler::ScratchRegisterScope scope(basm);
+ basm->masm()->Push(ToRegister(basm, &scope, arg));
+ return 1;
+ }
+ static int PushReverse(BaselineAssembler* basm, Arg arg) {
+ return Push(basm, arg);
+ }
+};
+template
+struct PushAllHelper {
+ static int Push(BaselineAssembler* basm, Arg arg, Args... args) {
+ PushAllHelper::Push(basm, arg);
+ return 1 + PushAllHelper::Push(basm, args...);
+ }
+ static int PushReverse(BaselineAssembler* basm, Arg arg, Args... args) {
+ int nargs = PushAllHelper::PushReverse(basm, args...);
+ PushAllHelper::Push(basm, arg);
+ return nargs + 1;
+ }
+};
+template <>
+struct PushAllHelper {
+ static int Push(BaselineAssembler* basm, interpreter::RegisterList list) {
+ for (int reg_index = 0; reg_index < list.register_count(); ++reg_index) {
+ PushAllHelper::Push(basm, list[reg_index]);
+ }
+ return list.register_count();
+ }
+ static int PushReverse(BaselineAssembler* basm,
+ interpreter::RegisterList list) {
+ for (int reg_index = list.register_count() - 1; reg_index >= 0;
+ --reg_index) {
+ PushAllHelper::Push(basm, list[reg_index]);
+ }
+ return list.register_count();
+ }
+};
+
+template
+struct PopAllHelper;
+template <>
+struct PopAllHelper<> {
+ static void Pop(BaselineAssembler* basm) {}
+};
+template <>
+struct PopAllHelper {
+ static void Pop(BaselineAssembler* basm, Register reg) {
+ basm->masm()->Pop(reg);
+ }
+};
+template
+struct PopAllHelper {
+ static void Pop(BaselineAssembler* basm, Register reg, T... tail) {
+ PopAllHelper::Pop(basm, reg);
+ PopAllHelper::Pop(basm, tail...);
+ }
+};
+
+} // namespace detail
+
+template
+int BaselineAssembler::Push(T... vals) {
+ return detail::PushAllHelper::Push(this, vals...);
+}
+
+template
+void BaselineAssembler::PushReverse(T... vals) {
+ detail::PushAllHelper::PushReverse(this, vals...);
+}
+
+template
+void BaselineAssembler::Pop(T... registers) {
+ detail::PopAllHelper::Pop(this, registers...);
+}
+
+void BaselineAssembler::LoadTaggedPointerField(Register output, Register source,
+ int offset) {
+ __ LoadTaggedPointerField(output, FieldMemOperand(source, offset));
+}
+void BaselineAssembler::LoadTaggedSignedField(Register output, Register source,
+ int offset) {
+ __ LoadTaggedSignedField(output, FieldMemOperand(source, offset));
+}
+void BaselineAssembler::LoadTaggedAnyField(Register output, Register source,
+ int offset) {
+ __ LoadAnyTaggedField(output, FieldMemOperand(source, offset));
+}
+void BaselineAssembler::LoadWord16FieldZeroExtend(Register output,
+ Register source, int offset) {
+ __ Lhu(output, FieldMemOperand(source, offset));
+}
+void BaselineAssembler::LoadWord8Field(Register output, Register source,
+ int offset) {
+ __ Lb(output, FieldMemOperand(source, offset));
+}
+void BaselineAssembler::StoreTaggedSignedField(Register target, int offset,
+ Smi value) {
+ ASM_CODE_COMMENT(masm_);
+ ScratchRegisterScope temps(this);
+ Register tmp = temps.AcquireScratch();
+ __ li(tmp, Operand(value));
+ __ StoreTaggedField(tmp, FieldMemOperand(target, offset));
+}
+void BaselineAssembler::StoreTaggedFieldWithWriteBarrier(Register target,
+ int offset,
+ Register value) {
+ ASM_CODE_COMMENT(masm_);
+ __ StoreTaggedField(value, FieldMemOperand(target, offset));
+ __ RecordWriteField(target, offset, value, kRAHasNotBeenSaved,
+ SaveFPRegsMode::kIgnore);
+}
+void BaselineAssembler::StoreTaggedFieldNoWriteBarrier(Register target,
+ int offset,
+ Register value) {
+ __ StoreTaggedField(value, FieldMemOperand(target, offset));
+}
+
+void BaselineAssembler::AddToInterruptBudgetAndJumpIfNotExceeded(
+ int32_t weight, Label* skip_interrupt_label) {
+ ASM_CODE_COMMENT(masm_);
+ ScratchRegisterScope scratch_scope(this);
+ Register feedback_cell = scratch_scope.AcquireScratch();
+ LoadFunction(feedback_cell);
+ LoadTaggedPointerField(feedback_cell, feedback_cell,
+ JSFunction::kFeedbackCellOffset);
+
+ Register interrupt_budget = scratch_scope.AcquireScratch();
+ __ Lw(interrupt_budget,
+ FieldMemOperand(feedback_cell, FeedbackCell::kInterruptBudgetOffset));
+ // Remember to set flags as part of the add!
+ __ Add32(interrupt_budget, interrupt_budget, weight);
+ __ Sw(interrupt_budget,
+ FieldMemOperand(feedback_cell, FeedbackCell::kInterruptBudgetOffset));
+ if (skip_interrupt_label) {
+ DCHECK_LT(weight, 0);
+ __ Branch(skip_interrupt_label, ge, interrupt_budget, Operand(weight));
+ }
+}
+
+void BaselineAssembler::AddToInterruptBudgetAndJumpIfNotExceeded(
+ Register weight, Label* skip_interrupt_label) {
+ ASM_CODE_COMMENT(masm_);
+ ScratchRegisterScope scratch_scope(this);
+ Register feedback_cell = scratch_scope.AcquireScratch();
+ LoadFunction(feedback_cell);
+ LoadTaggedPointerField(feedback_cell, feedback_cell,
+ JSFunction::kFeedbackCellOffset);
+
+ Register interrupt_budget = scratch_scope.AcquireScratch();
+ __ Lw(interrupt_budget,
+ FieldMemOperand(feedback_cell, FeedbackCell::kInterruptBudgetOffset));
+ // Remember to set flags as part of the add!
+ __ Add32(interrupt_budget, interrupt_budget, weight);
+ __ Sw(interrupt_budget,
+ FieldMemOperand(feedback_cell, FeedbackCell::kInterruptBudgetOffset));
+ if (skip_interrupt_label)
+ __ Branch(skip_interrupt_label, ge, interrupt_budget, Operand(weight));
+}
+
+void BaselineAssembler::AddSmi(Register lhs, Smi rhs) {
+ ASM_CODE_COMMENT(masm_);
+ if (SmiValuesAre31Bits()) {
+ __ Add32(lhs, lhs, Operand(rhs));
+ } else {
+ __ Add64(lhs, lhs, Operand(rhs));
+ }
+}
+
+void BaselineAssembler::Word32And(Register output, Register lhs, int rhs) {
+ __ And(output, lhs, Operand(rhs));
+}
+
+void BaselineAssembler::Switch(Register reg, int case_value_base,
+ Label** labels, int num_labels) {
+ ASM_CODE_COMMENT(masm_);
+ Label fallthrough;
+ if (case_value_base != 0) {
+ __ Sub64(reg, reg, Operand(case_value_base));
+ }
+
+ // Mostly copied from code-generator-riscv64.cc
+ ScratchRegisterScope scope(this);
+ Label table;
+ __ Branch(&fallthrough, AsMasmCondition(Condition::kUnsignedGreaterThanEqual),
+ reg, Operand(int64_t(num_labels)));
+ int64_t imm64;
+ imm64 = __ branch_long_offset(&table);
+ CHECK(is_int32(imm64 + 0x800));
+ int32_t Hi20 = (((int32_t)imm64 + 0x800) >> 12);
+ int32_t Lo12 = (int32_t)imm64 << 20 >> 20;
+ __ BlockTrampolinePoolFor(2);
+ __ auipc(t6, Hi20); // Read PC + Hi20 into t6
+ __ addi(t6, t6, Lo12); // jump PC + Hi20 + Lo12
+
+ int entry_size_log2 = 3;
+ __ CalcScaledAddress(t6, t6, reg, entry_size_log2);
+ __ Jump(t6);
+ {
+ TurboAssembler::BlockTrampolinePoolScope(masm());
+ __ BlockTrampolinePoolFor(num_labels * kInstrSize * 2);
+ __ bind(&table);
+ for (int i = 0; i < num_labels; ++i) {
+ __ BranchLong(labels[i]);
+ }
+ DCHECK_EQ(num_labels * 2, __ InstructionsGeneratedSince(&table));
+ __ bind(&fallthrough);
+ }
+}
+
+#undef __
+
+#define __ basm.
+
+void BaselineAssembler::EmitReturn(MacroAssembler* masm) {
+ ASM_CODE_COMMENT(masm);
+ BaselineAssembler basm(masm);
+
+ Register weight = BaselineLeaveFrameDescriptor::WeightRegister();
+ Register params_size = BaselineLeaveFrameDescriptor::ParamsSizeRegister();
+
+ {
+ ASM_CODE_COMMENT_STRING(masm, "Update Interrupt Budget");
+
+ Label skip_interrupt_label;
+ __ AddToInterruptBudgetAndJumpIfNotExceeded(weight, &skip_interrupt_label);
+ __ masm()->SmiTag(params_size);
+ __ masm()->Push(params_size, kInterpreterAccumulatorRegister);
+
+ __ LoadContext(kContextRegister);
+ __ LoadFunction(kJSFunctionRegister);
+ __ masm()->Push(kJSFunctionRegister);
+ __ CallRuntime(Runtime::kBytecodeBudgetInterrupt, 1);
+
+ __ masm()->Pop(params_size, kInterpreterAccumulatorRegister);
+ __ masm()->SmiUntag(params_size);
+
+ __ Bind(&skip_interrupt_label);
+ }
+
+ BaselineAssembler::ScratchRegisterScope temps(&basm);
+ Register actual_params_size = temps.AcquireScratch();
+ // Compute the size of the actual parameters + receiver (in bytes).
+ __ Move(actual_params_size,
+ MemOperand(fp, StandardFrameConstants::kArgCOffset));
+
+ // If actual is bigger than formal, then we should use it to free up the stack
+ // arguments.
+ Label corrected_args_count;
+ __ masm()->Branch(&corrected_args_count, ge, params_size,
+ Operand(actual_params_size), Label::Distance::kNear);
+ __ masm()->Move(params_size, actual_params_size);
+ __ Bind(&corrected_args_count);
+
+ // Leave the frame (also dropping the register file).
+ __ masm()->LeaveFrame(StackFrame::BASELINE);
+
+ // Drop receiver + arguments.
+ __ masm()->DropArguments(params_size, MacroAssembler::kCountIsInteger,
+ MacroAssembler::kCountIncludesReceiver);
+ __ masm()->Ret();
+}
+
+#undef __
+
+inline void EnsureAccumulatorPreservedScope::AssertEqualToAccumulator(
+ Register reg) {
+ assembler_->masm()->Assert(eq, AbortReason::kUnexpectedValue, reg,
+ Operand(kInterpreterAccumulatorRegister));
+}
+} // namespace baseline
+} // namespace internal
+} // namespace v8
+
+#endif // V8_BASELINE_RISCV64_BASELINE_ASSEMBLER_RISCV64_INL_H_
diff --git a/deps/v8/src/baseline/riscv64/baseline-compiler-riscv64-inl.h b/deps/v8/src/baseline/riscv64/baseline-compiler-riscv64-inl.h
new file mode 100644
index 00000000000000..1fbdaa0761e1ea
--- /dev/null
+++ b/deps/v8/src/baseline/riscv64/baseline-compiler-riscv64-inl.h
@@ -0,0 +1,79 @@
+// Copyright 2021 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef V8_BASELINE_RISCV64_BASELINE_COMPILER_RISCV64_INL_H_
+#define V8_BASELINE_RISCV64_BASELINE_COMPILER_RISCV64_INL_H_
+
+#include "src/baseline/baseline-compiler.h"
+
+namespace v8 {
+namespace internal {
+namespace baseline {
+
+#define __ basm_.
+
+void BaselineCompiler::Prologue() {
+ ASM_CODE_COMMENT(&masm_);
+ // Enter the frame here, since CallBuiltin will override lr.
+ __ masm()->EnterFrame(StackFrame::BASELINE);
+ DCHECK_EQ(kJSFunctionRegister, kJavaScriptCallTargetRegister);
+ int max_frame_size =
+ bytecode_->frame_size() + max_call_args_ * kSystemPointerSize;
+ CallBuiltin(
+ kContextRegister, kJSFunctionRegister, kJavaScriptCallArgCountRegister,
+ max_frame_size, kJavaScriptCallNewTargetRegister, bytecode_);
+ PrologueFillFrame();
+}
+
+void BaselineCompiler::PrologueFillFrame() {
+ ASM_CODE_COMMENT(&masm_);
+ // Inlined register frame fill
+ interpreter::Register new_target_or_generator_register =
+ bytecode_->incoming_new_target_or_generator_register();
+ __ LoadRoot(kInterpreterAccumulatorRegister, RootIndex::kUndefinedValue);
+ int register_count = bytecode_->register_count();
+ // Magic value
+ const int kLoopUnrollSize = 8;
+ const int new_target_index = new_target_or_generator_register.index();
+ const bool has_new_target = new_target_index != kMaxInt;
+ if (has_new_target) {
+ DCHECK_LE(new_target_index, register_count);
+ __ masm()->Add64(sp, sp, Operand(-(kPointerSize * new_target_index)));
+ for (int i = 0; i < new_target_index; i++) {
+ __ masm()->Sd(kInterpreterAccumulatorRegister, MemOperand(sp, i * 8));
+ }
+ // Push new_target_or_generator.
+ __ Push(kJavaScriptCallNewTargetRegister);
+ register_count -= new_target_index + 1;
+ }
+ if (register_count < 2 * kLoopUnrollSize) {
+ // If the frame is small enough, just unroll the frame fill completely.
+ __ masm()->Add64(sp, sp, Operand(-(kPointerSize * register_count)));
+ for (int i = 0; i < register_count; ++i) {
+ __ masm()->Sd(kInterpreterAccumulatorRegister, MemOperand(sp, i * 8));
+ }
+ } else {
+ __ masm()->Add64(sp, sp, Operand(-(kPointerSize * register_count)));
+ for (int i = 0; i < register_count; ++i) {
+ __ masm()->Sd(kInterpreterAccumulatorRegister, MemOperand(sp, i * 8));
+ }
+ }
+}
+
+void BaselineCompiler::VerifyFrameSize() {
+ ASM_CODE_COMMENT(&masm_);
+ __ masm()->Add64(kScratchReg, sp,
+ Operand(InterpreterFrameConstants::kFixedFrameSizeFromFp +
+ bytecode_->frame_size()));
+ __ masm()->Assert(eq, AbortReason::kUnexpectedStackPointer, kScratchReg,
+ Operand(fp));
+}
+
+#undef __
+
+} // namespace baseline
+} // namespace internal
+} // namespace v8
+
+#endif // V8_BASELINE_RISCV64_BASELINE_COMPILER_RISCV64_INL_H_
diff --git a/deps/v8/src/builtins/builtins-shadow-realms.cc b/deps/v8/src/builtins/builtins-shadow-realms.cc
new file mode 100644
index 00000000000000..08b3f3ec31c818
--- /dev/null
+++ b/deps/v8/src/builtins/builtins-shadow-realms.cc
@@ -0,0 +1,226 @@
+// Copyright 2021 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "src/builtins/builtins-utils-inl.h"
+#include "src/codegen/compiler.h"
+#include "src/logging/counters.h"
+#include "src/objects/js-shadow-realms-inl.h"
+
+namespace v8 {
+namespace internal {
+
+// https://tc39.es/proposal-shadowrealm/#sec-shadowrealm-constructor
+BUILTIN(ShadowRealmConstructor) {
+ HandleScope scope(isolate);
+ // 1. If NewTarget is undefined, throw a TypeError exception.
+ if (args.new_target()->IsUndefined(isolate)) { // [[Call]]
+ THROW_NEW_ERROR_RETURN_FAILURE(
+ isolate, NewTypeError(MessageTemplate::kConstructorNotFunction,
+ isolate->factory()->ShadowRealm_string()));
+ }
+ // [[Construct]]
+ Handle target = args.target();
+ Handle new_target = Handle::cast(args.new_target());
+
+ // 3. Let realmRec be CreateRealm().
+ // 5. Let context be a new execution context.
+ // 6. Set the Function of context to null.
+ // 7. Set the Realm of context to realmRec.
+ // 8. Set the ScriptOrModule of context to null.
+ // 10. Perform ? SetRealmGlobalObject(realmRec, undefined, undefined).
+ // 11. Perform ? SetDefaultGlobalBindings(O.[[ShadowRealm]]).
+ // 12. Perform ? HostInitializeShadowRealm(O.[[ShadowRealm]]).
+ // These steps are combined in
+ // Isolate::RunHostCreateShadowRealmContextCallback and Context::New.
+ // The host operation is hoisted for not creating a half-initialized
+ // ShadowRealm object, which can fail the heap verification.
+ Handle native_context;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, native_context,
+ isolate->RunHostCreateShadowRealmContextCallback());
+
+ // 2. Let O be ? OrdinaryCreateFromConstructor(NewTarget,
+ // "%ShadowRealm.prototype%", « [[ShadowRealm]], [[ExecutionContext]] »).
+ Handle result;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, result,
+ JSObject::New(target, new_target, Handle::null()));
+ Handle O = Handle::cast(result);
+
+ // 4. Set O.[[ShadowRealm]] to realmRec.
+ // 9. Set O.[[ExecutionContext]] to context.
+ O->set_native_context(*native_context);
+
+ // 13. Return O.
+ return *O;
+}
+
+namespace {
+
+// https://tc39.es/proposal-shadowrealm/#sec-getwrappedvalue
+MaybeHandle |